MCP vs function calling: what each does and when to use which

Both are about one thing: letting a model do something outside its own text, such as look up an order. Function callingFunction CallingThe developer's name for tool use. The model replies with the name of a function and its arguments in a fixed format, and your code runs it. is the mechanism inside a single conversation with the model. The Model Context ProtocolModel Context ProtocolAn open standard for connecting AI applications to tools and data. A system offered once as an MCP server works in any application that speaks MCP. is a standard for packaging tools so that any app can use them. Most confusion comes from treating them as 2 answers to the same question, when each answers a different one.

Function calling: the model asks, your code runs

The model cannot run anything. With function calling you send, alongside the user's message, a list of tools: each one a name, a sentence on what it does and a JSON schema for its inputs. When the model decides a tool would help, it does not answer in text; it replies with the tool's name and the arguments it chose. Your code runs the function, and you send the result back in the next request, marked with the id of the call it answers. The model reads it and either answers or asks for another tool. That repeated round trip is the agent loop in its plainest form.

Every major model API works this way, under 2 names. Anthropic calls it tool useTool UseGiving a model a list of things it can ask to have done, such as search the web or read a file. The model asks; the program around it does the work and hands back the result., OpenAI calls it function calling or tool calling, and the shapes are close: a name, a description and a schema.

MCP: tools in a server any app can use

Function calling leaves one question open: where do the tools come from? If your agent, Claude Code and a colleague's chat app all need to look up orders, each one would need its own copy of the code. MCP answers that question. An MCP server holds the tools, and any app that speaks MCP can connect to it, ask for its list of tools with tools/list and run one with tools/call.

A server can run on your machine, started by the app and spoken to over standard input and output, or on another machine, reached over HTTP. Besides tools, a server can offer resources, which are data the app can read, and prompts, which are templates a person can pick.

How they fit together

This is the part most comparisons miss. The model never talks to an MCP server. When an app such as Claude Code connects to one, it fetches the server's tools and hands them to the model as ordinary tool definitions, through function calling. When the model asks for one of those tools, the app catches the call, sends it to the server with tools/call and puts the result back into the conversation.

So MCP decides where tools live and how apps reach them; function calling is still how the model asks for one. Even the Claude Agent SDK's own custom tools are an in-process MCP server, offered to Claude through the same tool calls.

Side by side

The same tool both ways

import anthropic

ORDERS = {"A-1042": "total 140.00, delivered 6 days late"}


def get_order(order_id: str) -> str:
    return ORDERS.get(order_id, "no such order")


tools = [
    {
        "name": "get_order",
        "description": "Look up an order: its total and how it was delivered.",
        "input_schema": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    }
]

client = anthropic.Anthropic()
messages = [{"role": "user", "content": "What happened to order A-1042?"}]
while True:
    reply = client.messages.create(model="claude-sonnet-5-5", max_tokens=1024, tools=tools, messages=messages)
    messages.append({"role": "assistant", "content": reply.content})
    if reply.stop_reason != "tool_use":
        break
    # Your code runs each tool the model asked for and sends back what it returned.
    results = [
        {"type": "tool_result", "tool_use_id": block.id, "content": get_order(**block.input)}
        for block in reply.content
        if block.type == "tool_use"
    ]
    messages.append({"role": "user", "content": results})

print(next(block.text for block in reply.content if block.type == "text"))

from mcp.server import MCPServer

ORDERS = {"A-1042": "total 140.00, delivered 6 days late"}

mcp = MCPServer("shop")


@mcp.tool()
def get_order(order_id: str) -> str:
    """Look up an order: its total and how it was delivered."""
    return ORDERS.get(order_id, "no such order")


if __name__ == "__main__":
    mcp.run(transport="stdio")

The function-calling file holds everything in 1 program: the schema, written by hand, the function and the loop. The MCP file holds only the tool. Its schema comes from the type hint and the docstring, and it has no model and no loop, because those belong to whichever app connects.

Which to use

Things to watch with MCP

• A server is code you run. A local MCP server is a program on your machine with your permissions. Connect servers from sources you trust, as you would install any package.
• Tool descriptions reach the model. A server's descriptions and results go into the model's context, where text written to mislead it can act as prompt injectionPrompt InjectionAn attack that hides instructions in text a model reads, such as a web page, an email or a file, so the model follows the attacker instead of you.. Keep a person's approval on tools that change things.
• Ask for the narrowest access. A server that signs in to another system should hold only the scopes it needs, so a leaked token can do little.
• Many tools cost context. Every tool's definition takes room in the context windowContext WindowEverything a model can see at once while it writes an answer, counted in tokens. When the window is full, something has to be left out. on every request, so connect the servers a job needs, not every one you have.

To see a tool call inside a whole agent, with the loop, memory and a guardrail, follow one request through How AI agents work. To choose a framework that runs the loop for you, read LangGraph vs CrewAI vs Claude Agent SDK.