What it is
MCP stands for Model Context Protocol. It's a shared set of rules that lets an AI assistant connect to other software: your cloud drive, your calendar, a team chat app, a database, or a tool someone built for their own business. Once a piece of software "speaks MCP", any AI app that also speaks MCP can use it, without anyone writing a special bridge between the two.
The easiest way to picture it is a universal adapter. Before USB-C, every phone and laptop seemed to need its own charger, and a drawer full of cables was the price of owning more than one device. USB-C replaced that with one shape of plug that fits everything. The official MCP documentation uses exactly this comparison: think of MCP like a USB-C port for AI applications. The AI app has the port, the outside tool has the plug, and the protocol is the agreed shape that lets them fit together.
"Protocol" is just a formal word for an agreed way of talking. Email works because every email program follows the same protocol, so a message from one service arrives in another. MCP does the same job for AI assistants and the tools they use.
There are three parts worth knowing by name, because you'll see them in settings screens and help pages.
The host is the AI app you're using, such as a chat app on your phone, a desktop assistant, or a coding tool. It's where you type.
The server is the thing on the other end that offers abilities. Despite the name, it doesn't have to be a big machine in a data centre. An MCP server is simply a program that says "here is what I can do". A Google Drive server might offer "search files" and "read a document". A calendar server might offer "list my events" and "create an event". Some servers run on your own computer, and others run on the company's website and you connect to them over the internet.
The client is the small connector inside the host that keeps one line open to one server. If your AI app is connected to three servers, it runs three clients. As a user you rarely see the client itself; it's the plumbing.
Each server describes what it offers in a standard format. The most important kind of offering is a tool: an action the AI can ask for, such as "send a message" or "look up an order". Servers can also offer resources, which are pieces of information to read, such as a file or a database record, and prompts, which are ready-made instructions for common jobs. Every tool comes with a name and a written description in plain language, so the AI can decide when to use it. That detail matters later, in the section on security.
Here's what happens when you use one. You ask your assistant, "What's on my calendar on Thursday, and draft a note to Sam moving our call?" The AI app has already asked each connected server for its list of tools. The model reads your request, sees there's a calendar tool that fits, and asks the app to use it. The app passes the request to the calendar server, gets the events back, and hands them to the model, which then writes your answer. The model never logs into your calendar directly. It asks, and the app and server do the work. This general pattern, where a model requests an action and software carries it out, is called tool use or function calling. MCP is the common format that lets those tools be plugged in from anywhere.
MCP is not an AI model, and it's not a product you buy. It's an open standard, which means anyone can read the rules and build to them for free. It also doesn't replace an API, the programming interface a service already offers to other software. Most MCP servers are thin wrappers around an existing API, translating it into the shape AI apps expect.
Why it matters
It solves the "every pair needs its own cable" problem. Before MCP, if an AI app wanted to read your Google Drive, its makers had to write a custom connection to Google Drive. If a second AI app wanted the same thing, its makers wrote their own, separately. Multiply that by every AI app and every service, from Slack to Salesforce to the spreadsheet your business runs on, and the work explodes. Anthropic's announcement put the problem simply: every new data source needed its own custom implementation, which made truly connected systems hard to scale. With a shared standard, a service builds one MCP server and every compatible AI app can use it. An AI app supports MCP once and gains access to all of those servers.
It turns a chatbot into an assistant that can act. A language model on its own only knows what was in its training data and what you paste into the chat. It can't see today's inbox or check whether an invoice was paid. Connecting it to your real tools is what lets it answer questions about your actual work and, with your permission, take actions such as filing a note or updating a record. That's the step from a clever conversation partner to an agent that gets things done.
It gives you choice. Because the standard is shared across rival companies, a connector built for one AI app can often work in another. If you move from one assistant to a different one, the tools you rely on are more likely to come with you. For small businesses and creators, that means less lock-in.
It lets ordinary businesses plug in. A bookshop, a course platform or a booking service doesn't need a partnership with each AI company to become usable from AI assistants. It can publish an MCP server and let customers connect it. That's why, within a year of launch, thousands of servers existed.
It raises the stakes on security. Every connection is a door. An AI that can read your email and send messages is much more useful than one that can't, and much more dangerous if something tricks it. The same openness that makes MCP easy to adopt means anyone can publish a server, including people with bad intentions. Understanding the risks is part of understanding MCP, which is why the examples below include the two best-known warnings.
Real-world examples
Anthropic opens up MCP (25 November 2024)
Anthropic, the company that makes Claude, announced the Model Context Protocol on 25 November 2024 and released it as an open-source project, meaning the rules and the starter code were published for anyone to use. The announcement described MCP as a universal, open standard for connecting AI systems with data sources, replacing the separate connectors each source had needed until then.
It shipped with ready-made servers for several popular systems, including Google Drive, Slack, GitHub, Git, the Postgres database and the Puppeteer browser-automation tool. Anthropic named the payments and software company Block and the sales-data company Apollo as early adopters, and said developer-tool companies including Zed, Replit, Codeium and Sourcegraph were working with it. At first, using MCP in practice meant editing configuration files on a desktop computer, so it was mainly a tool for developers. That changed quickly.
Rivals sign up: OpenAI, Google and Microsoft (2025)
A standard is only a standard if competitors use it. On 26 March 2025, OpenAI's chief executive Sam Altman announced that OpenAI would add MCP support across its products, as TechCrunch reported the same day. Support arrived immediately in OpenAI's Agents SDK, a toolkit for developers, with the ChatGPT desktop app and OpenAI's main developer API to follow. A leading rival adopting a format created by Anthropic was a strong signal that MCP was becoming common ground rather than one company's feature.
About two weeks later, in April 2025, Demis Hassabis, the chief executive of Google DeepMind, posted that Google would support MCP for its Gemini models and developer toolkit, describing it as a good protocol that was rapidly becoming an open standard for what he called the agentic era.
Then on 19 May 2025, at its Build developer conference, Microsoft announced plans to support MCP natively in Windows 11. In a post on the Windows blog, David Weston, a Microsoft vice president responsible for operating-system security, described a planned registry of MCP servers that would have to meet baseline security requirements, and explicit user approval before an AI app could use a particular tool. The same post listed the threats Microsoft was designing against, including cross-prompt injection and tool poisoning. The first version was an early preview for developers only, not a feature for everyday Windows users.
MCP gets a neutral home (9 December 2025)
On 9 December 2025, the Linux Foundation, the non-profit that looks after Linux and many other shared software projects, announced the Agentic AI Foundation. Anthropic contributed MCP as a founding project, alongside Block's open-source agent goose and OpenAI's AGENTS.md, a standard file for giving instructions to coding agents. Platinum members listed in the announcement included Amazon Web Services, Anthropic, Block, Bloomberg, Cloudflare, Google, Microsoft and OpenAI.
The announcement said there were more than 10,000 published MCP servers and listed Claude, ChatGPT, Gemini, Microsoft Copilot, Cursor and Visual Studio Code among the platforms using it. Moving MCP to a foundation matters because no single company now owns the rules. That makes it safer for businesses to build on, in the same way that the web's standards are not owned by any one browser maker.
The security wake-up calls (April and May 2025)
Two pieces of research from the security firm Invariant Labs showed what can go wrong.
On 1 April 2025, Invariant Labs published a warning about what it called tool poisoning. Remember that every MCP tool comes with a written description the AI reads to decide how to use it. The researchers built a harmless-looking tool that added two numbers together. Hidden in its description, in text the user wouldn't normally see in full, were instructions telling the AI to read private files on the computer, including a file holding the user's secret login keys, and send their contents out quietly while giving a normal-looking maths answer. Tested in the popular coding editor Cursor, it worked. The researchers also described a "rug pull", where a server changes its tool descriptions after you've already approved it, and "shadowing", where one malicious server's descriptions change how the AI uses tools from other, trusted servers.
On 26 May 2025, the same team showed a different route in, through the data rather than the tool. They used the official GitHub MCP server, a legitimate and widely used connector, in Claude Desktop. An attacker wrote a public "issue", a kind of bug report anyone can post on a public project, containing hidden instructions. When the victim asked their assistant to look at the open issues on their public project, the assistant read the planted text, followed it, gathered information from the victim's private projects, including details about planned relocation and salary, and published it in the public project where anyone could read it. Invariant stressed that this was not a bug in GitHub's code but a problem with how agents combine private access, untrusted content and the ability to publish. This is a real-world case of prompt injection, the trick of hiding instructions in text an AI reads, which is explained on the Prompt page, with the limits of simple defences covered on the XML Tags page.
An everyday scenario: the author who connected her notes
This is an illustrative scenario, not a documented event. Dana writes cosy mystery novels and keeps her series notes, character lists and timelines in a cloud drive. She connects her chat assistant to the drive through the app's built-in connector, choosing read-only access to a single "Series bible" folder. Now she can ask, "In book two, what colour was the vicar's car, and who noticed it first?" and the assistant searches her own notes instead of guessing. When it offers to "tidy up" her timeline file, the app asks her to approve the change first, and she says no, because she'd rather edit the master file herself. She has the benefit of the connection without handing over the keys to everything else she stores.
Try it yourself
You'll connect one trusted service to an AI chat app you already use, test it with a harmless question, and then check its permissions. Most major chat apps support connectors at the time of writing, but the feature's name varies (connectors, apps, integrations or plugins), menu locations move often, and some options are limited to paid plans or to one connector on a free plan. Check your app's current help pages and terms before you start.
- Pick one service you already trust and use every day. Good first choices are the cloud drive, calendar or notes app you use most, from a well-known company. Don't start with email, and don't start with anything that holds money or client records.
- Open your chat app's settings and find the list of connectors. Look for a section called Connectors, Apps, Integrations or Tools. Browse the built-in directory rather than adding a custom one. Built-in connectors have usually been reviewed by the app maker; custom ones connect to any address you type, and the app can't vouch for them.
- Check who made the connector. It should come from the service itself (for example, the drive's own company) or from the chat app's maker. If the name is close but not quite right, or the publisher is someone you've never heard of, stop.
- Read the permission screen before you approve. You'll usually be sent to the service's own sign-in page to grant access. Read what it's asking for. If there's a choice between "read" and "read and write", or between one folder and everything, pick the smallest option that does the job.
- Test with a harmless question. Start a new chat, turn the connector on if your app asks you to, and try something like this:
Using my connected drive, find the most recent document with "plan" in the title. Tell me its name, when it was last changed, and a three-line summary. Don't change anything.
- Watch what the app shows you. Many apps display each tool the AI is using and ask you to approve actions. Read those prompts rather than clicking through them. If the AI tries to use a tool you didn't expect, deny it and ask why.
- Ask the AI to explain its own access. Try:
List every tool you can currently use through my connectors, in plain language, and say which ones can change or send anything.
The answer isn't a security audit, but it's a quick way to spot a connector that can do more than you realised.
- Know how to disconnect. Find the button that turns the connector off in the chat app, and also where to remove the chat app's access from inside the service's own account settings. Removing it on both sides is the thorough way to finish.
A short safety checklist to keep:
- Only install servers and connectors from sources you trust, and prefer the app's official directory over custom addresses.
- Give the smallest access that works: read-only where possible, one folder rather than everything.
- Keep "ask before acting" switched on for anything that sends, deletes, buys or publishes.
- Be extra careful when one chat combines private data with content written by strangers, such as public web pages, shared documents, forum posts or incoming email. That combination is exactly what the GitHub attack used.
- Don't connect a new, unknown server in the same session as your most sensitive tools.
- Review your connected apps every few months and remove the ones you no longer use.
Common mistakes and misunderstandings
Thinking MCP is an AI model or a product. MCP is a set of rules, like the rules that let email travel between services. It doesn't think, and you don't subscribe to it. What you see in practice is your chat app's connectors feature, which is built on MCP.
Assuming "open standard" means "safe". Open means anyone can build a server, including careless and malicious people. The standard defines how the AI and the tool talk. It doesn't check that a server is honest. Some app makers review the connectors in their directories, and Microsoft designed its Windows plans around a vetted registry, but a custom server you add yourself has had no such check.
Believing approval is a one-time decision. The "rug pull" research showed a server can change what its tools claim to do after you've said yes. Prefer connectors from companies with a reputation to protect, and pay attention if an app tells you a connector's tools have changed.
Trusting data just because it came through a trusted connector. In the GitHub case, the connector was official and the code worked as designed. The danger was the text it fetched, written by a stranger. Anything the AI reads, including shared files, web pages and messages, can carry hidden instructions. The broader fix is guardrails outside the model and a human in the loop for consequential actions.
Granting everything to save time. It's tempting to approve full access so you never see another pop-up. But the damage an attack can do depends on what the AI is allowed to reach. Narrow permissions turn a potential disaster into a minor annoyance. This matters most for anything holding personal data, which is covered on the Privacy page.
Connecting too many tools at once. Every connected server adds tool descriptions to what the model has to read, which uses up space in its context window and can make it choose the wrong tool. A handful of well-chosen connectors usually works better than dozens.
Confusing MCP with web search or RAG. Web search lets an AI look things up on the public internet. RAG is a technique for feeding relevant passages from your documents into a prompt. MCP is the plug that can connect an AI to either of those, or to anything else. They work together rather than competing.
Assuming it only matters to programmers. Early MCP setups meant editing configuration files, so many people filed it under "developer stuff". Today, the connectors in mainstream chat apps put it in front of everyday users, which is exactly why the permission and safety habits above matter to everyone.
Related elements
- API: the programming interface most MCP servers wrap and translate for AI apps.
- Tool Use: the general ability of a model to ask software to act, which MCP standardises.
- Function Calling: the structured request a model sends when it wants a tool run.
- Agent: the kind of AI system that uses connected tools to complete tasks on its own.
- Coding Agents: among the first and heaviest users of MCP servers.
- Workflow Automation: chaining connected tools together to handle routine jobs.
- Prompt: where prompt injection, the attack behind the GitHub example, is explained.
- Guardrails: the outside checks that limit what a hijacked assistant can do.
- Human in the Loop: keeping a person's approval on actions that send, delete or publish.
- Privacy: what to think about before connecting tools that hold personal data.