What is the Model Context Protocol (MCP)?

The problem MCP solves

Even the most capable models are constrained by isolation from the systems where data and functionality actually live. Anthropic's core argument on launch was that every new data source has historically required its own custom integration, making genuinely connected AI systems hard to build and impossible to scale cleanly.

This is often described as the 'M x N' problem: with M AI applications and N tools or data sources, naive integration requires roughly M times N bespoke connectors, each maintained separately. MCP collapses that to M plus N. Each AI app implements the MCP client side once, each tool implements the MCP server side once, and any client can then talk to any server.

The official documentation captures the intent with a hardware analogy: MCP is 'like a USB-C port for AI applications', a single standardised way to connect a model to external systems in place of a tangle of proprietary plugs.

How MCP works

MCP follows a client-server architecture. An MCP host, an AI application such as Claude Desktop, Claude Code, or an IDE, creates one MCP client for each MCP server it connects to, and each client maintains a dedicated connection to its server. An MCP server is simply a program that exposes data or actions; it can run locally on the same machine or remotely.

Communication uses JSON-RPC 2.0 as the underlying message format. The official architecture documentation splits the protocol into two layers: a data layer, which defines the JSON-RPC-based exchange including capability discovery and the core primitives, and a transport layer, which carries those messages. MCP supports a stdio transport for local processes and a streamable HTTP transport for remote servers, with authentication typically handled via OAuth.

In a typical flow, the client discovers what a server offers, lists the available tools, and then calls them. When the model decides to use a tool during a conversation, the host routes the call to the right server, executes it, and returns the structured result to the model as fresh context, giving the model real-time data and the ability to act in the outside world.

Clients, servers, and primitives

The MCP documentation names three participants. The host is the AI application that coordinates one or more clients; a client is the component that maintains a single connection and fetches context; a server is the program that provides that context. Each client-server pair keeps a dedicated connection, so a host running four connectors runs four clients.

Servers expose their capabilities through three core primitives. Tools are executable functions the AI can invoke to perform actions, such as querying a database or calling an API. Resources are data sources that supply context, such as file contents or records. Prompts are reusable templates that structure interactions, such as system prompts or few-shot examples.

The design is dynamic and self-describing. A client sends a list request (for example tools/list) to discover what a server offers, each tool carrying a name, description, and input schema, and can then execute a chosen tool. Because servers can advertise changes, an AI app's set of available capabilities can update at runtime rather than being fixed in advance.

Who backs MCP and how far it has spread

MCP was created and open-sourced by Anthropic, which announced it on 25 November 2024 and published the specification, SDKs in several languages, and a set of reference servers under an open licence. At launch Anthropic also shipped pre-built servers for common systems including Google Drive, Slack, GitHub, Git, Postgres, and Puppeteer.

Crucially, MCP is model-agnostic: nothing in the protocol ties it to Anthropic's models. Support has since broadened across the ecosystem. According to the official documentation, AI assistants including Claude and ChatGPT and development tools including Visual Studio Code and Cursor now support MCP, and a large community of third-party servers has grown up around it.

This cross-vendor uptake is what distinguishes MCP from an ordinary vendor plugin format. That said, adoption figures move quickly and vary by source, so specific claims about the number of servers or companies using it should be checked against current data rather than taken as fixed.

Why MCP matters for AI agents

Agents are only as useful as the tools and data they can reach. Before MCP, giving an agent access to a new system meant writing a bespoke integration for that particular agent and that particular tool, work that did not transfer to the next combination. MCP standardises that layer, so an agent that speaks MCP can immediately use any MCP server anyone has built.

This directly serves the tool-use loop at the heart of agentic AI. An MCP server presents its tools with machine-readable schemas that a model can discover and call, which is exactly what an agent needs to plan and act. In effect, MCP is becoming the connective tissue between the reasoning core of an agent and the external world it operates in.

The practical payoff is reuse and portability: build a capability once as an MCP server and every compliant agent can use it, rather than re-implementing the same connector for each product.

Limitations and open questions

MCP is deliberately narrow. As the documentation states, it focuses solely on the protocol for exchanging context and does not dictate how an AI application uses a model or manages the context it receives. It is plumbing, not intelligence, and it does not by itself make an agent smarter or safer.

Because MCP servers can execute actions and are often connected to sensitive systems, security is a real concern. Connecting an agent to arbitrary third-party servers widens the attack surface, including risks such as prompt injection through tool output and over-broad permissions, which is why authentication, scoping, and trust in server sources matter. The protocol is also still evolving, with the specification and its primitives changing across versions.

It is likewise not the only approach. Other emerging standards address agent-to-agent communication rather than tool access, and MCP coexists with existing function-calling and plugin mechanisms. It is best understood as a widely supported, open interface for context and tools, not a finished or universal solution.

Frequently asked questions

Who created MCP and when?

The Model Context Protocol was created by Anthropic, the company behind Claude, which introduced and open-sourced it on 25 November 2024. Anthropic released the specification, software development kits, and reference server implementations under an open licence, and the protocol is now developed as an open, community-supported standard.

Is MCP an open standard?

Yes. MCP is an open-source standard published by Anthropic with an openly available specification, SDKs, and reference servers. It is model-agnostic, meaning it is not tied to Anthropic's models, and it is supported by a range of clients and servers across the ecosystem, including tools from other vendors such as ChatGPT, VS Code, and Cursor.

What problem does MCP solve?

MCP solves the fragmentation of connecting AI models to external systems, often called the 'M x N' problem: without a standard, M applications and N tools require roughly M times N custom integrations. By defining one common interface, MCP reduces that to M plus N. Anthropic describes it as a 'USB-C port for AI applications', one connector replacing many bespoke ones.

What are MCP tools, resources, and prompts?

These are the three core primitives an MCP server exposes. Tools are executable functions the AI can call to take actions, such as running a query or hitting an API. Resources are data sources that provide context, such as file contents or database records. Prompts are reusable templates, such as system prompts or few-shot examples, that structure how the model is used.

How is MCP related to AI agents?

MCP standardises how an agent connects to the tools and data it needs to act. Agents work by calling tools in a reason-act loop, and an MCP server presents its tools with schemas the model can discover and invoke. Build a capability once as an MCP server and any MCP-compliant agent can use it, making MCP a key piece of connective tissue for agentic AI.

What protocol does MCP use under the hood?

MCP uses JSON-RPC 2.0 as its message format. Its architecture separates a data layer, which defines the JSON-RPC exchange, capability discovery, and primitives, from a transport layer, which carries the messages. Supported transports include stdio for local servers and streamable HTTP for remote servers, with OAuth commonly used for authentication.

Related

Explainers: AI agent, LLM

Glossary: Agentic AI, AI agent

Sources

• Anthropic — Introducing the Model Context Protocol
• Model Context Protocol — Introduction
• Model Context Protocol — Architecture overview
• Wikipedia — Model Context Protocol
• VentureBeat — Anthropic releases Model Context Protocol