Definition
The Model Context Protocol (MCP) is an open standard interface that enables Large Language Models (LLMs) to securely and consistently access external data sources, tools, and capabilities. It establishes a standardized communication layer between AI applications and various context providers, serving as the “USB-C” for AI systems.
Key Components
Architecture
MCP follows a client-server architecture:
- MCP Hosts: Applications where users or AI systems interact (e.g., Claude Desktop, IDE plugins)
- MCP Clients: Components within host applications that handle communication with servers
- MCP Servers: Lightweight programs exposing specific capabilities (file access, database connections, API access) through the standardized MCP interface
- Data Sources: Local or remote information repositories that MCP servers can securely access
Core Primitives
MCP defines three fundamental primitives that form the building blocks of the protocol:
1. Resources
Resources represent data and content that MCP servers make available to LLMs.
- Characteristics: Application-controlled, identified by unique URIs
- Data Types: Text (UTF-8 encoded) or Binary (Base64 encoded)
- Discovery Methods: Direct listing or templates for dynamic resource requests
- Operations: Reading content, receiving updates
Example use case: An MCP server exposing a log file as a resource with URI file:///logs/app.log
2. Prompts
Prompts are predefined templates or workflows that servers offer to guide LLM interactions.
- Characteristics: User-triggered, often appearing as slash commands
- Structure: Unique name, description, optional arguments
- Capabilities: Accept customization arguments, incorporate resource context, define multi-step interactions
- Operations: Discovery through listing, execution by request
Example use case: A git commit message generator prompt that accepts code changes as input
3. Tools
Tools expose executable functions that LLMs can invoke (usually with user approval) to perform actions.
- Characteristics: Model-controlled, requiring well-defined input schemas
- Annotations: Include hints about behavior (read-only, destructive, idempotent, open-world)
- Security Features: Input validation, access control, clear user warnings
- Operations: Discovery through listing, execution through calls with parameters
Example use case: A calculator tool that performs mathematical operations on model-provided inputs
Importance and Benefits
For Developers
- Standardized Integration: Connect AI applications to diverse data sources without custom code for each
- Security Best Practices: Built-in guidelines for safely exposing sensitive information
- Simplified Architecture: Clear separation between AI models and their context sources
For Users and Organizations
- Flexibility: Easier to switch between different LLM providers or host applications
- Interoperability: Reduced vendor lock-in through standardized interfaces
- Enhanced Capabilities: AI systems gain access to more diverse information and action capabilities
Implementation Examples
File Resource Server
typescript// Server exposing a single log file as a resource
const server = new Server({ /* config */ }, { capabilities: { resources: {} } });
// List available resources
server.setRequestHandler(ListResourcesRequestSchema, async () => {
return {
resources: [
{
uri: "file:///logs/app.log",
name: "Application Logs",
mimeType: "text/plain"
}
]
};
});
// Provide resource content
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
if (request.params.uri === "file:///logs/app.log") {
const logContents = await readLogFile();
return {
contents: [{
uri: request.params.uri,
mimeType: "text/plain",
text: logContents
}]
};
}
throw new Error("Resource not found");
});
Calculator Tool Server
typescriptconst server = new Server({ /* config */ }, { capabilities: { tools: {} } });
// List available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [{
name: "calculate_sum",
description: "Add two numbers together",
inputSchema: {
type: "object",
properties: {
a: { type: "number", description: "First number" },
b: { type: "number", description: "Second number" }
},
required: ["a", "b"]
},
annotations: {
title: "Calculate Sum",
readOnlyHint: true,
openWorldHint: false
}
}]
};
});
// Handle tool execution
server.setRequestHandler(CallToolRequestSchema, async (request) => {
if (request.params.name === "calculate_sum") {
try {
const { a, b } = request.params.arguments;
if (typeof a !== 'number' || typeof b !== 'number') {
throw new Error("Invalid input: 'a' and 'b' must be numbers.");
}
const sum = a + b;
return {
content: [{ type: "text", text: String(sum) }]
};
} catch (error: any) {
return {
isError: true,
content: [{ type: "text", text: `Error calculating sum: ${error.message}` }]
};
}
}
throw new Error("Tool not found");
});
Related Concepts
- LLM Function Calling: Model Context Protocol provides a standardized approach to the concept of LLMs invoking functions
- AI Agents: MCP offers a structured way for agent-based AI systems to access tools and information
- AI Plugins: Similar to browser extensions, MCP servers can be thought of as “plugins” that extend AI capabilities
Future Directions
As the AI landscape evolves, MCP is positioned to become increasingly important for:
- Enterprise AI Integration: Connecting corporate knowledge bases, tools, and workflows
- Multi-modal AI: Standardizing access to diverse types of data beyond text
- Collaborative AI Systems: Enabling AI assistants to work together through shared protocols
Summary
Model Context Protocol (MCP) represents a significant step toward standardizing how AI systems interact with external data and capabilities. By providing a common language for these interactions, MCP reduces development complexity, enhances security, and enables more powerful AI applications across diverse environments.
