What Is MCP (Model Context Protocol)? A Complete Guide
Model Context Protocol (MCP) is an open standard, introduced by Anthropic in November 2024, that lets AI models connect to external tools, data sources, and APIs through one uniform interface. By May 2026, Claude, ChatGPT, Cursor, Windsurf, VS Code, Zed, and JetBrains support it. AI apps act as hosts running clients, and your integrations run as servers.
What is MCP?
Model Context Protocol (MCP) is an open standard that lets AI models talk to external systems — tools, data sources, prompts, APIs — through a single uniform interface. Anthropic introduced the protocol in November 2024 and by May 2026 it has become the de facto integration layer for AI applications. The full specification lives at modelcontextprotocol.io. Claude, ChatGPT, Cursor, Windsurf, Claude Code, VS Code, Zed, JetBrains, and most major SaaS platforms now ship MCP clients or servers.
Before MCP, every AI vendor had its own way to wire up tools — OpenAI's function calling, Anthropic's tool use, Google's tool calling, custom SDKs, and a long tail of one-off integrations. MCP collapses that into one protocol that works across vendors.
If your goal is less "give a model new tools" and more "trigger a model from existing apps and route its output somewhere," that is the territory of the no-code workflow automation platforms we compared — MCP and those tools solve adjacent problems and increasingly meet in the middle.
If you have ever written glue code to make an AI model "do something in the world" — query a database, call an API, read a file — MCP replaces that with a portable, vendor-neutral interface. It is also the plumbing underneath the agent boom: if you are new to that side of the stack, start with our guide to what agentic AI actually is.
The Mental Model
MCP defines three roles:
- Host — the AI application you interact with (Claude Desktop, Cursor, VS Code, ChatGPT Desktop)
- Client — the protocol layer inside the host that speaks MCP to a server
- Server — the thing that exposes capabilities (your GitHub, your Notion, your local files)
A host can run many clients at once, each connected to a different server. The model never talks to a server directly. The flow is:
- The user prompts the host
- The model decides it wants to invoke a tool
- The host's client forwards the call to the right MCP server
- The server runs the work and returns a result
- The result goes back to the model, which continues the response
This is the same pattern as Language Server Protocol (LSP), which is exactly the analogy the MCP authors used. LSP let any editor talk to any language toolchain; MCP lets any AI host talk to any tool integration.
The Three Primitives
MCP servers expose three kinds of capabilities:
Tools
Functions the model can invoke. Each tool has a name, a natural-language description, and a JSON Schema input. Example: a 'search_notion' tool with a 'query: string' input that returns matching pages. If a tool searches the open web, the backend behind it decides cost and quality; our web search APIs for AI agents comparison prices six of them per 1,000 searches.
Tools are the most-used primitive. Most useful MCP servers expose 2–10 tools.
Resources
Read-only data the model can pull into context. Resources are identified by URIs (custom schemes like 'notion://workspace/page-id'). The model decides whether to read a resource based on the resource's name and description — it does not see resource content unless it asks for it.
Resources are how you give the model "files" without dumping everything into context. For corpora too large to enumerate as resources, most teams pair an MCP server with semantic search backed by one of the options in our vector database showdown.
Prompts
Pre-built prompt templates the user can invoke as slash commands. Example: a '/review-pr <url>' prompt that fills in a template with the PR contents and asks the model to review it.
Prompts are the least-used primitive — most MCP servers in 2026 ship only tools and resources.
A Minimal MCP Server
Here is a 30-line TypeScript MCP server that exposes one tool, 'echo':
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
const server = new Server(
{ name: 'echo', version: '1.0.0' },
{ capabilities: { tools: {} } }
);
server.setRequestHandler(ListToolsRequestSchema, async () => ({
tools: [{
name: 'echo',
description: 'Echo back the input string',
inputSchema: {
type: 'object',
properties: { text: { type: 'string' } },
required: ['text'],
},
}],
}));
server.setRequestHandler(CallToolRequestSchema, async (req) => ({
content: [{ type: 'text', text: `Echo: ${req.params.arguments?.text}` }],
}));
await server.connect(new StdioServerTransport());Save it as 'echo-server.ts', compile with 'tsc', then point Claude Desktop or Cursor at it via the host's config file (typically '~/.config/claude/claude_desktop_config.json'). The next time you prompt the model, the 'echo' tool is available.
How MCP Won the Integration War in 2026
The momentum shift happened in three waves:
Wave 1 (late 2024 — early 2025): Anthropic ships the protocol and reference SDKs. Cursor and Zed integrate within months. The community starts publishing servers for GitHub, Slack, Postgres, and Brave Search.
Wave 2 (mid 2025): Microsoft adds MCP support to GitHub Copilot Workspace and Copilot Studio. OpenAI announces MCP client support in ChatGPT Desktop. Google's Gemini API adds MCP-compatible tool calling.
Wave 3 (early 2026): Every major IDE (VS Code, JetBrains, Cursor, Windsurf, Zed) ships native MCP client support. The MCP server registry grows to thousands of community-maintained servers. SaaS vendors (Notion, Linear, Figma) ship first-party MCP servers as official products.
By May 2026, asking "what protocol should I use to integrate an AI model with my tool" has a single, boring answer: MCP.
For a view of which IDEs use MCP most aggressively, see our Cursor vs Claude Code vs Copilot comparison.
Where MCP Falls Short
The protocol is not perfect, and four limitations come up consistently:
- Discoverability. Finding a trustworthy MCP server for a given tool is still hard. The community registry helps, but quality varies and there is no MCP-equivalent of npm audit yet.
- Long-running tasks. MCP is request/response. Long-running work (a 5-minute deploy, a 20-minute training run) requires polling or a custom progress channel.
- Security model. Servers run with the user's permissions. A malicious server can do anything the user can do. Per-tool approval helps, but supply-chain risk is real.
- Authentication. OAuth flows in MCP clients still feel grafted-on. Most servers ship with API-key auth as a pragmatic compromise.
The MCP working group is iterating on all four — the OAuth flow was meaningfully better in the May 2026 spec revision than in late 2024.
What the Specification Says About Transports and Security
The specification separates what a message means from how it travels, and the transport you pick decides how you secure a server.
Per the transports page, a local server over stdio exchanges newline-delimited messages over the standard streams of a client-launched subprocess. A remote server uses Streamable HTTP, where each message is an HTTP POST to a single MCP endpoint and replies arrive as a JSON object or a request-scoped SSE stream.
Authorization follows the transport. The authorization section says implementations using an HTTP-based transport should conform to it, while implementations using stdio should instead retrieve credentials from the environment. In practice, a local stdio server inherits whatever secrets you place in its environment, and a remote server belongs behind a proper OAuth flow rather than a shared API key.
The specification overview is direct about trust: tools represent arbitrary code execution and must be treated with appropriate caution, and hosts must obtain explicit user consent before invoking any tool. For builders, that means writing tool descriptions that say exactly what a call does, flagging destructive actions clearly, and never relying on the model to ask permission on its own. For users, it means reading the approval prompt rather than clicking through it.
When to Use MCP — and When Not To
Use MCP when:
- You want one integration that works across Claude, ChatGPT, Cursor, and your IDE of choice
- You are building an internal AI tool and want to expose company systems to the model without writing per-vendor glue
- You are publishing an integration for other people to use — MCP is the broadest distribution channel for "AI plugins" in 2026
Skip MCP when:
- You are building a single-vendor product where you control both the model and the integration (just use that vendor's tool-use SDK)
- The integration runs in a browser context — MCP is mostly stdio and server-side
- Your tool needs sub-100ms latency at scale — the protocol's overhead is non-trivial under heavy load
Building Your First MCP Server
The fastest way to get hands-on is the official quickstart (the SDKs live on the modelcontextprotocol GitHub org):
npm install -g @modelcontextprotocol/create-servernpx create-mcp-server my-first-server- Edit the generated 'src/index.ts' to wrap an API you care about
- Build with 'npm run build'
- Add it to your Claude Desktop or Cursor config and restart the host
The cycle from "blank file" to "Claude can call my new tool" is under 10 minutes once you have the SDK installed.
For more on building agent-style tools, see our companion guide on AI agent frameworks compared in May 2026 — MCP is the integration layer underneath most of those frameworks now. Agent memory layers are a fast-growing consumer of MCP tools too: our comparison of Mem0, Letta, Zep, and LangMem covers how those systems plug in.
Conclusion
Model Context Protocol is the boring infrastructure that 2026 needed. It is not glamorous. It is not a model. It does not generate images.
But every interesting AI integration shipped after late 2025 either uses MCP directly or could have been simpler if it did.
If you are starting an AI integration today, default to MCP. If you have legacy integrations using per-vendor tool calling, the migration path is straightforward — wrap each existing integration in a thin MCP server and reuse it across every host. The cost is one afternoon. The payoff is no longer rewriting the same integration for each new AI product your team adopts.
Once your server is running agent-generated code, where it executes becomes the next decision: our comparison of agent sandboxes covers E2B, Daytona, Modal, Vercel and Cloudflare on billing meter and isolation.
Sources
The primary sources this article cites, checked in November 2026:
- introduced the protocol (anthropic.com)
- reference SDKs (github.com)
- Specification overview (Model Context Protocol) (modelcontextprotocol.io)
- Transports overview (Model Context Protocol specification) (modelcontextprotocol.io)
- Authorization (Model Context Protocol specification) (modelcontextprotocol.io)
Key Takeaways
- MCP is an open, vendor-neutral protocol that standardizes how AI models call tools, read resources, and use prompts.
- The AI app is the host; it runs clients that connect to MCP servers, and the model never talks to a server directly.
- Tools are the most-used primitive, and most MCP servers in 2026 ship only tools and resources.
- By May 2026, OpenAI, Google, Microsoft Copilot Studio, Cursor, Windsurf, Zed, and JetBrains all ship MCP support.
- MCP servers run with the user's permissions, so install them only from trusted sources, as you would browser extensions.
- A useful first MCP server takes about 30 lines of TypeScript using the official SDK.
Frequently Asked Questions
Who made MCP, and is it tied to Anthropic?
Anthropic introduced MCP (Model Context Protocol) in November 2024 and authored the initial specification, but it is an open protocol with a vendor-neutral working group. By May 2026, OpenAI, Google, Microsoft, and major IDE vendors including Cursor, Windsurf, Zed, and JetBrains ship MCP support. It is not a Claude-only feature.
How is MCP different from OpenAI function calling?
Function calling is a model-level feature: the model returns a structured request, but developers write their own glue code for dispatching, authentication, and error handling in every integration. MCP standardizes that glue into a portable server interface, so one MCP server works across Claude, ChatGPT, Cursor, Windsurf, and any other MCP-aware host without per-vendor rewrites.
What is the difference between an MCP client and an MCP server?
The host is the AI application, such as Claude Desktop, Cursor, or VS Code. It runs one or more clients, each connected to an MCP server. The server exposes capabilities, like calling your GitHub API or reading your Notion workspace. The model never talks to a server directly; the host's client mediates every call.
Is MCP secure?
The protocol runs JSON-RPC over stdio or Streamable HTTP, but real security depends on the host. MCP servers run with the user's permissions, so a malicious server can do anything the user can. Major hosts now require explicit per-tool approval before a model invokes a server. Treat servers like browser extensions and install only from trusted sources.
How do I build an MCP server?
Pick TypeScript or Python, the most mature runtimes, and install the official SDK. Define each tool with a name, a description, and an input schema, then write its handler. A useful first server is about 30 lines. Add it to your Claude Desktop or Cursor config, restart the host, and the model can call it.
About the Author
Aisha Patel
AI Editorial Desk
AI Editorial Desk · Web3AIBlog
Aisha Patel is a pen name for our AI editorial desk. Posts under this byline are written and reviewed by our team of contributors with backgrounds in machine learning, large language models, AI infrastructure, and applied research. The desk covers frontier model releases, agent architectures, retrieval-augmented generation, on-device inference, and the engineering tradeoffs that matter when shipping AI in production. Every technical claim is verified against primary sources before publication.