Compare
MCP vs function calling
Two layers of one tool call, often used together.
The short answer
Function calling is a feature of a model's API: you send tool definitions with a request, the model answers with the call it wants, and your code runs it. MCP is an open protocol between an app and tool servers: a server lists its tools and runs them, so any app that speaks MCP can use them. They sit at different layers, and an app that uses MCP still relies on function calling to let the model pick a tool.
MCP
Use it when
- Several apps or agents should share the same tools.
- You want tools someone else already built, such as an issue tracker or a database.
- The tools live in another process or service, with their own sign-in.
- What it costs
- A server to build and run, and a spec that moves: the current version, 2026-07-28, dropped the handshake that older servers still use. Every connected tool's definition also costs tokens on each request.
- Watch out
- Third-party tool descriptions and results reach your model as text, and a server can change its descriptions after you approve it. Pin definitions, give each server a narrow token, and approve writes in the app.
Function calling
Use it when
- One app, with tools you write yourself.
- You want the fewest moving parts: definitions in the request, functions in your code.
- A tool needs your app's own state, such as the signed-in user.
- What it costs
- Nothing beyond the model API. Each provider has its own format, so tools are written for each app, and sometimes for each provider.
- Watch out
- The model can still pick the wrong tool or invent arguments, and every definition costs tokens on each request. Check every call's arguments before it runs.
At a glance
| Question | MCP | Function calling |
|---|---|---|
| Where it sits | Between your app and tool servers | Between your app and the model |
| Who writes the tool | A server's author, once, for any MCP app | You, inside your app |
| Where the tool runs | In the server: a local process or a remote service | In your app's own code |
| How tools are found | Asked for at run time, with tools/list | A fixed list sent with each request |
| Format | One open spec, on JSON-RPC 2.0 | Each model provider's own API |
| Sign-in | OAuth for remote servers; local ones read the environment | Whatever your app already uses |
How to choose
- Start with function calling and two or three tools in your own code: it is the shortest path to a working agent.
- If the tools you need already exist as MCP servers, such as an issue tracker, a database or a browser, connect those instead of writing your own.
- Write an MCP server when several apps or agents need the same tools, or when you want people to use your service from any AI app.
- Before connecting any server, check what it can reach, pin its tool definitions, and give it the narrowest token that works.
When you need both
Learn it properly
Questions
Does MCP replace function calling?
No, they work at different layers. Function calling is how a model asks your app to run a tool. MCP is how your app finds tools in servers and runs them there. An app that speaks MCP still uses the model's function calling to let it choose.
Do I need MCP to build an agent?
No. An agent is a loop of model calls and tool calls, and plain function calling is enough for tools you write yourself. MCP pays off when you want tools someone else built, or when several apps should share yours.
What changed in the current MCP spec?
Version 2026-07-28 made MCP stateless. There is no initialize handshake and no session: every request carries its protocol version and the client's capabilities. A server that needs more input answers input_required, and the client calls again. Servers on 2025-11-25 and earlier still use the handshake. MCP end to end walks through the messages.
Is MCP safe to use?
As safe as the servers you connect and the app you run them in. Tool descriptions and results reach the model as text, so a malicious server can steer it. Use servers you trust, pin their tool definitions, give each a narrow token, and approve anything that writes.
Who maintains MCP?
Anthropic published it in November 2024, and in December 2025 gave it to the Agentic AI Foundation, part of the Linux Foundation. OpenAI's and Anthropic's model APIs both support it, as do many AI apps.