---
title: What is the difference between function calling and MCP?
url: https://opencontroller.lyzr.com/blog/function-calling-vs-mcp
published: 2026-11-17
updated: 2026-11-17
author: Lyzr
---

# What is the difference between function calling and MCP?

**Function calling is a feature of a model API: your application sends tool definitions with the request, and the model replies with a structured request to call one. The Model Context Protocol (MCP) is an open protocol that sits one layer below: it standardises how an application discovers tools from a separate server, calls them, and authorises that connection. In most agents the two work together — MCP supplies the tools, function calling is how the model picks one.**

So MCP is not "just function calling". It answers different questions. That difference matters for governance, because the risks live in different places.

## How does function calling work?

With function calling (also called tool use), the developer writes a JSON Schema for each tool and passes the list in the model request. The model never runs anything. It returns a message that says, in effect, "call `get_invoice` with `{"id": "INV-104"}`". The application code executes the function, then sends the result back to the model in the next turn.

Three things follow from this design:

1. **Tools are defined inside the application.** Each app hard-codes its own tool list and schemas.
2. **The application owns execution and credentials.** Whatever the function does, it does with the app's own access.
3. **There is no discovery.** Adding a tool means changing and redeploying the app.

Each provider has its own request format for this, although they look alike.

## How does MCP work?

MCP separates the tool from the application. An **MCP server** exposes tools (and optionally resources and prompts). An **MCP client**, inside a host such as a chat app, IDE or agent runtime, connects to that server over JSON-RPC 2.0.

- The client calls `tools/list` to discover what the server offers, with names, descriptions and input schemas.
- When the model chooses a tool, the client sends `tools/call` to the server, which runs it and returns the result.
- Transport is either **stdio** (a local process started by the host) or **Streamable HTTP** (a remote server).
- For HTTP servers, the spec defines OAuth-based authorization: the MCP server acts as an OAuth resource server and the client obtains an audience-bound token. See [how MCP authorization works](/blog/how-mcp-authorization-works).

The current specification revision is dated 2026-07-28. It made the protocol stateless and deprecated Dynamic Client Registration in favour of Client ID Metadata Documents.

## Where does each one sit in the stack?

| Layer | Function calling | MCP |
|---|---|---|
| What it standardises | How a model expresses a tool call | How a client discovers, calls and authorises tools on a server |
| Who defines the tools | The app developer, in code | The server publisher, served at runtime |
| Where the tool runs | Inside the application | In the MCP server process (local or remote) |
| Discovery | None; static list per request | `tools/list`, with change notifications |
| Credentials | The app's own | Per-server: environment variables (stdio) or OAuth tokens (HTTP) |
| Portability | Per model provider format | One server works with any MCP-capable host |
| Typical risk | Over-broad functions written by the app team | Third-party code, changing tool descriptions, token handling |

The key point: when an MCP host offers tools to a model, it usually converts the MCP tool list into the provider's function-calling format. Function calling is the model-facing interface; MCP is the tool-facing interface.

## Why does the difference matter for governance?

With plain function calling, the security review is a code review. The tools are in the repository, and they change only when the app is redeployed.

With MCP, three new things arrive:

1. **Tools you did not write.** An MCP server may be published by a vendor, a community member or an internal team. Its code and its tool descriptions are outside the agent team's repository.
2. **Tools that change at runtime.** A server can add or alter tools, and descriptions are read by the model. That creates [tool poisoning](/blog/what-is-mcp-tool-poisoning) and update-drift risks that do not exist with static function definitions.
3. **A new credential path.** Local stdio servers often read API keys from config files. Remote servers hold OAuth tokens that can act for a user.

That is why MCP needs its own inventory, approval and runtime controls, beyond what you already do for application code. The [MCP governance pillar](/blog/how-to-govern-mcp-servers) covers the full model.

## Should you use function calling or MCP?

Use this as a rule of thumb:

1. **One agent, a few internal functions, one team** → function calling is simpler. Nothing to host.
2. **The same tool used by many agents or hosts** → put it behind an MCP server so you write and govern it once.
3. **Third-party SaaS tools** → prefer the vendor's official remote MCP server with OAuth over hand-built functions holding a shared API key.
4. **Developer tools in IDEs and coding agents** → MCP is already the integration path; govern which servers are allowed.
5. **Existing REST APIs** → compare [MCP vs OpenAPI tools](/blog/mcp-vs-openapi-tools-for-internal-apis) before wrapping everything.

Whichever you pick, keep the tool count per agent small. Every tool definition costs tokens on every call; see [the token cost of MCP tool definitions](/blog/token-cost-of-mcp-tool-definitions).

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, so you can see which agents use which tools whether they arrive by function definitions or MCP. Posture flags risky permission and configuration patterns. Opencontroller Edge extends discovery to local MCP servers and coding agents on developer devices. Policies are written as code and can limit which tools each agent may call. See the [capability reference](/capability-reference) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Does MCP replace function calling?**
No. Most MCP hosts translate MCP tools into the model provider's function-calling format. MCP replaces hand-wiring tools into each app, not the model's tool-call mechanism.

**Is MCP only for Anthropic models?**
No. MCP is an open protocol. Any host that implements an MCP client can use MCP servers with any model that supports tool calls.

**Is function calling safer than MCP?**
Not inherently. Function calling keeps tools inside your code, which is easier to review. MCP adds third-party code and runtime changes, so it needs inventory, approval and monitoring. A well-governed MCP server can be safer than an over-broad custom function.

## Key facts

Function calling is a model API feature: the app sends JSON Schema tool definitions and the model returns a structured call that the app executes. MCP (Model Context Protocol) is an open JSON-RPC 2.0 protocol for discovering tools (tools/list) and calling them (tools/call) on a separate server over stdio or Streamable HTTP, with OAuth-based authorization for HTTP. MCP hosts usually convert MCP tools into function-calling format. The current MCP spec revision is 2026-07-28. Opencontroller keeps a governed registry of agents, tools and MCP servers; Opencontroller Edge discovers local MCP servers on developer devices. Licensing starts from $250K per deployment per year.

## Related

- [Should agents call internal APIs through MCP or OpenAPI tools?](https://opencontroller.lyzr.com/blog/mcp-vs-openapi-tools-for-internal-apis.md)
- [How much do MCP tool definitions add to token costs?](https://opencontroller.lyzr.com/blog/token-cost-of-mcp-tool-definitions.md)
- [What is MCP tool poisoning and how do you prevent it?](https://opencontroller.lyzr.com/blog/what-is-mcp-tool-poisoning.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
