MCP vs Function Calling

What Is Function Calling?

Function calling (sometimes called "tool use") is a feature built into AI model APIs that allows a model to request the execution of a predefined function during a conversation. You define a set of functions — their names, descriptions, and input schemas — and pass them alongside your prompt. When the model decides a function is relevant, it returns a structured response indicating which function to call and with what arguments. Your code executes the function and sends the result back to the model.

OpenAI introduced function calling in 2023. Anthropic, Google, and other providers followed with their own implementations under names like "tool use" and "function declarations."

Function calling is genuinely useful. It's the mechanism that lets a model check the weather, look up a customer record, or trigger a workflow — all within a single API call sequence.

The Problem: Every Provider Is Different

Here's the fragmentation issue in concrete terms. Defining a tool for OpenAI looks like this:

json { "type": "function", "function": { "name": "get_weather", "description": "Get current weather for a city", "parameters": { "type": "object", "properties": { "city": { "type": "string" } } } } }

Anthropic's tool use format uses a slightly different structure. Google's Gemini uses function_declarations with its own schema conventions. The concepts are equivalent, but the API contracts are incompatible. If you build an integration against OpenAI's function calling format, it doesn't work with Anthropic's API without modification — and vice versa.

This means every tool you build is tightly coupled to a single AI provider. Want to switch providers or support multiple models? Rewrite your integration layer.

MCP was partly motivated by this exact fragmentation problem.

What MCP Does Differently

MCP is a protocol between systems, not a feature within a single API.

Instead of defining tools inside an API request, you build a standalone MCP server that exposes those tools. Any MCP-compatible host can connect to your server — regardless of which underlying AI model it uses.

The key difference:

| | Function Calling | MCP | |---|---|---| | Scope | Single API/provider | Cross-provider protocol | | Portability | Not portable | Write once, use anywhere | | Architecture | Inline with API request | Separate server process | | Reusability | Per-project | Shared across projects/models | | Standardization | Provider-specific | Open standard |

With function calling, your GitHub integration only works with the one provider you built it for. With MCP, your GitHub MCP server works with Claude Desktop, Cursor, a custom Python app, or any other MCP host — including ones built on different underlying models.

When Function Calling Is Still the Right Choice

MCP is not a replacement for function calling in all scenarios. Function calling remains appropriate when:

• You're building a simple, single-model integration. If your product uses exactly one AI provider and you have a small number of tools, function calling is simpler to set up — no separate server process, no transport configuration.
• You're prototyping quickly. Function calling requires less infrastructure overhead. For a proof of concept or internal script, it's often faster to get working.
• You're using a provider that doesn't yet support MCP. Not every provider or SDK supports MCP hosting yet, though adoption is accelerating.
• Your tools are stateless and simple. If you're just wrapping a few API calls with no shared state or complex lifecycle, function calling is sufficient.

When MCP Is the Better Choice

MCP becomes clearly preferable when:

• You want reusable tools across multiple AI models or projects. Build once, use everywhere.
• You're building a production agentic system. MCP is designed for the kind of multi-tool, multi-step workflows that agentic systems require. It handles connection lifecycle, tool discovery, and resource management as first-class concerns.
• Your team works across different AI providers. A shared MCP server is provider-agnostic infrastructure that the whole team benefits from.
• You want to use community-built integrations. The ecosystem of public MCP servers (for GitHub, Slack, databases, browsers, and more) is growing rapidly. Adopting MCP means you can plug in existing servers rather than building from scratch.
• You're thinking about long-term maintainability. Tying your integration layer to a single provider's format is technical debt. MCP abstracts that away.

The Bottom Line

Function calling and MCP are not competing features — they operate at different levels. Function calling is how a model invokes a capability within a single API request. MCP is how a model connects to external systems as a first-class protocol.

For simple use cases, function calling is fine. For anything that needs to be reusable, multi-model, or production-grade, MCP is the better foundation — and the direction the industry is moving.