modelcontextprotocol.io

MCP defines a bidirectional protocol standard that allows AI applications (clients) to discover, invoke, and interact with external tools and data sources (servers) through a USB-C-like standardized interface. The protocol abstracts away implementation details of individual tools, enabling a single client to work with heterogeneous tool ecosystems without custom integration code for each tool. Servers expose capabilities via a registry that clients query to understand available operations, parameters, and schemas.

MCP enables AI applications to both read data from external systems (passive access) and perform actions/mutations (active tool use) through a unified protocol. Servers expose tools as callable operations with defined input schemas and return types; clients invoke these tools with parameters and receive structured results. The framework handles parameter validation, error propagation, and result serialization without requiring the AI application to understand the underlying tool implementation.

MCP abstracts external data sources (databases, file systems, APIs, services like Google Calendar or Notion) as 'resources' that AI applications can query and access. Servers define resources with URIs, metadata, and access patterns; clients can discover available resources, read their contents, and in some cases modify them. The abstraction decouples the AI application from knowing how to authenticate, query, or parse each individual data source — the server handles all integration logic.

MCP clients can query servers to discover what tools and resources are available, along with their input/output schemas, descriptions, and constraints. Servers expose a capability registry that clients use to understand what operations are possible before invoking them. This enables dynamic tool selection, parameter validation, and graceful degradation when tools are unavailable — the AI application can adapt its behavior based on what the server actually exposes.

MCP is designed as a protocol standard that multiple AI clients (Claude, ChatGPT, VS Code, Cursor, custom applications) can implement and use interchangeably. A single MCP server can serve multiple different clients without modification; clients can connect to multiple servers and aggregate their capabilities. This enables an ecosystem where tools and data sources are decoupled from specific AI applications, creating network effects as more clients and servers adopt the standard.

MCP supports both local server connections (running on the same machine as the client, e.g., stdio-based communication) and remote server connections (over network protocols). This enables flexible deployment patterns: developers can run MCP servers locally for development/testing, while production deployments can use remote servers with proper authentication and scaling. The protocol abstracts away transport details, allowing the same server implementation to work in both scenarios.

MCP is positioned as an open-source protocol with example servers and SDKs available for building custom servers. The documentation references 'Example Servers' and 'Example Clients' (not included in provided content) that developers can use as templates. This enables a community-driven ecosystem where developers can build and share MCP servers for various tools and services, similar to how open-source package managers create network effects.

MCP enables building AI agents by composing multiple tools and resources as 'skills' that the agent can invoke. The protocol provides the infrastructure for agents to discover available skills, reason about which skills to use for a given task, invoke them with appropriate parameters, and chain results across multiple skill invocations. This enables complex multi-step workflows where agents can autonomously decide which tools to use and in what order.