The mental model: host / client / server
The mental model: host, client, and server
Level: from scratch — you don't need any previous experience. If you're coming from the previous lesson, you already know why MCP exists. Now we'll arrange the pieces: who is who when an AI connects to a tool. Watch the video above and follow this guide at your own pace.
In the last lesson we saw the what for of MCP. In this one we build the mental map: the three pieces that appear every time an AI application uses an external tool. Once this drawing is clear to you, the rest of the course reads itself. We still don't write code — this is pure concept.
What you'll learn
- The three roles of MCP: host, client, and server, with concrete examples.
- Why client and server are logical roles, not different computers.
- The two layers of MCP: the data layer and the transport layer (just the names for now).
- A simple analogy so you never forget it again.
The three roles, one by one
Think of a plug and an appliance: you need a standard so that anything connects with anything. In MCP that "connection" has three protagonists.
- Host — the AI application where you work. It's the one that "commands": it receives your request, talks to the model, and decides when to use a tool. Examples: Claude Desktop, an IDE with AI, or an app you build yourself.
- Client — a connector that lives inside the host. Its only job is to keep the conversation going with one server. Golden rule: one client per server. If the host connects to three servers, inside it has three clients.
- Server — the program that exposes capabilities: tools, data, or instructions the AI can use. This course teaches you to build these servers.
Full example: you open Claude Desktop (host) and ask it something about your GitHub repository. Inside, a client talks to the GitHub server, which exposes the capability "read issues". The host assembles the response and shows it to you. Three pieces, one flow.
Key idea: "client" and "server" are logical roles, not separate machines. It's not "one client computer and another server one". A single app can be server of one thing and client of another at the same time. It's like the words "guest" and "host": they describe a role in a situation, not two different people forever.
The two layers of MCP
MCP is organized into two layers. For now you only need to recognize the names; each one has its own lesson later on.
- Data layer — defines what the client and the server say to each other: the common language. That language is called JSON-RPC 2.0, a standard message format. You don't need to understand it yet; keep the name.
- Transport layer — defines how those messages travel from one side to the other (for example, inside your computer or over the network). We see it in detail in the transports lesson.
One way to remember it: the data layer is the language; the transport layer is the mail carrier who delivers the letter. You can change mail carriers without changing the language.
Key moments in the video
- 4 — The clients and servers appear: how each role fits into the drawing.
- 6 — The N×M problem explained with the microservices analogy: why a standard avoids building a hand-made integration for every pair.
Quick glossary
- Host: the AI application that coordinates everything (e.g. Claude Desktop).
- Client: a connector inside the host; one per server.
- Server: exposes capabilities (tools/data) — what you'll learn to build.
- Data layer: the language of the messages (JSON-RPC 2.0).
- Transport layer: how those messages travel.
- Logical role: a function in the conversation, not a different computer.
Downloads
- 📄 Diagram — Host / Client / Server (1-page PNG with the full flow).
- 📄 Cheat sheet — MCP mental model (1-page PDF with the three roles and the two layers).
Before moving on
If you keep one idea, let it be this: the host coordinates, the client connects, and the server exposes capabilities — and "client/server" are roles, not machines. In the next lesson we open the hood of the server: which primitives it exposes (tools, resources, prompts).