Skip to main content
Glama

MCP Toolkit Server


Overview

The MCP Toolkit Server is a production-ready Model Context Protocol (MCP) server that equips Claude, ChatGPT, and other LLM agents with a rich set of tools for interacting with databases, external APIs, the file system, and more — directly relevant to the agentic AI wave.

Built with TypeScript and the official @modelcontextprotocol/sdk, this server runs as a local stdio process and integrates seamlessly with Claude Desktop, the MCP Inspector, or any MCP-compatible client.


Related MCP server: MCP Toolkit

Features & Tools

Tool

Description

Example Use Case

db_query

Execute SQL queries against SQLite (explore mode with demo DB or file mode)

"Show me all users who placed orders this month"

api_call

Make HTTP requests to any REST API with custom headers, params, and body

Fetch data from a weather API, send a webhook

file_read

Read file contents from the local filesystem

Read a config file, inspect a log

file_write

Write content to files (creates parent dirs automatically)

Save generated code, export data

file_list

List files/directories with optional recursive listing and filtering

Explore a project structure

calculator

Safely evaluate math expressions (no eval)

Calculate compound interest, unit conversions

get_datetime

Get current date/time with timezone support

Timestamp logging, scheduling

json_parser

Parse, validate, query, and summarize JSON data

Extract fields from API responses

text_transform

17+ text operations: case conversion, slug, base64, extract emails/URLs, word count

Data cleaning, text normalization

get_environment

Get server environment info (OS, CPU, memory, Node.js version)

Debug, context awareness


Quick Start

Prerequisites

  • Node.js >= 18.0.0

  • npm >= 9.0.0

Installation

# Clone the repository
git clone https://github.com/vyshnavi-nandyala/mcp-toolkit-server.git
cd mcp-toolkit-server

# Install dependencies
npm install

# Build the TypeScript project
npm run build

Configure Claude Desktop

Add the server to your Claude Desktop configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "toolkit": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-toolkit-server/dist/index.js"]
    }
  }
}

Replace /absolute/path/to/mcp-toolkit-server with the actual path on your machine.

Restart Claude Desktop, and you'll see a 🔨 icon in the input area — your tools are ready!

Using with MCP Inspector (Debugging)

npx @modelcontextprotocol/inspector node dist/index.js

This opens a web UI where you can manually test each tool, inspect request/response payloads, and debug issues.


Usage Examples

DB Query — Explore the Demo Database

Ask Claude:

"Show me the top 5 products by price from the demo database."

Claude will use the db_query tool:

{
  "sql": "SELECT name, category, price FROM products ORDER BY price DESC LIMIT 5"
}

API Call — Fetch Weather Data

Ask Claude:

"What's the current weather in San Francisco?"

Claude will use the api_call tool:

{
  "url": "https://api.open-meteo.com/v1/forecast?latitude=37.7749&longitude=-122.4194&current_weather=true",
  "method": "GET"
}

File Operations

Ask Claude:

"List all TypeScript files in my project, then read the main entry point."

Claude will chain file_list → file_read:

{ "dirPath": "/path/to/project", "extension": ".ts", "recursive": true }
{ "filePath": "/path/to/project/src/index.ts" }

JSON Parsing

Ask Claude:

"Parse this JSON and extract the first user's email: {\"users\":[{\"email\":\"alice@example.com\"},{\"email\":\"bob@example.com\"}]}"

{
  "json": "{\"users\":[{\"email\":\"alice@example.com\"}]}",
  "operation": "query",
  "path": "users[0].email"
}

Text Transform

Ask Claude:

"Convert this to camelCase and slug: 'My Project Name'"

{ "text": "My Project Name", "operation": "camelcase" }
// → "myProjectName"

{ "text": "My Project Name", "operation": "slug" }
// → "my-project-name"

Architecture

mcp-toolkit-server/
├── src/
│   ├── index.ts                  # Entry point — creates and starts the MCP server
│   ├── tools/
│   │   ├── db-query.ts           # SQLite query tool (explore + file modes)
│   │   ├── api-call.ts           # HTTP request tool (fetch-based)
│   │   ├── file-operations.ts    # file_read, file_write, file_list
│   │   ├── calculator.ts         # Safe math expression evaluator
│   │   ├── datetime.ts           # Date/time with timezone support
│   │   ├── json-parser.ts        # Parse, query, validate, summarize JSON
│   │   ├── text-transform.ts     # 17+ text manipulation operations
│   │   └── environment.ts        # System environment info
│   └── utils/
│       └── helpers.ts            # Shared response-building utilities
├── tests/
│   └── tools.test.ts             # Unit tests (vitest)
├── package.json
├── tsconfig.json
└── README.md

Design Principles

  1. Safety First — SQL injection prevention, no eval(), read-only defaults for DB queries

  2. Modular — Each tool is a self-contained module; easy to add/remove tools

  3. Typed — Full TypeScript with Zod schemas for input validation

  4. Observable — Structured JSON responses with metadata (timing, counts, types)

  5. Developer-Friendly — MCP Inspector support, comprehensive README, unit tests


Adding Custom Tools

Adding a new tool is straightforward:

// src/tools/my-custom-tool.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";

export function registerMyCustomTool(server: McpServer): void {
  server.tool(
    "my_custom_tool",
    "Description of what this tool does.",
    {
      param1: z.string().describe("First parameter."),
      param2: z.number().optional().describe("Optional second parameter."),
    },
    async ({ param1, param2 }) => {
      // Your logic here
      return {
        content: [
          { type: "text", text: JSON.stringify({ result: "..." }, null, 2) },
        ],
      };
    }
  );
}

Then register it in src/index.ts:

import { registerMyCustomTool } from "./tools/my-custom-tool.js";
// ...
registerMyCustomTool(this.server);

Development

# Run in development mode (no build step needed)
npm run dev

# Build for production
npm run build

# Run tests
npm test

# Watch tests
npm run test:watch

# Lint
npm run lint

Why This Matters: The Agentic AI Wave

MCP (Model Context Protocol) is the open standard that allows AI agents like Claude to interact with external tools, data sources, and services. Instead of being confined to a chat window, MCP servers give agents the ability to:

  • Query databases with natural language

  • Call external APIs to fetch real-time data

  • Read and write files on the local filesystem

  • Perform computations and data transformations

  • Compose multi-step workflows by chaining tools together

This server is a concrete, production-ready implementation of that vision — a toolkit that transforms Claude from a conversational AI into an actionable agent capable of interacting with the real world.


License

MIT License. See LICENSE for details.

Available Tools

10 tools
api_callA

Make an HTTP request to any external API endpoint and return the response.

Supported features:

  • All HTTP methods: GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS

  • Custom headers (including Authorization / Bearer tokens)

  • JSON and form-urlencoded request bodies

  • URL query parameters (via url or params)

  • Configurable timeout (default 15 seconds)

  • Response includes status code, headers, and body

Use cases:

  • Fetching data from REST APIs

  • Sending webhooks

  • Querying third-party services (weather, maps, etc.)

  • Testing and debugging API endpoints

Inputs: url (required), method, headers, body, +2 more.

calculatorA

Evaluate a mathematical expression and return the result.

Supported operations:

  • Arithmetic: +, -, *, /, %, **

  • Parentheses for grouping: (2 + 3) * 4

  • Common functions: abs, ceil, floor, round, sqrt, min, max

  • Constants: PI, E

Safety:

  • Does NOT use eval() — uses a safe expression parser

  • Rejects any non-mathematical input

Examples:

  • "2 + 3 * 4" → 14

  • "(2 + 3) * 4" → 20

  • "sqrt(144)" → 12

  • "round(3.14159, 2)" → 3.14

  • "max(10, 20, 30)" → 30

Inputs: expression (required).

db_queryA

Execute a SQL query against a SQLite database and return the results.

Modes:

  • "explore" (default): Uses a built-in in-memory demo database pre-loaded with sample tables (users, products, orders). Great for quick testing.

  • "file": Queries a user-specified SQLite file on disk.

Security:

  • In "explore" mode only SELECT statements are allowed.

  • In "file" mode only SELECT, EXPLAIN, and WITH ... SELECT are allowed.

  • DML/DDL (INSERT, UPDATE, DELETE, DROP, etc.) will be rejected.

Returns:

  • rows: array of objects

  • rowCount: number of rows returned

  • columns: list of column names

Inputs: sql (required), mode, dbPath, limit.

file_listA

List files and directories at a given path.

Features:

  • List contents of any directory

  • Recursive listing with configurable depth

  • Filter results by file extension

  • Returns file sizes and types

Use cases:

  • Exploring project structures

  • Finding specific file types

  • Auditing directory contents

Inputs: dirPath (required), recursive, extension.

file_readA

Read the contents of a file from the local filesystem.

Features:

  • Read entire file or a specific byte range

  • Automatic encoding detection (UTF-8 default)

  • Returns file metadata (size, last modified)

  • Supports any text file type

Security:

  • Rejects paths outside the allowed root directories

  • Refuses to read binary files or directories

Inputs: filePath (required), encoding.

file_writeA

Write content to a file on the local filesystem.

Features:

  • Creates parent directories automatically if they don't exist

  • Overwrites existing files or creates new ones

  • Supports any text encoding (default: UTF-8)

Use cases:

  • Saving generated code, configs, or data

  • Creating log files

  • Writing reports or exports

Inputs: filePath (required), content (required), encoding.

get_datetimeA

Get the current date and time in various formats.

Returns:

  • ISO 8601 string

  • Unix timestamp

  • Individual components (year, month, day, hour, minute, second)

  • Day of week and week number

  • Timezone information

This tool does not require any parameters.

Inputs: timezone.

get_environmentA

Get information about the current server environment.

Returns:

  • Operating system details (platform, arch, release)

  • Node.js version

  • Server process info (PID, uptime, memory usage)

  • CPU information

  • Memory (total, free, used)

  • Network hostname

This tool does not require any parameters. No sensitive environment variables or secrets are exposed.

Inputs: no named parameters.

json_parserA

Parse, validate, and query JSON data.

Modes:

  • "parse": Parse a JSON string and return it formatted.

  • "query": Extract a specific field using dot-notation (e.g., "data.users[0].name").

  • "validate": Check if a string is valid JSON and describe its structure.

  • "summarize": Return a schema-like summary of a JSON object's structure.

Examples:

  • Parse: '{"a":1,"b":2}' → pretty-printed object

  • Query: '{"users":[{"name":"Alice"}]}' with path "users[0].name" → "Alice"

  • Validate: '{"a":1}' → {"valid": true, "type": "object", "keys": ["a"]}

Inputs: json (required), operation, path.

text_transformA

Transform text using various operations.

Supported operations:

  • "uppercase": Convert to UPPERCASE

  • "lowercase": Convert to lowercase

  • "titlecase": Convert to Title Case

  • "camelcase": Convert to camelCase

  • "snakecase": Convert to snake_case

  • "kebabcase": Convert to kebab-case

  • "reverse": Reverse the text

  • "trim": Remove leading/trailing whitespace

  • "slug": URL-safe slug (lowercase, hyphens, no special chars)

  • "base64_encode": Encode to Base64

  • "base64_decode": Decode from Base64

  • "word_count": Count words, characters, sentences, and paragraphs

  • "remove_duplicates": Remove duplicate lines

  • "sort_lines": Sort lines alphabetically

  • "extract_emails": Extract all email addresses from text

  • "extract_urls": Extract all URLs from text

  • "hash": Simple hash summary (character frequency)

Inputs: text (required), operation (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.3/5.0

    Scored across 10 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: HTTP requests, math, SQL, file operations, datetime, environment, JSON parsing, text transformation. No overlap or ambiguity.

    Naming Consistency5/5

    All tool names use snake_case consistently, with a verb_noun pattern for most (file_list, file_read, file_write, get_datetime, get_environment) and simple nouns for others (calculator, json_parser). No mixing of conventions.

    Tool Count5/5

    10 tools is an appropriate size for a general-purpose utility toolkit, covering diverse common operations without being unwieldy or too sparse.

    Completeness4/5

    Covers majority of common utility tasks: HTTP, math, SQL, file I/O, datetime, environment, JSON, text transforms. Missing a file delete tool and more advanced date or CSV operations, but overall solid for the toolkit domain.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol server built with mcp-framework that allows users to create and manage custom tools for processing data, integrating with the Claude Desktop via CLI.
      46 npm
      5
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      A comprehensive Model Context Protocol server implementation that enables AI assistants to interact with file systems, databases, GitHub repositories, web resources, and system tools while maintaining security and control.
      146 npm
      2
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      A Model Context Protocol server that provides AI models with structured access to external data and services, acting as a bridge between AI assistants and applications, databases, and APIs in a standardized, secure way.
      2
      -