Opens in a new tab
Explainer

MCP: getting the missing records into the conversation

In brief

The assistant has your question. The release system has the answer. Follow how MCP connects the two, from a request for records to an explanation you can trace.

7 min read

Is this the right starting point?
Before you read
Ordinary experience using a computer and an AI chat application; no MCP, API or programming knowledge is required.
What you will take away
Explain how MCP connects an AI application to tools and information, trace a request and result, and distinguish that connection from the model’s reasoning, permission and the wider data path.
Sources
A coral plug faces a teal hub connected to a stack of papers, a round gauge and a lever.
On this page6 sections

“What changed in the catalog service this week?” sounds like a question an assistant ought to handle. The release records exist. So does the documentation explaining the settings. Unfortunately, neither is in the chat.

In this hypothetical example, you could copy the records into the conversation yourself. Or the application could retrieve them from the systems that hold them. Model Context Protocol, or MCP, gives compatible AI applications a shared way to ask outside software for data and operations. It connects the question to the records without making you carry every page across.

The useful part is reuse. A release-system team can describe its available operations once, through an MCP server, rather than inventing a different exchange for each compatible application. The project introduction describes that common interface. MCP carries descriptions, requests and results; the application decides how to use them, and the service does the work.

The chat window is only the beginning

You type the question into an AI application. That application is the host: it arranges the conversation with the model and presents the answer. Inside it, an MCP client talks to a particular MCP server, the software exposing the outside capabilities.

For the catalog question, one server might expose release records and another the configuration documentation. The host can manage a separate client for each. “Server” describes a role here, not a requirement to buy another machine: that software can run on your computer or elsewhere. The architecture guide lays out these relationships.

There are two exchanges to keep in view. The host asks the model to interpret your question. Its client asks a server for records or an operation. The server need not contain a model, and connecting it does not train the model on its data.

This separation lets a chat application and an editor use the same release interface while giving people quite different experiences. The team maintaining the records does not have to move them into either application.

Find the releases, open the reference, arrange the review

Our question needs more than a list of names. First, the assistant needs to find the deployments. A server could offer list_deployments, an operation accepting a service and date range. MCP calls such an operation a tool. Its schema describes the inputs it accepts. Clients can ask what tools are available with tools/list, then invoke one with tools/call, as the tool specification describes. A tool may read, calculate or write; the name does not make it harmless.

Next comes the setting nobody quite remembers. The configuration reference can be a resource: context identified by a URI, an address identifying the material. It need not be a file on your laptop. Finding that address in a list and reading its contents are separate steps, much as finding a document in a catalog is not the same as opening it. The resource specification defines both.

Finally, the application might offer a ready-made way to organize the release review. A server-supplied prompt is a reusable interaction template for that purpose, not a newly trained ability. The server concepts guide explains these three building blocks. A server need not provide all three, and different hosts may present them differently.

For our reader, they fit together naturally: find what changed, open the explanation of the setting, and arrange the findings into a review. The different names describe different jobs, not three rival ways to answer the question.

Give “this week” a service and two dates

Suppose the release server advertises three inputs: service, from and to. The host supplies that description to the model. The model can propose catalog as the service and dates for the requested week. Before anything goes out, the application checks the proposal against the person's request and its own controls.

The client then sends the request to the server. The server validates those inputs and uses its connection to the release system to retrieve the records. The results return through the client, ready for the host to supply to the model for explanation.

If two release IDs and deployment times come back, the assistant has something more useful than a plausible account of a typical release. It can describe the changes recorded by this system. Documentation can explain the settings. Neither record, by itself, proves which version a particular running instance actually loaded.

Keep the returned IDs beside the explanation so a reader can follow it back to the records. The handoff guide separates that information from interpretation and execution. If the next question is “Can you change it back?”, the application needs a fresh permission check for the current target. Having looked something up does not authorize changing it.

Nor does a known weekly lookup necessarily need a model to choose its inputs. Fixed code can perform a stable query. Model interpretation becomes useful when people phrase questions differently or one result shapes the next question. MCP can connect either approach; it does not require deliberation where a reliable rule will do.

Four stages of a hypothetical MCP lookup: host proposes and checks a request, client calls a server, server retrieves release records, and results return for explanation.
A hypothetical read-only lookup, not a complete wire trace. The model interaction belongs to the host; MCP carries the client/server request and result.

The second question still has to introduce itself

Before asking for deployments, a client can ask what sort of server it has reached. In the 2026-07-28 protocol revision discussed here, server/discover returns supported versions and capabilities. Discovery might establish that tools are supported; listing the actual tools is another request.

Now suppose you ask a second question on the same open connection. It is tempting to imagine the server picking up where the conversation left off. Under this revision, the new request still carries its protocol version and relevant capabilities. If it needs application state saved earlier, it must explicitly identify that state.

The release database has not forgotten its records. The connection simply is not a conversation history: unrelated requests can share it. The base specification makes that distinction explicit. Reusing a connection does not tell the server which earlier task to assume.

Older examples may start with initialize. Match the versions both ends support rather than combining instructions from different generations; backward compatibility can matter. This is an explanation of the architecture, not a tested installation guide.

On your laptop is not necessarily inside your laptop

A development tool might launch an MCP server process on your computer and exchange messages through that process's standard input and output. That route is called stdio. A centrally hosted service can instead use Streamable HTTP: the client sends messages to an HTTP endpoint, which replies with a JSON data object or a stream. Both carry the common protocol described in the transport specification.

The local arrangement can suit a development checkout; the remote arrangement can serve several authorized clients centrally. The practical difference is where the adapter runs and what it depends on.

Watch where the retrieved release record goes next. A local server may call a cloud service, and the host may send the result to a hosted model. The local-AI privacy guide follows those connections. A process running on your laptop does not, by itself, keep the whole exchange there.

A useful connection has a particular job

The catalog review needs release records and documentation. It does not need the power to deploy or delete. For protected HTTP servers, MCP's authorization framework describes OAuth-based access: credentials and permission scopes govern what the client can request. The stdio route handles credentials differently. Finding a capability through discovery does not grant permission to use it; integrations should request only the access needed for their intended operations.

The same distinction applies to the words that come back. A release note asking for secrets is still a release note, not permission to expand the task. A tool's claim to be read-only is not an access control. The tools specification treats annotations from untrusted servers as untrusted. If a change is needed, the remediation method checks authority against the current target and checks the effect afterward.

MCP earns its place when several applications need the same systems, or one application needs several systems. For a small fixed job already served by a reliable software interface, another adapter may add little while giving you another connection to operate. Reuse is valuable when there is actually something worth reusing.

Back at the chat window, “What changed?” can now lead to two release records, an explanation of the settings, and IDs the reader can follow. The answer is no longer waiting for someone to paste in the missing pages. The host has shaped the conversation, the service has retrieved the records, and MCP has given them a common way to exchange the request and result.

Source context

Source links appear within this article. Read them alongside the author’s analysis and evaluate the guidance against your environment.

Report an error or outdated detail

Keep reading

Where to go next