What are MCP resources?
MCP resources are pieces of data an MCP server offers to the client as context for the model: a file, a database schema, a record, each identified by a URI. The client lists them, reads the ones it wants, and decides what reaches the model. Unlike tools, the model does not call them; the application does.
Part of Glossary: the terms behind MCP, coding agents and shared pages, defined plainly.
The server declares the resources capability, then answers resources/list with every resource the caller may see: a URI, a name, a MIME type, maybe a size.
The client, or the person using it, picks one and sends resources/read with the URI. The server returns the contents as text or a base64 blob, one or several.
For whole families of data the server publishes URI templates such as file:///{path} in resources/templates/list, and the client fills in the blanks.
{ "uriTemplate": "file:///{path}", "name": "Project Files" }To hear about changes, the client opens a subscriptions/listen stream naming the URIs it cares about; the server sends notifications/resources/updated.
The host app chooses how the data reaches the model: a picker, a search box, or automatic inclusion. The protocol leaves that decision to the application.
Source: MCP specification: resources
Resources versus tools
MCP gives a server three things to offer: tools, resources and prompts. The spec sorts them by who is in charge. Tools are for the model to call. Prompts are for the person to pick. Resources sit in between: the application reads them, and the application decides what to do with the result. That might be a file tree in a sidebar where you tick the files you want in context, a search box, or a rule like "always include the schema of the open database".
The practical consequence is the thing people miss. A resource is only useful if the client you are targeting surfaces resources somewhere. If it has no picker and no inclusion rule, the model never hears about them. A tool that returns the same bytes works in every client, because every client lets the model call tools. Intraface, for example, hands board files to agents through tools (pull_board, read_file) rather than resources, so the same agent can read a board whether or not its client has a resource picker.
Example: a project file and a template
A filesystem server lists file:///project/src/main.rs with the name main.rs, a title, a description and the MIME type text/x-rust. It can also attach annotations: an audience of user, assistant or both, a priority from 0 to 1, and a lastModified timestamp. A client can sort by recency, hide assistant-only material from the sidebar, or treat priority 1 as "always include".
Listing every file one by one would be silly, so the same server publishes a template, file:///{path}. The client expands it with a path the user typed, and the completion API can suggest values for the blank. A read of a directory URI may return several contents at once, one per file. From the 2026-07-28 revision, resources/list, resources/read and resources/templates/list results also carry ttlMs and cacheScope, so a client knows how long it may keep the answer and whether a shared cache may hold it.
When to use resources
Use a resource when the data is something a person would recognise and choose: documentation pages, config files, records in a system, a design spec. Use a tool when the model needs to fetch data as part of acting, or when the data depends on arguments the model works out at runtime. If a resource should always be in context, a client-side rule or a prompt that embeds it does the job; listing it is not enough.
Pick the URI scheme with care. The spec says https:// is only for resources the client can fetch from the web on its own, without going through the server. If the server has to do the downloading, use file://, git:// or a custom scheme that follows RFC 3986.
Common mistakes
- Assuming subscribe still works the old way. The 2025-11-25 revision had
resources/subscribeandresources/unsubscribe. In 2026-07-28 they are gone; the client opens asubscriptions/listenstream withresourceSubscriptionsset to the URIs it wants, and the server answers withnotifications/resources/updatedon that stream. - Returning an empty contents array for a missing resource. The spec forbids it, because an empty array could mean "exists but blank". Return a JSON-RPC error with code -32602; clients should still accept -32002, the code older revisions used.
- Making the list depend on the connection. Since sessions were removed,
resources/listmust not vary per connection. It may vary by the credentials on the request, so a server can show each caller only what their scopes allow. - Trusting the path. A
file://server must sanitize paths; the spec names directory traversal as the attack to prevent.
FAQ
- Are MCP resources sent to the model automatically?
- No. The spec calls resources application-driven: the host application decides whether to show them in a picker, let the user search them, or include some by its own rules. A server that lists a resource has only made it available, not put it in front of the model.
- What is the difference between MCP resources and MCP tools?
- Who controls them. A tool is called by the model when it decides to act. A resource is read by the application, usually because a person selected it. Both can return the same bytes; the difference is who asks and when.
- How do MCP resources handle binary files?
- A resources/read result carries either a text field or a blob field holding base64-encoded bytes, plus a mimeType. An image, PDF or archive comes back as a blob. The spec requires servers to encode binary data properly and to validate every URI they are asked for.
Stop sending HTMLover Slack.
Create an account in a minute, connect your coding agent, and make your first board.