About Model Context Protocol
MCP is an open protocol that enables seamless integration between AI applications and your tools and data sources.
What is MCP?
Model Context Protocol (MCP) is an open protocol that standardizes how AI applications interact with external systems. It provides a unified interface for connecting AI models to the tools and data they need.
MCP was developed by Anthropic to address the fragmentation in how AI systems are built and integrated with external tools and data sources. It provides a standard way for AI applications to access and interact with various systems, from databases to APIs to local file systems.
By using MCP, developers can build AI applications that can connect to any MCP-compatible server with zero additional work, making it easier to create powerful, context-rich AI applications.
Core Components of MCP
MCP standardizes interactions through three primary interfaces.
Tools are model-controlled functions that allow AI models to take actions, retrieve data, and interact with external systems. The server exposes tools to the client application, and the model within the client application can choose when to invoke these tools.
Examples include:
- Reading data from databases
- Writing to external systems
- Manipulating files
- Calling APIs
Resources are data exposed to the application and are application-controlled. The server can define or create images, text files, JSON, or other data structures and expose them to the client application.
Examples include:
- Static files
- Dynamic resources based on user context
- Structured data like JSON
- Images and other media
Prompts are user-controlled templates for common interactions with the AI model. These are predefined templates that users can invoke to perform specific tasks with the server.
Examples include:
- Slash commands in IDEs
- Document Q&A templates
- Standardized formatting rules
- Task-specific interaction patterns
MCP Architecture
How MCP connects AI applications with external systems.
MCP clients are AI applications that connect to MCP servers to access tools, resources, and prompts. Examples include:
- Claude for Desktop
- Perplexity
- Cursor
- Zed
- Other AI assistants and applications
Once an application is MCP-compatible, it can connect to any MCP server with zero additional work.
MCP servers are wrappers around tools, APIs, and data sources that expose functionality to AI applications through a standardized interface. Examples include:
- GitHub server for repository access
- File system server for local file access
- Database servers for data access
- API gateways for external service access
Servers can be built once and used by any MCP-compatible client.
MCP Client
- Invokes tools
- Queries resources
- Interpolates prompts
MCP Server
- Exposes tools
- Provides resources
- Defines prompts
Advanced MCP Concepts
Explore more advanced features and capabilities of MCP.
In MCP, the client and server distinction is a logical separation, not a physical one. Any application or agent can be both an MCP client and an MCP server, enabling composable architectures.
This allows for the creation of hierarchical systems where:
- A user interacts with an AI assistant (client)
- The assistant connects to specialized agents (servers)
- Those agents connect to other tools and data sources (more servers)
This composability enables complex AI systems where each component specializes in a particular task, creating powerful, modular architectures.