By Fahad Murtaza · Published
MCP resources and prompts: what they are, when to use
MCP resources and prompts: what they are and when to use them
An MCP server can offer a client three kinds of things: tools, resources and prompts. Tools get most of the attention, because they are the part that does work. MCP resources and MCP prompts are the other two, and they solve different problems: giving a model something to read, and giving a person something to start from.
This article explains both, shows the actual JSON-RPC messages from the specification, compares them with tools, and then shows what a WordPress site running WP MCP serves through each. If you are new to the protocol, start with what an MCP server is. The tools side has its own page, MCP tools explained.
Who controls what
The specification gives each primitive a different controller, and that is the clearest way to tell them apart.
| Tools | Resources | Prompts | |
|---|---|---|---|
| Controlled by | The model | The application | The user |
| What it is | An action to call | Data to read | A message template |
| Typical trigger | The model decides mid-task | The app attaches it, or the user picks it | The user picks it, often a slash command |
| Main calls | tools/list, tools/call |
resources/list, resources/read |
prompts/list, prompts/get |
| Can change data | Yes | No | No |
The spec words it this way: tools are model-controlled, resources are application-driven, and prompts are user-controlled. It also says the protocol does not force any particular interface, so a client is free to expose them in other ways. Treat the table as the intended design, not a rule every client follows.
One consequence: a resource or prompt is something the client application or the person reaches for. A tool is something the model reaches for. That changes what you put where.
MCP resources
A resource is data identified by a URI. The spec describes them as a way for servers to share data that gives a language model context, such as files, database schemas or application-specific information.
Declaring support
A server that supports resources must declare the resources capability when the connection starts. It has two optional flags:
{
"capabilities": {
"resources": {
"subscribe": true,
"listChanged": true
}
}
}
subscribe means a client can ask to be told when one resource changes. listChanged means the server will send a notification when the list of resources changes. A server can support neither, either or both.
Listing and reading
A client lists resources with resources/list, which supports pagination:
{ "jsonrpc": "2.0", "id": 1, "method": "resources/list" }
Each entry has a uri and a name, and may have a title, description, mimeType and size. To get the contents, the client sends resources/read with the URI:
{
"jsonrpc": "2.0",
"id": 2,
"method": "resources/read",
"params": { "uri": "file:///project/README.md" }
}
The result holds a contents array. Text comes back in a text field, and binary data comes back base64-encoded in a blob field, each with its uri and mimeType.
Templates, subscriptions and annotations
Three smaller features are worth knowing.
- Resource templates. A server can publish a URI template, such as
file:///{path}, and the client fills in the parameter. They are listed withresources/templates/list. - Subscriptions. If
subscribeis true, a client sendsresources/subscribefor a URI and getsnotifications/resources/updatedwhen it changes, then reads it again. - Annotations. Optional hints such as
audience(user,assistantor both),priorityfrom 0.0 to 1.0, andlastModified. A client can use them to decide what to include in context.
A missing resource should return the JSON-RPC error code -32002.
Why not just use a tool?
A tool can return the same data. The difference is who decides. A resource can sit in a picker or be attached to a conversation by the app without the model spending a turn calling something. That suits stable, read-only context: a schema, a style guide, a site summary. A tool suits anything that depends on arguments the model works out as it goes, or anything that changes state.
MCP prompts
A prompt is a reusable message template that the server offers and the user selects. The spec’s example is a slash command: the person types a command, picks the prompt, and the client inserts the messages into the conversation.
Declaring support
{
"capabilities": {
"prompts": {
"listChanged": true
}
}
}
As with resources, listChanged means the server will notify the client when the list changes.
Listing and getting
prompts/list returns each prompt’s name, and optionally a title, description and a list of arguments, each with a name, a description and whether it is required. prompts/get returns the filled-in messages:
{
"jsonrpc": "2.0",
"id": 3,
"method": "prompts/get",
"params": {
"name": "code_review",
"arguments": { "code": "def hello():\n print('world')" }
}
}
The result is a list of messages, each with a role of user or assistant and a content block. Content can be text, an image, audio, or an embedded resource, which is how a prompt can pull a server-side resource straight into the conversation. An unknown prompt name, or a missing required argument, should return the JSON-RPC error code -32602.
When a prompt is the right tool
Use a prompt when a person should choose the starting point: a code review request, a release-notes template, a checklist a team wants everyone to run the same way. A prompt does not run anything on its own. It gives the model a well-formed first message.
What a WordPress MCP server serves
WP MCP serves both primitives, on the HTTP endpoint at https://your-site.com/wp-json/mcp/wpmcp-server and on the stdio bridge. It advertises both capabilities when the connection starts.
Prompts: the skills library
The plugin ships short markdown playbooks called skills. They cover safe writes and rollback, governance and scoped identities, surgical Elementor editing, WooCommerce catalog work and safe database work. They are also available as tools, list-skills and get-skill, which are free.
Through the prompts primitive:
prompts/listoffers every skill the site can serve, named by its slug, for examplewpmcp-safe-writes.prompts/getreturns the skill body exactly as written, as a single user message.
A skill whose tools are not available on the site, such as the WooCommerce playbook on a site without WooCommerce, is hidden so that an agent is never handed a playbook it cannot follow. A skill marked Pro stays behind the licence until the site has one.
In a client that shows prompts as a picker, that gives a person a one-step way to load the “how to write safely” guidance before they ask for a change. The prompt text does not enforce anything: the safety checks still run in the plugin, whether or not anyone loaded the playbook.
Resources: site context and the skills catalog
Two resources are listed by resources/list, both with the MIME type application/json:
wpmcp://site/context: the same payload as theget-site-contexttool.wpmcp://skills: the same catalog as thelist-skillstool.
A read looks like this:
{
"jsonrpc": "2.0",
"id": 4,
"method": "resources/read",
"params": { "uri": "wpmcp://site/context" }
}
Site context is the summary an agent reads before it plans work, the same one get-site-context returns. A client that attaches resources can put it in front of the model before the conversation starts.
Governed like the tools behind them
Each prompt and resource is backed by the ability that serves the same data, so it is subject to that ability’s rules. The capability check, governance toggles, scoped identities, project-memory rules, audit log, rate limit and request log all apply, and when the backing ability is not registered the primitive is absent. A read-only scoped identity can use them because every backing ability is a read. Nothing here writes, so there is nothing to snapshot or undo. Writes still go through the tools, where each supported change takes a snapshot and can be rolled back with rollback-operation or rollback-session.
Why serve the same data twice
How a client handles resources and prompts is up to the client, and the specification makes both optional, so do not assume yours surfaces them. WP MCP therefore exposes the same content both ways: a client that supports prompts and resources can offer a picker and attachable context, and a client that only calls tools can reach the same data with get-skill, list-skills and get-site-context. You lose nothing by using a tools-only client.
In compact mode, the server advertises five tools: list-tools, get-tool-schema, call-tool, get-connection-info and get-site-context. That keeps the tool list short for clients that count tokens.
See them on your own site
- Connect MCP Inspector to your endpoint with the same URL and credentials your client uses.
- Open the Resources tab, list the resources and read
wpmcp://site/context. - Open the Prompts tab, list the prompts and get one of the skill slugs.
- Compare what you see with the output of
get-site-contextandlist-skillscalled as tools.
If a list is empty, check the exposure and governance settings. A switched-off backing ability removes its primitive, and so does turning skills off on the Skills screen. For signing in to the endpoint, see MCP authentication methods compared.
Design notes if you build your own server
- Put stable, read-only context in resources and actions in tools.
- Use prompts for starting points a person should choose, and keep arguments few.
- Validate every resource URI and every prompt argument. The spec says servers must validate resource URIs and treat prompt inputs and outputs carefully, since both can carry injected text.
- Apply the same access control to a resource as to the tool that returns the same data.
- Offer a tool equivalent if your audience uses tools-only clients.
For the protocol around all three, see what an MCP server is and MCP server examples. For what the plugin exposes, read the WordPress MCP server page. Pro adds deep page builder editing and more, and plans are on the pricing page.
Common questions
What are MCP resources?
MCP resources are data a server exposes for a client to read, each identified by a URI. They give a model context, such as a file, a database schema or a site summary. A client lists them with resources/list and reads one with resources/read. They are application-driven: the host app decides how to use them.
What are MCP prompts?
MCP prompts are reusable message templates a server offers to a client. A client lists them with prompts/list and fetches one with prompts/get, optionally with arguments. They are user-controlled, usually surfaced as something a person picks, such as a slash command.
What is the difference between MCP tools, resources and prompts?
Tools are actions the model can choose to call. Resources are data the application attaches as context. Prompts are templates the user chooses to start from. Per the spec, tools are model-controlled, resources are application-driven and prompts are user-controlled.
Do all MCP clients support resources and prompts?
Not necessarily. The spec makes both optional, and how a client surfaces them is up to the client, so check your client's own documentation. Some may use only tools. A server can still offer the same information as a tool, which is why WP MCP serves its site context and skills both ways.
Can an MCP resource change data?
A resource is for reading. The spec defines resources/read, subscriptions and change notifications, and no write call. Anything that changes data belongs in a tool. Every resource WP MCP serves is backed by a read-only ability, so none of them writes.
How do I see the resources and prompts on a WordPress MCP server?
Connect MCP Inspector to the endpoint with the same URL and credentials as your client, then open the Resources and Prompts tabs and run the list calls. You can also send resources/list and prompts/list yourself as JSON-RPC requests.