If OpenAI and Anthropic already let models call functions, why does anyone need a separate protocol for it?
It’s a fair question, because on the surface the two look identical: both let an LLM call an external function. Underneath, they solve different problems. Function calling is a feature of the model API. You hand the model a JSON schema, and it hands back arguments. The Model Context Protocol, which Anthropic open-sourced on November 25, 2024, is an open standard for how AI applications connect to the tools and data around them. In Anthropic’s words, it’s about “replacing fragmented integrations with a single protocol.”
Here’s a way to picture it (our analogy, not the spec’s). Before USB-C, every device came with its own charger and cable. AI tooling had the same problem: if you wanted Claude Desktop, VS Code, and an internal agent to talk to GitHub or a Postgres database, each app needed its own connector. N apps times M data sources meant N×M integrations to maintain. With a shared protocol, each app implements an MCP client once and each tool ships an MCP server once, so you’re down to N+M.
Where function calling and MCP split
Putting the two side by side makes the difference easier to see.
| Dimension | Function Calling (Tool Use) | Model Context Protocol (MCP) |
|---|---|---|
| Nature | API feature that sends tool schemas with a model request | Communication protocol between AI apps and external servers |
| Coupling | Connector code lives inside the application | Client and server run as separate processes or remote services |
| Wire format | Whatever each model provider’s API expects | Stateless JSON-RPC 2.0 exchange |
| Surface | Executable functions (tools) | Server primitives: Tools, Resources, and Prompts |
| Tool list | Developers put the schemas in every request | Clients fetch them from the server with tools/list (progressive discovery when there are many) |
Function calling stops at telling the model a function exists. Where that function runs, how it authenticates, and what it returns is up to whoever builds the app. MCP pulls that plumbing out into a standalone server and standardizes the messages in between.
It’s not just a tool-calling standard
A lot of people file MCP under “standardized tool calls.” The spec actually gives servers three primitives, and the docs go as far as saying who controls each one.
Tools are model-controlled. They’re the functions that do things, like writing to a database, calling an external API, or modifying files, and the model decides when to use them based on the conversation. The client runs one by sending a tools/call request to the server.
Resources are controlled by the application. They’re read-only context such as file contents, database schemas, or API docs, each with its own URI like file:///path/to/document.md. The app decides which of them to pass to the model, which is the key difference from tools: the model doesn’t trigger them on its own.
Prompts are user-controlled templates that only run when someone explicitly invokes them. The docs use a plan-vacation template as the example and suggest surfacing prompts as slash commands like /plan-vacation, command palettes, or buttons. The architecture overview lists system prompts and few-shot examples as typical uses.
That split draws a protocol-level line between what the model may run by itself, what the app chooses to feed it, and what only starts when a person asks. These three are the server primitives. On the client side there’s Elicitation, which lets a server ask the user for more input or a confirmation. Sampling, which let servers request model completions from the client, is marked deprecated as of protocol version 2026-07-28.
Hosts, clients, servers, and transports
MCP has three participants. The host is the AI app the user sees; the docs name Claude Code, Claude Desktop, and VS Code. For every server it connects to, the host creates a client, and each client keeps a dedicated connection to one server. If VS Code connects to both the Sentry server and a local filesystem server, it spins up two client objects.
Every message is JSON-RPC 2.0. Each request carries the protocol version and capabilities in its _meta field, so a server can handle it without remembering anything from earlier requests. To learn which versions and capabilities a server supports, a client sends server/discover. The actual tool list comes from tools/list.
There are two transports. Stdio connects processes on the same machine through standard input and output, with no network overhead. That’s what Claude Desktop uses when it launches the filesystem server, and local servers like that typically serve a single client.
Streamable HTTP is for remote servers. Client-to-server messages go over HTTP POST, with optional Server-Sent Events when streaming is needed. Sentry’s official MCP server runs this way on the Sentry platform, and remote servers typically serve many clients. Auth works with standard HTTP methods like bearer tokens, API keys, and custom headers, and the docs recommend OAuth for getting tokens.
What happens when you have hundreds of tools
With a couple of servers and a handful of tools, you won’t notice anything. As you add servers, one problem grows fast: tool definitions eat your context window.
The MCP client best practices page warns that once a host can reach dozens of servers exposing hundreds of tools, the definitions alone can take up most of the context window before the model reads the user’s message. Its comparison diagram shows the load-everything approach spending about 150,000 tokens on definitions, against about 2,000 tokens for loading only what the task needs. Keep in mind that’s an illustration in the docs, not an independent benchmark. It still gives you a sense of scale. The page also says loading everything upfront increases latency and degrades model performance.
The fix it recommends is Progressive Tool Discovery. Clients should set a threshold as a share of the context window, for example 1-5%, and switch to progressive discovery once tool definitions cross it. The search-based version in the docs has three layers:
- Catalog: instead of loading definitions, the host exposes a
search_toolsmeta-tool. The model sends a natural-language query and gets back matching tool names with one-line descriptions. - Inspect: once it has a candidate, the model calls
get_tool_detailsto fetch that one tool’s full definition, including input and output schemas. - Execute: the model calls the tool with the definition it just loaded.
The model ends up looking at a few relevant tools instead of scanning hundreds of irrelevant ones. The docs say this cuts token usage dramatically and “can improve tool selection accuracy,” which is a careful claim, not a guarantee. For the search itself you can use keywords, embeddings, or a small model that picks tools, and the page notes that OpenAI and Anthropic both offer built-in tool search.
We measured four official servers
How close is that 1-5% line in practice? To find out, we ran four of the reference servers published by the MCP project. We used the latest npm versions as of November 10, 2026, connected to each one over stdio with the official MCP TypeScript SDK client (1.32.2), pulled the tools/list response, converted it into the shape you’d send to a model (name, description, input schema), and counted tokens.
| Server (version) | Tools | Size of tool definitions |
|---|---|---|
| filesystem (2.2.0) | 16 | about 2,200 tokens |
| everything (2.2.1) | 16 | about 1,700 tokens |
| memory (2.1.0) | 9 | about 1,500 tokens |
| sequential-thinking (2.1.1) | 1 | about 500 tokens |
| All four | 42 | about 5,900 tokens |
One caveat up front: we counted with OpenAI’s o200k tokenizer. Every provider splits text into tokens a little differently, so Claude or another model would land on slightly different numbers. Read these as ballpark figures, not exact counts. Being off by a few hundred tokens doesn’t change anything below.
Take a model with a 200,000-token context window. 1% is 2,000 tokens and 5% is 10,000. That means the filesystem server alone already nudges past the 1% line, and all four together sit around 3%. The average works out to roughly 140 tokens per tool, so you’d hit 5% at around 70 tools. Run the docs’ 150,000-token example backwards with the same average and you get about 1,000 tools, so the “hundreds or thousands of tools” framing isn’t an exaggeration. (All of this is our own math on the measured numbers.)
One more thing stood out. Our first run accidentally pulled filesystem 1.0.0, which had 14 tools at about 1,700 tokens. Version 2.2.0 has 16 tools at about 2,200. Same server, over 30% heavier after updates. Upgrading a server can quietly raise the cost of every conversation.
Worth knowing: the repository’s README calls these servers “educational examples,” not production-ready solutions. Servers you actually use may expose more tools or longer descriptions, so the most reliable number is your own. Pull tools/list from your setup once and measure it.
When it’s worth it, and what to lock down
MCP isn’t a drop-in replacement for every integration. If you’re building a backend around one model with a few fixed functions, plain function calling is simpler. There’s no reason to run extra server processes or speak another protocol.
It starts paying off when several AI tools need the same systems. If your team uses Claude Desktop, VS Code, and an internal chatbot against the same database, building the connector once as an MCP server means every MCP-capable client can use it.
Since tools are the primitive the model calls on its own, the spec is fairly specific about guardrails. It says there SHOULD always be a human in the loop who can deny tool invocations. Clients SHOULD ask for confirmation on sensitive operations, show tool inputs to the user before calling the server to prevent data exfiltration, and validate tool results before passing them to the model. Servers MUST validate all inputs, enforce access controls, and rate-limit tool calls. And clients MUST treat tool annotations as untrusted unless they come from a trusted server.
Every MCP server you add is one more thing the model can do on your behalf. Before connecting one you don’t know, check whether your client actually asks you to approve each tool call.