Skip to main content

What the Model Context Protocol actually standardises

· 8 min read

Every AI application wants to reach the same things: the repository, the issue tracker, a database, the documentation. Before the Model Context Protocol, each of those connections was written once per application. An integration built for one editor was useless in the next one.

MCP is the agreement that lets one integration work in every application that speaks it. It is much smaller than the noise around it suggests, and that is the best thing about it. This post is about what it actually pins down, checked against the current specification, revision 2026-07-28.

The N times M problem​

With N AI applications and M tools, the old world needed N times M integrations. Each application had its own plugin format, and each tool vendor picked a few applications to support and ignored the rest.

A shared protocol turns that into N plus M. Every application implements the client side once, every tool implements the server side once, and any pair can talk. The specification says plainly where the idea comes from: the Language Server Protocol, which did the same thing for programming languages and editors. A language ships one language server instead of a plugin for every editor.

Hosts, clients and servers​

The specification names three roles, and the distinction matters more than it first appears.

  • The host is the LLM application: Claude Code, VS Code, Cursor, a chat app. It holds the conversation, talks to the model and asks the user for consent.
  • A client is a connector inside the host. Each client talks to exactly one server, so a host with four servers runs four clients.
  • A server provides context and capabilities. It can be a local process or a remote service.

One design principle in the specification explains the shape: servers should not be able to read the whole conversation, nor see into other servers. The host keeps the history and decides what each server gets. A server only sees the requests sent to it.

Three things a server can offer​

A server exposes up to three kinds of primitives, and the specification assigns each one to a different party.

PrimitiveWho controls itExample
ToolsThe modelRun a query, create an issue
ResourcesThe applicationFile contents, a schema, git history
PromptsThe userA slash command that starts a workflow

Tools are functions the model decides to call. Because a tool is arbitrary code, the specification says there should always be a human in the loop who can deny an invocation, and that clients must treat tool annotations, such as "read-only", as untrusted unless the server is trusted.

Resources are data identified by a URI. The host decides how to use them: show them in a picker, let the user attach them, or include them automatically.

Prompts are templates a user picks on purpose, usually surfaced as slash commands.

I find this table the most useful part of the specification. When I design a server, the first question for each feature is who should be in control of it. If the user should choose, it is a prompt; if the model should decide, it is a tool.

Clients can offer features to servers too. The one the current revision keeps is elicitation, where a server asks the user for more information. Sampling and roots still work but are now deprecated.

JSON-RPC underneath​

Every MCP message is a JSON-RPC 2.0 request, response or notification, encoded in UTF-8. A tool call looks like this:

{
"jsonrpc": "2.0",
"id": 7,
"method": "tools/call",
"params": {
"name": "convert_time",
"arguments": { "utc": "2026-10-11T09:00:00Z", "timeZone": "Europe/Istanbul" },
"_meta": {
"io.modelcontextprotocol/protocolVersion": "2026-07-28",
"io.modelcontextprotocol/clientCapabilities": {}
}
}
}

The specification separates two kinds of failure. A protocol error, such as an unknown tool or a malformed request, is an ordinary JSON-RPC error. A tool execution error, such as a date in the wrong format, comes back as a normal result with isError: true, and clients should show it to the model so it can correct itself and try again. That second kind is where most of a server's usefulness lives.

Two transports​

The protocol means the same thing on every transport. The specification defines two.

stdio. The client starts the server as a subprocess. Messages are newline-delimited JSON on stdin and stdout. The server must not write anything to stdout that is not a valid MCP message; logs go to stderr. Most servers you install locally with a single command use this.

Streamable HTTP. The server exposes one endpoint, and every message from the client is a new HTTP POST. The server answers with a single JSON object or with an SSE stream scoped to that request. Servers must validate the Origin header, and a local server should bind to 127.0.0.1 rather than every interface. The older HTTP+SSE transport is deprecated.

Capability negotiation, now per request​

Earlier revisions started every connection with an initialize handshake in which client and server agreed on a protocol version and exchanged capabilities. The 2026-07-28 revision removed it, and this is the biggest change in the current specification.

MCP is now stateless. Every request carries its protocol version and the client's capabilities in _meta, as in the example above. Servers must implement server/discover, which returns the protocol versions they support, their capabilities and their identity; a client may call it first, or just send requests and handle UnsupportedProtocolVersionError. Protocol-level sessions and the Mcp-Session-Id header are gone from Streamable HTTP. A server that needs state across calls mints its own handle and has it passed back as an ordinary tool argument.

I think this is the right call. A stateless server is an ordinary HTTP service: it can sit behind a load balancer, restart, and scale out without sticky sessions.

A server in C#​

The official C# SDK is the ModelContextProtocol package on NuGet. With it and Microsoft.Extensions.Hosting, this is a complete stdio server:

using System.ComponentModel;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ModelContextProtocol;
using ModelContextProtocol.Server;

var builder = Host.CreateApplicationBuilder(args);

// stdout belongs to the protocol, so every log line goes to stderr.
builder.Logging.AddConsole(o => o.LogToStandardErrorThreshold = LogLevel.Trace);

builder.Services
.AddMcpServer()
.WithStdioServerTransport()
.WithToolsFromAssembly();

await builder.Build().RunAsync();

[McpServerToolType]
public static class TimeTools
{
[McpServerTool(Name = "convert_time", ReadOnly = true)]
[Description("Convert a UTC time to local time in an IANA time zone.")]
public static string ConvertTime(
[Description("UTC time in ISO 8601, e.g. 2026-10-11T09:00:00Z")] DateTimeOffset utc,
[Description("IANA time zone id, e.g. Europe/Istanbul")] string timeZone)
{
if (!TimeZoneInfo.TryFindSystemTimeZoneById(timeZone, out var zone))
throw new McpException($"Unknown time zone '{timeZone}'. Use an IANA id such as Europe/Istanbul.");

return TimeZoneInfo.ConvertTime(utc, zone).ToString("yyyy-MM-dd HH:mm zzz");
}
}

WithToolsFromAssembly finds every class marked [McpServerToolType] and turns each [McpServerTool] method into a tool, with the descriptions and an input schema generated from the parameters. The exception matters: the SDK returns a thrown McpException as a tool result with isError set and its message intact, while any other exception becomes a generic message so internal details don't leak. So the message is written for the model, and it says what a valid value looks like.

What MCP is not​

It is not an agent framework. MCP has no planner, no loop, no memory and no opinion about which model you use. Deciding when to call a tool, and what to do with the result, is the host's job. MCP only defines how the host reaches the tool.

It is not security by itself. Authorization is optional in the specification. When it is used, it applies to HTTP transports and is built on OAuth 2.1; a stdio server is expected to take its credentials from the environment. Even with a valid token, authorization tells a server who is calling, not whether a particular call is wise. Consent, approvals and what a tool is allowed to do remain the host's and the server's responsibility.

It is not a guarantee of a good tool. The protocol carries whatever the server offers. A server that mirrors a REST API endpoint by endpoint is still hard for a model to use, however correct its JSON-RPC is. I wrote about that separately in designing tools an LLM can use correctly.

What MCP standardises is the plug: the roles, the three primitives and who controls them, the message format, two transports and how the two ends learn what the other supports. The specification is short enough to read in an evening, and reading it is the fastest way to stop being confused by everything written about it.