MCP Architecture: Host, Client, and Server
The Three Participants
MCP follows a client-server architecture, but with three named participants — and getting these names right is the foundation for everything else in the course. An MCP host (the AI application, such as Claude Desktop, Claude Code, or VS Code) establishes connections to one or more MCP servers. It does this by creating one MCP client for each server. Each client maintains a single dedicated connection to its corresponding server.
| Participant | What it is | Example |
|---|---|---|
| MCP Host | The AI application that coordinates and manages one or more clients | Claude Desktop, Claude Code, VS Code, Cursor |
| MCP Client | A component inside the host that maintains one dedicated connection to one server | The connector object VS Code spins up per server |
| MCP Server | A program that provides context (tools, resources, prompts) to a client | GitHub server, filesystem server, Sentry server |
Host : Client : Server is 1 : N : N — one host, one client per server, one server per client connection.
The most common mistake
Beginners often call the client 'your server' or merge host and client into one thing. The precise model is: the HOST is the app, the host creates one CLIENT per SERVER, and each client-server pair has its own dedicated connection. When you connect to three servers, the host holds three clients.
One Client Per Server
Why one client per server instead of a single client talking to everything? Isolation. Each connection has its own lifecycle, its own negotiated capabilities, and its own state. If one server crashes or is slow, it doesn't take down your connection to the others. It also keeps security boundaries clean — a server only ever sees the one client connected to it.
One host holds a dedicated client for each server it connects to. Servers can be local (stdio) or remote (HTTP).
Local vs. Remote Servers
An MCP server is simply 'the program that serves context' — regardless of where it runs. That location distinction is worth internalizing because it maps directly to which transport is used (the next lesson).
- •Local server: runs as a process on the same machine as the host, usually launched by the host itself. It typically uses the stdio transport and serves a single client. Example: Claude Desktop launching the filesystem server.
- •Remote server: runs on another machine or platform and is reached over the network. It uses the Streamable HTTP transport and can serve many clients at once. Example: the hosted Sentry MCP server.
'Server' is a role, not a place
Don't equate 'server' with 'a big machine in the cloud'. In MCP, a server can be a tiny Python script running on your laptop. What makes it a server is that it exposes tools, resources, and prompts to a client — not where it lives.
Why This Structure Matters
This separation of roles is what lets MCP scale cleanly. The host focuses on the user experience and orchestrating the language model. Each client handles the protocol details of one connection. Each server focuses on doing one integration well. Because the contract between them is standardized, any host can use any server without either side knowing the other's internals.
Host (Claude Desktop)
├── Client A ──connection──▶ Server: filesystem (local, stdio)
├── Client B ──connection──▶ Server: postgres (local, stdio)
└── Client C ──connection──▶ Server: sentry (remote, HTTP)Coming up next
You know WHO the participants are. Next we'll open up HOW they talk — the two layers of MCP (data and transport) and the JSON-RPC messages that flow between client and server.
Key Takeaways
- ✓MCP has three participants: the Host (AI app), the Client (one per server, inside the host), and the Server (provides context).
- ✓The relationship is 1 host : N clients : N servers — the host creates a dedicated client for each server it connects to.
- ✓One client per server gives isolation: independent lifecycles, capabilities, and state, with clean security boundaries.
- ✓A 'server' is a role (it serves tools/resources/prompts), not a location — it can be a small local script or a hosted remote service.
- ✓Local servers typically use stdio and serve one client; remote servers use Streamable HTTP and can serve many clients.
- ✓The standardized contract means any host can use any server without knowing its internals — the key to MCP's scalability.
Check Your Understanding
Test what you learned in this lesson.
Q1.In MCP, what is the relationship between hosts, clients, and servers?
Q2.Which statement about an 'MCP server' is correct?
Q3.Why does MCP use one client per server instead of a single shared client?
Q4.Which of these is an example of an MCP host?
Practice This Lesson