MCP vs Tools: How MCP Differs From Tool Calling

A tool is a function a model can call; MCP is the protocol that finds and runs tools on servers. See how they differ, and MCP tools vs resources.

10 min read

MCP vs Tools: How MCP Differs From Tool Calling

MCP and tools sit at different layers: a tool is a function a large language model can ask to run, described by a name and a JSON Schema, while the Model Context Protocol (MCP) is the open standard an AI application uses to discover tools on external servers at runtime and send each call to the server that runs it. MCP does not replace tool calling; it supplies the tools that tool calling uses.

The MCP vs tools question usually means MCP vs function calling (also called tool calling): the model API feature where an app lists functions in a request and the model returns a structured call for the app to run. Anthropic introduced MCP in November 2024 so hosts such as Claude Desktop and Cursor could share integrations, as the Model Context Protocol overview explains. Bifrost sits on both paths, passing function-calling requests to model providers and adding governed MCP tools to them.

How does MCP differ from tool calling?

MCP differs from tool calling in scope. Tool calling is how a model asks for one function to run; MCP is how an application finds those functions and who runs them. With plain tool calling, the developer writes each tool definition and its handler into the application. With MCP, an MCP server publishes the definitions and executes the calls, and any MCP host can use them.

The model's side does not change. In both cases the model receives tool definitions in its provider's format and returns a tool name plus JSON arguments. MCP changes everything around that step: discovery moves from build time to runtime, and execution and credentials move from application code to a server.

So MCP vs tools is not an either-or: the real choice is between tools inside one application and tools published on a server for many. How MCP compares with a REST API is covered in MCP vs API.

MCP vs tool calling at a glance

MCP and tool calling differ on where tools are defined, who runs them, how they are found and how many applications can use them. The table compares function calling in a model API with remote MCP tools under MCP specification revision 2026-07-28.

DimensionTool calling (function calling)MCP
What it isA feature of a model APIAn open protocol between hosts and servers, built on JSON-RPC 2.0
Where tools are definedIn application code, sent with each requestOn an MCP server, returned by tools/list
When tools are knownAt build timeAt runtime; servers can announce changes with notifications/tools/list_changed
Who runs the callYour application, in its own processThe MCP server, after the client sends tools/call
Schema formatProvider-specific JSON Schema wrapperOne MCP definition the host translates per provider
PortabilityOne integration per application, often per providerOne server works in Claude Desktop, Cursor, VS Code and custom agents
CredentialsHeld by the applicationHeld by the server; remote servers use OAuth 2.1 for authentication
ScopeFunctions onlyTools, plus resources and prompts

How an LLM calls an MCP tool, step by step

An LLM calls an MCP tool through the same function-calling interface it uses for any tool, and the MCP client does the extra work on both sides. The host fetches definitions with tools/list, translates them into the provider's tool format, sends the model's chosen call to the server with tools/call, and returns the result to the model.

Two lanes compare tool calling, where app code defines and runs functions, with MCP, where the client lists server tools and sends the model's call back

Figure 1: MCP changes where tools come from and where calls run; the model's tool-call step is the same.

The host is the AI application, and it runs one MCP client per server. A call moves through six steps:

  1. Discover. The client sends tools/list; the server returns each tool's name, description and input schema.
  2. Translate. The host converts each definition into the provider's tool format, prefixing names with a server identifier to avoid collisions.
  3. Select. The model returns a tool name and arguments, exactly as for a function defined in code.
  4. Approve. The host applies policy; the specification says a human SHOULD be able to deny any invocation.
  5. Invoke. The client sends tools/call to the server that owns the tool.
  6. Return. The server replies with content, optional structuredContent and an isError flag, which the host passes back as a tool result.

Step 3 is plain function calling. Steps 1, 2 and 5 are what MCP adds.

How MCP tool discovery works at runtime

MCP tool discovery is a protocol call, not code. A server with listChanged: true notifies subscribed clients when its tools change, so agents pick up new tools without a redeploy. The list may vary by the authorization on the request, and servers should return it in a deterministic order so provider prompt caches stay valid. MCP tools covers the definition format.

MCP tools vs native LLM tools

Native LLM tools come in two kinds, and MCP tools differ from both. Client tools are functions your application defines and runs. Server tools, such as web search or code execution, are defined and run by the model provider. MCP tools are defined and run by a third party, an MCP server, and usually reach the model as client tools through the host. Anthropic's tool use documentation draws the same line by where code runs.

Tool typeDefined byRuns inExample
Client tool (function calling)Your applicationYour applicationget_order_status in your backend
Provider server toolThe model providerThe provider's infrastructureAnthropic web_search
MCP tool through a hostAn MCP serverThe MCP serverGitHub issue tools, called from Cursor
MCP tool through a provider connectorAn MCP serverThe MCP server, called by the providermcp_servers in the Claude API

Model providers now act as the MCP client themselves. The Claude API's MCP connector, in beta, takes an mcp_servers list per request, supports only tool calls, and reaches only public servers over Streamable HTTP or SSE. OpenAI's Responses API has an mcp tool type with server_url and require_approval, per its remote MCP guide. Either way, the provider's network calls the server and the application never sees tools/call.

"MCP-enabled tools" are services that publish an MCP server, so any host can call them without custom code.

MCP tools vs resources and prompts

MCP tools differ from MCP resources in who decides to use them and whether they change anything. Tools are model-controlled actions that may have side effects. Resources are application-controlled, read-only data identified by a URI. Prompts are user-controlled templates. These are the three server primitives of the Model Context Protocol, each with its own list and fetch methods.

ToolsResourcesPrompts
Controlled byThe modelThe application (host)The user
Identified bynameuri (RFC 3986)name
Discoverytools/listresources/list, resources/templates/listprompts/list
Usetools/call with argumentsresources/readprompts/get with arguments
Side effectsAllowed, described by annotationsNone; the protocol has no write methodNone
ExampleCreate a Jira issueA database schema or a fileA "summarize this incident" template

The resources specification treats resources as context the host loads on its own heuristics or the user's selection. That gives a practical rule: if the model must choose arguments or the operation changes state, make it a tool; if the data can be named by a URI and the host decides when to load it, make it a resource. Many servers expose data both ways, because some clients, such as the Claude MCP connector, support only tools.

When to use MCP vs tool calling

Use plain tool calling when one application owns a small, fixed set of tools that run in its own process. Use MCP when tools should be shared across applications, teams or AI hosts, or owned by another team. Most production agents use both: local functions for app logic and MCP servers for shared systems.

Plain tool calling is the better fit when:

  • The tool is application logic that needs in-process state, such as a cart or a session.
  • Per-call latency matters. In-process tools in the Bifrost tool hosting comparison take about 0.1 ms, against 10-500 ms for an external MCP server.

MCP is the better fit when:

  • The same capability should work in Claude Desktop, Cursor and internal agents without per-host code.
  • Another team or vendor owns the system and should own its schemas and credentials.
  • Access needs central control over who can call which tool, which an MCP gateway provides.

Costs and risks of each approach

In the MCP vs tools comparison, both approaches share one cost, tool definitions sent to the model on every turn. Plain tool calling keeps credentials and execution inside one application. MCP adds a network hop, a server whose tool descriptions the model trusts, and a credential that must represent the right user.

  • Token cost. MCP makes prompts grow faster, because connecting a server adds all of its tools at once. In the Code Mode benchmark, 508 tools across 16 servers used 75.1M input tokens with classic MCP.
  • Tool poisoning. An MCP tool description is text from a server you may not control, placed in the model's context, which is why teams run guardrails on MCP traffic.
  • Authentication. A local function runs under your app's credentials. A remote MCP server is an OAuth 2.1 resource server, and the hard question is whose identity reaches the upstream system, as MCP authentication explains.
  • Execution and audit. With function calling, your code runs and logs every call. MCP calls spread across hosts, some of which run tools automatically, with no single record unless they pass through a shared layer.

MCP and tool calling with Bifrost

Bifrost, the open-source AI gateway built by Maxim AI, handles both halves of the MCP vs tools split. It forwards function-calling requests to 25+ providers through one OpenAI-compatible API and, as an MCP gateway, adds the MCP tools each caller may use next to the application's own tools array.

An application and MCP clients send requests to Bifrost, which injects allowed MCP tools, filters them per key and executes approved calls against MCP servers and model providers

Figure 2: One request carries both your own functions and the MCP tools a key is allowed to use, and Bifrost runs only approved calls.

  • Explicit execution. Tool calls the model returns are suggestions; the application runs approved ones through the tool execution endpoint, and Agent Mode auto-runs only the tools listed in tools_to_auto_execute.
  • Filtering. Tool filtering works per MCP client, per request (x-bf-mcp-include-tools) and per virtual key, and tool names carry their client name as a prefix. Virtual MCPs bundle chosen tools behind one /mcp/<slug> endpoint.
  • Native tools as MCP tools. In the Go SDK, Tool Hosting registers in-process functions in an internal MCP server, so local tools share the same filtering and execution path.
  • Token cost. Code Mode replaces large tool sets with four meta-tools and cut input tokens by 92.8% on that 508-tool run, at the same 100% pass rate.

Claude Desktop and Cursor can also connect to the Bifrost /mcp endpoint and see the same governed tools. To try both paths, start with the gateway quickstart or the open-source repository on GitHub.

Frequently asked questions

When to use MCP vs skill?

Use MCP when an agent needs to read from or act on an external system, and use a skill when it needs instructions for a task. An Agent Skill, in Anthropic's format, is a folder with a SKILL.md file and optional scripts that the agent loads only when a task calls for it. Skills often say which MCP tools to call and in what order, so the two work together.

Why are resources in MCP read only?

Resources are read only because the protocol defines them as context, not actions. The resources specification gives them list, read and subscribe methods but no write method, so anything that changes state must be a tool. That keeps every side effect on the model-controlled path, where hosts show the call and a human can deny it.

How many tools should an MCP have?

MCP sets no limit, and tools/list is paginated. The practical limit is how many tools a model can choose between reliably and what each turn costs, since every exposed definition is sent with each request. A focused server with task-shaped tools works better than one that mirrors every API endpoint, and a gateway can filter tools per caller.

Can you use MCP without function calling?

In practice, no. MCP defines how tools are discovered and invoked, but the decision to call a tool still comes from the model, through its function-calling interface. A model without tool-calling support can use MCP resources and prompts the host inserts into its context, but it cannot choose and call MCP tools.

Is MCP only for Claude?

MCP is not only for Claude. Anthropic created MCP and Claude Desktop was its first host, but the protocol works with any model. Cursor, VS Code, ChatGPT developer mode and many agent frameworks act as MCP hosts, and any model with function calling can use MCP tools through them.

  • mcp vs tools
  • function calling
  • tool calling

[ Keep reading ]

More on MCP Gateway

View all →