Skip to main content
Guide

MCP Explained: A One-Page Guide

Host, client and server, the three primitives, both transports, one tool call step by step, and a safety checklist.

By Matthews WongUpdated Checked against MCP specification 2026-07-28

Key takeaway

One Markdown page that answers what MCP is and how it fits together: the host, client and server roles, who controls tools, resources and prompts, when to pick stdio or Streamable HTTP, the eight steps of one tool call, and a checklist to run before you connect a server. It follows the 2026-07-28 specification, which is stateless.

1 file

The file

Exactly what the download contains. Read it first, then copy or download.

mcp-explained.md
# MCP explained, on one page

Checked against the MCP specification, revision 2026-07-28.

## What it is

The Model Context Protocol (MCP) is a protocol, built on JSON-RPC, that lets
an AI application reach tools and data on servers through one standard
interface. A server exposes its capabilities once, and any application that
speaks MCP can use them.

## Host, client, server

| Role   | What it is                        | What it does                                          |
| ------ | --------------------------------- | ----------------------------------------------------- |
| Host   | The AI application you use        | Creates clients, enforces consent, talks to the model |
| Client | A connector inside the host       | Talks to exactly one server                           |
| Server | A local process or remote service | Exposes tools, resources and prompts                  |

One host runs many clients, and each client has a 1:1 relationship with one
server. By design, a server should not be able to read the whole conversation
or see into other servers. The full history stays with the host.

## What a server exposes

| Primitive | Who decides when it is used | What it is                                  |
| --------- | --------------------------- | ------------------------------------------- |
| Tools     | The model                   | Functions the model can call, with a schema |
| Resources | The application             | Data for context, each identified by a URI  |
| Prompts   | The user                    | Message templates, often shown as commands  |

## Two standard transports

| Transport       | How it works                                                                               | Pick it when                                      |
| --------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------- |
| stdio           | The client launches the server as a subprocess; messages travel on stdin and stdout        | The server runs on the same machine as the client |
| Streamable HTTP | The server is an independent process with one endpoint; every message is its own HTTP POST | The server is remote, or shared by many clients   |

- stdio: the server must write nothing to stdout except MCP messages. Log to
  stderr.
- Streamable HTTP: the server must validate the `Origin` header and should
  authenticate every connection. A reply is one JSON object or an event stream
  scoped to that request.
- The messages mean the same thing on both. Only the delivery differs.
- The older HTTP+SSE transport is deprecated. Do not build on it.

## The life of one tool call

1. The host creates a client for each configured server.
2. The client may call `server/discover` to learn the server's supported
   versions and capabilities.
3. The client sends `tools/list`. The server returns each tool's `name`,
   `description` and `inputSchema`.
4. The model reads those definitions and selects a tool and its arguments.
5. The host should let a human see the call and deny it.
6. The client sends `tools/call` with the tool name and the arguments.
7. The server validates the input, does the work and returns a result:
   `content` for the model, and `isError: true` if the tool failed.
8. The client passes the result to the model, which continues.

The protocol is stateless in this revision. There is no `initialize`
handshake and no session: every request carries its own protocol version and
client capabilities in `_meta`. A server that needs more input answers with an
`input_required` result, and the client retries the same call with the input.

## Two kinds of errors

- **Tool execution error**: a result with `isError: true` and a message. The
  model can read it and retry with better arguments.
- **Protocol error**: a JSON-RPC error, for example an unknown tool. The model
  is less likely to recover from it.

## Before you connect a server

- [ ] I know who wrote it, and I have read what it does.
- [ ] It gets the least access the job needs: one folder, one database role.
- [ ] I start read-only and add write tools only when a task needs them.
- [ ] Secrets come from environment variables, never from a committed file.
- [ ] A human can see and deny tool calls, at least for sensitive operations.
- [ ] I treat tool output as untrusted input. A server that fetches external
      content can carry instructions written by someone else.
- [ ] I treat tool descriptions and annotations as untrusted unless I trust
      the server.
- [ ] A remote server uses HTTPS and authentication.

## Glossary

- **JSON-RPC**: the message format MCP uses, encoded as UTF-8.
- **Capability**: a feature a client or server declares, such as `tools`.
- **`server/discover`**: the request that returns a server's versions,
  capabilities and identity.
- **`inputSchema`**: the JSON Schema that defines a tool's parameters.
- **`_meta`**: the field on every request that carries the protocol version
  and client capabilities.
- **MCP endpoint**: the single URL a Streamable HTTP server accepts POST on.
- **`subscriptions/listen`**: the request a client opens to receive change
  notifications, such as a changed tool list.
- **Handle**: an id a tool returns so later calls can refer to stored state,
  because the protocol has no session.
How to use it

From download to working

Use it when

  • You keep hearing about MCP and want the whole picture in five minutes.
  • You are about to connect an MCP server and want a safety checklist first.
  • You are explaining MCP to a team and need one page to hand out.
  • You learned MCP on an older revision and want to see what the stateless one changed.
  1. Read the three tables

    Roles, primitives and transports each fit in one table. Read them top to bottom once; they are the vocabulary every MCP document assumes.

  2. Follow one tool call

    Walk the eight numbered steps with a server you already use. Name which part is the host, which is the client, and which message is tools/list or tools/call.

  3. Run the checklist before you connect

    Tick the eight boxes for each new server. If you cannot tick least access or read-only first, change the server's configuration before you connect it.

  4. Keep it next to your config

    Put the file in your repository's docs folder or pin it in your notes. The glossary is the part you will come back to.

What is inside

Why it is written this way

Roles: host, client, server

The host is the AI application. It creates one client per server, and each client talks to exactly one server. By design a server should not be able to read the whole conversation or see into other servers.

Primitives, by who controls them

Tools are model-controlled: the model decides when to call them. Resources are application-driven: the host decides how to bring them into context. Prompts are user-controlled: the user picks them, often as a slash command.

Transports, with when to pick each

With stdio the client launches the server as a subprocess and they talk over stdin and stdout. With Streamable HTTP the server is an independent process with one endpoint and every message is an HTTP POST. The messages mean the same on both.

The tool call, as the current revision describes it

The steps use tools/list and tools/call and the optional server/discover request. There is no initialize handshake in them, because in the 2026-07-28 revision every request carries its own protocol version and client capabilities.

A checklist and a glossary

Eight checks before you connect a server: trust, least access, read-only first, secrets in the environment, a human who can deny calls, and tool output treated as untrusted. Eight terms are defined in one line each.

Watch for

What goes wrong

  • Many tutorials describe an initialize handshake and an Mcp-Session-Id header. The 2026-07-28 revision removed both, so do not mix those descriptions with this page.
  • The guide describes the protocol, not one product. How a client asks for approval or shows resources is up to that client.
  • One page leaves things out: authorization, pagination, caching and subscriptions are named at most. Read the specification before you build a server.
Questions

Frequently asked

Short answers before you download it.

What is MCP in simple terms?

MCP, the Model Context Protocol, is a protocol built on JSON-RPC that lets an AI application reach tools and data on servers through one standard interface. A server exposes tools, resources and prompts, and any application that speaks MCP can use them.

What is the difference between an MCP host, client and server?

The host is the application that coordinates everything: it creates clients, enforces consent and works with the model. A client is created by the host and communicates with exactly one server. A server exposes resources, tools and prompts, and can be a local process or a remote service.

Should I use stdio or Streamable HTTP?

Use stdio when the server runs on the same machine as the client, because the client launches it as a subprocess. Use Streamable HTTP when the server is remote or shared, because it runs as an independent process that can handle multiple client connections. The older HTTP+SSE transport is deprecated.

Does MCP still have an initialize handshake?

Not in the 2026-07-28 revision. It makes the protocol stateless: the initialize handshake and protocol-level sessions are removed, and every request carries its protocol version and client capabilities in _meta. A client may call server/discover first to learn what a server supports.

Is it safe to connect any MCP server?

No. The specification says there should always be a human in the loop who can deny tool invocations, and that clients must treat tool annotations as untrusted unless they come from a trusted server. Give a server the least access the job needs and start with read-only tools.

Go deeper

Learn what this file packages

Free lessons and articles on this site that explain the ideas behind it.

Sources

Primary sources checked on the research date. Follow them for the current version.

More from the toolkit

Take these too

GuideFree

AI Coding Workflow Checklist

Six phases of checkboxes for working with a coding agent, from the first prompt to the commit.

  • Claude Code
  • Codex
  • Cursor

1 file2.7 KB.md

TemplateFree

CLAUDE.md Template for Any Repository

A 70-line starter CLAUDE.md: project, stack, commands, hard rules, how to verify work and what not to do.

  • Claude Code

1 file2.1 KB.md

PromptFree

Plan Before Code Prompt

A planning prompt that covers business, domain, tech design and steps, then lists the decisions it needs from you.

  • Claude Code
  • Cursor
  • Claude.ai

1 file2.3 KB.md

All toolkit items