The Model Context Protocol (MCP) is an open standard that defines how AI applications connect to external tools, data sources and services. It was introduced by the AI company Anthropic in November 2024 [1]. Rather than writing a separate custom integration for every combination of application and data source, developers implement the protocol once on each side, and any compatible client can then talk to any compatible server.
Overview
A language model on its own can only work with the text it is given. To be useful in real settings, it needs access to files, databases, calendars, code repositories and business systems. Before MCP, each AI product usually built its own connectors, and each connector had to be maintained separately. The result was a large number of one-off integrations.
MCP addresses this with a shared protocol. The comparison often made is to a universal port: any device that follows the standard can plug in. The aim is to reduce duplicated work and to let tools built once be used across many AI applications.
Architecture
The protocol uses three main roles, described in the official specification [2].
- Host. The AI application the user interacts with, such as a chat assistant or a coding tool. The host manages connections and decides what the model may do.
- Client. A component inside the host that keeps a one-to-one connection with a single server.
- Server. A program that exposes capabilities to the client. It may run on the user’s machine or on a remote system.
Messages between clients and servers use JSON-RPC 2.0, a lightweight remote procedure call format [2]. The protocol defines how a connection is opened, how the two sides agree on supported features, and how requests and responses are exchanged. Servers can be reached over standard input and output for local programs, or over HTTP-based transports for remote ones.
What a server can offer
An MCP server can expose three main kinds of capability [2].
- Tools. Functions the model can ask to run, such as searching a database, creating a file or sending a message. This is closely related to tool calling and function calling.
- Resources. Data the application can read and place in the model’s context, such as documents, records or log files.
- Prompts. Reusable templates that help users start common tasks in a consistent way. See also prompt templates.
Clients can also offer capabilities back to servers. For example, a server may ask the host to run a model completion on its behalf, which the host can approve or refuse.
How a typical interaction works
- The host starts and connects a client to each configured server.
- The client and server exchange information about the protocol version and the features each supports.
- The client asks the server to list its tools, resources and prompts.
- The host passes the tool descriptions to the model as part of its context window.
- When the model decides a tool is needed, it produces a structured request. The host, often after asking the user for approval, sends the call to the server.
- The server runs the operation and returns a result, which is added to the model’s context for the next step.
This loop lets an assistant perform multi-step work, such as reading a file, querying a database and writing a summary, using tools provided by separate servers.
Applications
- Coding assistants. Tools that read a repository, run tests or query documentation through servers.
- Enterprise assistants. Access to internal knowledge bases, ticketing systems and shared drives, supporting retrieval-augmented generation.
- Data analysis. Connecting a model to databases or spreadsheets so it can fetch current figures instead of relying on memory.
- Content and web management. Servers that expose the functions of a content management system so an assistant can create or edit pages.
- Agents. MCP is widely used as a way to give an AI agent a controlled set of actions in agentic AI systems.
Ecosystem and adoption
After its release, the protocol was supported by a growing number of developer tools and AI products, and developers published many open-source servers for common services. Software development kits are available in several programming languages. Because the specification is public, anyone can build a client or server, and the protocol has gone through revisions that added features such as remote server support and authorization. Readers should check the official specification for the current version, since the details continue to change.
Security considerations
Connecting a model to tools raises real security questions, and the specification itself discusses them [2].
- Prompt injection. Text returned by a tool or resource can contain instructions that try to steer the model. This is a form of prompt injection.
- Excessive permissions. A server with broad access can do broad damage if a model is misled. Granting the least access needed is a common safeguard.
- Untrusted servers. A malicious or compromised server can expose misleading tool descriptions or leak data, so users should install servers only from sources they trust.
- Consent. The specification stresses that users should understand and approve data access and tool use. This is a form of human-in-the-loop control.
- Authentication. Remote servers need proper authorization so that only the right users and applications can reach them.
Comparison with related approaches
MCP is not the first way to give models tools. Proprietary plug-in systems and framework-specific tool formats existed earlier. The difference is that MCP is an open, vendor-neutral protocol focused on the connection between application and tool, not on how a model chooses a tool. It also differs from agent-to-agent protocols, which concern communication between separate agents rather than between an agent and a tool.
Limitations
The protocol standardizes the connection, but it does not make a model use tools well. Models can pick the wrong tool, supply wrong arguments or be overwhelmed when many tools are listed. Tool descriptions also take up space in the context window, so very large tool sets can raise cost and reduce reliability. Quality of results still depends on how well each server is designed.
FAQs
What does MCP stand for in AI? MCP stands for Model Context Protocol, an open standard for connecting AI applications to external tools and data.
Who created the Model Context Protocol? Anthropic introduced it in November 2024 as an open standard, and the specification and many servers are developed in the open.
What is an MCP server? An MCP server is a program that exposes tools, resources or prompts to an AI application through the protocol, for example access to a database or a file system.
How is MCP different from an API? An API is an interface to a specific service. MCP is a common protocol that lets AI applications discover and call many different services in a uniform way, often by wrapping existing APIs.
Is MCP safe to use? It can be used safely with precautions, including least-privilege access, trusted servers and user approval of actions, but it also introduces risks such as prompt injection.
More in AI Agents and Autonomous Systems
Key facts
Related concepts
Quick checkWhat is the Model Context Protocol?Show answer
The Model Context Protocol (MCP) is an open standard that gives AI applications one common way to connect to external tools, data sources and services, so that each integration does not have to be built from scratch.
Sources
- Anthropic, Introducing the Model Context Protocol, https://www.anthropic.com/news/model-context-protocol
- Model Context Protocol, Specification, https://modelcontextprotocol.io/specification
Editorially reviewed by Specialty Digest Editorial TeamLast reviewed November 17, 2026Researched and drafted with AI assistanceReport an issue
