toolkit mcp server

Local 2025-08-31 23:54:34 0

A Model Context Protocol server that provides LLM Agents with a comprehensive toolset for IP geolocation, network diagnostics, system monitoring, cryptographic operations, and QR code generation.


TypeScript Model Context Protocol Version License Status GitHub

A Model Context Protocol server providing LLM Agents with system utilities and tools, including IP geolocation, network diagnostics, system monitoring, cryptographic operations, and QR code generation.

Model Context Protocol

The Model Context Protocol (MCP) enables communication between:

  • Clients: Claude Desktop, IDEs, and other MCP-compatible clients
  • Servers: Tools and resources for task management and automation
  • LLM Agents: AI models that leverage the server's capabilities

Table of Contents

Features

Network & Geolocation

  • IP geolocation with intelligent caching
  • Network connectivity testing
  • Ping and traceroute utilities
  • Public IP detection
  • Rate limiting (45 requests/minute)

System Utilities

  • System information retrieval
  • Resource monitoring
  • Load average tracking
  • Network interface details

Security Tools

  • Cryptographic hash generation (MD5, SHA-1, SHA-256, SHA-512)
  • Constant-time hash comparison
  • UUID generation

Generator Tools

  • QR code generation
  • Terminal output
  • SVG format
  • Base64 encoded images

Installation

# Using npm (recommended)
npm install @cyanheads/toolkit-mcp-server

# Or install from source
git clone [email protected]:cyanheads/toolkit-mcp-server.git
cd toolkit-mcp-server
npm install
npm run build

Configuration

Add to your MCP client settings:

{
  "mcpServers": {
    "toolkit": {
      "command": "node",
      "args": ["node_modules/@cyanheads/toolkit-mcp-server/build/index.js"],
      "env": {
        "NODE_ENV": "production"
      }
    }
  }
}

Tools

Network Operations

// Get geolocation data
const geo = await mcp.use('toolkit-mcp-server', 'geolocate', {
  query: '8.8.8.8'
});

// Check connectivity
const conn = await mcp.use('toolkit-mcp-server', 'checkConnectivity', {
  host: 'example.com',
  port: 443
});

System Operations

// Get system information
const sysInfo = await mcp.use('toolkit-mcp-server', 'getSystemInfo', {});

// Get load average
const load = await mcp.use('toolkit-mcp-server', 'getLoadAverage', {});

Security Operations

// Generate hash
const hash = await mcp.use('toolkit-mcp-server', 'hashData', {
  input: 'test data',
  algorithm: 'sha256'
});

// Generate UUID
const uuid = await mcp.use('toolkit-mcp-server', 'generateUUID', {});

Generator Operations

// Generate QR code
const qr = await mcp.use('toolkit-mcp-server', 'generateQRCode', {
  data: 'https://example.com',
  type: 'svg'
});

Contributing

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

License

Apache License 2.0. See LICENSE for more information.


Built with the Model Context Protocol
[
  {
    "description": "Get current time formatted with Intl.DateTimeFormat",
    "inputSchema": {
      "properties": {
        "locale": {
          "default": "en-US",
          "description": "Locale for formatting (e.g., en-US)",
          "type": "string"
        },
        "timeZone": {
          "default": "UTC",
          "description": "Time zone (e.g., America/New_York)",
          "type": "string"
        }
      },
      "type": "object"
    },
    "name": "getCurrentTime"
  },
  {
    "description": "Get system information using Node.js os module",
    "inputSchema": {
      "properties": {},
      "type": "object"
    },
    "name": "getSystemInfo"
  },
  {
    "description": "Get system load average for 1, 5, and 15 minutes",
    "inputSchema": {
      "properties": {},
      "type": "object"
    },
    "name": "getLoadAverage"
  },
  {
    "description": "Get network interface information",
    "inputSchema": {
      "properties": {},
      "type": "object"
    },
    "name": "getNetworkInterfaces"
  },
  {
    "description": "Test TCP connectivity to a host and port",
    "inputSchema": {
      "properties": {
        "host": {
          "description": "Target host",
          "type": "string"
        },
        "port": {
          "description": "Target port",
          "type": "number"
        },
        "timeout": {
          "default": 5000,
          "description": "Connection timeout in milliseconds",
          "type": "number"
        }
      },
      "required": [
        "host",
        "port"
      ],
      "type": "object"
    },
    "name": "checkConnectivity"
  },
  {
    "description": "Get public IP address using ip-api.com",
    "inputSchema": {
      "properties": {},
      "type": "object"
    },
    "name": "getPublicIP"
  },
  {
    "description": "Ping a host using system ping command",
    "inputSchema": {
      "properties": {
        "count": {
          "default": 4,
          "description": "Number of ping requests",
          "type": "number"
        },
        "host": {
          "description": "Target host to ping",
          "type": "string"
        }
      },
      "required": [
        "host"
      ],
      "type": "object"
    },
    "name": "pingHost"
  },
  {
    "description": "Perform traceroute to a host",
    "inputSchema": {
      "properties": {
        "host": {
          "description": "Target host",
          "type": "string"
        }
      },
      "required": [
        "host"
      ],
      "type": "object"
    },
    "name": "traceroute"
  },
  {
    "description": "Get geolocation information for an IP address or domain",
    "inputSchema": {
      "properties": {
        "query": {
          "description": "IP address or domain to lookup",
          "type": "string"
        }
      },
      "required": [
        "query"
      ],
      "type": "object"
    },
    "name": "geolocate"
  },
  {
    "description": "Clear the geolocation cache",
    "inputSchema": {
      "properties": {},
      "type": "object"
    },
    "name": "clearGeoCache"
  },
  {
    "description": "Generate a random UUID using crypto.randomUUID()",
    "inputSchema": {
      "properties": {},
      "type": "object"
    },
    "name": "generateUUID"
  },
  {
    "description": "Generate a QR code from input data",
    "inputSchema": {
      "properties": {
        "data": {
          "description": "Data to encode in QR code",
          "type": "string"
        },
        "errorCorrectionLevel": {
          "default": "M",
          "description": "Error correction level",
          "enum": [
            "L",
            "M",
            "Q",
            "H"
          ],
          "type": "string"
        },
        "type": {
          "default": "terminal",
          "description": "Output type (terminal, svg, or base64)",
          "enum": [
            "terminal",
            "svg",
            "base64"
          ],
          "type": "string"
        }
      },
      "required": [
        "data"
      ],
      "type": "object"
    },
    "name": "generateQRCode"
  },
  {
    "description": "Convert date/time between timezones using Luxon",
    "inputSchema": {
      "properties": {
        "date": {
          "description": "Date/time string to convert (ISO 8601 format)",
          "type": "string"
        },
        "format": {
          "default": "full",
          "description": "Output format (full, date, time, iso)",
          "enum": [
            "full",
            "date",
            "time",
            "iso"
          ],
          "type": "string"
        },
        "fromTZ": {
          "description": "Source timezone (IANA timezone identifier)",
          "type": "string"
        },
        "toTZ": {
          "description": "Target timezone (IANA timezone identifier)",
          "type": "string"
        }
      },
      "required": [
        "date",
        "fromTZ",
        "toTZ"
      ],
      "type": "object"
    },
    "name": "convertTimezone"
  },
  {
    "description": "List all available IANA timezones",
    "inputSchema": {
      "properties": {
        "region": {
          "description": "Filter timezones by region (e.g., America, Europe)",
          "optional": true,
          "type": "string"
        }
      },
      "type": "object"
    },
    "name": "listTimezones"
  },
  {
    "description": "Hash input data using Node.js crypto module",
    "inputSchema": {
      "properties": {
        "algorithm": {
          "default": "sha256",
          "description": "Hash algorithm to use",
          "enum": [
            "md5",
            "sha1",
            "sha256",
            "sha512"
          ],
          "type": "string"
        },
        "encoding": {
          "default": "hex",
          "description": "Output encoding",
          "enum": [
            "hex",
            "base64"
          ],
          "type": "string"
        },
        "input": {
          "description": "Data to hash",
          "type": "string"
        }
      },
      "required": [
        "input"
      ],
      "type": "object"
    },
    "name": "hashData"
  },
  {
    "description": "Compare two hashes in constant time",
    "inputSchema": {
      "properties": {
        "hash1": {
          "description": "First hash to compare",
          "type": "string"
        },
        "hash2": {
          "description": "Second hash to compare",
          "type": "string"
        }
      },
      "required": [
        "hash1",
        "hash2"
      ],
      "type": "object"
    },
    "name": "compareHashes"
  }
]