Essential Tools, Resources, and URI Schemes in MCP Explained

MCP’s tool calling interface has unlocked a wave of creativity across the developer community. But as more teams start wiring up tools and resources, it’s easy to hit performance bottlenecks or create noisy, brittle workflows. This guide pulls together practical insights from Aaron’s follow-up talk at the MCP Summit—designed to help you build smarter, faster, and more sustainable LLM apps.

Why Tools Are Powerful—and Risky

MCP tools give your server the power to inject information directly into the model’s context. This happens in two ways:

Tool Descriptions – instruct the model on how and when to use the tool.
Tool Results – inject data back into the context once the tool runs.

That makes tools incredibly flexible. Clients and servers only need to agree to speak MCP—no tight integrations required.

But flexibility comes at a cost:

Tool descriptions and results consume context space.
The more tools you use, the harder it becomes for the model to reason effectively.

Case Study: Hugging Face Search

Aaron’s team ran a simple experiment: they added GitHub and FileSystem tools alongside a basic search. The result?

47% slower response times
Nearly 2x more token usage

// Too many tools
agent.run([
  searchTool("paper"),
  githubTool(),
  fileTool()
])

Instead: consolidate intent into a single tool or use smarter prompt design whenever possible.

Smarter Resource Injection

Resources let you attach structured content—like PDFs, audio, or source code—directly to prompt turns or tool results. This gives models more context without overloading the token limit.

{
  "mime_type": "application/x-python",
  "uri": "mcp://resource/sample.py",
  "ui": { "display": "code-editor" }
}

Why This Helps

Structured resources are easier for the model to parse.
Clients can render them cleanly—code in editors, audio with play buttons, etc.

Better Prompting with Resources

Injecting resources into prompts creates more reusable workflows:

Refactor code snippets
Summarize long documents
Generate structured reports

prompt([
  { role: "user", content: "Refactor this code" },
  { role: "assistant", content: "Here's the cleaned version" },
  { role: "user", content: { resource: "bad_code.py" } }
])

Subscribable & Sampled Resources

Two special types of resources unlock more dynamic behavior:

Subscribable: Reacts to updates, like a file watcher.
Sampled: Lets you pull out summaries or generate follow-up prompts.

resource.subscribe("tasks.json", (newData) => {
  context.update("currentTasks", newData);
})

These patterns help you build agents that can iterate in real-time or generate structured outputs on demand.

Designing with URI Schemes

MCP URIs give structure and shared meaning to tools and resources. For example, embedding ui in a URI signals the client to render HTML directly:

{
  "uri": "mcp://ui/example.html",
  "mime_type": "text/html"
}

This enables:

Faster client-server integration
Reusable SDK logic based on mime types
Domain-specific workflows (e.g., scientific tools, smart home interfaces)

Final Thoughts

You don’t need a giant toolkit to build powerful LLM experiences. You just need to:

Use tools thoughtfully—avoid redundancy
Leverage resources to add context without noise
Design prompts with structure in mind
Embrace URI schemes for semantic clarity

These small design shifts can dramatically improve speed, accuracy, and scalability across your MCP-based apps.

Acknowledgements

This guide is based on Shaun Smith’s insightful session at the MCP Summit – "Resources: Building the Next Wave of MCP Apps", where he explored how tools, resources, prompts, and URI schemes are shaping the next generation of LLM-native applications.

Special thanks to the Anthropic team and the broader MCP developer community for fostering innovation and providing foundational protocols that enable developers to craft robust, interoperable, and context-aware applications using MCP.