Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Utility Tools cache the GitHub API response for my repos with a 5-minute TTL"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A collection of utility tools for the Model Context Protocol (MCP) that provide caching, retry logic, batch operations, and rate limiting capabilities to enhance any MCP-based workflow.
🔄 Retry with Exponential Backoff - Automatically retry failed operations with configurable delays
💾 TTL-based Caching - Cache expensive operations with automatic expiration
🚀 Batch Operations - Process multiple operations in parallel with concurrency control
🚦 Rate Limiting - Prevent API abuse with sliding window rate limiting
🔍 Full TypeScript Support - Type-safe with comprehensive TypeScript definitions
Related MCP server: MonoMCP Gateway
npm install mcp-utility-tools
# or with yarn
yarn add mcp-utility-tools
# or with bun
bun add mcp-utility-toolsAdd the utility tools to your Claude Desktop configuration:
{
"mcpServers": {
"utility-tools": {
"command": "npx",
"args": ["mcp-utility-tools"]
}
}
}Once configured, Claude can use these tools to enhance any workflow:
# Check cache before expensive operation
cache_result = mcp_cache_get(key="api-response", namespace="github")
if not cache_result["found"]:
# Fetch data with retry
response = fetch_with_retry("https://api.github.com/user/repos")
# Cache for 5 minutes
mcp_cache_put(
key="api-response",
value=response,
ttl_seconds=300,
namespace="github"
)Retry operations with exponential backoff and jitter.
{
"tool": "retry_operation",
"arguments": {
"operation_id": "unique-operation-id",
"operation_type": "http_request",
"operation_data": {
"url": "https://api.example.com/data",
"method": "GET"
},
"max_retries": 3,
"initial_delay_ms": 1000
}
}Features:
Tracks retry attempts across multiple calls
Exponential backoff with configurable delays
Optional jitter to prevent thundering herd
Prevents duplicate retries for successful operations
Retrieve values from cache with TTL support.
{
"tool": "cache_get",
"arguments": {
"key": "user-data-123",
"namespace": "users"
}
}Store values with automatic expiration.
{
"tool": "cache_put",
"arguments": {
"key": "user-data-123",
"value": { "name": "John", "role": "admin" },
"ttl_seconds": 300,
"namespace": "users"
}
}Features:
Namespace support to prevent key collisions
Automatic cleanup of expired entries
Configurable TTL (1 second to 24 hours)
Memory-efficient storage
Process multiple operations with controlled concurrency.
{
"tool": "batch_operation",
"arguments": {
"operations": [
{ "id": "op1", "type": "fetch", "data": { "url": "/api/1" } },
{ "id": "op2", "type": "fetch", "data": { "url": "/api/2" } },
{ "id": "op3", "type": "fetch", "data": { "url": "/api/3" } }
],
"concurrency": 2,
"timeout_ms": 5000,
"continue_on_error": true,
"use_cache": true
}
}Features:
Configurable concurrency (1-20 operations)
Per-operation timeout
Continue or fail-fast on errors
Optional result caching
Maintains order of results
Implement sliding window rate limiting.
{
"tool": "rate_limit_check",
"arguments": {
"resource": "api.github.com",
"max_requests": 60,
"window_seconds": 60,
"increment": true
}
}Features:
Per-resource tracking
Sliding window algorithm
Automatic reset after time window
Check without incrementing option
// Cache GitHub API responses
async function getRepositoryWithCache(owner: string, repo: string) {
const cacheKey = `github:${owner}/${repo}`;
// Check cache first
const cached = await mcp_cache_get({
key: cacheKey,
namespace: "github"
});
if (cached.found) {
return cached.value;
}
// Fetch with retry
const data = await retryableGitHubCall(owner, repo);
// Cache for 10 minutes
await mcp_cache_put({
key: cacheKey,
value: data,
ttl_seconds: 600,
namespace: "github"
});
return data;
}// Rate-limited Slack notifications
async function sendSlackNotifications(messages: string[], channel: string) {
for (const message of messages) {
// Check rate limit
const canSend = await mcp_rate_limit_check({
resource: `slack:${channel}`,
max_requests: 10,
window_seconds: 60,
increment: true
});
if (!canSend.allowed) {
console.log(`Rate limited. Retry in ${canSend.reset_in_seconds}s`);
await sleep(canSend.reset_in_seconds * 1000);
}
await mcp_slack_post_message({
channel_id: channel,
text: message
});
}
}┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐
│ │ │ │ │ │
│ Claude/Client │────▶│ MCP Utility Tools│────▶│ Cache Storage │
│ │ │ │ │ (In-Memory) │
└─────────────────┘ └──────────────────┘ └─────────────────┘
│ │
│ │
▼ ▼
┌─────────────────┐ ┌──────────────────┐
│ Other MCP │ │ Retry/Rate │
│ Servers │ │ Limit Tracking │
└─────────────────┘ └──────────────────┘# Clone the repository
git clone https://github.com/haasonsaas/mcp-utility-tools.git
cd mcp-utility-tools
# Install dependencies
npm install
# Build the project
npm run build
# Run tests
npm test
# Run in development mode
npm run devRun the comprehensive test suite:
# Unit tests
npm test
# Integration tests with test harness
npm run test:integration
# Test with MCP Inspector
npx @modelcontextprotocol/inspector build/index-v2.jsWe welcome contributions! Please see our Contributing Guide for details.
🔌 Storage Backends: Add Redis, SQLite support
🔧 New Tools: Circuit breakers, request deduplication
📊 Metrics: Add performance tracking and analytics
🌐 Examples: More integration examples with other MCP servers
MIT © Jonathan Haas
Built on top of the Model Context Protocol SDK by Anthropic.
Process multiple operations with configurable concurrency and error handling
Inputs: operations (required), concurrency, timeout_ms, continue_on_error, +2 more.
Clear all entries from the cache or a specific namespace
Inputs: namespace.
Delete a key from the cache
Inputs: key (required), namespace.
Get a value from the cache by key. Returns null if not found or expired.
Inputs: key (required), namespace.
Store a value in the cache with TTL. Useful for caching API responses, computed values, etc.
Inputs: key (required), value (required), ttl_seconds, namespace.
Check if an operation should be rate-limited
Inputs: resource (required), max_requests, window_seconds, increment.
Retry an operation with exponential backoff. Use this for operations that might fail temporarily (API calls, network requests, etc.)
Inputs: operation_id (required), operation_type (required), operation_data (required), max_retries, +2 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 7 tools
Each tool targets a distinct utility operation: caching operations (get, put, delete, clear), batch processing, retry logic, and rate limiting. There is no overlap or ambiguity among them.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., cache_get, retry_operation). The naming is predictable and uniform across the set.
With 7 tools covering caching, batching, retry, and rate limiting, the count is well-scoped for a utility toolkit. No tool feels extraneous or missing.
The set covers essential utility operations: complete CRUD for cache, plus batch, retry, and rate limiting. Minor gaps exist (e.g., no locking or logging), but the core domain is well addressed.
A hosted MCP suite providing workflow primitives: web search, content fetching, compression, deduplication, cost/budget management, and agent memory pipelines.
One OAuth connector for your team's remote MCP servers, with Tool Packs, guardrails and logs.
Single-connection MCP gateway discovering and executing 490+ verified MCP & A2A tools.
