# What is MCP (Model Context Protocol)?

> MCP, the Model Context Protocol, is an open-source standard that lets an AI app such as Claude Code or VS Code use outside systems like your files, a database or a web service. Each system sits behind an MCP server, which runs on your computer or at a web address. Once you connect one, the model can call the tools it offers.

Mindket editors · Published 2026-10-05 · Updated 2026-11-03 · https://mindket.com/blog/what-is-mcp

## In short

- Before you connect a server, check whether it runs on your machine or on someone else's. With a remote one, your requests leave your computer.
- Read the inputs of a tool call before you approve it.
- If you write a local server, keep stdout for MCP messages and send your logs to stderr.

## Host, client and server: who does what

Say your AI app has a weather server connected and you ask about New York. A small part of the app called a **client** sends that server one short request: run the tool called `get_weather`, with New York as the location. The server runs it and returns the result, and the model answers from that.

MCP fixes the shape of that request and its reply, so one server works in any app that speaks the protocol. The app itself, whether Claude Code, Claude Desktop or VS Code, is the **host**. It keeps one client per server, each holding a single connection, so VS Code with [Sentry's server and the local filesystem server](https://modelcontextprotocol.io/docs/learn/architecture) attached runs two of them.

The word "server" says nothing about where the program runs. A local one is launched by the host on your own machine, under your account, the way Claude Desktop starts the filesystem server, and it usually serves one client. A remote one runs on someone else's platform, as Sentry's does, and usually serves many clients at once.

> Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect electronic devices, MCP provides a standardized way to connect AI applications to external systems.
>
> MCP documentation, in its introduction, [modelcontextprotocol.io, What is MCP?](https://modelcontextprotocol.io/docs/getting-started/intro) (read 2026-11-03)

## What an MCP server lets an agent do

Connected to the right servers, an agent can read your [Google Calendar and Notion](https://modelcontextprotocol.io/docs/getting-started/intro), and Claude Code can build a whole web app from a Figma design.

Every tool counts as arbitrary code execution under the specification, and a host must get your explicit consent before calling one. The spec's tools page also asks apps to show you the inputs a call will send. For a local server, that prompt comes late: the program is already running when it appears. So [read the command](https://mindket.com/blog/are-mcp-servers-safe) in the app's config before the server starts: which program it runs, and with which arguments.

- The official [servers repository](https://github.com/modelcontextprotocol/servers) keeps a short set of reference servers: Everything, Fetch, Filesystem, Git, Memory, Sequential Thinking and Time. Its README calls them educational examples for people building their own, not production-ready solutions.
- Starting one takes a single line, such as `npx -y @modelcontextprotocol/server-memory` or `uvx mcp-server-git`.
- A remote server has nothing to install. Claude Code adds Notion's with `claude mcp add --transport http notion https://mcp.notion.com/mcp`, the example in [Anthropic's MCP docs](https://code.claude.com/docs/en/mcp).

[![Claude's post on X: Claude Code plus Figma turns design into code, with Claude reading a mockup's component hierarchies, design tokens and auto-layout rules through MCP, posted 23 September 2025](https://mindket.com/blog/shots/x-claudeai-figma-mcp.webp?v=96789639de20)](https://x.com/claudeai/status/1970541285615264071)

Claude on X, 23 September 2025

> The shots on this page are X's own embeds of each post, with times in US Pacific time. Select one to open the post on X.

## What a server offers: tools, resources and prompts

Before a client can ask for the weather, it has to know the tool exists. It first asks for the server's tools and gets back each one's name, description and the inputs it accepts (`tools/list`), and only then calls one (`tools/call`). A resource is fetched with `resources/read`, and prompts often turn up in an app as slash commands.

On a [database server](https://modelcontextprotocol.io/docs/learn/server-concepts), the app loads the schema into context as a resource. When your question needs data, the model runs a query through a tool. The prompt with worked examples for those tools is yours to pick.

A server can also ask you for more input, for example to confirm an action. The spec calls that elicitation.

| Primitive | What it is | Examples in the MCP docs | Who controls it |
| --- | --- | --- | --- |
| Tools | Functions the model calls to act: write to a database, call an API, change a file | Search flights, send messages, create calendar events | The model |
| Resources | Read-only data the app pulls in as context, each at its own URI | Documents, knowledge bases, calendars | The application |
| Prompts | Instruction templates that tell the model how to use the server's tools and resources | Plan a vacation, summarize my meetings, draft an email | The user |

## Who made MCP, and who runs it now

Anthropic open-sourced MCP on [November 25, 2024](https://www.anthropic.com/news/model-context-protocol), calling it "a new standard for connecting AI assistants to the systems where data lives." The problem it named was integration sprawl, where every new data source needed its own custom implementation. Ready-made servers for Google Drive, Slack, GitHub, Git, Postgres and Puppeteer shipped with it.

No single company owns it today. The project sits under LF Projects, LLC as its own series, named Model Context Protocol, and seats on its [steering group](https://modelcontextprotocol.io/community/governance) belong to people, not their employers. A change to the spec starts as a Specification Enhancement Proposal (SEP), published before it lands.

The official [MCP Registry](https://modelcontextprotocol.io/registry/about), still in preview, stores metadata about public servers but not their code. Security scanning is left to package registries such as npm and PyPI and to marketplaces downstream, so an entry there tells you a server exists, not that it's safe.

**How big MCP had grown, by Anthropic's own count**

- **10,000+** active public MCP servers on 9 December 2025 (Source: [Anthropic, 9 December 2025](https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation), read 2026-11-03)
- **97M+** monthly SDK downloads across Python and TypeScript, counted the same day (Source: [Anthropic, 9 December 2025](https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation), read 2026-11-03)

**MCP from its release to the stateless revision**

1. **November 25, 2024** Anthropic open-sources MCP. Ready-made servers ship with it.
2. **March 26, 2025** Revision 2025-03-26 is finalized. Streamable HTTP replaces HTTP+SSE, and OAuth 2.1 authorization arrives.
3. **November 25, 2025** Revision 2025-11-25. Adds URL mode elicitation and experimental tasks.
4. **December 9, 2025** Anthropic donates MCP to the Agentic AI Foundation. A directed fund under the Linux Foundation.
5. **July 28, 2026** Revision 2026-07-28 makes MCP stateless. No protocol-level sessions and no initialize handshake.

Sources: [Anthropic, 25 November 2024](https://www.anthropic.com/news/model-context-protocol) (read 2026-11-02), [MCP changelog, revision 2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26/changelog) (read 2026-11-03), [MCP changelog, revision 2025-11-25](https://modelcontextprotocol.io/specification/2025-11-25/changelog) (read 2026-11-03), [Anthropic, 9 December 2025](https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation) (read 2026-11-03), [MCP changelog, revision 2026-07-28](https://modelcontextprotocol.io/specification/2026-07-28/changelog) (read 2026-11-03)

[![Alex Albert's post on X introducing the Model Context Protocol, an open standard from Anthropic that connects LLM apps to your data, posted 25 November 2024](https://mindket.com/blog/shots/x-alexalbert-mcp-intro.webp?v=bc355b2d186a)](https://x.com/alexalbert__/status/1861079762506252723)

Alex Albert of Anthropic on X, 25 November 2024

[![Alex Albert's post on X: the new MCP spec is finalized, with OAuth 2.1 auth, Streamable HTTP instead of HTTP+SSE, JSON-RPC batching and tool annotations, posted 26 March 2025](https://mindket.com/blog/shots/x-alexalbert-mcp-spec-march-2025.webp?v=4b710cf2d358)](https://x.com/alexalbert__/status/1904908450473324721)

Alex Albert of Anthropic on X, 26 March 2025

> Read on November 2, 2026: every page linked here and under Sources. Re-read on November 3: the specification changelogs, the versioning page and Anthropic's donation post. The three shots are from that day.

## Reference: how MCP messages travel, stdio and Streamable HTTP

With **stdio**, the host starts the server as a subprocess on your machine. The server reads requests from standard input and writes replies to standard output, one message per line. The [stdio binding](https://modelcontextprotocol.io/specification/latest/basic/transports/stdio) forbids it from writing anything to stdout that isn't a valid MCP message, so one stray debug print can break a local server. Logs go to stderr, which the client may keep or ignore.

With **Streamable HTTP**, the server runs as its own process behind one endpoint, such as `https://example.com/mcp`. Each client message is a separate HTTP POST. The server answers with one JSON object, or a short stream of events that belongs to that request alone. This transport [replaced the older HTTP+SSE transport](https://modelcontextprotocol.io/specification/latest/basic/transports/streamable-http) in protocol version 2025-03-26, and Claude Code's docs mark their SSE option deprecated too.

Revision 2026-07-28, the [current specification](https://modelcontextprotocol.io/specification/latest/basic/transports), made MCP stateless: every request carries its own protocol version and capabilities, so a server can handle each one by itself. Earlier revisions opened a session with an `initialize` handshake. The new one drops protocol-level sessions and the long-lived GET stream, and a client may send `server/discover` first to learn which versions and features a server supports.

Two older client features are now deprecated: sampling, where a server asks the host's model for a completion, and logging.

Sign-in is optional. Under the [authorization spec](https://modelcontextprotocol.io/specification/latest/basic/authorization), a server reached over HTTP should use its OAuth 2.1 flow, while a stdio server takes its credentials from the environment.

Each revision of the specification is named for the date of its last backward-incompatible change, and an older app may still speak an earlier one.

Messages travel as JSON-RPC 2.0, as in this `tools/call` request for the weather, copied from the spec's [tools page](https://modelcontextprotocol.io/specification/latest/server/tools) without the metadata a real request carries.

````json
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": { "location": "New York" }
  }
}
````

**What each revision of the specification has**

| | 2024-11-05 | 2025-03-26 | 2025-11-25 | 2026-07-28 (Our pick) |
| --- | --- | --- | --- | --- |
| Streamable HTTP transport | ✗ No | ✓ Yes | ✓ Yes | ✓ Yes |
| OAuth 2.1 authorization framework | ✗ No | ✓ Yes | ✓ Yes | ✓ Yes |
| An initialize handshake before any request | ✓ Yes | ✓ Yes | ✓ Yes | ✗ No |
| URL mode elicitation | ✗ No | ✗ No | ✓ Yes | ✓ Yes |
| Tasks for long-running requests | ✗ No | ✗ No | Experimental | An extension |

**Our pick: 2026-07-28.** The current revision, per MCP's versioning page, and the one to write a new server against.

Sources: [MCP changelog, revision 2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26/changelog) (read 2026-11-03), [MCP changelog, revision 2025-11-25](https://modelcontextprotocol.io/specification/2025-11-25/changelog) (read 2026-11-03), [MCP changelog, revision 2026-07-28](https://modelcontextprotocol.io/specification/2026-07-28/changelog) (read 2026-11-03), [MCP versioning page](https://modelcontextprotocol.io/specification/versioning) (read 2026-11-03)

## Frequently asked questions

### Is an MCP server the same as an API?

No. An API is one service's own interface, designed its own way, and an MCP tool often calls one underneath. A weather server might call a weather API inside, while the host only sees a tool named `get_weather` and the inputs it takes.

### Do I need to write code to use an MCP server?

You change a setting, not code: a [command in Claude Code](https://mindket.com/blog/add-mcp-server-claude-code), or a block of JSON in an app such as Claude Desktop or Cursor. Code comes in only when you write a server of your own, in any of the several languages the official SDKs cover.

### Is MCP the same as Agent Skills?

No. A skill is [a folder of instructions](https://mindket.com/blog/what-are-agent-skills), and an MCP server is a live connection to another program. The specification does list one extension, Skills over MCP, that sends structured instructions for agent workflows over an MCP connection.

### Which apps can use MCP servers?

Claude, ChatGPT, Visual Studio Code and Cursor are among the apps MCP's introduction names, and each keeps its own configuration. Claude Code stores servers in `~/.claude.json` or in a project's `.mcp.json`, while Claude Desktop, Cursor and others read an `mcpServers` block of JSON.

### Is MCP free to use?

The protocol is. Code and specification contributions are under the Apache License 2.0, and documentation outside the specification is under Creative Commons Attribution 4.0. A server can still need your own account or API key for the service behind it.

### Can an MCP server see my whole conversation?

No, only what the host sends it. The specification says a host needs your explicit consent before it exposes your data to a server, and without that consent it may not pass resource data on elsewhere either.

## Sources

- [Model Context Protocol: What is MCP?](https://modelcontextprotocol.io/docs/getting-started/intro) (read 2026-11-03)
- [MCP docs: Architecture overview](https://modelcontextprotocol.io/docs/learn/architecture) (read 2026-11-02)
- [MCP docs: Understanding MCP servers](https://modelcontextprotocol.io/docs/learn/server-concepts) (read 2026-11-02)
- [MCP specification (revision 2026-07-28)](https://modelcontextprotocol.io/specification/latest) (read 2026-11-02)
- [MCP specification: Transports](https://modelcontextprotocol.io/specification/latest/basic/transports) (read 2026-11-02)
- [MCP specification: stdio transport](https://modelcontextprotocol.io/specification/latest/basic/transports/stdio) (read 2026-11-02)
- [MCP specification: Streamable HTTP transport](https://modelcontextprotocol.io/specification/latest/basic/transports/streamable-http) (read 2026-11-02)
- [MCP specification: Authorization](https://modelcontextprotocol.io/specification/latest/basic/authorization) (read 2026-11-02)
- [MCP specification: Tools](https://modelcontextprotocol.io/specification/latest/server/tools) (read 2026-11-02)
- [MCP: Governance and stewardship](https://modelcontextprotocol.io/community/governance) (read 2026-11-02)
- [MCP: The MCP Registry](https://modelcontextprotocol.io/registry/about) (read 2026-11-02)
- [Anthropic: Introducing the Model Context Protocol](https://www.anthropic.com/news/model-context-protocol) (read 2026-11-02)
- [GitHub: modelcontextprotocol/servers](https://github.com/modelcontextprotocol/servers) (read 2026-11-02)
- [Claude Code docs: Connect Claude Code to tools via MCP](https://code.claude.com/docs/en/mcp) (read 2026-11-02)
- [MCP specification changelog: revision 2025-03-26](https://modelcontextprotocol.io/specification/2025-03-26/changelog) (read 2026-11-03)
- [MCP specification changelog: revision 2025-11-25](https://modelcontextprotocol.io/specification/2025-11-25/changelog) (read 2026-11-03)
- [MCP specification changelog: revision 2026-07-28](https://modelcontextprotocol.io/specification/2026-07-28/changelog) (read 2026-11-03)
- [MCP specification: Versioning](https://modelcontextprotocol.io/specification/versioning) (read 2026-11-03)
- [Anthropic: Donating the Model Context Protocol and establishing the Agentic AI Foundation](https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation) (read 2026-11-03)

[Browse MCP servers](https://mindket.com/mcp-servers)