What Is MCP? Model Context Protocol Explained

MCP, short for Model Context Protocol, is an open standard that defines how AI language models connect to external tools, data sources, and services. It was introduced by Anthropic in November 2024 and has since become the de facto interface layer for AI tool connectivity, adopted by every major AI vendor including OpenAI, Google, Microsoft, and AWS. As of early 2026, the MCP ecosystem counts over 10,000 public server implementations and 97 million monthly SDK downloads.

The short definition: MCP is to AI agents what USB-C is to hardware. Instead of every application building a bespoke integration with every data source, both sides implement a single, agreed-upon protocol and interoperate out of the box.

The problem MCP solves

Before MCP, connecting an AI assistant to a database, a code editor, or a SaaS API required custom glue code for each pair. An AI coding tool that wanted to read your filesystem, query GitHub, and look up documentation would need three separate, hand-rolled integrations. Multiply that by the number of models and the number of tools on the market and you get an N-times-M integration problem that no team can maintain.

MCP collapses that into a 1-to-1 contract: any host that speaks MCP can connect to any server that speaks MCP, with no extra code on either side.

The architecture: hosts, clients, and servers

MCP separates the world into three roles.

MCP hosts are the AI-powered applications the user runs: a coding assistant, a chat interface, an autonomous agent, a notebook. The host is responsible for the user experience and for deciding which MCP servers to connect to.

MCP clients are the connection managers embedded inside a host. Each client opens and maintains exactly one two-way JSON-RPC 2.0 connection to one MCP server. A single host typically runs several clients in parallel, one per server. Clients handle the transport layer (local stdio for same-machine servers, or Streamable HTTP for remote ones) and translate the model's intent into protocol-level requests.

MCP servers are the capability providers. Each server exposes one or more of three primitive types:

Tools (functions the model can call, like search_web or create_issue)
Resources (readable data the model can consume, like a file, a database row, or an API response)
Prompts (reusable instruction templates the host can inject into context)

The model itself never connects directly to a server. It makes a request, the client routes it, the server executes, and the result comes back as context. The model is always one layer removed from the actual I/O.

What an MCP gateway is

A gateway sits between a set of MCP clients and a set of MCP servers. From the outside it looks like a single MCP server; from the inside it fans requests out to multiple upstream servers, applies authentication, enforces rate limits, and aggregates the results. Gateways matter for enterprises that need centralized governance over which tools an agent can reach and what data it can read. They also simplify client configuration: instead of registering twenty servers, a client registers one gateway.

MCP clients in practice

Several widely used developer tools already function as full MCP clients.

Cursor was one of the earliest adopters and lets you configure MCP servers directly in its settings file, giving the AI coding assistant access to any tool you expose.

Cline, the open-source VS Code extension, supports MCP natively and ships with a built-in server marketplace so you can add capabilities without writing any configuration.

Windsurf from Codeium embeds MCP client support in its agentic "Flow" feature, allowing the editor's AI to call external tools mid-task without leaving the IDE.

Zed, the high-performance collaborative editor, added MCP support as part of its AI assistant rollout, making it straightforward to connect any MCP-compatible tool to the editor context.

LibreChat brings MCP to the chat interface archetype: the self-hosted, multi-model chat application supports MCP servers so users can equip any connected model with external tools from a single configuration.

The transport layer

MCP uses JSON-RPC 2.0 as its message format. Two transports are supported:

Stdio for local servers running on the same machine as the client (the host spawns a subprocess and communicates over stdin/stdout).
Streamable HTTP for remote servers, which replaced Server-Sent Events as the recommended remote transport in the March 2025 spec update. Remote MCP servers authenticate using OAuth 2.1, standardized in the June 2025 specification.

The design is deliberately transport-agnostic. If a new transport (WebSockets, gRPC) proves more practical for a use case, the spec can accommodate it without changing the message schema.

Governance and standardization

In December 2025, Anthropic donated MCP to the Agentic AI Foundation (AAIF), a directed fund within the Linux Foundation co-founded by Anthropic, Block, and OpenAI. This move shifted governance from a single vendor to a multi-stakeholder body, which accelerated enterprise adoption significantly in Q1 2026. The protocol is now vendor-neutral in the same way HTTP and OAuth are vendor-neutral.

The core primitives, summarized

Primitive	What it is	Example
Tool	A callable function	`run_query(sql)`
Resource	A readable data object	`file://project/README.md`
Prompt	A reusable instruction template	"Summarize this PR in three bullets"
Sampling	A request from server to client to generate text	Server asks the model to draft an email

Sampling is the fourth primitive, less commonly discussed: it lets MCP servers ask the host to run an inference call, enabling server-side orchestration patterns without the server needing direct model access.

How to start using MCP

If you are a user, the fastest path is to open an MCP-capable editor such as Cursor, Cline, or Windsurf, find a server for a tool you already use (GitHub, Notion, PostgreSQL, and Slack all publish official servers), add its configuration entry, and restart the client. The AI will immediately be able to call that tool.

If you are a developer building an MCP server, Anthropic maintains official SDKs for TypeScript and Python. A minimal server that exposes one tool is around 30 lines of code. The server declares its capabilities at startup; the client discovers them via a tools/list call and presents them to the model as available functions.

If you are building enterprise infrastructure, the pattern is to deploy an MCP gateway in front of your internal servers, enforce OAuth 2.1 for all connections, and let individual teams register their own servers behind the gateway without needing to reconfigure every client.

Why this matters for AI agents

Autonomous agents need reliable, structured access to the outside world. Without a standard like MCP, every agent framework re-invents tool calling in an incompatible way, which fragments the ecosystem and makes it hard to reuse servers across platforms. MCP gives agents a stable interface contract: a server built for Cursor today also works in LibreChat tomorrow, with no changes required.

The protocol's design also enforces a clean separation between the model (which reasons) and the tools (which act). The model never holds credentials, never opens a socket directly, and never executes code without going through the client-server layer. That separation is what makes MCP safe to deploy in enterprise environments where audit trails and access controls are non-negotiable.

Learn more

Best MCP clients for a curated list of applications that support the protocol
Best MCP gateways if you are evaluating enterprise gateway options
Free MCP servers for a practical list of open-source servers you can start using today

What Is MCP (Model Context Protocol)?