Model Context Protocol (MCP) in short
The Model Context Protocol (MCP) is an open standard that defines how AI applications connect to external tools and data, such as files, databases, business software and APIs. Anthropic introduced MCP in November 2024. Today the protocol is part of the Agentic AI Foundation under the Linux Foundation, and OpenAI, Google, Microsoft and AWS all support it.
- A tool with an MCP server works in every AI application that supports MCP, which removes the need for one-off integrations.
- The current specification, dated 2026-07-28, made MCP a stateless protocol, so servers are easier to scale.
- MCP standardizes the connection, while the choice of which servers to trust stays with you.
What is the Model Context Protocol (MCP)?
MCP gives AI applications one standard way to discover and use external tools and data. The official documentation compares it to a USB-C port for AI applications: a tool is wrapped once in an MCP server and then works in every application that speaks the protocol.
MCP was created at Anthropic by David Soria Parra and Justin Spahr-Summers and released as open source on 25 November 2024. In December 2025 Anthropic donated MCP to the Agentic AI Foundation, which it co-founded with Block and OpenAI, with support from Google, Microsoft, AWS, Cloudflare and Bloomberg.
The name causes some confusion. Hopsworks’ MLOps glossary, for example, uses the term “model context protocol” for a concept that records a model’s context, such as references to its training data, hyperparameters and environment, so that results can be reproduced. Anthropic’s MCP is a different thing: an integration protocol that does not store datasets or training settings.
Key benefits of the Model Context Protocol
The benefits follow from putting one protocol between many AI applications and many tools.
- Standardisation: ten applications and twenty tools need thirty MCP implementations, one each, instead of two hundred custom integrations.
- Interoperability: Claude, ChatGPT, Microsoft Copilot Studio, the Gemini API, VS Code and Cursor all support MCP, so an integration you build once can be reused when you switch applications or models.
- Composability: one task can use several servers, for example to read a Jira ticket, check the code on GitHub and post a summary in Slack.
- Current context: the model works with live data from the source system instead of relying only on its training data, which is a core part of context engineering.
MCP architecture: how it works
MCP uses a client-host-server architecture in which one AI application connects to many servers. The specification defines three roles.
| Component | What it is | What it does |
|---|---|---|
| Host | The AI application the user works in, such as Claude, ChatGPT or VS Code | Manages the clients, decides which servers are connected, is responsible for user consent before tools run and combines the results |
| Client | A connector inside the host, one per server | Communicates with exactly one server and attaches the protocol version and capabilities to every request |
| Server | A program that exposes a tool or data source, such as GitHub, a database or a CRM | Offers tools, resources and prompts, usually on top of an existing API |
Tools are functions the model can call, resources are data the application can read, and prompts are templates the user can pick. Messages use JSON-RPC 2.0 over stdio for local servers or Streamable HTTP for remote servers. Remote servers that require authorization use OAuth 2.1. Since the 2026-07-28 revision, the protocol has been stateless: the initialization handshake and protocol-level sessions are gone, and every request carries its own protocol version and capabilities. As a result, any server instance behind a load balancer can handle any request.
Comparison of data integration approaches
MCP does not replace APIs. An MCP server usually wraps an existing API, so the difference is who builds the integration and how often.
| Aspect | Custom integration per application | Model Context Protocol (MCP) |
|---|---|---|
| Standardization | A separate connector for every pair of application and tool | One open protocol, versioned by date |
| Reuse | Rebuilt for each application or model vendor | One server works in every host that supports MCP |
| Switching models | Often tied to one vendor’s function-calling format | The server does not depend on the model, so switching models needs no rebuild |
| Security | Depends on each implementation | Also depends on the implementation, although the specification adds OAuth 2.1 and security guidance |
| Maintenance | Every API change touches every integration | The server is updated once for all applications |
MCP example workflow: scheduling a meeting
In this example, an AI assistant schedules a meeting through a calendar MCP server:
- The client asks the calendar server for its tools and gets back, for example, find_free_slots and create_event.
- You ask for a one-hour meeting with three colleagues next week, and the model calls find_free_slots.
- The server queries the calendar API and returns the available time slots.
- The model proposes a time, and the host asks for your confirmation before create_event runs.
- The server creates the invitation and the assistant reports the result.
The same pattern applies to every MCP server: the model chooses the tool, the host controls whether it runs, and the server talks to the underlying system.
Is MCP secure?
MCP can be used securely, but the protocol does not make an integration safe on its own. The specification lists security principles, such as the rule that hosts must obtain explicit user consent before invoking any tool, but states that “MCP itself cannot enforce these security principles at the protocol level”.
Two incidents show where the risk lies. In May 2025 researchers found that a malicious GitHub issue could hijack an agent that uses the GitHub MCP server and leak data from private repositories. In September 2025 Postmark warned that a fake postmark-mcp package had been secretly forwarding copies of emails to an outside server. You can limit this risk by connecting only trusted servers, giving each server minimal permissions, requiring approval for tools that change data and logging every tool call. Our article on AI guardrails covers the wider safeguards around AI applications.
MCP’s role in AI evolution
In less than two years, MCP has grown from an Anthropic project into shared infrastructure, with token cost as its main practical drawback.
- Adoption: OpenAI built its Apps SDK for ChatGPT on MCP, and Microsoft supports MCP in Copilot Studio and VS Code. Google Cloud lists more than 50 Google-managed MCP servers, generally available or in preview, and AWS’s own MCP server reached general availability in May 2026. The MCP maintainers report “close to half-a-billion downloads a month” across the official Tier 1 SDKs in July 2026.
- Token cost: every connected server adds tool descriptions to the model’s context, which costs tokens. Anthropic showed that having the model write code to call MCP tools cut one example workflow from 150,000 to 2,000 tokens.
Practical applications
MCP is used wherever an AI application has to work with existing systems.
- Software development: coding assistants such as Claude Code, GitHub Copilot and Cursor use MCP servers to read issues, query databases and look up documentation, and often pair them with skills that describe how to use those tools.
- Business assistants: ChatGPT apps, Copilot Studio agents and Claude connectors reach CRM, email, calendars and documents through MCP.
- Internal systems: organizations build MCP servers for their own ERP or CRM, so one integration works in every MCP-compatible AI application they use. If those systems hold personal data, the GDPR applies as it does to any integration.
Conclusion
The Model Context Protocol has become a shared standard for connecting AI applications to tools and data. MCP does not decide which servers deserve your trust, so treat every MCP server like any other integration, with an owner, minimal permissions and logging.
Wondering which of your systems to connect to AI first, and how to do it safely? Our AI consultancy helps you choose and build the right integrations.
Frequently asked questions (FAQ)
What does MCP stand for in AI?
MCP stands for Model Context Protocol, an open standard introduced by Anthropic in November 2024. The protocol defines how AI applications such as Claude, ChatGPT and Microsoft Copilot Studio connect to external tools and data through MCP servers.
Who developed the Model Context Protocol?
David Soria Parra and Justin Spahr-Summers created MCP at Anthropic, which released it as open source on 25 November 2024. Since December 2025 the protocol has been part of the Agentic AI Foundation under the Linux Foundation.
What is an MCP server?
An MCP server is a program that makes a tool or data source available to AI applications. It offers tools, resources and prompts, usually on top of an existing API, and runs either locally or remotely over HTTP.
What is the difference between MCP and an API?
MCP builds on APIs rather than replacing them. An MCP server usually wraps an existing API and describes its functions in a standard form, so every MCP-compatible AI application can use it without a custom integration.
How does MCP relate to A2A and ACP?
MCP connects an AI agent to tools and data, while the Agent2Agent protocol (A2A) lets agents work together in multi-agent systems. IBM’s Agent Communication Protocol (ACP) merged into A2A in August 2025. ACP can also refer to the Agentic Commerce Protocol from Stripe and OpenAI or the Agent Client Protocol from Zed.