MCP Server for AI Tooling: Encoding, Decoding, Conversions

Overview

The MCP Server for AI Tooling exposes the CorentinTh it-tools collection as an MCP (Model Context Protocol) service so AI agents and applications can call encoding, decoding, and conversion utilities programmatically. Instead of embedding many small libraries into an agent, you run a single MCP server that accepts tool requests over HTTP (or via socket) and returns structured JSON results. This centralizes developer utilities and makes them accessible as first-class “tools” in multi-agent or LLM-driven workflows.

This server is useful when building agents that must transform or inspect data (base64, hex, URL encoding), convert file formats (CSV ↔ JSON), or run developer helpers (timestamps, UUIDs, checksum) as callable operations. By standardizing these utilities behind MCP, you reduce token overhead, improve reproducibility, and simplify orchestration between models and deterministic utilities.

Features

• Exposes common encoding/decoding utilities as MCP tools (base64, hex, URL, percent-encoding)
• Supports conversions between common formats (CSV ↔ JSON, YAML ↔ JSON)
• Provides developer helpers (UUID, timestamp, checksums)
• Simple HTTP/MCP JSON API for integration with agents and apps
• Docker-ready for easy deployment
• Lightweight, designed to be run alongside LLM agents or orchestration services
• Extensible — add new it-tools handlers or custom utilities

Installation / Configuration

Clone the repository and run the server locally. The examples below assume Node.js is used to run the MCP server; adapt commands if your environment differs.

Install from GitHub and start:

git clone https://github.com/wrenchpilot/it-tools-mcp.git
cd it-tools-mcp
# Install dependencies (Node.js)
npm install
# Start in development mode
npm run dev
# Or production
npm start

Environment variables (example .env):

# Server settings
PORT=8080
MCP_BIND_ADDRESS=0.0.0.0

# Optional: enable verbose logging
LOG_LEVEL=info

Run with Docker:

# Build
docker build -t it-tools-mcp .

# Run
docker run -p 8080:8080 --env PORT=8080 it-tools-mcp

If the repository provides a different runtime (Python), replace npm commands with pip and python -m. Check the repository README for exact runtime notes: https://github.com/wrenchpilot/it-tools-mcp

Available Tools / Resources

The server exposes a set of tools. Common examples include:

Each tool accepts a small JSON payload describing input and options and returns a structured result indicating success, output, and any metadata.

API / Example Requests

The MCP server uses a simple JSON-over-HTTP contract. POST a tool invocation to /mcp (or your configured route).

Example: encode a string to Base64

curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "base64_encode",
    "args": {
      "text": "hello world"
    }
  }'

Example response:

{
  "ok": true,
  "tool": "base64_encode",
  "result": {
    "output": "aGVsbG8gd29ybGQ=",
    "meta": {
      "length": 12
    }
  }
}

Example: convert CSV to JSON

curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "csv_to_json",
    "args": {
      "csv": "name,age\nalice,30\nbob,25",
      "headers": true
    }
  }'

Response will include parsed JSON array in result.output.

Use Cases

• Agent tool-call: An LLM agent receives a prompt referencing a binary or encoded payload. Instead of spending tokens to instruct the model, it issues an MCP request to decode Base64, inspect contents, and act on the result.
• Data ingestion pipeline: A preprocessor converts CSV uploads to normalized JSON using csv_to_json, then hands structured data to downstream ML or indexing services.
• File conversions for automation: A service receives YAML snippets and needs JSON for a REST API—call yaml_to_json through MCP to ensure a deterministic transformation.
• Deterministic helpers: Generate UUIDs or timestamps server-side to avoid relying on model outputs for values that must be exact.
• Sanitization & normalization: Use url_encode/url_decode or hex conversions when preparing data for storage, logging, or transport between components.

Extending the Server

To add a new tool:

1. Implement a handler function that accepts args and returns a standardized result object.
2. Register the handler in the server’s tool registry.
3. Add API input validation and tests.
4. Optionally expose the new tool in discovery endpoints so agents can list available capabilities.

Troubleshooting & Tips

• Confirm PORT and bind address if the server is not reachable.
• Use verbose logging (LOG_LEVEL=debug) to inspect incoming requests and handler errors.
• For large payloads, check request body size limits in your server configuration (Express/Flask limits).
• Secure the MCP endpoint behind authentication if used in production, since tool operations may expose sensitive transformations.

For the canonical source and updates, see the project on GitHub: https://github.com/wrenchpilot/it-tools-mcp.