MCP: hosts, clients, servers, resources and tools
MCP separates the host that coordinates, the server that exposes, and the data it shares.

The Model Context Protocol (MCP) is a specification for how an AI application obtains context from other programs. It fixes the vocabulary — host, client, server, and the primitives exchanged between them — so a server written once can be reused.
The protocol is deliberately narrow. It “focuses solely on the protocol for context exchange—it does not dictate how AI applications use LLMs or manage the provided context.” Everything else — which tools exist, when one is called, what happens to the result — belongs to the host.
Host, client and server
MCP “follows a client-server architecture where an MCP host — an AI application like Claude Code or Claude Desktop — establishes connections to one or more MCP servers. The MCP host accomplishes this by creating one MCP client for each MCP server.” The roles are named directly: the host is “The AI application that coordinates and manages one or multiple MCP clients”; the server is “A program that provides context to MCP clients”; the client is what “maintains a connection to an MCP server”.
The ratio is the part people misread: one host, possibly many servers, exactly one client object per server. “A host application creates and manages multiple clients, with each client having a 1:1 relationship with a particular server.” Each connection carries its own negotiated state — MCP is a “stateful session protocol” on JSON-RPC — and the architecture keeps them apart: “Servers should not be able to read the whole conversation”. The host enforces that separation, not the servers.
Two layers: data and transport
MCP “consists of two layers”. The data layer defines the “JSON-RPC based protocol for client-server communication”, carrying version and capability discovery and the core primitives. The transport layer defines the “communication mechanisms and channels” — local standard input/output, or remote HTTP. The same messages travel over either, so a server’s behaviour does not change with the transport; its reach does. “Local MCP servers that use the STDIO transport typically serve a single MCP client, whereas remote MCP servers that use the Streamable HTTP transport will typically serve many MCP clients.”
Three primitives a server can expose
A server offers three kinds of thing. “Tools : Executable functions that AI applications can invoke to perform actions”. “Resources : Data sources that provide contextual information to AI applications”. “Prompts : Reusable templates that help structure interactions with language models”.
They differ in who decides. Tools are “model-controlled, meaning that the language model can discover and invoke tools automatically”. Resources are “application-driven, with host applications determining how to incorporate context based on their needs”. Prompts are “user-controlled”, typically reached through a user-initiated command. Discovery is uniform: “Each primitive type has associated methods for discovery ( */list ), retrieval ( */get ), and in some cases, execution ( tools/call ).” One server can offer all three at once — a database server “can expose tools for querying the database, a resource that contains the schema of the database, and a prompt that includes few-shot examples”.
From discovery to a tool call
A connection follows a fixed lifecycle: “The Model Context Protocol (MCP) defines a rigorous lifecycle for client-server connections that ensures proper capability negotiation and state management” — initialization, operation, shutdown. “The initialization phase MUST be the first interaction between client and server”, where the two sides agree a version and capabilities and may then use only what was negotiated.
A tool call is three steps. The client asks what the server offers and gets back each tool’s name, description and inputSchema; it sends tools/call with arguments matching that schema; the server returns a content array. The application sits in the middle: “the AI application intercepts the tool call, routes it to the appropriate MCP server, executes it, and returns the results back to the LLM as part of the conversation flow.” Servers may also push a notification when their tool list changes, so a client can refresh what it offers the model.
What the protocol does not do
MCP defines the wire format, not the policy. It does not decide which servers are trusted, which tools a model should prefer, or whether an action is safe — those are the host’s decisions, and the protocol only supplies the fields to express them. The obligations it does impose sit on both sides. Servers “MUST validate all resource URIs” and “Validate all tool inputs”, and “Implementations MUST carefully validate all prompt inputs and outputs to prevent injection attacks or unauthorized access to resources.” Metadata is not evidence: “clients MUST consider tool annotations to be untrusted unless they come from trusted servers”, and the tools page is explicit that there “SHOULD always be a human in the loop with the ability to deny tool invocations.”
Level and prerequisites. L4 — the protocol-level model of how a host, its clients and its servers fit together and what they exchange. The reader must hold three participant roles and three primitive types apart, and know that a tool call is two messages the application routes. Prerequisites: the L1 and L2 sheets on how a model generates text, context windows and structured output, and the L3 sheets on retrieval and tools.
Where to go next
- Automation & AI — the macro-area this sheet belongs to.
- Applications — the node this sheet sits in.
References
- Model Context Protocol — Architecture overview — the participants, the two layers, the three primitives and the tool-execution flow.
- Model Context Protocol — Architecture — the client-host-server split, the 1:1 client-to-server relationship and server isolation.
- Model Context Protocol — Lifecycle — initialization, capability negotiation, operation and shutdown.
- Model Context Protocol — Resources, Prompts and Tools — what each primitive is, who controls it, and the validation obligations on servers and clients.