Skip to main content
Glama

MCP Utility Tools

by haasonsaas
MIT License

MCP Utility Tools

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.

Features

  • 🔄 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

Installation

npm install mcp-utility-tools # or with yarn yarn add mcp-utility-tools # or with bun bun add mcp-utility-tools

Quick Start

1. Add to Claude Desktop

Add the utility tools to your Claude Desktop configuration:

{ "mcpServers": { "utility-tools": { "command": "npx", "args": ["mcp-utility-tools"] } } }

2. Use with Claude

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" )

Available Tools

🔄 retry_operation

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

💾 Cache Operations

cache_get

Retrieve values from cache with TTL support.

{ "tool": "cache_get", "arguments": { "key": "user-data-123", "namespace": "users" } }
cache_put

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

🚀 batch_operation

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

🚦 rate_limit_check

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

Integration Examples

With GitHub MCP Server

// 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; }

With Slack MCP Server

// 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 }); } }

Architecture

┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐ │ │ │ │ │ │ │ Claude/Client │────▶│ MCP Utility Tools│────▶│ Cache Storage │ │ │ │ │ │ (In-Memory) │ └─────────────────┘ └──────────────────┘ └─────────────────┘ │ │ │ │ ▼ ▼ ┌─────────────────┐ ┌──────────────────┐ │ Other MCP │ │ Retry/Rate │ │ Servers │ │ Limit Tracking │ └─────────────────┘ └──────────────────┘

Development

# 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 dev

Testing

Run 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.js

Contributing

We welcome contributions! Please see our Contributing Guide for details.

Areas for Contribution

  • 🔌 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

License

MIT © Jonathan Haas

Acknowledgments

Built on top of the Model Context Protocol SDK by Anthropic.


-
security - not tested
A
license - permissive license
-
quality - not tested

A collection of tools that enhance MCP-based workflows with caching, retry logic, batch operations, and rate limiting capabilities.

  1. Features
    1. Installation
      1. Quick Start
        1. Add to Claude Desktop
        2. Use with Claude
      2. Available Tools
        1. 🔄 retry_operation
        2. 💾 Cache Operations
        3. 🚀 batch_operation
        4. 🚦 rate_limit_check
      3. Integration Examples
        1. With GitHub MCP Server
        2. With Slack MCP Server
      4. Architecture
        1. Development
          1. Testing
            1. Contributing
              1. Areas for Contribution
            2. License
              1. Acknowledgments

                Related MCP Servers

                • A
                  security
                  F
                  license
                  A
                  quality
                  Enables interaction with Linear resources through an MCP interface, offering functionality for issue management and resource retrieval with rate limiting and error handling support.
                  Last updated -
                  3
                  324
                  1
                  JavaScript
                • -
                  security
                  A
                  license
                  -
                  quality
                  Provides a simple 'wait' tool that introduces deliberate pauses into workflows executed by MCP clients, allowing time for asynchronous operations to complete before proceeding to the next step.
                  Last updated -
                  582
                  1
                  JavaScript
                  MIT License
                  • Linux
                  • Apple
                • -
                  security
                  A
                  license
                  -
                  quality
                  Provides MCP multi-cluster Kubernetes management and operations, featuring a management interface, logging, and nearly 50 built-in tools covering common DevOps and development scenarios. Supports both standard and CRD resources.
                  Last updated -
                  315
                  Go
                  MIT License
                  • Linux
                  • Apple
                • -
                  security
                  A
                  license
                  -
                  quality
                  Provides MCP multi-cluster Kubernetes management and operations. It can be integrated as an SDK into your own project and includes nearly 50 built-in tools covering common DevOps and development scenarios. Supports both standard and CRD resources.
                  Last updated -
                  115
                  Go
                  MIT License
                  • Linux
                  • Apple

                View all related MCP servers

                MCP directory API

                We provide all the information about MCP servers via our MCP API.

                curl -X GET 'https://glama.ai/api/mcp/v1/servers/haasonsaas/mcp-utility-tools'

                If you have feedback or need assistance with the MCP directory API, please join our Discord server