Model Context Protocol (MCP)

Model Context Protocol, or MCP, is an emerging standard for connecting models to external tools, data sources, and execution environments. It gives assistants a common way to discover capabilities instead of relying on one-off custom integrations for every app.

If tool calling answers the question "can the model use a function?", MCP answers a broader one: "how do we expose tools and context to models in a consistent, portable way?"

Overview

Without a standard, every AI integration tends to invent its own tool format, auth flow, transport, and discovery mechanism. That makes ecosystems fragmented and difficult to reuse.

MCP creates a shared protocol for:

• listing available tools and resources
• describing what those tools do
• validating inputs and outputs
• connecting over supported transports
• letting clients and assistants interact with those capabilities in a uniform way

Why this matters

MCP is important because it shifts AI integration from bespoke glue code toward reusable interfaces. That makes it easier to plug assistants into IDEs, local tools, databases, internal systems, or SaaS platforms without redesigning the entire integration each time.

MCP vs regular tool calling

These concepts are related, but they are not identical. Tool calling is the model behavior. MCP is one way to provide tools and context in a standardized format.

A simple mental model

You can think of MCP as a protocol layer between AI clients and the systems they want to use. Instead of every client speaking a different dialect, MCP gives them a shared language.

That usually means three actors:

AI SDK example

The AI SDK has support for working with MCP clients and feeding discovered tools into generation. This example shows the general shape without tying it to any specific internal product logic.

import { createMCPClient } from "@ai-sdk/mcp";
import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
import { generateText, stepCountIs } from "ai";
import { openai } from "@ai-sdk/openai";

const transport = new Experimental_StdioMCPTransport({
  command: "node",
  args: ["./server.js"],
});

const client = await createMCPClient({ transport });
const tools = await client.tools();

const result = await generateText({
  model: openai("gpt-4o"),
  tools,
  prompt: "Find products under $100 and summarize the best options.",
  stopWhen: stepCountIs(5),
});

await client.close();

The important idea is that the model does not need hardcoded knowledge of each capability. It can discover and use tools through a consistent protocol.

When MCP is a good fit

MCP is not mandatory for every project. It shines when you want interoperability, reuse, and a cleaner separation between AI clients and backend capabilities.

Design considerations

Even with a protocol, good interface design still matters. MCP does not remove the need for careful tool and resource design.

Where MCP fits in a modern AI stack

MCP is easiest to understand when you place it in the bigger picture. It is not a replacement for models, retrieval, or prompting. It is a way to connect them to external capability surfaces.

Common misconceptions

MCP is powerful, but it helps to be clear about what it does and does not solve. That keeps teams from overcomplicating their architecture too early.

Related documentation

If you are learning this capability for the first time, the most useful follow-up is to pair it with tool calling. MCP becomes much easier to reason about when you already understand how models use tools in practice.

Learn more

These references are the best next stop if you want to understand both the protocol and how it plugs into modern AI tooling.

• Model Context Protocol
• AI SDK MCP tools cookbook
• AI SDK tool calling docs
• TurboStarter AI Tool calling docs