**Function calling and MCP** address two distinct boundaries in the agent stack, and confusing them signals a surface level understanding.
Function calling is the provider's mechanism for getting reliable structured output from the model. When Claude, GPT, or Gemini decides to use a tool, it emits a well formed JSON object naming the tool and its arguments. The provider's API guarantees that shape through constrained decoding. The host application receives this object and can parse it without regex or guesswork.
MCP sits on the other side of the host. Once the host has the model's tool call, it needs to actually execute it. MCP standardizes that execution path. The host connects to an MCP server, discovers available tools via `tools/list`, routes the call via `tools/call`, and receives structured results. The server might run locally as a subprocess over stdio or remotely over streamable HTTP.
The two compose rather than compete. A 2026 agent uses function calling so the model can express intent, and MCP so the host can fulfill that intent against any external system. The portability payoff is the practical reason MCP exists: write a server once and every MCP capable host (Claude Desktop, Cursor, Zed, Cline) can use it, regardless of which LLM provider powers the model.
Your colleague is conflating two protocols that sit on opposite sides of the host process. **Function calling** is the inference layer contract: how the model tells the host which tool to invoke. **MCP** is the system layer contract: how the host actually invokes that tool against an external implementation.
When a model decides to call a tool, it emits a structured tool call object through the provider's API. Anthropic calls these tool_use blocks, OpenAI calls them tool_calls entries, Gemini calls them function_call parts. The structure is guaranteed at the sampling layer, so the host gets a deterministic JSON object it can parse without ambiguity.
The host then needs to fulfill the call. Without MCP, the host has handwritten code for every integration: a custom GitHub client, a custom Slack wrapper, a custom Postgres adapter. With MCP, the host speaks one protocol, JSON-RPC 2.0, to any server that implements it. The server advertises tools, the host routes calls, results flow back as structured content.
The portability argument is the practical anchor. An MCP server written for GitHub works identically in Claude Desktop, Cursor, Cline, VS Code Copilot, and custom runtimes. No rewrites, no bespoke adapters. By 2026, the ecosystem has crossed eight thousand published servers because the write once promise delivers.
The interview one liner: function calling is how the model emits the call; MCP is how the host fulfills it. Modern agents use both on every tool using turn.
Quick reference
TL;DR
Function calling governs LLM to host communication; MCP governs host to tool communication. They are complementary layers, not alternatives.
Imagine ordering food at a restaurant. You tell the waiter what you want by filling out a slip with the dish name and how you want it cooked. That slip is function calling: a standard way for the customer (the model) to communicate an order to the waiter (the host). Now the waiter walks to the kitchen. The kitchen might be in house or it might be an outside caterer. MCP is the standard form the waiter uses to talk to any kitchen, whether it is next door or across town. The waiter still needs the customer's slip to know what to order, and the waiter still needs the kitchen form to actually get food made. Neither replaces the other. They sit on different sides of the waiter, solving different problems. In the AI world, the model fills out the slip (function calling), the host carries it, and the host hands it to the right MCP server (kitchen) to get the actual work done.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Single purpose agent with one hardcoded tool and no plan to add more MCP adds protocol overhead that pays off only when you reuse servers across hosts or models. A single tool agent can call the tool directly without an MCP layer.
Latency sensitive in process tool call where the function lives in the same binary as the host MCP's transport layer (stdio or streamable HTTP) adds milliseconds of overhead. An in process function call has zero protocol cost.
Working with a model that does not support native function calling Without function calling, the LLM to host boundary falls back to regex parsing of free text, which is fragile. MCP alone cannot fix that; you need a function calling capable model on the model side.
Quick scan · 2–4 min
Everything important, quickly.
5 min: name the two boundaries, identify which protocol owns each, walk one turn of a real agent end to end, explain the portability win, and close with the failure mode contrast that proves the layers are distinct.
Real-world examples
Real products, models, and research that use this idea.
1Claude Desktop uses Anthropic tool_use (function calling) on the model side and MCP on the tool side. Adding a new MCP server to the config gives the model access to new tools without any prompt changes.
2Cursor advertises MCP servers as tools to whichever LLM the user selects (Claude, GPT, Gemini, or a local open weight model). Each model uses its own function calling API while the integration layer stays MCP.
3The official MCP servers repo plus the broader ecosystem of over eight thousand servers demonstrates the write once payoff: a server for GitHub, Slack, or Postgres works across every MCP capable host with zero host specific code.
4VS Code Copilot Agents and Cline both consume MCP servers, and developers do not rewrite servers per editor because MCP is the shared integration protocol.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QTrace one turn of a 2026 agent end to end. Where does function calling stop and MCP begin?
Sign in or go Pro to see the approach for this follow-up.
QIf function calling already gives structured JSON, why do we also need MCP?
Sign in or go Pro to see the approach for this follow-up.
QWhat kinds of failures are function calling failures versus MCP failures?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Treating MCP as a replacement for function calling. They solve different problems on opposite sides of the host process and a modern agent depends on both simultaneously.