MCP vs Function Calling: What the Protocol Adds to Tool Use
MCP vs function calling from the wire up: what a model API's tool definition does, what tools/list, tools/call and annotations add, and when to use each.
Este artículo está en inglés.
TL;DR. Function calling is a feature of a model API: you send tool definitions (a name, a description, a JSON Schema) with each request, the model answers with a structured call, and your own code runs it. MCP is a protocol between your application and a separate server that publishes tools, so the definitions are fetched at runtime with tools/list and executed with tools/call, over stdio or HTTP, with change notifications, an authorization framework and a few primitives that a model API's tool definition has no field for. The model still uses function calling to pick a tool. MCP decides where the tools come from. This article walks through MCP vs function calling at the level of the actual fields and messages.
What is function calling?
Function calling is a feature of a model API that lets the model request a call to a function your application defined, with arguments that follow a JSON Schema you supplied in the request. The model does not run anything. Your application receives the structured call, executes it, and sends the result back in the next request so the model can continue.
Two model APIs describe the same loop with different field names. The Claude docs say that "Tool use (also called function calling) lets Claude call functions that you define or that Anthropic provides," and that for client tools "Claude responds with stop_reason: "tool_use" and one or more tool_use blocks. Your code runs the operation and sends back a tool_result." A tool is defined with name, description and input_schema (Tool use with Claude).
OpenAI's guide calls the same thing function calling, "also known as tool calling." A function definition has type (always function), name, description, parameters and strict. The model emits a function_call item with call_id, name and JSON-encoded arguments, and you reply with a function_call_output. The guide is direct about who does the work: "When the model calls a function, you must execute it and return the result" (Function calling).
| Step | Claude Messages API | OpenAI function calling guide |
|---|---|---|
| Tool definition | name, description, input_schema | type: "function", name, description, parameters, strict |
| The model's request | tool_use block, stop_reason: "tool_use" | function_call item with call_id, name, arguments |
| Your reply | tool_result with tool_use_id | function_call_output |
| Who executes | your application (client tools) | you ("you must execute it") |
The part that matters for the rest of this article: in plain function calling, the list of tools is whatever your code puts in the tools array. The definition lives in your application, ships with your deploy, and changes when you change it.
What does MCP add on top of function calling?
MCP adds a standard way for an application to get its tools from somewhere other than its own code: a server, local or remote, that the application asks for a tool list at runtime and asks to execute each call. The project's intro defines it as "an open-source standard for connecting AI applications to external systems" (What is MCP).
The architecture page of the 2026-07-28 specification splits the application into a host and clients. Each client "communicates with exactly one server." Servers "Expose resources, tools and prompts via MCP primitives" and "Can be local processes or remote services." The same page states that MCP is a stateless protocol: every request carries its own protocol version and capabilities.
On the wire, every message is JSON-RPC 2.0 (base protocol). Discovery is a tools/list request. The tools page shows a response like this (trimmed):
{
"jsonrpc": "2.0",
"id": 1,
"result": {
"resultType": "complete",
"tools": [
{
"name": "get_weather",
"title": "Weather Information Provider",
"description": "Get current weather information for a location",
"inputSchema": {
"type": "object",
"properties": {
"location": { "type": "string", "description": "City name or zip code" }
},
"required": ["location"]
}
}
],
"ttlMs": 300000,
"cacheScope": "public"
}
}Compare that object with a function-calling definition. name, description and inputSchema map onto what you already send to a model API; the spec says inputSchema "MUST be a valid JSON Schema object" and defaults to JSON Schema 2020-12. The tool object also carries fields with no model-API equivalent: title, icons, an optional outputSchema for the result, and annotations describing behavior.
Invocation is a tools/call request. Under 2026-07-28 every request must include _meta with the protocol version and client capabilities (the spec's examples omit them for brevity; a request without them is rejected with -32602):
{
"jsonrpc": "2.0",
"id": 2,
"method": "tools/call",
"params": {
"name": "get_weather",
"arguments": { "location": "New York" },
"_meta": {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientCapabilities": {},
"io.modelcontextprotocol/clientInfo": { "name": "example-client", "version": "1.0.0" }
}
}
}The result has a content array (text, image, audio, resource links or embedded resources), an optional structuredContent value, and an isError flag. That is the MCP half of the loop. The model-API half has not changed.
How do MCP and function calling work together in one request loop?
MCP and function calling stack rather than compete: the host fetches tool definitions from a server with tools/list, passes them to the model in the model API's own tool format, and when the model answers with a tool call, the host translates it into tools/call and returns the result. The specification's message flow names the three stages: Discovery, Tool Selection, Invocation.
The spec describes tools as "model-controlled, meaning that the language model can discover and invoke tools automatically based on its contextual understanding and the user's prompts" (tools). It does not say which model or which API; the host decides. In practice a host turns each MCP tool into a tools entry for its model API, with inputSchema becoming input_schema or parameters, then maps a tool_use block or a function_call item back to tools/call.
Results need a translation too, and the spec is specific about errors. Protocol errors (an unknown tool, a malformed request) come back as JSON-RPC errors such as -32602 with "Unknown tool: invalid_tool_name". Tool execution errors (a bad date, an upstream API failure) come back inside the result with isError: true, and "Clients SHOULD provide tool execution errors to language models to enable self-correction." A host that forwards the second kind as a tool_result or function_call_output gives the model a chance to retry with better arguments.
Both model-API vendors also document a shortcut where their API does the MCP part for you. The Claude docs list an MCP connector to "Connect to remote MCP servers from the Messages API without a separate MCP client," and OpenAI's function calling guide mentions built-in tools that can "access the functionality of an MCP server." Either way, the model is still doing function calling underneath. MCP changed where the tool definitions and the execution live.
Where does the tool definition live, and why does that matter?
The practical difference between MCP and function calling is ownership of the tool definition: with function calling it is in your repository, and with MCP it belongs to the server, which may change it at any time without a deploy on your side. The specification makes that explicit and gives clients two ways to keep up.
The tools page says the set of tools "MAY be empty and MAY change over time." Servers that declare listChanged in their capabilities "SHOULD send a notification to clients that have opened a subscriptions/listen stream with toolsListChanged: true," the notification being notifications/tools/list_changed. Since 2026-07-28, every tools/list result also carries ttlMs and cacheScope, so a client knows how long it may cache the list (changelog).
That is what you gain: a vendor fixes a parameter description or adds a tool, and every client picks it up at the next list. It is also what you take on. Descriptions and schemas you did not write go into your model's context. The spec treats them with care: "clients MUST consider tool annotations to be untrusted unless they come from trusted servers," there "SHOULD always be a human in the loop with the ability to deny tool invocations," and clients SHOULD "Show tool inputs to the user before calling the server." Even serverInfo is "self-reported by the server and is not verified by the protocol" (discovery).
This is the gap mcp.tc tries to help with. For every listed server whose tool list can be read without signing in, mcp.tc fetches the list every 3 hours and records added and removed tools, changed tool and parameter descriptions, input and output schemas, annotations and server instructions on the listing's History tab, each with a date and time, after two reads agree. On 8 November 2026 the directory listed 1,380 servers, 1,060 remote and 320 local, and 462 of those listings had a tool list that mcp.tc compares this way; the history began on 6 October 2026. You can see the format on mcp.tc's own server listing, and the newest changes across the directory are on the recent changes page. Sign in and press Follow on a listing to get an email when its tools or version change.
The limits are worth stating plainly. The History shows what mcp.tc's own reads saw, without signing in. Servers that list their tools only after sign-in, and local servers without a bundle manifest, have no watched tool list. A change undone between two checks can be missed. It is not a security review and it does not approve or block anything; it helps you notice that the definition you are feeding your model is no longer the one you read last month. The changes documentation has the full rules.
What does MCP have that function calling has no field for?
Beyond runtime discovery, MCP defines server primitives, transports, an authorization framework and tool metadata that a plain tools array cannot express; a model API's tool definition carries a name, a description and an input schema. The table below lists each MCP feature next to the closest thing you would do by hand in a function-calling application.
| MCP feature | Where it is specified | What you would do with function calling alone |
|---|---|---|
tools/list at runtime | tools | hard-code the tools array |
| Prompts (user-controlled templates) | server overview | build your own slash commands |
| Resources (application-controlled context) | server overview | fetch files or records in your code |
Server instructions | discovery | write the system prompt yourself |
Tool annotations (readOnlyHint and others) | tools | keep a private allowlist |
outputSchema and structuredContent | tools | parse result strings yourself |
| stdio and Streamable HTTP transports | transports | call functions in-process |
| Authorization framework for HTTP | base protocol | manage credentials in your code |
notifications/tools/list_changed, ttlMs | tools | redeploy |
The server overview sorts the three primitives by who controls them: prompts are "User-controlled" ("Slash commands, menu options"), resources are "Application-controlled" ("File contents, git history"), and tools are "Model-controlled" ("API POST requests, file writing"). Function calling covers the third row only.
Two details from the table deserve a line each. Server instructions are returned by server/discover, which every 2026-07-28 server MUST implement, as "Optional natural-language guidance for LLMs on how to use this server effectively." And annotations are hints a server gives about its own tools; what they mean, and why clients may not trust them, is in our post on MCP tool annotations.
One thing to know before you build on older material: the 2026-07-28 changelog deprecates the Roots, Sampling and Logging features, and says "new implementations should not add support for them." Tasks moved out of the core into an extension. If a comparison you read lists sampling as a headline MCP advantage, it predates this revision.
When is function calling alone enough, and when do you want MCP?
Function calling alone fits when you wrote the tools, one application uses them, and they run in the same process as the application; MCP fits when the tools are maintained by someone else, used from more than one client, or need to run somewhere else, such as a local subprocess with file access or a remote service behind OAuth. The decision is about where the definition and the execution should live.
Signs that plain function calling is the right size:
- You own every function and its schema, and you are happy to redeploy when one changes.
- One application calls them, so there is no second client to share them with.
- The functions run in-process, with credentials your application already holds.
- You want the fewest moving parts between the model and the code.
Signs that you want MCP:
- The tools belong to a vendor or a colleague who publishes a server, and you would rather fetch their definitions than copy them.
- Several clients need the same tools. A listing on mcp.tc carries setup steps for nine clients plus a generic JSON config, because the server is the same for all of them.
- The tool must run outside your process: a local server launched over stdio ("newline-delimited messages over the standard streams of a client-launched subprocess," per the transports page) or a remote one over Streamable HTTP, where "each message is an HTTP POST to a single MCP endpoint."
- You are the one publishing tools and want any MCP client to be able to use them.
The costs of MCP are the ones the spec itself points at. There is an extra hop, a subprocess or an HTTP round trip. There is a trust boundary, so the human-in-the-loop and show-inputs rules above apply. And there is the protocol surface: under 2026-07-28 a client attaches _meta to every request, may call server/discover first, and handles UnsupportedProtocolVersionError when versions do not match. A client that also talks to servers written for the legacy initialize handshake detects the server's era and falls back, which the versioning page describes. None of that is hard, but it is more than an array in a request body.
What you can do next on mcp.tc
If you have decided the tools should come from a server, the mcp.tc directory lists public MCP servers with filters for no sign-in, sign-in or API key, and runs locally, and each listing shows the server's tools before you connect anything. Install buttons and setup steps use the server's own URL or package, so your client talks to the server directly; mcp.tc is not in the path.
You can search the directory from inside an assistant through mcp.tc's own read-only server, which needs no sign-in and exposes search_servers, get_server and list_categories (docs):
claude mcp add --transport http mcp-tc https://mcp.tc/mcp{
"mcpServers": {
"mcp-tc": {
"type": "http",
"url": "https://mcp.tc/mcp"
}
}
}From a terminal, the open-source mcp-tc command-line tool (Node.js 20 or later, MIT) does the same job: npx mcp-tc search <term> finds a server, npx mcp-tc add <slug> --client cursor adds it with the vendor's own URL or package after showing you the change, and npx mcp-tc check https://mcp.example.com/mcp reads a server you are building the way clients and mcp.tc do, so you can see your tools/list as others will.
Once a server is in your config, open its listing and press Follow to get an email when mcp.tc's checks find a change in its tools or version. And if you built a server, or use one that is missing, you can suggest it by pasting its URL.
FAQ
Does MCP replace function calling?
No. Function calling is how a model asks for a tool to be run: it is a feature of the model API, with a tool definition in the request and a structured call in the response. MCP is a protocol between the application and a server that publishes tools. An application using MCP still sends the discovered tools to the model as function definitions and still receives a tool call back. MCP changes where the definitions and the execution live, and adds discovery, transports, authorization and change notifications around them.
Is MCP just function calling over the network?
Partly, and the rest is what makes it a protocol. The tools/call message does carry a function name and JSON arguments to a server, which may be a local subprocess over stdio rather than a network service. But MCP also defines tools/list for discovery at runtime, server/discover for versions and capabilities, result shapes with content, structuredContent and isError, tool annotations, output schemas, prompts and resources, an HTTP authorization framework, and notifications/tools/list_changed for updates.
Do MCP tool schemas use the same JSON Schema as function calling?
Yes, with small differences in field names. An MCP tool's inputSchema "MUST be a valid JSON Schema object" and defaults to JSON Schema 2020-12 when no $schema field is present. The Claude API calls the same thing input_schema; OpenAI's guide calls it parameters. A host maps one to the other when it hands MCP tools to a model. MCP additionally allows an outputSchema for the result, which the server's structuredContent must conform to.
What happens when an MCP server changes its tools?
The specification lets the tool set change over time. A server that declares listChanged should send notifications/tools/list_changed to clients that opened a subscriptions/listen stream, and every tools/list result carries a ttlMs freshness hint. Clients then fetch the list again. If you want to see such changes outside your client, mcp.tc reads the tool lists it can access without sign-in every 3 hours and records the differences on each listing's History tab, with an optional email when you follow the listing.
When is function calling alone the better choice?
When you own the tools, one application uses them, they run in the same process, and you accept a redeploy whenever a schema changes. In that case an MCP server adds a hop and a trust boundary without adding anything you need. MCP earns its place when the tools are maintained by someone else, are shared across several clients, must run outside your process, or are something you want to publish for other people's clients.
Can I use an MCP server without writing an MCP client?
Yes, in two ways. Most assistants and coding tools already include an MCP client, so you add the server to their configuration and they handle tools/list and tools/call for you; each mcp.tc listing shows those steps for nine clients. The model-API vendors also document connectors where their API reaches the MCP server directly: the Claude docs describe one that connects "to remote MCP servers from the Messages API without a separate MCP client."
Fuentes
- modelcontextprotocol.io/specification/2026-07-28/server/tools
- modelcontextprotocol.io/specification/2026-07-28/architecture
- modelcontextprotocol.io/specification/2026-07-28/changelog
- modelcontextprotocol.io/specification/2026-07-28/basic/transports
- modelcontextprotocol.io/specification/2026-07-28/server/discover
- modelcontextprotocol.io/specification/2026-07-28/server
- modelcontextprotocol.io/specification/2026-07-28/basic/index
- modelcontextprotocol.io/specification/2026-07-28/basic/versioning
- modelcontextprotocol.io/docs/getting-started/intro
- platform.claude.com/docs/en/agents-and-tools/tool-use/overview
- developers.openai.com/api/docs/guides/function-calling