How is MCP different from function calling built directly into an LLM API?
Quick Answer
Native function calling (OpenAI, Anthropic's tool use, etc.) is a model capability: you send a list of tool schemas in your API request, and the model returns which function to call with what arguments. You are still responsible for writing the code that executes the function, discovering what functions exist, and wiring everything together yourself, per app. MCP operates one layer below that: it standardizes how a server exposes and executes those tools (plus resources and prompts) so any MCP-aware app can discover and call them without custom integration code. In practice they compose: a host takes the tool list an MCP server provides, converts it into whatever schema its LLM's function-calling API expects, sends it to the model, and when the model picks a tool, the host routes that call through MCP to the actual server. MCP doesn't replace function calling, it's the plumbing that gets tools to the function-calling mechanism.
Detailed Answer
It's easy to hear "MCP lets the model call tools" and assume it competes with function calling. It doesn't — they sit at different layers.
Two different jobs
- Function calling is the model-facing contract. Given a list of tool definitions (name, description, JSON Schema for arguments) in the request, the model decides whether to call a tool and with what arguments. It returns that decision as structured output, instead of or alongside plain text.
- MCP is the integration-facing contract. It defines how a server advertises its tools, resources, and prompts, and how a client discovers and invokes them — independent of any specific model or vendor's API shape.
Where they meet
MCP Server (tools/list) --> Host converts tool defs --> LLM API's function-calling format
|
v
Model picks a tool + args
|
v
Host routes the call back through MCP --> MCP Server (tools/call) --> result
The host bridges the two. It fetches the server's tool catalog via tools/list. It reshapes each tool's JSON Schema into whatever the target LLM API expects for function-calling. It sends the prompt plus that reshaped tool list to the model. When the model's response includes a function call, the host executes it: an MCP tools/call to the right server, then the result feeds back into the conversation.
The practical difference this makes
Without MCP, "adding a new tool" means writing execution code baked directly into your app, per data source, per app. With MCP, adding a new tool to an MCP-aware host just means pointing it at a new server — the discovery and execution machinery is already generic. Function calling is what lets the model decide to use a tool. MCP is what lets any app plug that tool in without bespoke glue.