Short answer: the Model Context Protocol (MCP) is an open standard that lets an AI application, such as Claude, ChatGPT, Cursor or VS Code, plug into outside tools and data through one common interface instead of a custom integration for each pair. A program called an MCP server exposes tools, data and prompt templates; the AI application connects to it and can then use them, with your approval. The current specification is version 2026-07-28, and since December 2025 the project has been hosted by the Agentic AI Foundation under the Linux Foundation.
The problem MCP solves
A large language model (LLM, the AI model behind a chat assistant) only knows what was in its training data and what you paste into the conversation. To be useful at work it needs to read your files, query your database, open a pull request or search your docs. Before MCP, every AI application had to write its own connector for every service, and every service had to write a plugin for every AI application. Ten apps and ten services meant up to a hundred separate integrations.
Anthropic described exactly this when it open-sourced MCP on 25 November 2024: "Every new data source requires its own custom implementation, making truly connected systems difficult to scale." MCP replaces that grid with one protocol (a protocol is just an agreed set of message formats and rules). A service writes one MCP server; any application that speaks MCP can use it. The official site compares it to a USB-C port for AI applications: one standard socket instead of a drawer of adapters.
MCP is deliberately narrow. The architecture docs say it "focuses solely on the protocol for context exchange": it does not decide which model you use or how the application reasons about what it gets back.
Hosts, clients and servers
MCP has three roles, and the names trip people up because "client" does not mean the app you click on.
- Host: the AI application you use, such as Claude Desktop, Claude Code, Cursor or VS Code. It holds the conversation and the model.
- Client: a connector object inside the host. The host creates one client per server, and each client keeps its own dedicated connection.
- Server: a program that provides context and capabilities. It might wrap your file system, GitHub, a database or a documentation service.
So if Cursor is connected to a filesystem server and a GitHub server, Cursor is one host running two MCP clients, each talking to one server. The official architecture page uses the same shape with VS Code and the Sentry server as its example.
A server can run in two places. A local server runs on your own machine, started by the host as a child process; the filesystem reference server works this way. A remote server runs on someone else's infrastructure and you reach it by URL; Sentry's official server is the example the docs give. The protocol is the same either way, only the transport changes (more on that below).
What a server can offer: tools, resources and prompts
The specification calls these the three server "features" or primitives. The useful way to tell them apart is to ask who decides when each one is used.
| Primitive | What it is | Who controls it (spec wording) | Example |
|---|---|---|---|
| Tools | Functions the AI model can execute | Model-controlled: the model discovers and calls them based on your request | read_text_file, create_issue, run_query |
| Resources | Context and data, identified by a URI (a web-address-style name) | Application-driven: the host decides how to bring them into context | A file's contents, a database schema, notes://all |
| Prompts | Templated messages and workflows | User-controlled: you pick them explicitly, often as a slash command | "Review this pull request", "Summarise this incident" |
Clients can offer features back to servers too. The current one is elicitation, which lets a server ask you for more information or a confirmation mid-task. Three older features, roots, sampling and logging, are marked deprecated in the 2026-07-28 revision: they still work during a deprecation window of at least twelve months, but new code should not adopt them. The changelog suggests passing directories as tool parameters instead of roots, calling an LLM provider directly instead of sampling, and logging to stderr (the standard error stream) instead of protocol logging.
Every primitive is discoverable. A client calls tools/list, resources/list or prompts/list to see what is on offer, then uses tools/call, resources/read or prompts/get. That is why a host can show you a server's tools the moment it connects.
How messages travel: JSON-RPC and the two transports
Under the hood every MCP message is JSON-RPC 2.0: a small JSON object with a method name, parameters and an ID that pairs a request with its reply. Here is the shape of a tool call from the official architecture page, trimmed:
{
"jsonrpc": "2.0",
"id": 3,
"method": "tools/call",
"params": {
"name": "weather_current",
"arguments": { "location": "San Francisco", "units": "imperial" },
"_meta": {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientInfo": { "name": "example-client", "version": "1.0.0" }
}
}
}
A transport is how those JSON messages physically get from client to server. The specification defines two standard ones:
- stdio: the host launches the server as a subprocess and they exchange newline-delimited JSON over the process's standard input and output. No network port is opened. The spec is strict that the server "MUST NOT write anything to its
stdoutthat is not a valid MCP message", which is why a strayprint()breaks a local server; logs go to stderr instead. This is the transport for local servers. - Streamable HTTP: each message is an HTTP POST to a single endpoint (usually a URL ending in
/mcp), and replies come back as a JSON object or a request-scoped Server-Sent Events (SSE) stream. This is the transport for remote servers, and it supports normal HTTP authentication; the docs recommend OAuth for obtaining tokens.
You will still see an older HTTP+SSE transport in some tools. It has been deprecated since protocol version 2025-03-26, and the current changelog tells implementers to migrate to Streamable HTTP. Claude Code's docs, for example, now label SSE as deprecated and try HTTP first.
Who maintains MCP, and which version is current
Anthropic created MCP and open-sourced it on 25 November 2024. On 9 December 2025 Anthropic donated it to the newly formed Agentic AI Foundation (AAIF) under the Linux Foundation, which the official MCP blog says was "co-founded by Anthropic, Block and OpenAI". The same post is clear that day-to-day control did not move to the foundation: "The governance model we introduced earlier this year continues as is", and the Linux Foundation "will not dictate the technical direction of MCP".
Formally the project is now "Model Context Protocol a Series of LF Projects, LLC". Technical decisions sit with a maintainer hierarchy (Lead Maintainers, Core Maintainers, Maintainers), and the governance page notes that membership is for individuals, not companies. As of the MAINTAINERS.md file in the specification repository (last updated 1 October 2026), the Lead Maintainers are David Soria Parra and Den Delimarsky. Changes to the protocol go through public Specification Enhancement Proposals (SEPs).
Spec versions are named by date. The released ones are 2024-11-05, 2025-03-26, 2025-06-18, 2025-11-25 and the current 2026-07-28, published on GitHub on 28 July 2026. It is a major, partly breaking revision; the release blog calls the stateless core its highlight:
- MCP is now stateless. The old
initializehandshake is gone. Every request carries its own protocol version and client capabilities in a_metafield, so any request can be handled on its own. - A new
server/discovermethod lets a client ask a server which versions and capabilities it supports before doing anything else. - Sessions were removed from Streamable HTTP, including the
Mcp-Session-Idheader. Servers that need state across calls now pass explicit handles as ordinary tool arguments. - Servers no longer send requests to clients. When a server needs input mid-task, it returns an "input required" result and the client retries with the answer (the spec calls this Multi Round-Trip Requests).
Older clients and servers still interoperate: the spec defines how each side detects the other's era and falls back. In practice you rarely deal with versions directly; the SDK you use (for example the official Python SDK, version 2.3.0 on PyPI) negotiates them for you.
Security basics
MCP is powerful because a server can read data and run actions on your behalf. The specification says so plainly: "Tools represent arbitrary code execution and must be treated with appropriate caution." Four habits cover most of the risk.
- Keep a human in the loop. The tools spec says there "SHOULD always be a human in the loop with the ability to deny tool invocations", and hosts must get your consent before invoking a tool. Claude Desktop's docs say every filesystem action needs your explicit approval, and Cursor's help page says it asks before using an MCP tool by default, although from Cursor 3.6 the default Auto-review mode runs allowlisted tools straight away and sends the rest to a safety classifier rather than to you. Read the arguments before you approve, and be careful with "always allow" settings.
- Treat server content as untrusted. Prompt injection is when text the model reads (a web page, an issue comment, a file) contains instructions that try to hijack it. Claude Code's MCP docs warn: "Servers that fetch external content can expose you to prompt injection risk." The spec also says tool descriptions and annotations should be considered untrusted unless they come from a trusted server.
- Only install servers you trust. A local server runs with your user account's permissions. The spec's security best practices give examples of a malicious "startup" command that exfiltrates your SSH key. Prefer official servers from the vendor or the reference repository, read the command before you add it, and pin a version for anything important.
- Grant the least access that works. Give the filesystem server one project folder, not your home directory (its README also documents a
--read-onlyflag). Give API servers scoped, read-only tokens where you can. Cursor's docs make the same point: "Use restricted API keys with minimal required permissions."
Try it: see a real server's tools in one command
You can watch MCP work without configuring any AI app. The official MCP Inspector has a command-line mode that launches a server, asks it for its tools and prints the reply. With Node.js installed, run this in an empty folder (replace the path with a folder you are happy to expose):
mkdir demo-dir
echo "hello" > demo-dir/hello.txt
npx -y @modelcontextprotocol/inspector --cli \
npx -y @modelcontextprotocol/server-filesystem "$PWD/demo-dir" \
--method tools/list
When we ran it on 14 November 2026 (Inspector 2.15.0, filesystem server 2.3.0), the server logged its allowed directory to stderr and the Inspector printed JSON listing 16 tools, starting like this:
Secure MCP Filesystem Server running on stdio
Effective allowed directories (from the command line):
/.../demo-dir
{
"tools": [
{
"name": "read_file",
"title": "Read File (Deprecated)",
...
The 16 tool names were read_file, read_text_file, read_media_file, read_multiple_files, write_file, append_file, edit_file, create_directory, list_directory, list_directory_with_sizes, directory_tree, move_file, copy_file, search_files, get_file_info and list_allowed_directories. That list is exactly what Claude or Cursor would see when they connect.
Troubleshooting the demo
npm warn EBADENGINE Unsupported engine(seen in our test). Inspector 2.15.0 declares Node^22.23.4 || ^24.22.1 || >=26.12.1. On Node 25.9.0 it printed this warning and still worked. Switch to a current LTS release (Node 24 or 26) to silence it.- The server "hangs" when you run it on its own (documented in the servers README). A stdio server opens no port and waits for messages on stdin, so
npx -y @modelcontextprotocol/server-filesystem DIRprints a startup line and then appears frozen. That is normal; press Ctrl+C and let a client start it. Access denied - path outside allowed directories: /etc/hosts not in ...(seen in our test). The filesystem server refuses any path outside the folders you passed. Add the folder to the command, or keep the restriction: it is the point.npx: command not foundorspawn npx ENOENT(common in the servers repository's issues). Node.js is not installed or not on the PATH. Install it from nodejs.org; the next guide in this series covers the GUI-app PATH problem in detail.
What to do next
- Connect your first servers: How to set up an MCP server in Claude Desktop, Claude Code and Cursor.
- Write your own in Python: Build an MCP server in Python from zero.
- Pick servers worth installing: Best MCP servers for Claude, Cursor and Codex.
- Understand what uses them: What is an AI agent?
- Official sources: the architecture overview and the latest specification.
FAQ
Is MCP only for Claude?
No. The official site lists Claude, ChatGPT, Visual Studio Code and Cursor among supporting applications, and the project has been hosted by a Linux Foundation body since December 2025. A server you write once works in any compliant host.
Is an MCP server the same as an API?
It usually wraps one. An API is designed for programmers; an MCP server describes its tools in a way a model can discover and call, with a JSON Schema for each tool's inputs. The Python SDK README calls MCP "like a web API, but designed for LLM interactions".
Do I need to know the spec to use MCP?
No. To use servers you only edit a config file or run one command. To build them you use an SDK, which handles JSON-RPC, transports and version negotiation for you.
What changed in the 2026-07-28 version that I should care about?
If you only use servers, very little: hosts and SDKs handle it. If you build servers, note that the protocol is now stateless, sessions are gone from Streamable HTTP, roots, sampling and logging are deprecated, and the HTTP+SSE transport is on its way out.
Is it safe to install any MCP server I find?
No. A local server runs with your permissions and a remote one sees whatever you send it. Stick to official or well-maintained servers, read the command, and grant the narrowest access that works.
How this guide was tested
Facts about the protocol come from modelcontextprotocol.io (the intro, architecture, governance, debugging and connect-local-servers pages, and the 2026-07-28 specification pages for transports, stdio, tools, resources, prompts, security best practices and the changelog), the MCP blog post of 9 December 2025, Anthropic's launch post of 25 November 2024, the modelcontextprotocol/modelcontextprotocol repository on GitHub (schema folder, release tags and MAINTAINERS.md) and the PyPI and npm registries, all read on 14 November 2026.
Executed here, on macOS 26.5 on Apple M4 with Node 25.9.0 and npm 11.12.1: the Inspector command above with @modelcontextprotocol/inspector 2.15.0 and @modelcontextprotocol/server-filesystem 2.3.0, including a tools/call of read_text_file inside and outside the allowed folder. The npm cache and the Inspector's catalog file were pointed at a scratch folder so nothing was written to the real home directory. Checked against official docs only: the governance and maintainer details, the version history, the security guidance and the host behaviour of Claude Desktop, Claude Code and Cursor. We re-test these steps monthly and record any change in this page's changelog.
Comments 0
No comments yet. Be the first to share your thoughts.
Leave a comment