MCP Prompts
MCPDefinition
The user-controlled MCP primitive. Pre-defined prompt templates that users explicitly trigger via the application UI (e.g., a '/summarize' command). The user chooses when to apply them. Prompts can be parameterized and support autocomplete via the MCP completion endpoint.
Example Usage
Create a 'review_pr' MCP prompt that users trigger from the IDE to automatically format a pull request review request.
Why It Matters for the CCA-F Exam
The CCA-F exam tests whether candidates can correctly classify the three MCP primitives by who controls them. Confusing Prompts (user-controlled) with Tools (model-controlled) is the most common mistake. Expect scenario questions that describe a slash-command or an autocomplete-powered template and ask which primitive is in use.
In Depth
MCP Prompts are the user-controlled primitive in the Model Context Protocol. Where MCP Tools (Primitive) are invoked by the model and MCP Resources are read-only data feeds, Prompts are explicitly triggered by the end user — typically through a slash-command or UI affordance in the host application. They are pre-defined, parameterized templates that standardize how a user hands off a task to the model.
How Prompts Work
When a MCP Server exposes a prompt, it registers a name, a description, and an optional list of arguments. The host application (client) calls prompts/list at startup to enumerate available prompts, then surfaces them in the UI. When a user invokes a prompt — say, /review-pr — the client sends a prompts/get request with any argument values the user supplied. The server returns a fully rendered messages array that the client injects into the conversation context, ready for the model to process.
Prompts can be parameterized: a /summarize prompt might accept a language argument so the user can request a French-language summary without rewriting the instruction each time. Argument completion is supported through the MCP completion endpoint (completion/complete), enabling IDE-style autocomplete as the user types argument values.
The Three Primitives Compared
| Primitive | Controlled by | Typical trigger | Transport direction |
|---|---|---|---|
| Tools | Model | Autonomous reasoning | Client → Server |
| Resources | Application | Data subscription | Server → Client |
| Prompts | User | Explicit invocation | Client → Server → Client |
Why Prompts Matter in Practice
Prompts encode team knowledge. Instead of every developer remembering to include the right context for a PR review, a single /review-pr prompt template can ensure the model always receives the diff, the ticket link, and the style guide reference. This is especially useful in multi-user environments where consistency across team members matters.
Because the prompt content is assembled on the server side, templates can pull in dynamic data at invocation time — for example, fetching the current open issues from a tracker and embedding them in the message list. This blurs the line between a static template and a lightweight resource, making Prompts a powerful composition point.
See also the MCP Primitives overview and MCP Server Configuration & Scoping for how servers are wired into a project.
How It's Tested & Common Confusions
Common question patterns:
- A scenario describes a
/standupcommand a developer types in their IDE to generate a standup update. Which MCP primitive is this? → Prompts (user triggers it explicitly). - Distinguish: the model autonomously calls a database lookup vs. the user invokes
/summarize. The first is a Tool; the second is a Prompt. - Questions about argument completion reference the
completion/completeendpoint, which only Prompts expose. - Lifecycle questions: prompts are fetched via
prompts/listat client startup, not cached forever — servers can update them between sessions.
Frequently Asked Questions
What is the difference between MCP Prompts and a system prompt?
A system prompt is injected by the application at the start of every conversation without user awareness or control. An MCP Prompt is explicitly chosen by the user at a specific moment — it produces a messages array that gets inserted into the conversation context when invoked, not at session start by default.
Can an MCP Prompt include tool calls or resource references?
Yes. The messages array returned by `prompts/get` can include any valid MCP message content, including embedded resource URIs or instructions that will cause the model to use tools. Prompts are templates for the full conversation context, not just the user turn.
Are MCP Prompts the same as prompt templates in the Anthropic API?
No. MCP Prompts are a server-side primitive registered in the MCP protocol and surfaced through a client UI. Anthropic API prompt templates are a separate concept — they live in Anthropic's console and are used for version management. The two are unrelated mechanisms.