How is an MCP host different from an MCP client?

Flashcard·Easy·4.0 · 0·~30s·Asked atKrutrim Yellow Ai·Relevant atAnthropic Block Zed

Attempt it

The host is the end-user AI application (Claude Desktop, Cursor, Claude Code, Zed, Continue) that owns the user interface, calls the LLM, and orchestrates the agent loop. It contains one or more MCP clients, each a library-level object maintaining a single connection to one server. The host decides which servers to connect to, merges their tool catalogs, handles user consent, and routes tool calls. The client handles JSON-RPC plumbing for one server connection. Containment: host contains clients; each client connects to one server.

Your answer

**An MCP host** is the AI application a user opens on their machine. Claude Desktop, Cursor, Zed, Claude Code, and Continue are all hosts. The host is the only MCP role that has a user-facing interface. The key distinction is between host and client. The client is a small library inside the host that handles the JSON-RPC protocol for one server connection. The host is the entire application: the window or terminal, the chat thread, the configuration UI, the code that calls the LLM, and the orchestration logic that drives the agent loop. A host contains zero or more clients. Each client maintains exactly one connection to one server. You can have a host with no clients (no MCP servers configured) and it is still a host; it just is not using MCP yet. You cannot have a client without a host because the client is a library that must be embedded in something. The host's responsibilities go well beyond protocol mechanics. It decides which servers to connect to, prompts the user for consent before connecting to remote servers, merges tool catalogs from all connected clients into a single catalog for the LLM, calls the inference API, parses the model's tool calls, routes each call to the correct client, and renders everything in the UI. Mnemonic: host = app the user opens, client = library inside that app, server = external capability provider.

**An MCP host** is the end-user AI application that calls the LLM, owns the user interface, and orchestrates one or more MCP clients to expose external capabilities to the model. Each client is a library-level object inside the host, maintaining a single connection to one server. The host's responsibilities are everything outside the protocol boundary. Configuration: which servers the user has added and how to launch or connect to them. Consent: prompting the user before connecting to remote servers or executing destructive tool calls. Catalog merging: combining tool lists from all clients into the single catalog advertised to the model through the provider's function-calling API. Model orchestration: calling the inference API, parsing function calls, and driving the agent loop with stopping conditions. Routing: forwarding each tool call to the correct client. UI rendering: displaying the chat, tool-call transcripts, slash-command menus from prompt templates, and resource previews. The client is intentionally thin. It lives inside the host process, speaks JSON-RPC 2.0 on the wire, handles the initialize handshake, serializes requests and responses, and manages disconnect. It does not own a UI, does not call the LLM, and does not decide which tools to expose. A host with five configured servers has five client objects, all doing the same minimal protocol work, while the host orchestrates the user experience around them. The 2026 host landscape includes Claude Desktop, Cursor, Zed, Continue, Sourcegraph Cody, Windsurf, Claude Code, OpenAI Agents SDK, and Google Gemini CLI. The protocol stops at the client intentionally: each vendor builds the host experience they want while sharing the integration substrate underneath.

TL;DR

The host is the user-facing AI app (Claude Desktop, Cursor) that calls the LLM and orchestrates the agent loop. The client is a library inside the host, one per server connection.

Memory aid

Easy to grasp

If MCP is a city of services, the host is the building the user walks into. Inside that building are several phones (clients), each wired to a different outside helper (servers). The building has a front desk, lights, and a kitchen that talks to the AI brain (the LLM). The user never picks up the phones directly; they ask the front desk and the building decides which phone to use. Claude Desktop, Cursor, Claude Code, Zed, and Continue are all examples of these buildings.

Key concepts

MCP Host MCP Client MCP Server User Application

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

An MCP host is the user-facing AI application that sits on top of the Model Context Protocol stack. It is the role most people interact with directly: opening Claude Desktop, chatting in Cursor, running Claude Code in a terminal.

The host is also the most consequential role for product experience because it owns everything outside the protocol boundary. This deep dive walks through the definition, the containment relationship with clients, the six responsibility areas the protocol leaves to the host, the 2026 host landscape, and why the design intentionally leaves the host shape open to each vendor.

The definition, unpacked

An MCP host is the end-user AI application that calls the LLM, owns the user interface, and decides which servers to connect to and how to surface their capabilities.

Four claims carry weight in that sentence. End-user application means the host is what the user opens. It has a window, a terminal session, or a CLI prompt. Calls the LLM means the host consumes inference by calling the model API, passing a prompt and tool catalog, and reading back function calls and answers. Owns the user interface means the host decides how to render chats, tool-call transcripts, slash-command menus, and consent prompts. Decides which servers to connect to means the host controls configuration, authentication, and the lifecycle of every MCP client inside it.

Below the host sit one or more MCP clients (one per connected server) that handle JSON-RPC plumbing. Below those clients sit MCP servers wrapping real systems. Above the host sits the user. The host is the only role with both a UI obligation and an LLM obligation; everything else is infrastructure.

Host versus client: the sharpest line in MCP vocabulary

Six host responsibilities the protocol leaves open

The 2026 host landscape

Why MCP leaves the host shape open

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

Claude Desktop is Anthropic's desktop AI app and the original MCP host, shipped alongside the protocol launch in November 2024.
Cursor is a popular AI-first code editor that embeds MCP clients and supports both local stdio and remote HTTP servers for tool integrations.

What an interviewer would ask next. Try answering before peeking at the approach.

QCan two hosts share the same MCP server, and if so, what does each see?

Yes. For a stdio server, each host launches its own subprocess instance, so they run independent server processes. For a remote HTTP server, both hosts open separate authenticated connections and the server handles multi-tenant access. Neither host sees the other.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Confusing host with client. The host is the AI app the user opens (Claude Desktop, Cursor). The client is a library inside that app, instantiated once per connected server.

60 second bullets to scan on the way to the call.

Define an MCP host as the user-facing AI application.
State the containment relationship: host contains clients, each client connects to one server.

Primary sources. Browse if you want the original framing.