MCP Toolkit Server
Provides SQL query execution against SQLite databases, supporting both a demo database and file-mode databases.
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 Toolkit Server What's the current weather in San Francisco?"
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.
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 |
| Execute SQL queries against SQLite (explore mode with demo DB or file mode) | "Show me all users who placed orders this month" |
| Make HTTP requests to any REST API with custom headers, params, and body | Fetch data from a weather API, send a webhook |
| Read file contents from the local filesystem | Read a config file, inspect a log |
| Write content to files (creates parent dirs automatically) | Save generated code, export data |
| List files/directories with optional recursive listing and filtering | Explore a project structure |
| Safely evaluate math expressions (no | Calculate compound interest, unit conversions |
| Get current date/time with timezone support | Timestamp logging, scheduling |
| Parse, validate, query, and summarize JSON data | Extract fields from API responses |
| 17+ text operations: case conversion, slug, base64, extract emails/URLs, word count | Data cleaning, text normalization |
| 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 buildConfigure 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-serverwith 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.jsThis 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¤t_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.mdDesign Principles
Safety First — SQL injection prevention, no
eval(), read-only defaults for DB queriesModular — Each tool is a self-contained module; easy to add/remove tools
Typed — Full TypeScript with Zod schemas for input validation
Observable — Structured JSON responses with metadata (timing, counts, types)
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 lintWhy 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 toolsapi_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
Scored across 10 tools
Each tool has a clearly distinct purpose: HTTP requests, math, SQL, file operations, datetime, environment, JSON parsing, text transformation. No overlap or ambiguity.
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.
10 tools is an appropriate size for a general-purpose utility toolkit, covering diverse common operations without being unwieldy or too sparse.
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
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
Hosted PostgreSQL MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA 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 npm5MIT
- AlicenseNot gradedqualityDmaintenanceA 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 npm2MIT
- FlicenseNot gradedqualityDmaintenanceA 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-
- AlicenseNot gradedqualityDmaintenanceModel Context Protocol server that standardizes tool discovery, execution, and context management for AI applications.MIT