The Model Context Protocol (MCP) is an open standard introduced by Anthropic in November 2024 that defines how AI systems—particularly large language models—connect to external tools, data sources, and services through a unified client-server protocol. Think of it as the “USB-C for AI”: a single, standardized interface that replaces the tangled web of custom integrations that previously plagued AI application development.
Before MCP, every AI application that needed to access a database, call an API, or read from a file system required a bespoke connector. If you had N AI applications and M data sources, you needed up to N×M custom integrations—an unsustainable scaling problem. MCP collapses this into an N+M problem: each AI host implements one MCP client, each data source implements one MCP server, and they all interoperate through the shared protocol.
MCP’s adoption has been remarkably rapid. OpenAI adopted it in March 2025, and by December 2025, Anthropic donated the protocol to the Agentic AI Foundation (AAIF) under the Linux Foundation, co-founded with Block and OpenAI. In 2026, every major AI provider supports MCP, making it one of the fastest-adopted infrastructure standards in the AI ecosystem.
MCP’s architecture consists of three layers that work together to bridge AI models and external capabilities:
The AI application or environment (e.g., Claude Desktop, an AI-powered IDE, a chatbot) where the LLM runs and the user interacts. The host manages one or more MCP client instances.
A protocol-aware component inside the host that maintains a 1:1 connection with a specific MCP server. It translates the LLM’s requests into MCP protocol messages and converts server responses back for the model to consume.
A lightweight service that exposes specific capabilities—tools, resources, and prompts—to AI clients. Each server typically wraps one external system (a database, API, file system, or web service) and presents it through the standardized MCP interface.
This separation of concerns means the LLM never directly touches external systems. The client mediates all interactions, enforcing security boundaries and protocol compliance.
MCP reuses the message-flow ideas from the Language Server Protocol (LSP)—the same standard that powers code intelligence in editors like VS Code. All messages are encoded as JSON-RPC 2.0, providing a well-understood, battle-tested format for request-response and notification patterns.
A typical message flow looks like this:
MCP defines two standard transport mechanisms for client-server communication:
stdio (Standard I/O): Designed for local connections where the MCP server runs as a child process on the same machine. The client spawns the server process and communicates through standard input/output streams. This is the simplest transport—no networking, no authentication overhead—ideal for development and local tool integration.
Streamable HTTP: Introduced in March 2025 as the standard for remote MCP connections, replacing the earlier SSE-based transport. It uses a single HTTP endpoint that supports both POST (for sending JSON-RPC messages) and GET (for establishing optional Server-Sent Events streams for server-initiated messages). This transport supports bidirectional communication over standard HTTP infrastructure.
// Example: MCP message over Streamable HTTP
POST /mcp HTTP/1.1
Content-Type: application/json
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "query_database",
"arguments": {
"sql": "SELECT * FROM users WHERE active = true"
}
}
}MCP servers expose capabilities through three primitive types:
When a client connects to a server, they perform a capability negotiation handshake. The server advertises what it supports (which tools, resources, and prompts are available), and the client confirms what it can consume. This allows both sides to evolve independently—a server can add new tools without breaking existing clients that don’t know about them.
Code editors like Cursor, VS Code with Copilot, and Windsurf use MCP to give AI assistants access to project files, terminal output, documentation, and external services. A single MCP server for GitHub lets the AI read issues, create pull requests, and review code—without the IDE needing to implement GitHub-specific logic.
Organizations deploy MCP servers that wrap internal databases, CRM systems, knowledge bases, and monitoring dashboards. An AI assistant can query Salesforce data, check Grafana metrics, and search Confluence docs—all through the same protocol. This dramatically reduces the integration burden for enterprise AI rollouts.
In multi-step agent systems, MCP provides a standardized way for agents to discover and use tools at runtime. An agent can enumerate available MCP servers, inspect their tool schemas, and dynamically decide which tools to invoke based on the task at hand. This is foundational for building flexible, composable AI agent architectures.
Because MCP is vendor-neutral, the same MCP server works with Claude, ChatGPT, Gemini, or any other MCP-compatible host. A company can build one MCP server for their internal tools and immediately make it available to any AI platform their team uses.
stdio for local connections and Streamable HTTP for remote connections.