Your colleague says MCP and function calling do the same thing. Where are they wrong?

MCQ·Easy·4.0 · 0·~1 min·Relevant atAnthropic OpenAI

Attempt it

**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.

Memory aid

Easy to grasp

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.

Key concepts

Function Calling Host-to-Tool Boundary Tool Portability

Detailed answer & concept explanation

~7 min read

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.

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.

Claude 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.
Cursor 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.
The 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.
VS 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?

QIf function calling already gives structured JSON, why do we also need MCP?

QWhat kinds of failures are function calling failures versus MCP failures?

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.

60-second cheat sheet

The night-before-the-interview bullets. Scan these on the way to the call.

References

Primary sources. Skim if you want the original framing.