Skip to content
Status

Intro to MCP

MCP in AI: meaning, servers, and when to use it

Governing MCP across your organization?

Speakeasy’s AI control plane connects, secures, and observes every agent and MCP server from one entry point, with SSO, RBAC, runtime guardrails, and a full audit trail.

In AI, MCP stands for the Model Context Protocol, the open standard that AI applications use to reach tools and data outside the model. This page answers the questions people ask most often about it: what MCP means, how an MCP server works under the current version of the spec, and whether your project needs it. It also covers MCP vs API and how MCP compares to CLIs, skills, and other agent protocols.

If you’re new to MCP, start with What is MCP?, which explains the problem MCP solves and walks through a real example.

What does MCP mean in AI?

MCP is short for Model Context Protocol. The official documentation describes it as an open-source standard for connecting AI applications to external systems, and compares it to a USB-C port: one connector that works with many devices.

Anthropic created MCP and open-sourced it in November 2024. In December 2025, Anthropic donated the protocol to the Agentic AI Foundation (AAIF), which Anthropic, Block, and OpenAI co-founded as a directed fund under the Linux Foundation. MCP’s governance model stayed the same after the donation, but the protocol is no longer a single vendor’s project.

The design takes some inspiration from the Language Server Protocol (LSP). LSP standardizes how development tools add support for programming languages, and MCP standardizes how AI applications add tools and context.

What is an MCP server and how does it work?

An MCP server is a program that exposes capabilities to AI applications. Common examples connect an agent to a filesystem, a database, GitHub, Slack, or a calendar. The term refers to the program wherever it runs, whether that’s on your laptop or as a remote service.

MCP server architecture and components

MCP has three participants:

  • The host is the AI application, such as Claude Code or VS Code.
  • The client is the connection component inside the host. The host creates one client for each server it connects to.
  • The server is the program that provides tools and data.

Hosts, clients, and servers exchange JSON-RPC 2.0 messages. The protocol has two layers: a data layer that defines the messages and the primitives a server can expose, and a transport layer that carries those messages.

The diagram shows how these parts connect, along with the three core primitives a server exposes, each controlled by a different party.

MCP architecture: host, clients, and serversAn MCP host, which is an AI application such as Claude Code, contains the model and one MCP client for each server it connects to. Client A connects to a local MCP server over stdio. Client B connects to a remote MCP server over Streamable HTTP. Each server exposes tools, resources, and prompts. Tools are functions the AI application can call and are controlled by the model. Resources are data that gives the model context and are controlled by the application. Prompts are reusable templates for interactions and are controlled by the user.MCP ARCHITECTUREOne MCP client for each serverHOSTAI application, such as Claude CodeModelChooses whichtools to callMCP client AMCP client Bstdiostandard input and outputLocal MCP serverRuns as a subprocess and usually serves one clientToolsResourcesPromptsStreamable HTTPHTTP POST, OAuthRemote MCP serverRuns as a service and usually serves many clientsToolsResourcesPromptsWHAT EACH SERVER EXPOSESToolsFunctions the AI application can callControlled by the modelResourcesData that gives the model contextControlled by the applicationPromptsReusable templates for interactionsControlled by the user
MCP architecture: host, clients, and serversAn MCP host, which is an AI application such as Claude Code, contains the model and one MCP client for each server it connects to. Client A connects to a local MCP server over stdio. Client B connects to a remote MCP server over Streamable HTTP. Each server exposes tools, resources, and prompts. Tools are functions the AI application can call and are controlled by the model. Resources are data that gives the model context and are controlled by the application. Prompts are reusable templates for interactions and are controlled by the user.MCP ARCHITECTUREOne MCP clientfor each serverHOSTAI application, such as Claude CodeModelChooses which tools to callMCP client AMCP client Bstdiostdin and stdoutLocal MCPserverSubprocess,usually one clientToolsResourcesPromptsStreamable HTTPHTTP POST, OAuthRemote MCPserverService, usuallymany clientsToolsResourcesPromptsWHAT EACH SERVER EXPOSESToolsControlled by the modelFunctions the AI application can callResourcesControlled by the applicationData that gives the model contextPromptsControlled by the userReusable templates for interactions

The host asks each server what it offers (for example, with tools/list), registers the tools with the model, and routes the model’s tool calls to the right server with tools/call. The spec says a human should stay in the loop and be able to deny a tool call. Core concepts covers each primitive in more depth.

MCP defines two standard transports:

  • stdio: The host launches the server as a local subprocess and exchanges messages over standard input and output. A local server typically serves one client.
  • Streamable HTTP: Every client message is an HTTP POST to a single endpoint, and the server replies with a JSON object or a stream scoped to that request. A remote server typically serves many clients, and MCP recommends OAuth for authentication. Streamable HTTP replaced the original HTTP+SSE transport, which is now deprecated.

What changed in the 2026-07-28 spec

MCP versions are named by date, and the current version, 2026-07-28, changed how the protocol works:

  • MCP is stateless. The initialize handshake is gone. Every request carries its own protocol version and client capabilities, and servers must not rely on state from earlier requests. Protocol-level sessions and the Mcp-Session-Id header were removed.
  • Servers describe themselves on request. Every server must implement server/discover, which returns the protocol versions, capabilities, and identity it supports.
  • Servers no longer send requests to clients. When a server needs more input, it returns a result asking for it, and the client retries the original request with the answer.
  • Some features are deprecated. Roots, Sampling, and Logging still work but are scheduled for removal, and new implementations shouldn’t add them. Deprecated features normally stay in the spec for at least twelve months.
  • Optional features moved into extensions. Tasks is now an official extension. Another notable extension, MCP Apps, lets a tool return an interactive interface that the host renders in a sandboxed frame, and a working group is developing Skills over MCP.

Where MCP is installed and used

Most major AI applications and agent platforms can connect to MCP servers. Each one documents its own setup:

Client
Claude Code
How it uses MCP
Its v2 runtime supports the 2026-07-28 spec. By default, it loads only tool names at session start and searches for full tool definitions when needed.
Claude apps
How it uses MCP
Connect to MCP servers through connectors, with a directory of more than 75 connectors as of December 2025.
ChatGPT
How it uses MCP
Adds custom MCP servers from ChatGPT Plugins. The server needs a public HTTPS endpoint that supports Streamable HTTP, or OpenAI's Secure MCP Tunnel.
OpenAI API
How it uses MCP
The Responses API connects to remote MCP servers through the mcp tool type and asks for approval of each tool call by default.
VS Code with GitHub Copilot
How it uses MCP
Uses MCP tools, resources, prompts, and MCP Apps in chat. Can sandbox local servers on macOS and Linux.
Cursor
How it uses MCP
Supports stdio, Streamable HTTP, and the deprecated SSE transport, plus MCP Apps.
Gemini
How it uses MCP
Gemini CLI supports stdio and HTTP servers. The Gemini API's Interactions API connects to remote servers over Streamable HTTP only.
Ollama
How it uses MCP
Ollama's own docs cover tool calling but not MCP. Third-party clients, such as ollmcp, connect local Ollama models to MCP servers.

To connect a server to one of these clients, see Intro to using MCP servers.

Why use MCP and why it exists

When Anthropic launched MCP, it described the problem as models being isolated from data, trapped behind information silos and legacy systems. Every new data source needed its own custom integration, which made connected AI systems hard to scale.

MCP replaces those one-off integrations with a single protocol. Servers and applications each implement it once, instead of building a custom integration for every pairing. In practice, that gives you three reasons to use it:

  • One integration for many clients. A remote MCP server over Streamable HTTP works with Claude, ChatGPT, Cursor, VS Code, and other MCP clients without separate integrations.
  • Tools the model finds at runtime. The client asks the server which tools exist and lets the model choose, so you don’t hard-code each call.
  • Authorization for agents that act for others. MCP recommends OAuth for remote servers, so an agent acting for a customer or employee can use that person’s own access.

What is MCP? walks through the problem and the benefits for each group in more detail.

MCP vs API, CLI, skills, RAG, A2A, and ACP

MCP is often compared to other parts of the agent stack. Most of these comparisons describe layers that work together rather than alternatives:

Compared to
API
What it is
The interface a service exposes to other software
Relationship to MCP
Complements MCP
CLI
What it is
Command-line tools an agent runs directly
Relationship to MCP
An alternative for single-user setups
Skills
What it is
Instructions that tell an agent how to do a task
Relationship to MCP
Complements MCP
Function calling
What it is
The model capability for invoking a tool
Relationship to MCP
Complements MCP
RAG
What it is
A pattern for retrieving context before the model answers
Relationship to MCP
Complements MCP
A2A
What it is
A protocol for communication between agents
Relationship to MCP
Complements MCP
ACP
What it is
Two protocols with this name, covered below
Relationship to MCP
Complements MCP

MCP vs API

MCP doesn’t replace APIs. An MCP tool can call an API behind the scenes, although some servers don’t use one at all, such as a filesystem server that reads local files directly. The difference is the caller: a developer writes code against an API’s endpoints, while an MCP client asks the server which tools exist at runtime and lets the model choose. One reason to use MCP instead of an API directly is reach: a single MCP server can work with any MCP client that supports its transport.

If your own code decides which endpoint to call, call the API directly. See When to use MCP for the trade-offs and Build tools from OpenAPI to turn an existing API into MCP tools.

MCP vs CLI

Some developers argue that agents should run command-line tools instead of MCP servers (see, for example, MCP is dead. Long live the CLI). In a Scalekit benchmark using GitHub’s MCP server, the CLI was 10 to 32 times cheaper on read-only tasks, mostly because the MCP client loaded all 43 tool schemas upfront. Scalekit attributes that cost to schema loading rather than to the protocol. Its rule of thumb is that a CLI is often enough when you’re the only user, while MCP adds per-user authorization, explicit tool boundaries, and an audit trail when an agent acts for customers or employees. For a fuller framework for choosing between the two, see MCP vs CLI.

MCP vs skills, tools, and agents

  • Skills are folders of instructions (a SKILL.md file) that tell an agent how to do a task. MCP connects the agent to the systems it does the task in, so the two work together. Speakeasy plugins bundle both and assign them to roles. See Skills vs MCP.
  • Tools are what a model invokes through function calling, and MCP is a standard way to supply those tools from external servers.
  • Agents are the AI applications that do the work. In MCP terms, an agent such as Claude Code is the host. See Introduction to AI agents.

MCP vs RAG, A2A, and ACP

  • RAG (retrieval-augmented generation) is a pattern for searching a knowledge base before the model answers. It isn’t a protocol, and an MCP server can offer a RAG search as a tool. See MCP vs RAG and Designing RAG tools.
  • A2A (Agent2Agent) connects agents to other agents, while MCP connects an agent to tools. Google created A2A and donated it to the Linux Foundation, and the project describes the two protocols as complementary.
  • ACP can mean the Agent Client Protocol, which connects code editors to coding agents and reuses MCP’s JSON formats where possible. The other ACP, IBM’s Agent Communication Protocol, merged into A2A in August 2025.

MCP terminology: protocol, gateway, registry, and hub

A few terms come up often when people discuss MCP:

  • Protocol: The MCP specification itself. It defines the JSON-RPC messages and is versioned by date, with 2026-07-28 as the current version.
  • Gateway: An MCP gateway sits between agents and MCP servers and adds authentication, authorization, and inspection to every tool call. See What is an MCP gateway?.
  • Registry: The official MCP Registry is a central list of metadata for publicly available MCP servers. It’s still in preview, holds metadata rather than code, and doesn’t support private servers. It’s designed to feed marketplaces and other aggregators. For internal servers, the docs recommend hosting your own registry. See What is an MCP registry?.
  • Hub: An informal term for directories of MCP servers and for collections of MCP guides like this one.
  • Control plane: An AI control plane is the layer that governs every agent and every system those agents can reach. Speakeasy’s AI control plane includes an MCP gateway alongside identity, policy, and observability. It connects agents to tools, distributes access by team and role, secures data in flight, and records every tool call. See What is an AI control plane?.

Common use cases for MCP servers

The official MCP documentation and client docs describe uses such as these:

  • Personal assistants that work with your Google Calendar and Notion.
  • Coding agents that build a web app from a Figma design, implement features from an issue tracker, or query a database.
  • Enterprise chatbots that answer questions using data from several databases across an organization.
  • Creative tools, such as models that create 3D designs in Blender.

Claude Code’s documentation gives a practical rule: if you keep copying data from another tool into a chat, connect that tool’s MCP server instead. For worked examples, see MCP use cases, including customer support and account management.

Is MCP dead or still relevant today?

MCP is still widely used, although it drew prominent criticism in 2026. A February 2026 post, MCP is dead. Long live the CLI, argues that the protocol adds overhead without real benefit, citing servers that fail to start and repeated sign-ins. Others, summarized in a Milvus post, point to tool schemas that fill the model’s context window.

Even the critics stop short of calling it useless. Its author concedes that MCP might be the right call for tools that have no CLI equivalent, and the Milvus post concludes that MCP isn’t dead but that its scope is narrowing.

The context-window problem is being addressed in clients and gateways rather than by replacing the protocol. Anthropic showed that presenting MCP servers to an agent as code APIs cut one workflow from 150,000 tokens to 2,000, a 98.7% saving. By default, Claude Code searches for tool definitions instead of loading them all upfront, and gateways can put many servers behind a few discovery tools.

Usage has kept growing. From September 16 through October 15, 2026, the official TypeScript SDK recorded about 259 million downloads on npm, and the official Python SDK recorded about 254 million downloads on PyPI, excluding mirrors. These totals were checked on October 20, 2026; the PyPI total sums the daily counts for that period. Downloads include automated installations and do not measure unique users. When the AAIF launched in December 2025, the MCP project’s announcement reported more than 97 million monthly SDK downloads across both, 10,000 active servers, and adoption by ChatGPT, Cursor, Gemini, Microsoft Copilot, and VS Code. The spec also keeps evolving, with the 2026-07-28 revision and a formal deprecation policy. MCP for skeptics answers the most common criticisms.

Should I use MCP for my project?

Use these questions to decide:

  • Is the agent acting for other people? If it acts for customers or employees, use MCP so each person’s access is authorized and recorded.
  • Do you need one integration for many clients? Build a remote MCP server over Streamable HTTP.
  • Are you the only user? For tools that already have a good CLI, a CLI and skills may be enough.
  • Does your code decide what to call? If no model makes the choice, call the API directly.
  • Do agents need to hand work to other agents? Use A2A alongside MCP.

Whichever you choose, treat MCP servers as code that runs with your data. Claude Code and OpenAI both warn that untrusted servers can carry prompt injection. The spec says MCP can’t enforce security at the protocol level, so implementers should build consent and authorization flows. Organizations that run many servers can handle this centrally with an MCP gateway. When to use MCP covers the decision in more detail.

Where to find MCP resources and the MCP website

The official MCP website is modelcontextprotocol.io. It hosts the MCP specification (2026-07-28) and its changelog, the MCP SDKs, and the MCP Registry of public servers.

This hub covers the next steps:

Related protocols and formats have their own sites: A2A, Agent Skills, and the Agent Client Protocol.