MCP vs function calling: what is the difference and when to use each

MCP and function calling are not competitors. They sit at different layers. Function calling is the model capability that lets an LLM emit a structured request to invoke a named function. MCP, the Model Context Protocol, is the protocol that standardizes how those functions, which it calls tools, plus resources and prompts, are exposed to and discovered by any client. You use function calling to run one tool inside one app. You use MCP so the same tool works across every client without rewiring. Most real systems use both.

What is function calling?

Function calling is a feature of the model API. You give the model a list of function definitions, each with a name, a description, and a JSON Schema for its parameters. When the model decides a function is needed, it does not run it. It returns a structured object naming the function and the argument values it wants. Your code executes the function and passes the result back for the next turn. OpenAI shipped this in 2023; Anthropic tool use and Google function calling work the same way. The model chooses and fills the arguments; your code runs the function and returns the result.

The important part is what function calling does not include: it says nothing about where the function lives, how it is transported, or how a second application would reuse it. The tool schema is something you hand-write into each request, in each app, against each provider SDK.

What is MCP?

MCP is a wire protocol, not a model feature. An MCP server exposes capabilities over a transport, stdio for a local subprocess or Streamable HTTP for a remote service, and any MCP client can connect, list what the server offers, and call it. The three primitives are tools (actions the model can call), resources (read-only context addressed by URI), and prompts (reusable templates the user picks). The point is decoupling: a server author writes one server, and every MCP-capable client, whether Claude Desktop, Cursor, MCPOrbit, or your own agent, can use it with no custom glue. The current specification is dated 2026-07-28.

MCP vs function calling: the key difference

• Layer: function calling is a model API capability; MCP is an integration and transport protocol that sits around it.
• Scope: function calling connects one model to tools inside one application; MCP connects many clients to many servers.
• Who defines the tool: with function calling you hard-write the schema into each app; with MCP the schema arrives at runtime from tools/list.
• Reuse: a function-calling tool is bound to the app that declared it; an MCP tool is reusable by any MCP client with zero extra code.
• Beyond tools: function calling only covers callable tools; MCP also standardizes resources (read-only context) and prompts (user-picked templates).

How do MCP and function calling work together?

In a system that uses both, MCP delivers the tool definitions and the model function calling selects among them. The MCP client calls tools/list on each connected server, hands the returned JSON Schemas to the model as function definitions, and when the model emits a function call, the client routes it back to the correct server as a tools/call request. Function calling is the model decision step. MCP is the discovery, transport, and execution layer wrapped around it.

// Function calling on its own: you hand-write the tool schema into every request
const tools = [{
  name: "get_weather",
  description: "Get current weather for a city",
  input_schema: {
    type: "object",
    properties: { city: { type: "string" } },
    required: ["city"]
  }
}];

// With MCP: the same schema arrives at runtime from a server you did not hardcode
const { tools } = await client.request({ method: "tools/list" });
// pass `tools` straight to the model as its function definitions

When should you use function calling on its own?

• You are building a single application and the tools live in the same codebase.
• The tool set is small, stable, and not meant to be reused by other clients.
• You want the lowest possible number of moving parts and are fine wiring each tool to one provider SDK.
• You are prototyping and do not yet need cross-app reuse or a separate server process.

When should you use MCP?

• You want the same tools to work in Claude Desktop, Cursor, your own agent, and other clients without rewriting them.
• You are shipping tools for other people to consume, so a standard contract matters more than a bespoke integration.
• You need resources or prompts, not just callable actions.
• You want to swap the underlying model or client without touching the tool implementation.

Does MCP replace function calling?

No. MCP depends on function calling. The model still uses its native function-calling mechanism to decide which tool to invoke and to fill the arguments. MCP does not change that step. What MCP replaces is the bespoke, per-app, per-provider glue you would otherwise write to declare, host, and reuse those tools. Think of function calling as the engine and MCP as the standard chassis and wiring that lets you drop the same engine into any car.

The short version: use function calling to run a tool, use MCP so you only build that tool once. If you are deciding whether to expose a server over a local or remote transport, read our guide on MCP transport, stdio vs Streamable HTTP. If you are new to the primitives, start with MCP tools vs resources vs prompts.