MCP vs Function Calling: When to Use Which

Use function calling when one process owns the model request and the tool. Use MCP when a second host must call that tool, or the tool needs its own auth, rate limit, and deploy. A ten-line helper that only your agent calls should stay a function. A notes tool that Cursor, Claude, and a second service all call should be an MCP server.

By Tayyab Javed, AI agent developer.

Function calling

On the OpenAI Responses API a tool is a flat object: type, name, description, parameters, and strict. I checked that shape against OpenAI's function-calling guide on October 12, 2026. I did not send it to the API. I did run the dispatcher. It returned Saved: ship it.

const tools = [{
    type: 'function',
    name: 'add-note',
    description: 'Save a note and echo it back',
    parameters: {
        type: 'object',
        properties: {
            text: { type: 'string', description: 'The note to save' }
        },
        required: ['text'],
        additionalProperties: false
    },
    strict: true
}];

function addNote(text) {
    return 'Saved: ' + text;
}

const handlers = {
    'add-note': (args) => addNote(args.text)
};

// Shape of a function_call item on the Responses API.
const call = {
    type: 'function_call',
    name: 'add-note',
    arguments: '{"text":"ship it"}'
};

const output = handlers[call.name](JSON.parse(call.arguments));
// output === 'Saved: ship it'

That handler lives in the same process as the model call. There is no URL, no bearer token, and no second team that can call add-note without copying this file. Anthropic's tool object uses input_schema instead of parameters. The dispatch is the same idea.

The same tool as an MCP server

Register the function once. A host connects, lists tools, and calls one. I ran this on @modelcontextprotocol/server 2.3.1. A tools/call for add-note with {"text":"ship it"} returned a text block Saved: ship it. The wiring around it, including Python, is how to build an MCP server.

import { McpServer } from '@modelcontextprotocol/server';
import * as z from 'zod/v4';

const server = new McpServer({ name: 'notes', version: '1.0.0' });

server.registerTool(
    'add-note',
    {
        description: 'Save a note and echo it back',
        inputSchema: z.object({
            text: z.string().describe('The note to save')
        })
    },
    async ({ text }) => ({
        content: [{ type: 'text', text: 'Saved: ' + text }]
    })
);

This snippet registers the tool. Serving it over stdio or Streamable HTTP is a separate step, covered in the build post and in how to deploy an MCP server. The schema the model sees is generated from the Zod object. You do not hand-write the JSON Schema.

Which one to pick

A function call stays in the process. An MCP call crosses a pipe (stdio) or an HTTP request (Streamable HTTP). Pay that cost when the boundary buys you something: one implementation for several hosts, or a place to put authentication. Skip the server when the only caller is the file next to it.

Schemas travel. The OpenAI object above and the Zod tool describe the same string argument. What does not travel is the running code, the credential, and the deploy. The MCP production guide has the longer version of this table, including LangChain tools. If the surrounding loop is new, start with how to build an AI agent.

Frequently Asked Questions

Conclusion

Function calling is the dispatch. MCP is the shared server. Start with the function. Move the tool to MCP when a second caller shows up, or when the tool is dangerous enough to need its own token check. If you want that boundary drawn for a product that already has users, hire me and we will pick it on one call.