Plexara
What you will take away from this lesson
In 208 - MCP Prompts: reusable prompts, we covered the second MCP primitive. This lesson takes the third. Resources are URI-addressable, read-only reference material the server exposes: brand assets, templates, worked examples, reference data. The stuff a well-built agent session pulls in at the right moment without anybody having to paste it into the chat.
Resources are the least talked-about primitive but often the one that changes how polished the output looks. A report generated with the company's brand logo and style guide already loaded is different from one the agent tried to reconstruct from training data.
Learning Objectives
- 01Explain what an MCP resource is: URI-addressable, read-only reference material the server exposes to the client.
- 02Distinguish resources from tools (dynamic calls), prompts (reusable instructions), catalog metadata (facts about data), and memory (per-user persistence).
- 03Name the four common categories of resources: brand assets, templates, worked examples, and reference data.
- 04Reference a resource from a prompt, either by naming it inline or by baking it into a prompt definition so every invocation pulls it in automatically.
- 05Recognize the MCP App as a special kind of resource: a URI with an HTML profile that renders as an interactive surface inside capable clients.
Where we are in the curriculum
If any term in this lesson feels unfamiliar, the 100 series is one click back. The 200 series assumes that mental model.
100 Series: the foundation
- 101What is a Large Language Model?Brilliant at language, blind about your data. Tokens, hallucination, the grounding problem.
- 102Tokens and your budgetSubscription-plan economics, session limits, and Plexara enrichment dedup.
- 103Context, compression, and memoryThe keep / compress / clear playbook and how memory carries across sessions.
- 104Frontier models, specialized models, and why enterprise AI uses bothThree knowledge sources (training, web search, tools). MCP as the exposure protocol.
- 105What is an AI agent?The think/call-tool/observe loop. Professor's knowledge, child's literalism.
- 110Is MCP just an API wrapper?MCP as an application layer. Spectrum from thin wrapper to full application server.
If a term in this lesson looks unfamiliar, back up to the 100 series. The 200 series assumes that mental model. Every row above is a direct link.
What an MCP resource actually is
The Model Context Protocol defines resources as URI-addressable, read-only content the server exposes to the client. Each resource has a URI, a name, a description, and a MIME type. Clients list resources with resources/list and fetch them with resources/read. The agent treats a resource like a piece of context it can pull in when the current task calls for it.
Resources are distinct from tools (which execute code and return dynamic results) and from prompts (which are reusable instructions). Resources are the static reference material that neither of those primitives covers: logos, style tokens, templates, worked examples, lookup data.
Anatomy of an MCP resource
URI
The unique identifier the agent uses to fetch the resource. Usually a custom scheme that makes the resource addressable without colliding with real URLs.
brand://theme, brand://logo, ui://platform-info
Name
A short human-readable label shown to the user in UI. Distinct from the URI.
ACME Brand Theme
Description
A sentence or two about what the resource contains and when to use it. Clients use this for pickers and tooltips.
Official ACME Corp colors and typography tokens for generated artifacts.
MIME type
Tells the client how to render or embed the content. Covers everything from static JSON to inline SVG to HTML profiles for interactive surfaces.
application/json, image/svg+xml, text/html;profile=mcp-app
The agent calls resources/list to enumerate what is available and resources/read to fetch the content of a specific resource by URI.
Where resources fit against everything else
Plexara already offers several places to put content. The catalog (DataHub) holds facts about the data. Memory holds per-user persistence. Tools execute operations. Prompts encode workflows. Resources are the fifth slot: static reference material the whole organization should be able to pull in verbatim.
Getting this division right keeps each layer focused. Content that belongs in the catalog will never be as good as a resource as it is as a first-class catalog entry with lineage, ownership, and review history. Content that belongs in memory will drift when it lives in a resource that everybody shares.
What resources are not (so it is clear what they are)
Tools
Holds: Dynamic operations the agent invokes to do work.
A resource is not a tool. Resources do not execute code or return computed results; they return static content.
Prompts
Holds: Reusable instruction templates with arguments.
A resource is not a prompt. Prompts tell the agent what to do; resources are the reference material it consults.
Catalog metadata (DataHub)
Holds: Facts about data: descriptions, owners, tags, glossary terms, lineage, curated queries.
A resource is not a catalog replacement. Information about your data goes in the catalog, not in a resource file.
Memory
Holds: Per-user or per-session persistence. Things that evolve over time.
A resource is not memory. Content that is personal, session-durable, or evolving belongs in the memory subsystem.
Resources are the right home for reference material the whole organization should be able to pull in verbatim: static content that does not execute, is not a workflow, is not about the data, and does not evolve per user.
Four common categories of resources
Most production use of the resource primitive falls into one of four buckets. Each solves a specific class of 'why did the agent not know this' problem.
Four common categories of resources
Brand assets
Logos, color tokens, typography. The agent loads them and embeds them verbatim in any dashboard, report, or slide deck it produces.
brand://logo and brand://theme in the ACME deployment. Every generated artifact uses the real brand palette rather than a guess.
Templates
Skeletons the agent fills in with live data: a quarterly-report template, an incident-writeup template, a compliance-export template. The template defines the shape; the data fills it.
A markdown report template with sections for executive summary, metrics, regional detail, and footnotes, ready for the agent to populate.
Worked examples
A sample of 'what a good output looks like' that the agent matches. Few-shot references that lift consistency without needing prompt changes.
A sample finished Q3 report the agent can study before producing the Q4 one. The structure, tone, and level of detail propagate automatically.
Reference data
Static lookups the agent may need to consult but that are not operational datasets: holiday calendars, currency codes, SLA definitions, regulatory category maps.
A bank-holiday calendar resource the agent consults when a date-aware query needs to account for holidays.
How a session reaches a resource
A user can name a resource directly in a text prompt, or a prompt author can bake a reference into a prompt definition. Either path ends in a resources/read call; the user just sees a better answer.
How resources get added to a deployment
Administrators add resources through the Plexara Portal or the REST API. The Portal is the usual path for ad-hoc uploads (a brand logo, a report template, a one-off reference document). The API is the usual path when resources are maintained programmatically or synced from an upstream source of truth, like a brand system or a document management system.
Once uploaded, a resource becomes available to every session on the deployment (subject to persona governance from 207). The agent sees it in the resources/list output and can fetch it on demand.
The MCP App: a resource that renders as an interactive surface
One resource type is worth singling out. A resource with MIME type text/html;profile=mcp-app is an interactive HTML application that capable clients render inline. Plexara deployments ship at least one of these automatically.
Where this leads
All three MCP primitives are now in place: tools, prompts, resources. Alongside them are the Plexara subsystems: semantic enrichment, memory, knowledge, governance. The 200 series closes with a lesson that threads a single real question through every piece at once.
Key terms
Five terms cover the vocabulary of resources. MCP App is the one most worth knowing by name; it is how a Plexara resource can become a full interactive surface rather than just static content.
Key Terms
- MCP resource
- A URI-addressable, read-only piece of reference material the server exposes to the client. Fetched with resources/read; enumerated with resources/list. Distinct from tools (which run code) and prompts (which are instructions).
- Resource URI
- The identifier the agent uses to fetch a resource. Plexara uses custom schemes (for example brand://, ui://) to keep resources addressable without colliding with real URLs.
- MIME type
- The content-type descriptor attached to a resource. Tells the client how to render it: application/json for structured data, image/svg+xml for vector graphics, text/html;profile=mcp-app for the interactive MCP App profile.
- MCP App
- An HTML-profile resource that capable clients render as an interactive surface. Plexara's ui://platform-info is an MCP App that shows the deployment description as a human-facing companion to the agent-facing JSON.
- resources/list and resources/read
- The MCP methods for enumerating available resources and fetching the content of a specific one by URI. The agent uses both during a session; the user rarely calls them by name.