MCP vs function calling vs plugins: which to use

1// OpenAI function calling example
2const response = await openai.chat.completions.create({
3  model: "gpt-4o",
4  messages: [{ role: "user", content: "What is the weather in Tokyo?" }],
5  tools: [{
6    type: "function",
7    function: {
8      name: "get_weather",
9      description: "Get weather for a city",
10      parameters: {
11        type: "object",
12        properties: {
13          city: { type: "string", description: "City name" }
14        },
15        required: ["city"]
16      }
17    }
18  }]
19});
20// Model returns: tool_calls: [{ function: { name: 'get_weather', arguments: '{"city":"Tokyo"}' } }]
21// YOU execute the function and send the result back

1// MCP server (runs as a persistent process)
2import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
3import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
4import { z } from "zod";
5
6const server = new McpServer({ name: "weather", version: "1.0.0" });
7
8server.tool(
9  "get_weather",
10  "Get weather for a city",
11  { city: z.string() },
12  async ({ city }) => ({
13    content: [{ type: "text", text: `Tokyo: 22°C, Clear` }]
14  })
15);
16
17// Server runs persistently, host discovers tools automatically
18// Same server works in Claude Desktop, Cursor, VS Code, OpenAI Agents SDK
19await server.connect(new StdioServerTransport());

1// Comparison matrix:
2//
3// | Feature              | Function Calling    | MCP                  | Plugins (deprecated) |
4// |----------------------|---------------------|----------------------|----------------------|
5// | Scope                | Per API request     | Per session          | Per platform         |
6// | Tool definition      | In API payload      | In server code       | In OpenAPI spec      |
7// | Execution            | Your code           | MCP server process   | Cloud API endpoint   |
8// | Model-agnostic       | No (format varies)  | Yes                  | No (ChatGPT only)    |
9// | Host-agnostic        | N/A                 | Yes (any MCP host)   | No                   |
10// | Runs locally         | Yes                 | Yes (stdio)          | No (cloud required)  |
11// | Persistent connection| No                  | Yes                  | No                   |
12// | Discovery            | Manual per request  | Automatic            | Marketplace          |
13// | Approval required    | No                  | No                   | Yes                  |
14// | Status in 2026       | Active              | Active (growing)     | Deprecated           |

1// How they work together:
2//
3// 1. MCP server exposes tools via protocol
4// 2. Host discovers tools during MCP handshake
5// 3. Host converts tools to model's function calling format
6// 4. Model uses function calling to select a tool
7// 5. Host routes the function call to the MCP server
8// 6. MCP server executes and returns result
9// 7. Host converts result to model's expected format
10// 8. Model incorporates result into its response

1// When to use each:
2//
3// Function Calling:
4// - Building a custom chatbot with OpenAI API
5// - Need different tools per conversation
6// - Want full control over execution flow
7// - Single-model application
8//
9// MCP:
10// - Want tools in Claude Desktop, Cursor, VS Code, etc.
11// - Need persistent tool connections (databases, file systems)
12// - Sharing tools across team members
13// - Building tools for the community
14// - Need model-agnostic tool definitions
15//
16// Both together:
17// - OpenAI Agents SDK + MCP servers
18// - Any MCP host that uses function calling internally