Model Context Protocol (MCP) practice questions

Worked examples for Model Context Protocol (MCP)

1. Question 1

   A team is building an MCP server to sit in front of an internal expense system. They want an AI assistant connected to that server to be able to **submit a new expense report** on the user's behalf — an operation that changes state in the backing system and returns a result the model can reason about. Which MCP server primitive is intended for exposing that capability?

   1. A. A resource, because the server controls all interaction with the expense system through resources

      Confuses resources with actions. Resources are context/data the client or model can read — file contents, records, documents — and are not the primitive through which the model effects change in an external system.

   2. B. A prompt, because prompts are how an MCP server executes a workflow on the user's behalf

      Misconception that prompts execute work. Prompts are reusable templates/workflows the server offers to shape a request; selecting one does not itself perform an action against a backend system.

   3. C. A sampling request, because the server must ask the host to generate the submission before it can act

      Confuses a client-side capability with a server primitive. Sampling lets a server request a model completion from the client; it is not the primitive for exposing an invocable action, and no such request is needed to define one.

   4. D. A tool, because tools are the executable actions an MCP server exposes for the model to invokeCorrect answer

      Correct. In MCP, tools are the primitive representing actions/functions the server makes invocable, which the model can call to perform operations and receive results (MCP core architecture — server primitives).

   Explanation

   MCP servers expose three primitives — tools, resources, and prompts. Tools are the executable actions the server makes available for the model to invoke, so a state-changing operation such as submitting an expense report is modelled as a tool. Resources are read-only context the model can consume rather than a way to act on a system; prompts are reusable templates that structure an interaction but perform no backend work themselves; and sampling is a client-side capability that lets a server request a completion, not a way to publish an invocable capability.

2. Question 2

   An architect is explaining why the Model Context Protocol separates its data layer from its **transport layer**. One team wants to run an MCP server as a local subprocess on the developer's machine; another wants to reach an equivalent remote MCP server over HTTP. Both teams expect the meaning of the exchanged messages to stay the same. Which statement best describes the purpose of the transport layer in MCP?

   1. A. It is the mechanism that carries messages between client and server, so the same protocol semantics can run over different transports such as a local subprocess or a remote HTTP connection.Correct answer

      MCP separates the data layer (what messages mean) from the transport layer (how they are exchanged), which is why MCP supports both local stdio-style and remote HTTP-based transports without changing protocol semantics.

   2. B. It defines which tools and resources a server offers, so changing the transport changes the set of capabilities available to the client.

      Confuses the transport with the server's capabilities. What a server exposes is declared at the data layer and is independent of how bytes move; swapping transports does not add or remove tools.

   3. C. It decides which capability the model should invoke for a given user request, acting as the routing and reasoning component of the protocol.

      Confuses the transport with reasoning and orchestration. Choosing which tool to call is the job of the host application and its model, not of the mechanism that carries messages.

   4. D. It is a single fixed communication channel mandated by MCP, so every compliant server must be reachable the same way regardless of where it runs.

      Assumes MCP is bound to one transport. The specification deliberately defines multiple transport mechanisms so that local and remote servers can both be supported by the same protocol.

   Explanation

   MCP layers the protocol so that the data layer defines what messages mean while the transport layer defines how those messages are physically exchanged between a client and a server. That separation is exactly why the same server semantics can be reached either as a local process or over a remote HTTP-based connection. Claiming the transport defines the available tools mixes it up with server capabilities declared at the data layer; claiming it selects which capability to call assigns it the host's and model's reasoning role; and claiming MCP mandates one fixed channel contradicts the protocol's support for multiple transport mechanisms (Model Context Protocol — Core architecture, https://modelcontextprotocol.io/docs/concepts/architecture).

3. Question 3

   An MCP server for a source-control system publishes a reusable, parameterized workflow called "summarize this pull request" that a user can pick from a menu in the host application. Choosing it fills in a structured, well-tested set of instructions for the model rather than performing an operation on the repository. Which MCP primitive does this workflow represent?

   1. A. A **tool**, since the user triggers it and something happens as a result

      Confuses being user-triggered with being an action. Tools execute functions with effects; this item only supplies structured instructions for the model.

   2. B. A **resource**, since the workflow text is data the server makes available

      Confuses prompts with resources. Resources are the data/content a client reads for context; a reusable, parameterized interaction template is the prompt primitive.

   3. C. A **client capability**, since anything selected by the user in the host is contributed by the client rather than the server

      Misattributes the primitive to the wrong side. Prompts are exposed by servers; the host merely surfaces them for the user to choose.

   4. D. A **prompt**, since prompts are reusable templates the server offers to structure an interaction with the modelCorrect answer

      Correct. Prompts are the MCP primitive for reusable, often user-selected templates and workflows that shape how the model is asked to do something.

   Explanation

   Prompts are the MCP primitive for reusable templates and parameterized workflows a server offers to structure interactions with the model, and they are typically surfaced for explicit user selection in the host. They are distinct from tools, which execute actions, and from resources, which supply readable data for context. The fact that a user picks the item in the host does not make it a client-side capability — it is still published by the server.

4. Question 4

   A team is building an MCP server that fronts their internal document store. They want a connected AI application to be able to (1) read the text of a specific policy document so the model has it as background context, and (2) file a support ticket in their tracking system on the user's behalf. Which MCP **server primitives** should be used for these two capabilities, respectively?

   1. A. A resource for reading the policy document, and a tool for filing the support ticketCorrect answer

      Correct. Resources expose data/context the client and model can read, while tools are the executable functions the model can invoke to take actions with side effects — exactly the read-vs-act split defined for MCP server primitives.

   2. B. A tool for reading the policy document, and a resource for filing the support ticket

      Inverts the two primitives — the classic tools/resources mix-up. A resource is not an executable action, so it cannot file a ticket, and read-only context is precisely what resources exist to expose.

   3. C. A prompt for reading the policy document, and a tool for filing the support ticket

      Misconceives prompts as a data-delivery channel. Prompts are reusable, parameterized templates that structure an interaction; the primitive for exposing readable content is a resource.

   4. D. A resource for reading the policy document, and a prompt for filing the support ticket

      Assumes prompts execute actions. Prompts only supply templated instructions to the model; invoking behaviour that changes external state is the job of a tool.

   Explanation

   An MCP server exposes three primitives with distinct purposes: resources provide data and context that the client or model can read, tools provide executable functions the model can invoke to perform actions, and prompts provide reusable templates that structure interactions. Reading a stored document is read-only context, so it belongs to the resource primitive; creating a ticket changes external state, so it belongs to the tool primitive. Treating a read as a tool and a state-changing action as a resource reverses those roles, and assigning either capability to prompts misreads templates as either a data channel or an execution mechanism.

5. Question 5

   Before the Model Context Protocol, every combination of an AI application and an external system (a ticketing system, a wiki, a database) tended to require its own bespoke integration, so adding one new data source meant new custom work in every application that wanted it. Which statement best describes the **primary problem MCP was created to solve**?

   1. A. It defines a faster binary wire format so that model inference requests consume less network bandwidth

      Confuses MCP with a performance/serialization optimization. MCP's purpose is interoperability of context and tool integrations, not reducing inference bandwidth.

   2. B. It standardizes how models are fine-tuned on proprietary company data so external lookups become unnecessary

      Confuses MCP with model training. MCP does not change model weights; it supplies context and tool access to a model at run time.

   3. C. It provides an open, standard way to connect AI applications to external context and tools, so an integration written once can be reused by any compatible applicationCorrect answer

      Correct. MCP exists to standardize how applications supply models with context and tools, replacing N×M bespoke integrations with a common protocol any host and server can speak.

   4. D. It replaces the need for an application layer by letting the model itself open direct network connections to any external system

      Misconceives the architecture: MCP does not give the model its own network stack. A host application and its clients mediate every server connection.

   Explanation

   MCP is an open protocol whose stated purpose is to standardize how applications provide context and tools to language models, so that an integration built once against the protocol can be consumed by any MCP-compatible application instead of being rewritten per application. It is not a serialization or bandwidth optimization, it does not train or fine-tune models, and it does not remove the host application — connections are always mediated by a host and its clients.

6. Question 6

   An architect is reviewing an MCP integration. One server runs as a local process alongside the host application, while another runs as a remote HTTP service; both expose the same set of capabilities to the same host, and the host's behaviour is unchanged between them. A colleague asks what the **transport layer** contributes to this arrangement. Which statement best describes the role of the transport layer in MCP?

   1. A. It defines which tools, resources, and prompts a server offers, so changing the transport changes the capability set the host can see.

      Confuses transport with the data layer. Capabilities such as tools, resources, and prompts are defined by the server and described at the semantic layer; swapping the transport does not alter what the server exposes.

   2. B. It is a single fixed communication channel mandated by MCP, so every compliant server must be reachable the same way.

      Assumes MCP is tied to one transport. The specification supports more than one transport mechanism — including local process communication and HTTP-based remote connections — precisely so servers can be deployed either way.

   3. C. It performs the reasoning that decides which server capability should be invoked for a given user request, relieving the model of that choice.

      Attributes decision-making to plumbing. Selecting which tool or resource to use is the job of the host application and its model, not of the channel that moves the messages.

   4. D. It is the mechanism that carries messages between a client and a server, and it is deliberately kept separate from the meaning of those messages, so the same capabilities work over local or remote connections.Correct answer

      Correct: MCP separates the data layer, which defines what messages mean, from the transport layer, which defines how they are exchanged — which is why a server behaves the same whether it runs locally or as a remote service.

   Explanation

   MCP draws a clear line between the data layer, which defines the semantics of the exchanged messages, and the transport layer, which defines how those messages actually travel between client and server. Because the two are separate, the specification supports multiple transport mechanisms — such as communication with a local process or an HTTP-based connection to a remote service — without changing what a server exposes or how the host uses it. A server's tools, resources, and prompts are therefore properties of the server rather than of the channel, and no transport is mandated for all deployments. Deciding which capability to invoke for a request remains the responsibility of the host application and its model, not of the message-carrying layer.

7. Question 7

   An enterprise already maintains hand-written adapters that let each of its four AI applications reach each of its six internal data systems, and an architect argues that adopting the **Model Context Protocol** would add a layer without removing any real work. A colleague counters by pointing at the reason MCP was defined in the first place. Which statement best describes the problem MCP exists to solve?

   1. A. It provides one standard way for models to connect to external context and tools, so each system is exposed once through a server that any MCP-compatible host can consume, instead of a bespoke integration per application-and-system pair.Correct answer

      This is the stated purpose of MCP: a common protocol for connecting models to external context and tools, which collapses the many-to-many set of custom adapters into one server per system plus one client per connection inside each host.

   2. B. It embeds the definitions of an organization's tools and data sources into the model itself during training, so a model natively knows how to reach each system without any integration code.

      Confuses a connection protocol with model training or fine-tuning. MCP is a wire protocol spoken at runtime between a client and a server; it changes nothing about model weights and does not require retraining when a system is added.

   3. C. It mandates one single network transport for every integration, so the benefit is that all AI applications and data systems finally communicate over the same wire protocol.

      The 'MCP is tied to one transport' misconception. MCP deliberately separates protocol semantics from the transport carrying the messages, and supports more than one transport; transport uniformity is not the point of the standard.

   4. D. It supplies the decision engine that inspects a user request and selects and invokes the appropriate tool, relieving the host application and its model of that reasoning.

      The 'protocol reasons about capability selection' misconception. MCP standardizes how capabilities are exposed and invoked; deciding which capability to use remains with the host application and the model it drives.

   Explanation

   MCP exists to give models a standard way to connect to external context and tools: a system is exposed once by a server, and any host running an MCP client can consume it, so N applications times M systems of custom adapters becomes N clients plus M servers. It is a runtime connection protocol, not a training-time mechanism, so it never places tool definitions inside model weights. It is also explicitly transport-agnostic — the messages are defined separately from the transport carrying them — so unifying on a single wire protocol is neither its aim nor its promise. And it standardizes how capabilities are described and invoked, while the judgment of which capability to invoke stays with the host and its model rather than the protocol (Model Context Protocol — Specification & docs, https://modelcontextprotocol.io/).

8. Question 8

   During a design review, a developer proposes collapsing an MCP server's three primitives into a single one, arguing that "tools, resources, and prompts are really the same thing with different names." The lead pushes back and asks the team to state the **defining difference** among the three primitives in terms of what each one contributes to a session. Which statement best captures that difference?

   1. A. Tools and resources are both executable, differing only in whether the server or the client runs them, while prompts store the transcript of past executions.

      Misconception: treating resources as executable. Resources are read-only context, not code the model runs; and prompts are forward-looking templates, not stored transcripts.

   2. B. All three are ways of returning data to the model, differing only in payload size: prompts for small strings, tools for medium results, and resources for large documents.

      Misconception: distinguishing the primitives by data volume rather than by role. The split is functional — action vs. context vs. template — and has nothing to do with payload size.

   3. C. Resources are the actions the model takes on the world, prompts are the read-only data the server offers, and tools are the reusable templates the client can list.

      Misconception: the classic three-way swap of the primitives' roles. Every mapping here is inverted relative to MCP, where tools act, resources are read, and prompts are the templates.

   4. D. Tools supply executable actions the model can invoke, resources supply readable context/data the model can consume, and prompts supply reusable templates that structure how a task is framed.Correct answer

      Correct. This is the standard separation of MCP server primitives: tools = actions, resources = context to read, prompts = reusable, parameterized templates (MCP core architecture).

   Explanation

   The three MCP server primitives are distinguished by role, not by implementation detail or size. Tools are executable actions the model can invoke; resources are context or data the server makes available for reading; prompts are reusable, parameterized templates that give a task a ready-made framing. Claiming resources are executable, or that the primitives differ only by payload size, ignores this functional split, and rotating the three definitions among each other simply restates the roles incorrectly (Model Context Protocol — Specification & docs).