MCP vs function calling: how they differ and fit together

Function calling, also called tool calling, is how a model asks your application to run a function: you describe functions with a JSON schema in the API request, the model replies with a call and its arguments, and your code runs it and sends the result back. MCP is a protocol that puts tools on a server, where any MCP client can discover and call them. They work together: the app connected to an MCP server hands the server's tools to the model as callable tools, so MCP standardizes where tools live and how apps reach them, while the model still decides when to call one.

Function calling is described from OpenAI's function calling guide and Anthropic's tool use overview; MCP from its Architecture overview and Understanding MCP servers. All were read on 2026-09-28. The Sume example comes from its MCP overview and MCP tools and gates.

What is the difference between MCP and function calling?

Function calling is a model feature you use inside one application; MCP is a protocol between applications and tool servers. Side by side:

How does function calling work?

OpenAI's guide lists five steps, and Anthropic's round trip has the same shape, with a tool_use block from the model and a tool_result from your code:

• Send the model a request with the tools it could call.
• Receive a tool call from the model.
• Run the code on your side with the call's input.
• Send the model a second request with the tool output.
• Receive the final answer, or more tool calls.

How does MCP use function calling?

Through the host application. It fetches the tools from every connected MCP server and combines them into one registry the model can access. When the model decides to call one, the app intercepts the call, routes it to the right server, and returns the result to the model. MCP's docs say the protocol covers context exchange only and doesn't dictate how applications use the LLM.

Some model APIs make the connection for you. OpenAI lists access to an MCP server among its built-in tools, and Anthropic's MCP connector reaches remote MCP servers from the Messages API without a separate MCP client. How each one works with Sume is covered in OpenAI Responses API MCP tool and Claude API MCP connector with Sume.

When should I use MCP instead of my own functions?

• Define your own functions when the tool belongs to your application: your code runs it, you own its schema, and one app uses it.
• Use MCP when the tools already live on a server, or several apps should share them. Any MCP client can discover them, and MCP's docs pitch it as a way to build once and integrate everywhere.
• In both, the model sees each tool's name, description, and input schema, so write the description with care. OpenAI describes a function's description as details on when and how to use it, and Anthropic says Claude decides when to call a tool based on the user's request and the tool's description.

What does this look like with Sume?

Both routes work. With function calling, you define a function that calls Sume's Developer API at https://api.sume.com/v1, such as `POST /v1/videos`, and run it on your backend, which attaches the API key as Sume's Authentication page says. Vercel AI SDK: generate video with a Sume API tool call shows one. With MCP, you connect a client to Sume's hosted server at https://mcp.sume.com/mcp, and it loads Sume's tools, such as generate_video and jobs_wait, without you wrapping the HTTP API.

The two surfaces differ: hosted MCP tools wrap selected API capabilities and are not full parity with the HTTP API. Sume's basics page says hosted MCP still works but is not part of the primary path today; MCP vs CLI vs API for AI agents compares the options.