Model Context Protocol

Overview

The Model Context Protocol (MCP) is an open standard that lets LLM applications such as ChatGPT and Claude reach into external systems—files, databases, search engines, business tools—to retrieve information and take action. The official MCP documentation defines it as "an open-source standard for connecting AI applications to external systems" and compares it to "a USB-C port for AI applications." Just as USB-C unified how devices connect, MCP standardizes how AI applications connect to the systems around them.

Before MCP, every new data source or tool a model needed required its own bespoke connector. Anthropic framed this as a world where "every new data source requires its own custom implementation"—commonly known as the N×M integration problem, where N models each have to be wired up to M tools one by one. MCP collapses that fragmentation into a single shared protocol, so developers can implement against one standard once rather than maintaining a separate connector per data source.

Host, client, and server

MCP follows a client-host-server design. The architecture documentation describes three key participants:

• MCP host: the AI application where the language model runs. Tools like Claude Desktop, Claude Code, and VS Code act as hosts, coordinating and managing one or more MCP clients.
• MCP client: the connector component, living inside the host, that maintains a link to an MCP server. The host creates one dedicated client per server, and each client holds a one-to-one connection with its server.
• MCP server: a standalone program that supplies context—data and capabilities—to the client. It can run locally or remotely.

For instance, when VS Code acts as the host and connects to an MCP server like Sentry, the runtime creates a single MCP client object that maintains the connection to that server. Connecting next to a local filesystem server spins up another client object. Keeping a separate client per server in this way draws clear security boundaries and isolates concerns.

Operational layers and primitives

MCP is built from two layers. The data layer is the client-server communication protocol, based on JSON-RPC 2.0; it handles lifecycle management—initializing and closing connections—and defines the core primitives. The transport layer handles the actual communication channel and authentication, supporting stdio transport for local inter-process communication and Streamable HTTP transport for remote communication.

The most important concept in MCP is the primitive, which defines what clients and servers can offer one another. Servers can expose three core primitives:

• Tools: executable functions the AI can invoke to perform work—for example, file operations, API calls, or database queries.
• Resources: data sources that supply contextual information to the AI, such as file contents, database records, or API responses.
• Prompts: reusable templates that structure how the model is engaged, such as system prompts or few-shot examples.

Clients can expose primitives in turn. The most notable is sampling, which lets a server ask the host's LLM for a completion—giving the server access to a model without bundling its own language-model SDK. Beyond that, elicitation requests additional information from the user, and logging supports debugging. Each primitive comes with discovery (*/list), retrieval (*/get), and execution (tools/call) methods.

The example below shows a JSON-RPC 2.0 request and response for a client querying the available tools.

// Request: list the available tools
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/list"
}

// Response (excerpt)
{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "tools": [
      {
        "name": "weather_current",
        "title": "Weather Information",
        "description": "Get current weather information for any location",
        "inputSchema": {
          "type": "object",
          "properties": {
            "location": { "type": "string" }
          },
          "required": ["location"]
        }
      }
    ]
  }
}

Significance and evidence

On November 25, 2024, Anthropic announced MCP on its official blog as "an open standard that enables developers to build secure, two-way connections between their data sources and AI-powered tools." The launch shipped alongside the MCP specification and SDK, local MCP server support in the Claude Desktop app, and an open-source repository of MCP servers. Anthropic also provided pre-built MCP servers for widely used systems including Google Drive, Slack, GitHub, Git, Postgres, and Puppeteer.

The announcement cited Block and Apollo among early adopters, and noted that development tools such as Zed, Replit, Codeium, and Sourcegraph were working to integrate MCP into their platforms. As of the current official documentation, a broad ecosystem of clients and servers—AI assistants like Claude and ChatGPT, development tools like VS Code and Cursor—supports MCP, with the goal of "build once, integrate everywhere."

From a GEO and AI-search standpoint, MCP matters because it opens a standardized path for generative AI to reach live external data and tools rather than relying solely on pre-trained knowledge. Since the data sources and tools an AI application connects to determine the grounding and scope of its answers, MCP is establishing itself as a key interface through which LLM-based agents pull in external context.

Sources

• Anthropic, "Introducing the Model Context Protocol" (2024-11-25)
• Model Context Protocol — What is MCP? (modelcontextprotocol.io)
• Model Context Protocol — Architecture overview
• JSON-RPC 2.0 Specification