What Is an MCP Client?

📘 One connection, one session

A client is the component that holds one connection to one server on behalf of a host application. It opens the connection, performs the initialization exchange in which both sides agree a protocol version and declare what they support, then sends requests, receives responses, and handles the notifications a server emits when something on its side changes.

One client to one server is a deliberate isolation rather than an implementation detail. Session state, negotiated capabilities and failure modes all belong to a single pairing, so a server that stops answering takes down its own client and nothing else. A host running four servers is running four clients, and none of them knows about the others.

Within the request loop itself a client is a participant rather than a decision-maker. It does not choose which operation to call, does not decide what is offered during an exchange, and does not interpret results beyond parsing them. Those decisions belong to the host. In most implementations the client is a small object obtained from a library, which is why it is often invisible in descriptions of the arrangement even though the specification names it as a role.

🧩 What it offers back, and what it has to remember

A client is not only a consumer of what a server offers. It declares capabilities of its own as the connection opens, and those are what allow a server to ask rather than assume. A server may request a completion, which travels through the client to the host — and the host decides whether to run it at all, against what, and what to hand back. A server may be given the boundaries it is expected to stay inside, so that a filesystem-shaped server is not left guessing which directories were meant. And a server may ask for a value that only the person using the application can supply, instead of inventing one.

What a client does own is state, and most of the trouble here is state trouble. The agreed version and the feature declarations are fixed for the life of the connection. Any listing it has read is a copy — accurate until the server says otherwise, and a server that announces a change expects to be asked again rather than to have a stale copy kept in use. Any subscription to a particular item is held here too. None of it survives a reconnection; a new session negotiates from the beginning.

Noticing failure is the other thing that belongs here. A connection can end because a process exited, because a network path went away, or because the far side simply stopped answering, and the client is the component positioned to see which. What should happen next is not settled by the specification: whether to retry, how often, whether to tell the person, and what the surrounding application does in the meantime are all decisions of the host.

📐 Two meanings of the same word

The word is also used loosely in ordinary speech to mean the whole application — "my MCP client", meaning a desktop app. In the specification it means the connection object, and the application around it is the host. Both usages will be encountered; only one of them is the protocol’s. The distinction is worth keeping because the two fail differently: a client losing its connection means one server is out of reach, while a host failing means none of them is.

⚙️ How the Registry classifies writing a client

Writing a client that connects, lists what a server exposes and calls an operation with validated arguments is code written against a protocol, which the code modification class covers. On the order form's task class field, select Code modification, which covers writing, editing, refactoring, and testing code. That class has its own page at /tasks/code.

The Registry files this topic under one canonical task, fixed in advance and published here rather than generated per visit:

Write an MCP client that connects to a running server, lists its operations, and calls one of them with validated arguments.

That string, hashed once, is 40ce4d67996a7662… — the first sixteen of sixty-four hex characters. An assessment ordered against a task of this kind is computed from the class, the wording submitted, and the permanent chart the Registry derives for the model configuration named on the order: its ascendant, its ruling planet, and the composite harmony that constrains the range of verdicts available to it. The whole derivation is published at /method.

The risk in client work is state: a connection assumed open, a capability assumed present, or a list cached past the notification that said it had changed. 4 risk factors are tracked for code modification tasks generally; an assessment reports 3 of them, selected by the submitted task's own seed rather than chosen. Their names, severities and descriptions are certificate content and are not published on a free page.

Get Assessment

📏 What this page does not claim

The Registry makes no representation that an assessment predicts the outcome of any task, and no assessment is validated against real-world results.

This page defines a term and states a classification. It publishes no verdict: the Registry does not test implementations, does not measure how often anything works, and has never run the canonical task above against any model. How the connection is retried, and what the surrounding application does when a server disappears mid-session, are outside the canonical brief.

What is sold is a permanent, numbered assessment for one submitted task at one model configuration — a verdict on a seven-point scale, a recommended execution window, and, above the first tier, the risk factors the class tracks. EUR 1.90 Standard, EUR 4.90 Extended, and EUR 14.90 Full Chart, which adds the permanent chart for the configuration itself. Assessments from EUR 1.90; machine-readable at /pricing.json.

🔗 Related surfaces

← All MCP topics · The AFR-1 method · Code modification task class

Related topics: MCP host · MCP server · Transports

❓ Questions about a client

What is an MCP client?

The component inside a host application that holds one connection to one server. It performs the opening handshake, sends requests, and receives responses and notifications for the life of the session.

Is a client the same thing as the application I use?

No. The application is the host. The client is one connection object inside it, and a host connected to three servers is running three clients.

What happens during initialization?

The two sides agree a protocol version and declare which features they support. Everything that follows is constrained by that exchange: a request for a feature the other side never declared is not expected to work.

Does a client decide which operation to call?

No. It carries requests and returns what comes back. Whether an operation is worth calling, and whether it should be called at all, are judgements made by the host application around it.

What does a client offer a server?

Whatever it declared when the connection opened. A server may request a completion, which the client passes to the host to decide on; it may be given the boundaries it should stay inside; and it may ask for a value only the person using the application can supply.