MCP Architecture Diagram: Host, Client and Server Explained for CCA-F

The Model Context Protocol (MCP) is an open standard maintained by Anthropic that connects AI host applications to external tools and data sources through a uniform interface. Its architecture has three components — host, client, and server — and two transport mechanisms: stdio for local servers and Streamable HTTP for remote servers.

For CCA-F candidates, the MCP architecture diagram is more than a technical reference — it is a compressed map of the entire protocol. A single image encodes which component initiates connections, which enforces permissions, which exposes capabilities, and which transport path fits which deployment. Learn to read it and most MCP exam scenarios become mechanical.

What Is the MCP Architecture Diagram?

The official MCP architecture diagram at modelcontextprotocol.io depicts the three participants in every MCP session. The diagram shows a host application box — the boundary of the AI runtime — containing multiple labelled client nodes. Each client connects outward via a dedicated line to a server outside the host boundary. The two distinct transport paths running between client and server are not interchangeable; which one applies is determined by where the server runs.

For the Anthropic Claude Certified Architect — Foundations (CCA-F) exam, MCP is one of the highest-priority topic areas. Exam questions test whether you can reason about the protocol's structure: which component plays which role, which transport applies in which scenario, and how JSON-RPC 2.0 ties the layers together. Starting from the official diagram rather than a prose description gives you a concrete mental model to carry into the exam — one that works whether you are self-studying or following a structured claude certified architect course that covers MCP as a core module.

What Does Each Visual Element of the MCP Architecture Diagram Represent?

The official MCP architecture diagram has four distinct element types. Each maps to an exam-testable concept:

• The Host box — the application boundary. This is the process that runs your LLM: a Claude desktop client, a custom agent built on the Claude API, or Claude Code itself. The host owns the conversation and decides which servers to connect to.
• Client nodes (inside the host) — one per server connection. The MCP specification requires a 1:1 relationship between clients and servers: each client maintains exactly one persistent connection. Multiple clients can coexist inside a single host, giving that host access to multiple servers simultaneously.
• Server nodes (outside the host) — the capability providers. Each server exposes some combination of tools (executable functions), resources (readable data), and prompts (reusable templates). A server can be a local process or a remote service.
• Transport lines — the two communication paths. The diagram deliberately shows two distinct routes: one for local servers and one for remote servers. These are not interchangeable; transport type is determined by where the server lives.

How Do MCP Hosts, Clients, and Servers Fit Together?

Think of the host as an embassy, the clients as its diplomatic staff, and the servers as foreign offices. The embassy decides which offices to contact; each staff member manages a single official channel to one office; the offices provide whatever services they are equipped to offer.

In protocol terms:

1. The host initialises the overall MCP session and enforces the user's consent and permission model. Human-in-the-loop controls live here, not in the servers.
2. Each client performs the MCP handshake with its paired server, negotiates capability sets, and relays JSON-RPC 2.0 messages in both directions.
3. The server responds to capability discovery requests (tools/list, resources/list, prompts/list) and handles invocation requests (tools/call, resources/read).

The CCA-F exam covers all three roles. Know which component initiates connections (the client), which exposes capabilities (the server), and which enforces user permissions (the host).

What Transports Does MCP Support — and Why Does the Diagram Show Two Paths?

MCP defines two transport mechanisms, and the architecture diagram encodes both as distinct visual paths:

• stdio (standard input/output) — used when the server runs as a local subprocess on the same machine as the host. The host spawns the server process and communicates over stdin/stdout. This is the standard path for local filesystem servers, local database adapters, and tooling like Claude Code extensions.
• Streamable HTTP — used when the server is remote. The client opens an HTTP connection; the server can stream responses using Server-Sent Events. This path suits cloud-hosted tools, shared organisational servers, and any server reachable via a public endpoint.

The diagram shows two distinct lines precisely because choosing the wrong transport is a hard deployment failure — local servers cannot receive HTTP calls, and remote servers cannot attach to a host's stdin. On the anthropic model context protocol MCP topics in the CCA-F exam, transport selection is a likely scenario type. When a question describes a deployment, your first move should be to identify whether the server is local (stdio) or remote (Streamable HTTP).

How Does the MCP Visual Model Map to CCA-F Exam Questions?

Once you can "read" the architecture diagram, you can decode most MCP exam scenarios mechanically. Here is a worked example using Plinth-authored practice material:

Practice scenario: An agent host connects to a local code-execution sandbox and a remote web-search API. Both connections carry JSON-RPC messages. Which transport does each connection use, and why?

Model answer: The local sandbox uses stdio — the host spawns it as a subprocess and communicates over standard streams. The remote web-search API uses Streamable HTTP — it lives outside the host machine, so a network transport is required. Both carry JSON-RPC 2.0 messages, but the framing layer differs by transport.

Where Can You Find Official MCP Diagrams and Brand Assets?

The authoritative source for MCP architecture diagrams is the official MCP documentation at modelcontextprotocol.io. The specification pages include the canonical host-client-server diagram referenced throughout this post. Anthropic's Claude developer documentation also covers MCP integration in depth. Both sources are the correct reference for exam preparation; Plinth Prep is an independent study resource and is not affiliated with Anthropic.

For the model context protocol logo and other brand assets, the MCP GitHub organisation at github.com/modelcontextprotocol hosts the specification and associated materials. If you need the logo for a study slide or presentation, check the repository's documentation for any provided assets — and verify availability directly at the source, as asset policies can change.

MCP Architecture Diagram FAQ: Quick Answers for CCA-F Candidates

What does the MCP architecture diagram show?

The MCP architecture diagram shows three participants: a host application (the AI runtime, such as Claude Desktop or a custom agent), one or more clients inside that host — each maintaining a dedicated connection to one server — and servers outside the host exposing tools, resources, and prompts. Two transports connect them: stdio for local servers and Streamable HTTP for remote servers.

What are the three components shown in the MCP architecture diagram?

The diagram shows hosts, clients, and servers. The host is the application boundary — your LLM runtime. Clients live inside the host, one per server connection, and manage the JSON-RPC session. Servers live outside the host and expose tools, resources, and prompts. The CCA-F exam covers all three roles and their precise relationships.

What transports does MCP support, and how do you choose between them?

MCP supports two transports: stdio for local servers running as subprocesses on the same machine, and Streamable HTTP for remote servers. Transport choice is determined by server location, not preference. Stdio communicates over stdin/stdout; Streamable HTTP opens a network connection and can stream responses from server to client using Server-Sent Events.

How does the MCP architecture diagram help with the Anthropic Claude Certified Architect — Foundations exam?

The Anthropic Claude Certified Architect — Foundations exam tests MCP across multiple scenario types: identifying host, client, and server roles; selecting the correct transport for a deployment; and distinguishing capability types — tools, resources, prompts. The architecture diagram provides one mental model that simultaneously covers all of these question patterns.

Where is the official MCP documentation for CCA-F study?

The primary MCP specification lives at modelcontextprotocol.io, maintained by Anthropic. Architecture diagrams, transport specifications, and capability definitions are all documented there. Anthropic's Claude developer docs also cover MCP integration patterns. Both are authoritative and free references for anthropic model context protocol MCP questions on the CCA-F exam.