Model Context Protocol (MCP)

MCP establishes a clean separation of concerns based on a client-server model. An MCP Host (like Claude Desktop or an IDE) runs an MCP Client, which maintains a persistent connection to an MCP Server. This server exposes specific capabilities—tools, resources, and prompts—through a standardized protocol. This architecture decouples the AI model from the integration logic, allowing any MCP-compliant client to connect to any MCP-compliant server without bespoke code.

• MCP Host: The application that initiates the connection (e.g., Claude Desktop).
• MCP Client: A protocol client running inside the host, managing 1:1 connections with servers.
• MCP Server: A lightweight program that exposes specific capabilities via the standard protocol.

The protocol defines three core primitives that servers can expose to models, each controlled by distinct authorization boundaries. Tools are model-controlled functions that enable the AI to perform actions—like querying a database or sending an email—with human-in-the-loop approval gates. Resources are application-controlled, structured data exposures (files, API responses) that the client can read without model intervention. Prompts are pre-defined, user-selectable templates that standardize common interactions.

• Tools: Model-executable functions with defined input schemas.
• Resources: Structured data exposed via URI schemes like file:// or postgres://.
• Prompts: Reusable templates for consistent model steering.

MCP is designed with a security-first posture that enforces explicit user consent for data access. Unlike traditional API integrations where a model might have unrestricted access, MCP requires servers to declare their capabilities upfront. The host application then enforces human-in-the-loop approval for sensitive operations. This architecture ensures that AI models cannot autonomously exfiltrate data or perform destructive actions. All context exchange happens over JSON-RPC 2.0, a transport-agnostic protocol that supports both stdio (for local processes) and Streamable HTTP (for remote servers).

• User Consent Model: Explicit approval required for tool invocation.
• Capability Declaration: Servers advertise their exact permissions scope.
• Transport Flexibility: Supports local (stdio) and remote (HTTP) connections.

Before MCP, connecting M models to N tools required building and maintaining M×N custom integrations—a brittle, unscalable pattern. Each new model or tool demanded a bespoke connector, leading to fragmented logic and security gaps. MCP collapses this into an M+N architecture: each model speaks the MCP client protocol, and each tool exposes an MCP server. This standardization dramatically reduces engineering overhead and allows organizations to swap models or add tools without rewriting integration code.

• Legacy Pattern: M models × N tools = M×N custom integrations.
• MCP Pattern: M clients + N servers = M+N standardized connections.
• Result: Plug-and-play interoperability across the AI ecosystem.

Anthropic open-sourced the Model Context Protocol under a permissive license, inviting the entire AI industry to adopt and contribute. The specification is hosted at modelcontextprotocol.io with full documentation, SDKs for TypeScript and Python, and a growing registry of pre-built servers. Major tool providers—including Block, Apollo, Replit, and Codeium—have announced support, signaling a convergence toward a shared standard for AI-tool interaction. This open governance model prevents vendor lock-in and accelerates ecosystem growth.

• Open Source: Permissively licensed specification and SDKs.
• Multi-Language SDKs: Official support for TypeScript and Python.
• Industry Adoption: Supported by Block, Apollo, Replit, Codeium, and others.