MCP Server Architecture: Hosts, Clients, Servers, and Transports

MCP server architecture is three roles and two transports. The host is the AI app. It opens one client per server. The server is the process that offers tools, resources, and prompts. Stdio is for a process on the same machine. Streamable HTTP is for a process somewhere else.

By Tayyab Javed, AI agent developer

What are the pieces of an MCP server architecture?

The host coordinates. Visual Studio Code, Claude Desktop, and Cursor are hosts. For each server the host wants, it creates a client that holds that one connection. A second server gets a second client. The server does not call the model. It answers tools/list, resources/list, and prompts/list, then runs the call the client sends. The guides that follow from this picture are on the MCP servers hub.

Two layers sit under that. The data layer is JSON-RPC: discovery, then the primitives. The transport layer is how the bytes move, and where authorization lives. Current protocol revision on that page is 2026-07-28. Discovery is a server/discover request. I did not print the raw JSON-RPC from a socket. I did list the three primitives through the Python SDK, which speaks that protocol.

Which transport should the server use?

Use stdio when the host starts the process. There is no port, so there is no network auth. Use Streamable HTTP when the server is remote and more than one client will call it. HTTP POST carries the client messages. Authorization on that transport is a bearer token, and the spec page says to prefer OAuth to get the token. The production shape of that choice is the MCP production guide. The smallest server you can run on stdio is how to build an MCP server.

What can a server expose?

Three primitives. A tool is a function the model invokes. A resource is data the host reads by URI. A prompt is a template the host can fill. This is mcp 2.3.0, Python 3.11 or newer, installed with pip install "mcp[cli]==2.3.0". I connected mcp.Client to the object in-process.

from mcp.server import MCPServer

mcp = MCPServer("architecture-demo")

@mcp.tool()
def ping() -> str:
    """Return pong."""
    return "pong"

@mcp.resource("status://app")
def status() -> str:
    """Current status."""
    return "ok"

@mcp.prompt()
def summarize() -> str:
    """Ask for a one-line summary."""
    return "Summarize the user's last message in one sentence."

if __name__ == "__main__":
    mcp.run()

list_tools returned ping. list_resources returned status://app. list_prompts returned summarize. Calling ping with no arguments returned the text pong. mcp.run() serves that same object over stdio. Sampling, where a server used to ask the host for a model completion, is marked deprecated on the architecture page as of protocol 2026-07-28. New servers should call a model API themselves if they need one.

In practice

Frequently Asked Questions