Understand the three types of resources an MCP Server can expose and when to use each one to create powerful integrations.
Tools are the most powerful and most widely used resource type in the MCP ecosystem. They represent concrete actions that the AI model can execute — functions with well-defined parameters that let you query APIs, run scripts, send messages, process data, and interact with external systems. The model analyzes the conversation context, decides when a tool is needed, selects the most suitable one, and sets the correct parameters for the call.
A Tool in MCP, a tool is an executable function that the server exposes to the AI model. Each tool has a name, description, and parameter schema (JSON Schema) that defines exactly what data it expects to receive. The model decides when and how call them based on the conversation context — without requiring human intervention.
Tools are by far the most widely used resource type in the MCP ecosystem. It's estimated that about 80% of MCP Servers published expose at least one tool—many expose only tools. This reflects the most common use case: allowing the AI model to execute actions in the real world, from simple queries to complex operations across multiple systems.
Resources represent data and content that the MCP server makes available for the model to query. Unlike tools, resources don’t perform actions — they work like virtual files that the model can read when it needs information. Documents, database records, system configurations, logs, schemas — all can be exposed as resources. Each resource is identified by a unique URI that follows a standardized scheme.
A Resource in MCP, a resource is data or content that the server exposes for reading. Each resource has a URI (Uniform Resource Identifier) that uniquely identifies it — for example, file:///config/settings.json or db://users/schema. The model reads the resource when it needs additional context, but does not perform actions through it. Resources are passive — they inform, they don’t transform.
Think of Resources as a library — the model goes to the bookshelf, looks up the book it needs, takes in the information, and returns to the conversation with more context. It doesn't alter the books, rearrange the bookshelf, or write new pages. It simply reads and queries. If you need the model to do something with the data (modify, send, process), that's a job for a Tool—not a Resource.
Prompts are the third type of resource in MCP — and the most subtle. They allow the server to provide reusable instruction templates structured prompts that guide the model's behavior on specific tasks. Instead of the user manually writing "analyze this code and find bugs," the server can expose a predefined prompt such as code_review that already contains all the necessary instructions. The user or model can invoke these prompts.
A Prompt in MCP, a prompt is an instruction template that the server exposes for invocation by the user or model. Each prompt has a name and description, and can accept parameters (arguments) that customize the instruction. Examples: "analyze this code" (with a language parameter), "generate a sales report" (with a period parameter), "summarize this document" (with a format parameter). Prompts encapsulate expertise and best practices in reusable instructions.
The key to mastering MCP is understanding the clear distinction between the three types of resources. Tools are actions (verbs) — they do things. Resources are data (nouns) — they inform. Prompts are instructions (templates) — they guide. Tools can change state in the real world, Resources are strictly read-only, and Prompts shape the model's behavior without executing or reading directly.
| Aspect | Tools | Resources | Prompts |
|---|---|---|---|
| Nature | Actions (verbs) | Data (nouns) | Instructions (templates) |
| Function | Run operations | Provide information | Guide behavior |
| Changes state? | Yes | No (read) | No (guidance) |
| Who invokes it? | The model decides | The model consults | User or model |
| Example | send_email() | file:///readme.md | code_review |
Think of it this way: Tools do, Resources inform, Prompts guide. When you want the model to do something (send, create, delete, process), use a Tool. When you want it to know something (read data, check settings, access documents), use a Resource. When you want it to follow a pattern (analyze code in a certain way, generate a report in a specific format), use a Prompt.
The best way to understand the distinction between Tools, Resources, and Prompts is to see how they appear in real MCP servers. Each server combines the three types according to its domain—a GitHub server uses different tools than a database server, but both follow the same logic of separating actions, data, and instructions.
See how the three types of resources apply to real-world MCP servers:
Tools for creating, moving, and deleting files. Resources for reading content and listing directories. Prompts for organizing projects and analyzing folder structures.
Tools for sending and replying to emails. Resources for accessing the inbox and contacts. Prompts for drafting professional messages and summarizing threads.
Tools for creating alerts and escalating incidents. Resources for accessing metrics and logs in real time. Prompts for diagnosing problems and generating postmortems.
A truly powerful MCP server isn’t limited to a single resource type — it intelligently combines Tools, Resources, and Prompts to create a complete experience. The synergy among the three types is what turns a simple server into a robust, versatile integration capable of handling complex real-world scenarios.
Imagine a e-commerce MCP server complete:
The three types work together: the Support Prompt guide the model, the Resources inform about products and orders, and the Tools execute actions such as processing returns or applying discounts.
When designing your MCP server, start by identifying the three pillars: which actions the model needs to perform (Tools), which data it needs to access (Resources), and which behavior patterns should be reusable (Prompts). Not every server needs all three — many work perfectly with Tools alone — but the most complete and useful ones combine all three types cohesively.
In practice, the distribution of usage across resource types in the MCP ecosystem follows a clear pattern: ~80% of servers expose Tools, ~40% expose Resources, e ~20% expose Prompts. Servers that combine all three types tend to be the most complete and highly rated by the community—they offer an integrated experience where the model can act, consult, and follow standards, all within the same server.
Next Module: 1.6 — Communication Transports