This content originally appeared on DEV Community and was authored by Om Shree
MCP’s tool calling interface has sparked a wave of developer creativity. But as with any flexible system, it introduces important trade-offs. This guide summarizes practical design principles from Aaron’s talk at the MCP Summit, helping developers make informed decisions when working with tools, resources, and URI schemes.
Why Tools Are Powerful—and Risky
MCP tools allow servers to inject information directly into a model’s context via:
- Tool Descriptions: Instructions that guide the model on when and how to invoke a tool.
- Tool Results: Data returned from the tool that is injected into the model’s context.
This enables flexible server-client integrations—servers simply need to support MCP without tight coupling. However, this flexibility comes with trade-offs:
- Tool descriptions and results consume context tokens.
- More tools increase the risk of context clutter, which can degrade model reasoning.
Case Study: Tool Overhead
Adding too many tools can slow down responses and increase token consumption. For example, layering GitHub and FileSystem tools alongside a search tool led to:
- 47% slower responses
- Nearly double the token usage
agent.run([
searchTool("paper"),
githubTool(),
fileTool()
])
Design recommendation: consolidate functionality into fewer tools or optimize prompt structures to reduce overhead.
Resource Injection for Structured Context
Resources in MCP allow developers to attach structured content (such as code files, PDFs, or media) to prompts or tool results. This provides the model with more relevant data without exceeding token limits.
{
"mime_type": "application/x-python",
"uri": "mcp://resource/sample.py",
"ui": { "display": "code-editor" }
}
Why Use Resources
- Models parse structured data more effectively.
- Clients can render specific UIs for different resource types (e.g., code editors for Python, audio players for media).
Context-Aware Prompting
Embedding resources within prompt sequences enables reusable workflows for tasks such as:
- Refactoring code
- Summarizing documents
- Generating reports
prompt([
{ role: "user", content: "Refactor this code" },
{ role: "assistant", content: "Here's the cleaned version" },
{ role: "user", content: { resource: "bad_code.py" } }
])
Dynamic Updates with Subscribable & Sampled Resources
MCP supports advanced resource types:
- Subscribable Resources: Trigger re-processing when the underlying data changes.
- Sampled Resources: Extract summaries or generate prompts from structured data.
resource.subscribe("tasks.json", (newData) => {
context.update("currentTasks", newData);
})
These mechanisms help in building agents that remain responsive to evolving data.
Designing with URI Schemes
URI schemes in MCP define how clients interpret resources and tools. For example, embedding ui in a URI helps clients know when to render specific interfaces like HTML.
{
"uri": "mcp://ui/example.html",
"mime_type": "text/html"
}
Benefits
- Enables predictable rendering across clients.
- Supports domain-specific interactions (e.g., data dashboards, automation interfaces).
Key Takeaways
To build performant and scalable LLM applications on MCP:
- Limit tool usage to prevent context overload.
- Use structured resources for richer, more efficient context.
- Employ dynamic resources for workflows requiring real-time updates.
- Leverage URI schemes to enable consistent client rendering.
These practices ensure better resource utilization and a more maintainable system architecture.
Acknowledgements
This guide is informed by Shaun Smith’s session at the MCP Summit – “Resources: Building the Next Wave of MCP Apps”, which explored how tools, resources, prompts, and URI schemes enhance LLM-native applications.
Special thanks to the Anthropic team and the broader MCP developer community for advancing these standards and supporting developers in crafting robust, context-aware applications.
This content originally appeared on DEV Community and was authored by Om Shree