The Model Context Protocol (MCP) is an open standard for connecting AI assistants to external tools, APIs, and data sources in a structured, interoperable way. It was designed to solve a fragmentation problem: every AI application was building its own custom integrations, with no shared standards for how models should communicate with tools.
The problem before MCP
Before MCP, integrating an AI assistant with external systems required writing custom code for each integration. Want your AI to read from a database? Write a custom function. Want it to search Slack? Write another custom function. Want to use that same integration with a different AI system? Rewrite it.
This was manageable at small scale but became a maintenance burden as AI systems proliferated. The same integrations were being rebuilt repeatedly, with no standardization of how tools advertised their capabilities or how models called them.
What MCP defines
MCP is a client-server protocol. It defines:
Servers: Systems that expose tools and resources. A server might expose a set of database query functions, or file system operations, or API calls. Each server advertises what it can do — its tools, their parameters, and their descriptions.
Clients: AI assistants or applications that connect to servers and use their capabilities. The client handles the conversation with the user and calls tools on servers as needed.
Resources: Data that servers can expose to clients (files, database records, etc.)
Prompts: Reusable prompt templates that servers can provide to clients
Tools: Functions that clients can invoke on servers
The protocol runs over standard transports — typically stdin/stdout for local processes or HTTP/SSE for remote servers.
How a tool call works
When a model needs to use a tool:
- The client sends a
tools/listrequest to the server to discover available tools - The server responds with tool definitions (name, description, parameter schema)
- The client includes these definitions in the model's context
- The model generates a tool call with the appropriate arguments
- The client sends the tool call to the server via
tools/call - The server executes the tool and returns the result
- The client includes the result in the conversation
This is conceptually similar to OpenAI's function calling, but MCP standardizes the server side — any MCP-compatible client can work with any MCP-compatible server.
Why interoperability matters
The value of a standard protocol is that it creates a shared ecosystem. Once you build an MCP server for your database, any MCP-compatible AI assistant can use it — not just one specific product.
This is analogous to how REST APIs became the standard way to expose web services: instead of each company building proprietary integrations, they exposed standard HTTP endpoints that any client could call.
MCP aims to do the same for AI tool access.
Local and remote servers
MCP supports two types of servers:
Local servers: Run as subprocesses on the user's machine. Suitable for file system access, local databases, command-line tools. Fast, private, no network required.
Remote servers: Hosted services accessible over HTTP. Suitable for cloud APIs, shared services, any resource that needs to be accessed from multiple machines.
Clients can connect to multiple servers simultaneously, combining local and remote resources.
Current adoption
MCP was released by Anthropic in late 2024 and has seen growing adoption from both AI providers and tool developers. The ecosystem includes servers for file systems, GitHub, databases like Postgres and SQLite, search engines, code execution environments, and many other services.
The open nature of the protocol means the community can build and share servers independently of any AI company.
Limitations
MCP is a protocol, not a complete agent framework. It handles how tools are discovered and called, but not:
- How agents plan across multiple tool calls
- Security and authorization (still the responsibility of individual servers)
- Performance optimization for high-throughput scenarios
These are areas of ongoing development.
Summary
The Model Context Protocol is a standardized way for AI assistants to discover and use external tools and data sources. By defining a shared protocol for tool exposure and invocation, it reduces the fragmentation of AI integrations and enables AI capabilities to be combined more flexibly. It runs over standard transports and supports both local and remote servers.