MCP server intelligence profile

IT Tools MCP Server

A comprehensive Model Context Protocol server providing access to 70+ IT tools for developers and system administrators, including encoding/decoding, text manipulation, hashing, and network utilities

Local Onlywrenchpilot
Awaiting current scanNpm · 5.10.8

The selected current version does not yet have completed public verification. Unknown does not mean clean or vulnerable.

1Distribution channel
119Independently observed tools
0Linked remote endpoints
AvailableVersion intelligence

Detailed security scan evidence is not public for this MCP yet. Public identity, registry metadata, and independently observed protocol inventory remain available.

Install and connect

Installation and connection instructions are shown only when supported by retained package, repository, or endpoint evidence.

Install it-tools-mcp from npm

Version 5.10.8 declares 1 executable entrypoint.

npm install --save-exact it-tools-mcp@5.10.8
npx -y -p it-tools-mcp@5.10.8 it-tools-mcp
MCP client configuration example
{
  "mcpServers": {
    "it-tools-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "-p",
        "it-tools-mcp@5.10.8",
        "it-tools-mcp"
      ]
    }
  }
}

Identity

Canonical slugit-tools-mcp-server-2fc97576DeploymentLocal Only
Canonical packagenpm:it-tools-mcpRepositorywrenchpilot/it-tools-mcp
First published—Latest release—
Last security verification—Classification confidence90%
PublicationDraftOfficial distributionNot verified

Distributions

ChannelIdentifierCurrent versionVersionsSource
npmit-tools-mcp5.10.877Repository

Current release

PackageVersionPublished / observedInventorySecurity scan
npmit-tools-mcp5.10.8CurrentSep 5, 2026119 toolsSucceeded · 25 resources · 3 promptsEvidence restricted
Enterprise protection

Continuously monitor this MCP for security risk

Independently scan the exact version your agents use, receive alerts when its risk changes, and investigate every finding with retained version evidence.

  • Independent exact-version security scans
  • Continuous release and vulnerability monitoring
  • Risk-change alerts with capability context
  • Historical evidence and API exports
Custom pricingContact salesTailored to your organization, integrations, data needs, and support requirements.

Current version evidence

No public current-version evidence is available yet.

Current protocol inventory

2025-06-18Negotiated protocol
it-tools-mcpServer-reported name
5Capability groups
Aug 15, 2026Observed

Tools 119

ToolCategoryAnnotationsRisk
analyze_distinct_wordsCount distinct words in text and show their frequency
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to analyze for distinct words"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Analyze Distinct Words",
  "readOnlyHint": true
}
—Read only—
analyze_text_statsGet statistics about text (character count, word count, etc.)
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to analyze"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Analyze Text Stats",
  "readOnlyHint": true
}
—Read only—
calculate_ip_subnetCalculate subnet information for IPv4
Input schema
{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string",
      "description": "IPv4 address (e.g., 192.168.1.1)"
    },
    "cidr": {
      "type": "number",
      "description": "CIDR notation (e.g., 24)"
    }
  },
  "required": [
    "ip",
    "cidr"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Ip-subnet-calculator",
  "readOnlyHint": false
}
—Writes—
calculate_ipv4_subnetCalculate IPv4 subnet information
Input schema
{
  "type": "object",
  "properties": {
    "cidr": {
      "type": "string",
      "description": "IPv4 CIDR notation (e.g., 192.168.1.0/24)"
    }
  },
  "required": [
    "cidr"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Ipv4-subnet-calc",
  "readOnlyHint": false
}
—Writes—
calculate_ipv6_subnetCalculate IPv6 subnet information
Input schema
{
  "type": "object",
  "properties": {
    "ipv6": {
      "type": "string",
      "description": "IPv6 address and prefix (e.g., 2001:db8::/32)"
    },
    "newPrefix": {
      "type": "number",
      "description": "New prefix length for subnetting"
    }
  },
  "required": [
    "ipv6"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Ipv6-subnet-calculator",
  "readOnlyHint": false
}
—Writes—
calculate_percentageCalculate percentages, percentage of a number, or percentage change
Input schema
{
  "type": "object",
  "properties": {
    "operation": {
      "type": "string",
      "enum": [
        "percentage-of",
        "what-percentage",
        "percentage-change"
      ],
      "description": "Type of percentage calculation"
    },
    "value1": {
      "type": "number",
      "description": "First value"
    },
    "value2": {
      "type": "number",
      "description": "Second value"
    }
  },
  "required": [
    "operation",
    "value1",
    "value2"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Calculate Percentage",
  "readOnlyHint": false
}
—Writes—
capitalize_textCapitalize first letter of each word
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to capitalize"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Capitalize Text",
  "readOnlyHint": false
}
—Writes—
catDisplay content of a file
Input schema
{
  "type": "object",
  "properties": {
    "file": {
      "type": "string",
      "description": "File path"
    }
  },
  "required": [
    "file"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Cat",
  "readOnlyHint": false
}
—Writes—
compare_jsonCompare two JSON objects and show differences
Input schema
{
  "type": "object",
  "properties": {
    "json1": {
      "type": "string",
      "description": "First JSON object"
    },
    "json2": {
      "type": "string",
      "description": "Second JSON object"
    }
  },
  "required": [
    "json1",
    "json2"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Compare Json",
  "readOnlyHint": false
}
—Writes—
compare_textCompare two texts and show differences
Input schema
{
  "type": "object",
  "properties": {
    "text1": {
      "type": "string",
      "description": "First text to compare"
    },
    "text2": {
      "type": "string",
      "description": "Second text to compare"
    }
  },
  "required": [
    "text1",
    "text2"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Compare Text",
  "readOnlyHint": false
}
—Writes—
convert_angleConvert between different angle units
Input schema
{
  "type": "object",
  "properties": {
    "value": {
      "type": "number",
      "description": "Angle value to convert"
    },
    "fromUnit": {
      "type": "string",
      "enum": [
        "degree",
        "radian",
        "gradian",
        "turn",
        "arcminute",
        "arcsecond"
      ],
      "description": "Source angle unit"
    },
    "toUnit": {
      "type": "string",
      "enum": [
        "degree",
        "radian",
        "gradian",
        "turn",
        "arcminute",
        "arcsecond"
      ],
      "description": "Target angle unit"
    }
  },
  "required": [
    "value",
    "fromUnit",
    "toUnit"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Angle",
  "readOnlyHint": false
}
—Writes—
convert_cidr_to_ip_rangeConvert CIDR notation to IP address range
Input schema
{
  "type": "object",
  "properties": {
    "cidr": {
      "type": "string",
      "description": "CIDR notation (e.g., 192.168.1.0/24)"
    }
  },
  "required": [
    "cidr"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Cidr-to-ip-range",
  "readOnlyHint": false
}
—Writes—
convert_docker_compose_to_runConvert Docker Compose files to docker run commands
Input schema
{
  "type": "object",
  "properties": {
    "content": {
      "type": "string",
      "description": "Docker Compose file content to convert"
    }
  },
  "required": [
    "content"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Docker Compose To Run",
  "readOnlyHint": false
}
—Writes—
convert_docker_run_to_composeConvert docker run commands to Docker Compose format
Input schema
{
  "type": "object",
  "properties": {
    "commands": {
      "type": "string",
      "description": "Docker run commands to convert (one per line)"
    }
  },
  "required": [
    "commands"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Docker Run To Compose",
  "readOnlyHint": false
}
—Writes—
convert_energyConvert between different energy units
Input schema
{
  "type": "object",
  "properties": {
    "value": {
      "type": "number",
      "description": "Energy value to convert"
    },
    "fromUnit": {
      "type": "string",
      "enum": [
        "joule",
        "kilojoule",
        "calorie",
        "kilocalorie",
        "btu",
        "watt-hour",
        "kilowatt-hour",
        "electronvolt",
        "foot-pound"
      ],
      "description": "Source energy unit"
    },
    "toUnit": {
      "type": "string",
      "enum": [
        "joule",
        "kilojoule",
        "calorie",
        "kilocalorie",
        "btu",
        "watt-hour",
        "kilowatt-hour",
        "electronvolt",
        "foot-pound"
      ],
      "description": "Target energy unit"
    }
  },
  "required": [
    "value",
    "fromUnit",
    "toUnit"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Energy",
  "readOnlyHint": false
}
—Writes—
convert_hex_to_rgbConvert HEX color to RGB
Input schema
{
  "type": "object",
  "properties": {
    "hex": {
      "type": "string",
      "description": "HEX color code (e.g., #FF5733 or FF5733)"
    }
  },
  "required": [
    "hex"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Hex To Rgb",
  "readOnlyHint": false
}
—Writes—
convert_html_to_markdownConvert HTML to Markdown
Input schema
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "description": "HTML content to convert to Markdown"
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Html To Markdown",
  "readOnlyHint": false
}
—Writes—
convert_ip_range_to_cidrConvert IP address range to CIDR notation(s)
Input schema
{
  "type": "object",
  "properties": {
    "startIP": {
      "type": "string",
      "description": "Starting IP address"
    },
    "endIP": {
      "type": "string",
      "description": "Ending IP address"
    }
  },
  "required": [
    "startIP",
    "endIP"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Ip-range-to-cidr",
  "readOnlyHint": false
}
—Writes—
convert_json_to_csvConvert JSON to CSV format
Input schema
{
  "type": "object",
  "properties": {
    "json": {
      "type": "string",
      "description": "JSON string to convert to CSV"
    },
    "delimiter": {
      "type": "string",
      "description": "CSV delimiter"
    }
  },
  "required": [
    "json"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Json To Csv",
  "readOnlyHint": false
}
—Writes—
convert_json_to_tomlConvert JSON to TOML format
Input schema
{
  "type": "object",
  "properties": {
    "json": {
      "type": "string",
      "description": "JSON string to convert"
    }
  },
  "required": [
    "json"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Json To Toml",
  "readOnlyHint": false
}
—Writes—
convert_listConvert between different list formats (comma-separated, line-separated, etc.)
Input schema
{
  "type": "object",
  "properties": {
    "list": {
      "type": "string",
      "description": "Input list to convert"
    },
    "inputFormat": {
      "type": "string",
      "enum": [
        "comma",
        "semicolon",
        "newline",
        "space",
        "pipe"
      ],
      "description": "Input format"
    },
    "outputFormat": {
      "type": "string",
      "enum": [
        "comma",
        "semicolon",
        "newline",
        "space",
        "pipe",
        "json",
        "quoted"
      ],
      "description": "Output format"
    },
    "trim": {
      "type": "boolean",
      "description": "Trim whitespace from items"
    }
  },
  "required": [
    "list",
    "inputFormat",
    "outputFormat"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert List",
  "readOnlyHint": false
}
—Writes—
convert_markdown_to_htmlConvert Markdown to HTML
Input schema
{
  "type": "object",
  "properties": {
    "markdown": {
      "type": "string",
      "description": "Markdown content to convert to HTML"
    }
  },
  "required": [
    "markdown"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Markdown To Html",
  "readOnlyHint": false
}
—Writes—
convert_number_baseConvert numbers between different bases (binary, octal, decimal, hexadecimal)
Input schema
{
  "type": "object",
  "properties": {
    "number": {
      "type": "string",
      "description": "Number to convert"
    },
    "fromBase": {
      "type": "number",
      "description": "Source base (2-36)"
    },
    "toBase": {
      "type": "number",
      "description": "Target base (2-36)"
    }
  },
  "required": [
    "number",
    "fromBase",
    "toBase"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Number Base",
  "readOnlyHint": false
}
—Writes—
convert_powerConvert between different power units
Input schema
{
  "type": "object",
  "properties": {
    "value": {
      "type": "number",
      "description": "Power value to convert"
    },
    "fromUnit": {
      "type": "string",
      "enum": [
        "watt",
        "kilowatt",
        "megawatt",
        "horsepower",
        "metric-horsepower",
        "btu-per-hour",
        "calorie-per-second",
        "foot-pound-per-second"
      ],
      "description": "Source power unit"
    },
    "toUnit": {
      "type": "string",
      "enum": [
        "watt",
        "kilowatt",
        "megawatt",
        "horsepower",
        "metric-horsepower",
        "btu-per-hour",
        "calorie-per-second",
        "foot-pound-per-second"
      ],
      "description": "Target power unit"
    }
  },
  "required": [
    "value",
    "fromUnit",
    "toUnit"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Power",
  "readOnlyHint": false
}
—Writes—
convert_rem_pxConvert between REM and PX units for CSS. Example: Convert 1.5rem to pixels, or 24px to rem units.
Input schema
{
  "type": "object",
  "properties": {
    "value": {
      "type": "number",
      "minimum": 0,
      "description": "Value to convert (e.g., 1.5 for 1.5rem or 24 for 24px)"
    },
    "fromUnit": {
      "type": "string",
      "enum": [
        "rem",
        "px"
      ],
      "description": "Source unit - either 'rem' or 'px'"
    },
    "rootFontSize": {
      "type": "number",
      "minimum": 1,
      "maximum": 100,
      "default": 16,
      "description": "Root font size in pixels (default: 16px - standard browser default)"
    }
  },
  "required": [
    "value",
    "fromUnit"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Rem Px",
  "readOnlyHint": false
}
—Writes—
convert_rgb_to_hexConvert RGB color to HEX
Input schema
{
  "type": "object",
  "properties": {
    "r": {
      "type": "number",
      "description": "Red value (0-255)"
    },
    "g": {
      "type": "number",
      "description": "Green value (0-255)"
    },
    "b": {
      "type": "number",
      "description": "Blue value (0-255)"
    }
  },
  "required": [
    "r",
    "g",
    "b"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Rgb To Hex",
  "readOnlyHint": false
}
—Writes—
convert_roman_numeralsConvert between Arabic numbers and Roman numerals
Input schema
{
  "type": "object",
  "properties": {
    "input": {
      "type": "string",
      "description": "Number to convert (Arabic number 1-3999 or Roman numeral)"
    }
  },
  "required": [
    "input"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Roman Numerals",
  "readOnlyHint": false
}
—Writes—
convert_temperatureConvert temperatures between Celsius, Fahrenheit, and Kelvin
Input schema
{
  "type": "object",
  "properties": {
    "temperature": {
      "type": "number",
      "description": "Temperature value to convert"
    },
    "from": {
      "type": "string",
      "enum": [
        "celsius",
        "fahrenheit",
        "kelvin"
      ],
      "description": "Source temperature unit"
    },
    "to": {
      "type": "string",
      "enum": [
        "celsius",
        "fahrenheit",
        "kelvin"
      ],
      "description": "Target temperature unit"
    }
  },
  "required": [
    "temperature",
    "from",
    "to"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Temperature",
  "readOnlyHint": false
}
—Writes—
convert_text_to_binaryConvert text to binary and vice versa
Input schema
{
  "type": "object",
  "properties": {
    "input": {
      "type": "string",
      "description": "Text to convert to binary, or binary to convert to text"
    },
    "operation": {
      "type": "string",
      "enum": [
        "encode",
        "decode"
      ],
      "description": "Operation: encode text to binary or decode binary to text"
    }
  },
  "required": [
    "input",
    "operation"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Text To Binary",
  "readOnlyHint": false
}
—Writes—
convert_text_to_camelcaseConvert text to camelCase format. Example: 'hello world' → 'helloWorld', 'my-variable-name' → 'myVariableName'
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to camelCase"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert to camelCase",
  "readOnlyHint": false
}
—Writes—
convert_text_to_kebabcaseConvert text to kebab-case
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to kebab-case"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Text To Kebabcase",
  "readOnlyHint": false
}
—Writes—
convert_text_to_lowercaseConvert text to lowercase
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to lowercase"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Text To Lowercase",
  "readOnlyHint": false
}
—Writes—
convert_text_to_natoConvert text to NATO phonetic alphabet
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to NATO phonetic alphabet"
    },
    "language": {
      "type": "string",
      "default": "International",
      "description": "Language/country variant (International, France, Germany, etc.)"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Text To Nato",
  "readOnlyHint": false
}
—Writes—
convert_text_to_pascalcaseConvert text to PascalCase
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to PascalCase"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Text To Pascalcase",
  "readOnlyHint": false
}
—Writes—
convert_text_to_unicodeConvert text to Unicode code points and vice versa
Input schema
{
  "type": "object",
  "properties": {
    "input": {
      "type": "string",
      "description": "Text to convert to Unicode or Unicode to convert to text"
    },
    "operation": {
      "type": "string",
      "enum": [
        "encode",
        "decode"
      ],
      "description": "Operation: encode text to Unicode or decode Unicode to text"
    }
  },
  "required": [
    "input",
    "operation"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Text To Unicode",
  "readOnlyHint": false
}
—Writes—
convert_text_to_uppercaseConvert text to uppercase
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to uppercase"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Text To Uppercase",
  "readOnlyHint": false
}
—Writes—
convert_toml_to_jsonConvert TOML to JSON format
Input schema
{
  "type": "object",
  "properties": {
    "toml": {
      "type": "string",
      "description": "TOML string to convert"
    }
  },
  "required": [
    "toml"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Toml To Json",
  "readOnlyHint": false
}
—Writes—
convert_unix_timestampConvert between Unix timestamps and human-readable dates
Input schema
{
  "type": "object",
  "properties": {
    "input": {
      "type": "string",
      "description": "Unix timestamp (seconds) or ISO date string"
    }
  },
  "required": [
    "input"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Unix-timestamp-converter",
  "readOnlyHint": false
}
—Writes—
curlMake HTTP requests to web endpoints. Example: GET request to an API or POST data to a server
Input schema
{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "URL to request"
    },
    "method": {
      "type": "string",
      "enum": [
        "GET",
        "POST",
        "PUT",
        "DELETE",
        "PATCH",
        "HEAD"
      ],
      "default": "GET",
      "description": "HTTP method"
    },
    "headers": {
      "type": "object",
      "additionalProperties": {
        "type": "string"
      },
      "description": "Request headers (object of key-value pairs)"
    },
    "body": {
      "type": "string",
      "description": "Request body (for POST/PUT/PATCH)"
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Curl",
  "readOnlyHint": false
}
—Writes—
decode_base64Decode Base64 text back to original text. Example: "SGVsbG8gV29ybGQ=" → "Hello World"
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "pattern": "^[A-Za-z0-9+/]*={0,2}$",
      "description": "Base64 text to decode"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Decode Base64",
  "readOnlyHint": false
}
—Writes—
decode_htmlDecode HTML entities
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "HTML encoded text to decode"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Decode Html",
  "readOnlyHint": false
}
—Writes—
decode_jwtDecode JWT token (header and payload only)
Input schema
{
  "type": "object",
  "properties": {
    "token": {
      "type": "string",
      "description": "JWT token to decode"
    }
  },
  "required": [
    "token"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Decode Jwt",
  "readOnlyHint": false
}
—Writes—
decode_safelinkDecode Microsoft Outlook SafeLink URLs
Input schema
{
  "type": "object",
  "properties": {
    "safelink": {
      "type": "string",
      "description": "SafeLink URL to decode"
    }
  },
  "required": [
    "safelink"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Decode Safelink",
  "readOnlyHint": false
}
—Writes—
decode_urlURL decode text
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "URL encoded text to decode"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Decode Url",
  "readOnlyHint": false
}
—Writes—
decrypt_ansible_vaultDecrypt Ansible Vault encrypted text
Input schema
{
  "type": "object",
  "properties": {
    "encryptedText": {
      "type": "string",
      "description": "Ansible Vault encrypted text to decrypt"
    },
    "password": {
      "type": "string",
      "description": "Password for decryption"
    }
  },
  "required": [
    "encryptedText",
    "password"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Decrypt Ansible Vault",
  "readOnlyHint": false
}
—Writes—
digPerform DNS lookup with dig command
Input schema
{
  "type": "object",
  "properties": {
    "target": {
      "type": "string",
      "description": "Hostname or IP address"
    },
    "type": {
      "type": "string",
      "default": "A",
      "description": "DNS record type"
    }
  },
  "required": [
    "target"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Dig",
  "readOnlyHint": false
}
—Writes—
encode_base64Encode text to Base64 format. Example: "Hello World" → "SGVsbG8gV29ybGQ="
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "minLength": 1,
      "description": "Text to encode to Base64"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Encode Base64",
  "readOnlyHint": false
}
—Writes—
encode_htmlEncode HTML entities
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to HTML encode"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Encode Html",
  "readOnlyHint": false
}
—Writes—
encode_html_entitiesExtended HTML entity encoding/decoding
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to encode or decode"
    },
    "operation": {
      "type": "string",
      "enum": [
        "encode",
        "decode"
      ],
      "description": "Operation to perform"
    }
  },
  "required": [
    "text",
    "operation"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Encode Html Entities",
  "readOnlyHint": false
}
—Writes—
encode_urlURL encode text
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to URL encode"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Encode Url",
  "readOnlyHint": false
}
—Writes—
encrypt_ansible_vaultEncrypt text using Ansible Vault format
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to encrypt"
    },
    "password": {
      "type": "string",
      "description": "Password for encryption"
    },
    "vaultId": {
      "type": "string",
      "description": "Vault ID for the encrypted content (optional)"
    }
  },
  "required": [
    "text",
    "password"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Encrypt Ansible Vault",
  "readOnlyHint": false
}
—Writes—
evaluate_mathSafely evaluate mathematical expressions
Input schema
{
  "type": "object",
  "properties": {
    "expression": {
      "type": "string",
      "description": "Mathematical expression to evaluate (e.g., '2 + 3 * 4')"
    }
  },
  "required": [
    "expression"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Evaluate Math",
  "readOnlyHint": false
}
—Writes—
fang_urlDefang or refang URLs for safe sharing (security analysis)
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text containing URLs to fang/defang"
    },
    "operation": {
      "type": "string",
      "enum": [
        "defang",
        "refang"
      ],
      "description": "Whether to defang (make safe) or refang (restore) URLs"
    }
  },
  "required": [
    "text",
    "operation"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Fang Url",
  "readOnlyHint": false
}
—Writes—
format_cssFormat and prettify CSS code
Input schema
{
  "type": "object",
  "properties": {
    "css": {
      "type": "string",
      "description": "CSS code to format"
    },
    "indentSize": {
      "type": "number",
      "description": "Number of spaces for indentation (default: 2)"
    }
  },
  "required": [
    "css"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Format Css",
  "readOnlyHint": false
}
—Writes—
format_htmlFormat and beautify HTML code
Input schema
{
  "type": "object",
  "properties": {
    "html": {
      "type": "string",
      "description": "HTML code to prettify"
    },
    "indentSize": {
      "type": "number",
      "default": 2,
      "description": "Number of spaces for indentation"
    }
  },
  "required": [
    "html"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Format Html",
  "readOnlyHint": false
}
—Writes—
format_javascriptFormat and beautify JavaScript/CSS code
Input schema
{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "description": "JavaScript or CSS code to prettify"
    },
    "type": {
      "type": "string",
      "enum": [
        "javascript",
        "css"
      ],
      "description": "Type of code to format"
    },
    "indentSize": {
      "type": "number",
      "default": 2,
      "description": "Number of spaces for indentation"
    }
  },
  "required": [
    "code",
    "type"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Format Javascript",
  "readOnlyHint": false
}
—Writes—
format_jsonFormat and prettify JSON with proper indentation. Example: {"a":1,"b":2} → formatted JSON with customizable spacing
Input schema
{
  "type": "object",
  "properties": {
    "json": {
      "type": "string",
      "description": "JSON string to format"
    },
    "indent": {
      "type": "number",
      "description": "Number of spaces for indentation"
    }
  },
  "required": [
    "json"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Format JSON",
  "readOnlyHint": false
}
—Writes—
format_phoneParse and format phone numbers
Input schema
{
  "type": "object",
  "properties": {
    "phoneNumber": {
      "type": "string",
      "description": "Phone number to parse and format"
    },
    "countryCode": {
      "type": "string",
      "description": "Country code (e.g., 'US', 'GB', 'FR')"
    }
  },
  "required": [
    "phoneNumber"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Format Phone",
  "readOnlyHint": false
}
—Writes—
format_sqlFormat and prettify SQL queries
Input schema
{
  "type": "object",
  "properties": {
    "sql": {
      "type": "string",
      "description": "SQL query to format"
    },
    "dialect": {
      "type": "string",
      "description": "SQL dialect to use for formatting (e.g., 'sql', 'mysql', 'postgresql', 'sqlite', 'mariadb', 'db2', 'plsql', 'n1ql', 'redshift', 'spark', 'tsql', 'trino', 'bigquery'). Default is 'sql'."
    }
  },
  "required": [
    "sql"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Format Sql",
  "readOnlyHint": false
}
—Writes—
format_xmlFormat and prettify XML
Input schema
{
  "type": "object",
  "properties": {
    "xml": {
      "type": "string",
      "description": "XML string to format"
    },
    "indent": {
      "type": "number",
      "description": "Number of spaces for indentation"
    }
  },
  "required": [
    "xml"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Format Xml",
  "readOnlyHint": false
}
—Writes—
format_yamlFormat and prettify YAML
Input schema
{
  "type": "object",
  "properties": {
    "yaml": {
      "type": "string",
      "description": "YAML string to format"
    }
  },
  "required": [
    "yaml"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Format Yaml",
  "readOnlyHint": false
}
—Writes—
generate_ansible_inventoryParse and validate Ansible inventory files
Input schema
{
  "type": "object",
  "properties": {
    "inventory": {
      "type": "string",
      "description": "Ansible inventory content (INI or YAML format)"
    }
  },
  "required": [
    "inventory"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Ansible Inventory",
  "readOnlyHint": false
}
—Writes—
generate_ascii_artGenerate ASCII art text using figlet fonts. Example: 'Hello' → stylized ASCII text art, supports 295+ fonts
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to ASCII art, or use 'LIST_FONTS' to get all available font names"
    },
    "font": {
      "type": "string",
      "description": "ASCII art font style. Supports all 295+ figlet fonts. Use 'standard' if unsure."
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate ASCII Art",
  "readOnlyHint": false
}
—Writes—
generate_basic_authGenerate HTTP Basic Authentication header
Input schema
{
  "type": "object",
  "properties": {
    "username": {
      "type": "string",
      "description": "Username"
    },
    "password": {
      "type": "string",
      "description": "Password"
    }
  },
  "required": [
    "username",
    "password"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Basic Auth",
  "readOnlyHint": false
}
—Writes—
generate_bip39Generate BIP39 mnemonic phrases
Input schema
{
  "type": "object",
  "properties": {
    "wordCount": {
      "type": "string",
      "enum": [
        "12",
        "15",
        "18",
        "21",
        "24"
      ],
      "description": "Number of words in the mnemonic"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Bip39",
  "readOnlyHint": false
}
—Writes—
generate_crontabGenerate crontab expressions
Input schema
{
  "type": "object",
  "properties": {
    "minute": {
      "type": "string",
      "description": "Minute (0-59, *, */n, n-m)"
    },
    "hour": {
      "type": "string",
      "description": "Hour (0-23, *, */n, n-m)"
    },
    "dayOfMonth": {
      "type": "string",
      "description": "Day of month (1-31, *, */n, n-m)"
    },
    "month": {
      "type": "string",
      "description": "Month (1-12, *, */n, n-m)"
    },
    "dayOfWeek": {
      "type": "string",
      "description": "Day of week (0-7, *, */n, n-m)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Crontab",
  "readOnlyHint": false
}
—Writes—
generate_hmacGenerate HMAC (Hash-based Message Authentication Code)
Input schema
{
  "type": "object",
  "properties": {
    "message": {
      "type": "string",
      "description": "Message to authenticate"
    },
    "key": {
      "type": "string",
      "description": "Secret key for HMAC"
    },
    "algorithm": {
      "type": "string",
      "enum": [
        "sha1",
        "sha256",
        "sha512"
      ],
      "description": "Hash algorithm"
    }
  },
  "required": [
    "message",
    "key"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Hmac",
  "readOnlyHint": false
}
—Writes—
generate_ipv6_ulaGenerate IPv6 Unique Local Address (ULA) prefix
Input schema
{
  "type": "object",
  "properties": {
    "globalId": {
      "type": "string",
      "description": "Global ID (40 bits in hex, auto-generated if not provided)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Ipv6-ula-generator",
  "readOnlyHint": false
}
—Writes—
generate_lorem_ipsumGenerate Lorem Ipsum placeholder text
Input schema
{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of items to generate"
    },
    "type": {
      "type": "string",
      "enum": [
        "words",
        "sentences",
        "paragraphs"
      ],
      "description": "Type of content to generate"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Lorem Ipsum",
  "readOnlyHint": false
}
—Writes—
generate_mac_addressGenerate random MAC address
Input schema
{
  "type": "object",
  "properties": {
    "prefix": {
      "type": "string",
      "description": "MAC address prefix (e.g., '00:1B:44')"
    },
    "separator": {
      "type": "string",
      "enum": [
        ":",
        "-"
      ],
      "description": "Separator character"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Mac-address-generate",
  "readOnlyHint": false
}
—Writes—
generate_markdown_tocGenerate a table of contents from Markdown headers
Input schema
{
  "type": "object",
  "properties": {
    "markdown": {
      "type": "string",
      "description": "Markdown content to generate TOC from"
    },
    "maxLevel": {
      "type": "number",
      "default": 6,
      "description": "Maximum header level to include (1-6)"
    },
    "generateAnchors": {
      "type": "boolean",
      "default": true,
      "description": "Whether to generate anchor links"
    }
  },
  "required": [
    "markdown"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Markdown Toc",
  "readOnlyHint": false
}
—Writes—
generate_numeronymGenerate numeronyms (abbreviations with numbers) from text
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to numeronym"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Numeronym",
  "readOnlyHint": false
}
—Writes—
generate_otpGenerate Time-based One-Time Password (TOTP) codes
Input schema
{
  "type": "object",
  "properties": {
    "secret": {
      "type": "string",
      "description": "Base32 encoded secret key"
    },
    "digits": {
      "type": "number",
      "description": "Number of digits in the code"
    },
    "period": {
      "type": "number",
      "description": "Time period in seconds"
    }
  },
  "required": [
    "secret"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Otp",
  "readOnlyHint": false
}
—Writes—
generate_passwordGenerate a secure password
Input schema
{
  "type": "object",
  "properties": {
    "length": {
      "type": "number",
      "description": "Password length"
    },
    "includeUppercase": {
      "type": "boolean",
      "description": "Include uppercase letters"
    },
    "includeLowercase": {
      "type": "boolean",
      "description": "Include lowercase letters"
    },
    "includeNumbers": {
      "type": "boolean",
      "description": "Include numbers"
    },
    "includeSymbols": {
      "type": "boolean",
      "description": "Include symbols"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Password",
  "readOnlyHint": false
}
—Writes—
generate_qr_codeGenerate QR code for any text including URLs, WiFi networks, contact info, etc.
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to encode in QR code (URLs, WiFi: WIFI:T:WPA;S:network;P:password;;, contact info, etc.)"
    },
    "size": {
      "type": "number",
      "description": "Size multiplier (1-3)"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Qr Code",
  "readOnlyHint": false
}
—Writes—
generate_random_portGenerate random port numbers
Input schema
{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of ports to generate"
    },
    "min": {
      "type": "number",
      "description": "Minimum port number"
    },
    "max": {
      "type": "number",
      "description": "Maximum port number"
    },
    "exclude": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Ports to exclude"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Random-port",
  "readOnlyHint": false
}
—Writes—
generate_svg_placeholderGenerate SVG placeholder images
Input schema
{
  "type": "object",
  "properties": {
    "width": {
      "type": "number",
      "description": "Width in pixels"
    },
    "height": {
      "type": "number",
      "description": "Height in pixels"
    },
    "backgroundColor": {
      "type": "string",
      "description": "Background color (hex)"
    },
    "textColor": {
      "type": "string",
      "description": "Text color (hex)"
    },
    "text": {
      "type": "string",
      "description": "Custom text (default: dimensions)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Svg Placeholder",
  "readOnlyHint": false
}
—Writes—
generate_tokenGenerate secure random tokens
Input schema
{
  "type": "object",
  "properties": {
    "length": {
      "type": "number",
      "description": "Token length"
    },
    "charset": {
      "type": "string",
      "enum": [
        "alphanumeric",
        "hex",
        "base64",
        "custom"
      ],
      "description": "Character set to use"
    },
    "customChars": {
      "type": "string",
      "description": "Custom characters (required if charset is 'custom')"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Token",
  "readOnlyHint": false
}
—Writes—
generate_traefik_composeGenerate Traefik Docker Compose configuration
Input schema
{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "description": "Domain for Traefik services (default: example.com)"
    },
    "email": {
      "type": "string",
      "description": "Email for Let's Encrypt (default: admin@example.com)"
    },
    "network": {
      "type": "string",
      "description": "Docker network name (default: traefik)"
    },
    "serviceName": {
      "type": "string",
      "description": "Example service name (default: webapp)"
    },
    "serviceImage": {
      "type": "string",
      "description": "Example service image (default: nginx:latest)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Traefik Compose",
  "readOnlyHint": false
}
—Writes—
generate_ulidGenerate Universally Unique Lexicographically Sortable Identifier (ULID). Example: creates time-sortable unique IDs like '01ARZ3NDEKTSV4RRFFQ69G5FAV'
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
Annotations
{
  "title": "Generate ULID",
  "readOnlyHint": false
}
—Writes—
generate_uuidGenerate a universally unique identifier (UUID). Example: generates "550e8400-e29b-41d4-a716-446655440000"
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
Annotations
{
  "title": "Generate Uuid",
  "readOnlyHint": false
}
—Writes—
grepSearch for patterns in files
Input schema
{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string",
      "description": "Pattern to search for"
    },
    "file": {
      "type": "string",
      "description": "File path"
    }
  },
  "required": [
    "pattern",
    "file"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Grep",
  "readOnlyHint": false
}
—Writes—
hash_bcryptGenerate bcrypt hash or verify password against hash
Input schema
{
  "type": "object",
  "properties": {
    "password": {
      "type": "string",
      "description": "Password to hash or verify"
    },
    "rounds": {
      "type": "number",
      "description": "Number of salt rounds (4-12, default 10)"
    },
    "hash": {
      "type": "string",
      "description": "Existing hash to verify against (for verification)"
    }
  },
  "required": [
    "password"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Hash Bcrypt",
  "readOnlyHint": false
}
—Writes—
hash_md5Generate MD5 hash
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to hash with MD5"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Hash Md5",
  "readOnlyHint": false
}
—Writes—
hash_sha1Generate SHA1 hash
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to hash with SHA1"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Hash Sha1",
  "readOnlyHint": false
}
—Writes—
hash_sha256Generate SHA256 hash of input text. Example: "hello" → "2cf24dba4f21d..."
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to hash with SHA256"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Hash Sha256",
  "readOnlyHint": false
}
—Writes—
hash_sha512Generate SHA512 hash
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to hash with SHA512"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Hash Sha512",
  "readOnlyHint": false
}
—Writes—
headDisplay the beginning of a file
Input schema
{
  "type": "object",
  "properties": {
    "file": {
      "type": "string",
      "description": "File path"
    },
    "lines": {
      "type": "number",
      "default": 10,
      "description": "Number of lines"
    }
  },
  "required": [
    "file"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Head",
  "readOnlyHint": false
}
—Writes—
identify_file_typeIdentify file type based on magic numbers/file signatures
Input schema
{
  "type": "object",
  "properties": {
    "data": {
      "type": "string",
      "description": "Hex data or base64 data of file header"
    },
    "format": {
      "type": "string",
      "enum": [
        "hex",
        "base64"
      ],
      "description": "Format of the input data"
    }
  },
  "required": [
    "data",
    "format"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Identify File Type",
  "readOnlyHint": false
}
—Writes—
logging_setLevelSet the minimum logging level for MCP logging notifications. Available levels: debug, info, notice, warning, error, critical, alert, emergency
Input schema
{
  "type": "object",
  "properties": {
    "level": {
      "type": "string",
      "enum": [
        "debug",
        "info",
        "notice",
        "warning",
        "error",
        "critical",
        "alert",
        "emergency"
      ],
      "description": "The minimum log level to report"
    }
  },
  "required": [
    "level"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
——
logging_statusGet current MCP logging configuration and status
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
——
lookup_http_statusGet information about HTTP status codes
Input schema
{
  "type": "object",
  "properties": {
    "code": {
      "type": "number",
      "description": "HTTP status code to look up (optional)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Lookup Http Status",
  "readOnlyHint": true
}
—Read only—
lookup_mime_typesLook up MIME types for file extensions
Input schema
{
  "type": "object",
  "properties": {
    "input": {
      "type": "string",
      "description": "File extension (e.g., 'txt') or MIME type (e.g., 'text/plain')"
    },
    "lookupType": {
      "type": "string",
      "enum": [
        "extension-to-mime",
        "mime-to-extension"
      ],
      "description": "Lookup direction"
    }
  },
  "required": [
    "input"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Lookup Mime Types",
  "readOnlyHint": true
}
—Read only—
lookup_port_numbersLook up common TCP/UDP port numbers and their services
Input schema
{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Port number or service name to look up"
    }
  },
  "required": [
    "query"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Lookup Port Numbers",
  "readOnlyHint": true
}
—Read only—
minify_jsonMinify JSON by removing whitespace and unnecessary characters. Example: formatted JSON → compact single-line JSON
Input schema
{
  "type": "object",
  "properties": {
    "json": {
      "type": "string",
      "description": "JSON string to minify"
    }
  },
  "required": [
    "json"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Minify JSON",
  "readOnlyHint": false
}
—Writes—
normalize_emailNormalize email addresses (remove dots, plus aliases, etc.)
Input schema
{
  "type": "object",
  "properties": {
    "email": {
      "type": "string",
      "description": "Email address to normalize"
    }
  },
  "required": [
    "email"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Normalize Email",
  "readOnlyHint": false
}
—Writes—
nslookupPerform DNS lookup on a hostname or IP address
Input schema
{
  "type": "object",
  "properties": {
    "target": {
      "type": "string",
      "description": "Hostname or IP address"
    }
  },
  "required": [
    "target"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Nslookup",
  "readOnlyHint": false
}
—Writes—
obfuscate_stringObfuscate text by replacing characters with their HTML entities or other representations
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to obfuscate"
    },
    "method": {
      "type": "string",
      "enum": [
        "html-entities",
        "unicode",
        "base64"
      ],
      "description": "Obfuscation method"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Obfuscate String",
  "readOnlyHint": false
}
—Writes—
parse_ansible_inventoryParse and validate Ansible inventory files
Input schema
{
  "type": "object",
  "properties": {
    "inventory": {
      "type": "string",
      "description": "Ansible inventory content (INI or YAML format)"
    }
  },
  "required": [
    "inventory"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Generate Ansible Inventory",
  "readOnlyHint": false
}
—Writes—
parse_urlParse URL into components
Input schema
{
  "type": "object",
  "properties": {
    "url": {
      "type": "string",
      "description": "URL to parse"
    }
  },
  "required": [
    "url"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Url-parse",
  "readOnlyHint": false
}
—Writes—
pingTest network connectivity to a host. Example: ping google.com to check if it's reachable
Input schema
{
  "type": "object",
  "properties": {
    "target": {
      "type": "string",
      "description": "Host to ping"
    },
    "count": {
      "type": "number",
      "default": 4,
      "description": "Number of ping attempts"
    }
  },
  "required": [
    "target"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Ping",
  "readOnlyHint": false
}
—Writes—
psList running processes
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
Annotations
{
  "title": "Ps",
  "readOnlyHint": false
}
—Writes—
scpCopy files to or from a remote host using SFTP (SCP-like)
Input schema
{
  "type": "object",
  "properties": {
    "target": {
      "type": "string",
      "description": "Target host"
    },
    "user": {
      "type": "string",
      "description": "Username"
    },
    "direction": {
      "type": "string",
      "enum": [
        "upload",
        "download"
      ],
      "description": "Direction: upload (local to remote) or download (remote to local)"
    },
    "localPath": {
      "type": "string",
      "description": "Local file path (source for upload, destination for download)"
    },
    "remotePath": {
      "type": "string",
      "description": "Remote file path (destination for upload, source for download)"
    },
    "privateKey": {
      "type": "string",
      "description": "Private key for authentication (PEM format, optional, or path to key file)"
    }
  },
  "required": [
    "target",
    "user",
    "direction",
    "localPath",
    "remotePath"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Scp",
  "readOnlyHint": false
}
—Writes—
search_emojiSearch for emojis by name or category
Input schema
{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term for emoji (name, category, or keyword)"
    }
  },
  "required": [
    "query"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Search Emoji",
  "readOnlyHint": false
}
—Writes—
show_ansible_referenceGet Ansible commands reference and cheatsheet
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
Annotations
{
  "title": "Show Ansible Reference",
  "readOnlyHint": true
}
—Read only—
show_device_infoGet basic device/system information
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
Annotations
{
  "title": "Show Device Info",
  "readOnlyHint": true
}
—Read only—
show_docker_referenceGet Docker commands reference and cheatsheet
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
Annotations
{
  "title": "Show Docker Reference",
  "readOnlyHint": true
}
—Read only—
show_unicode_namesConvert text to Unicode character names
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to Unicode names"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Show Unicode Names",
  "readOnlyHint": true
}
—Read only—
slugify_textConvert text to URL-friendly slug format
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to slug"
    },
    "separator": {
      "type": "string",
      "description": "Character to use as separator"
    },
    "lowercase": {
      "type": "boolean",
      "description": "Convert to lowercase"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Slugify Text",
  "readOnlyHint": false
}
—Writes—
sshConnect to a target via SSH
Input schema
{
  "type": "object",
  "properties": {
    "target": {
      "type": "string",
      "description": "Target host"
    },
    "user": {
      "type": "string",
      "description": "Username"
    },
    "command": {
      "type": "string",
      "description": "Command to run on remote host"
    },
    "privateKey": {
      "type": "string",
      "description": "Private key for authentication (PEM format, optional, or path to key file)"
    }
  },
  "required": [
    "target",
    "user",
    "command"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Ssh",
  "readOnlyHint": false
}
—Writes—
system_infoGet comprehensive system information, server details, available tool categories, and resource usage. Example: system information, tool categories, installation guide
Input schema
{
  "type": "object",
  "properties": {
    "include_tools": {
      "type": "boolean",
      "description": "Include detailed information about all available tools"
    },
    "category": {
      "type": "string",
      "description": "Get information about a specific category (dynamically discovered)"
    }
  },
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "System Information",
  "readOnlyHint": true
}
—Read only—
tailDisplay the end of a file
Input schema
{
  "type": "object",
  "properties": {
    "file": {
      "type": "string",
      "description": "File path"
    },
    "lines": {
      "type": "number",
      "default": 10,
      "description": "Number of lines"
    }
  },
  "required": [
    "file"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Tail",
  "readOnlyHint": false
}
—Writes—
telnetTest TCP connectivity to a host and port
Input schema
{
  "type": "object",
  "properties": {
    "target": {
      "type": "string",
      "description": "Host to connect to"
    },
    "port": {
      "type": "number",
      "description": "Port number"
    }
  },
  "required": [
    "target",
    "port"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Telnet",
  "readOnlyHint": false
}
—Writes—
test_regexTest regular expressions against text
Input schema
{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string",
      "description": "Regular expression pattern"
    },
    "text": {
      "type": "string",
      "description": "Text to test against the regex"
    },
    "flags": {
      "type": "string",
      "description": "Regex flags (g, i, m, s, u, y)"
    }
  },
  "required": [
    "pattern",
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Test Regex",
  "readOnlyHint": false
}
—Writes—
text_snakecaseConvert text to snake_case
Input schema
{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Text to convert to snake_case"
    }
  },
  "required": [
    "text"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Convert Text To Snake Case",
  "readOnlyHint": false
}
—Writes—
topDisplay system processes (snapshot)
Input schema
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
Annotations
{
  "title": "Top",
  "readOnlyHint": false
}
—Writes—
validate_ansible_playbookValidate Ansible playbook syntax and structure
Input schema
{
  "type": "object",
  "properties": {
    "playbook": {
      "type": "string",
      "description": "Ansible playbook YAML content"
    }
  },
  "required": [
    "playbook"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Validate Ansible Playbook",
  "readOnlyHint": false
}
—Writes—
validate_docker_composeValidate Docker Compose files for syntax errors, compatibility issues, and best practices. Example: check YAML syntax, service configuration, network setup
Input schema
{
  "type": "object",
  "properties": {
    "content": {
      "type": "string",
      "description": "Docker Compose file content to validate"
    }
  },
  "required": [
    "content"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Validate Docker Compose",
  "readOnlyHint": false
}
—Writes—
validate_ibanValidate and parse IBAN (International Bank Account Number)
Input schema
{
  "type": "object",
  "properties": {
    "iban": {
      "type": "string",
      "description": "IBAN to validate and parse"
    }
  },
  "required": [
    "iban"
  ],
  "additionalProperties": false,
  "$schema": "http://json-schema.org/draft-07/schema#"
}
Annotations
{
  "title": "Iban-validate",
  "readOnlyHint": false
}
—Writes—

Resources 25

  • docs://ansibledocs://ansible

    Documentation for ansible tools

  • docs://colordocs://color

    Documentation for color tools

  • docs://cryptodocs://crypto

    Documentation for crypto tools

  • docs://data_formatdocs://data_format

    Documentation for data_format tools

  • docs://developmentdocs://development

    Documentation for development tools

  • docs://dockerdocs://docker

    Documentation for docker tools

  • docs://encodingdocs://encoding

    Documentation for encoding tools

  • docs://forensicdocs://forensic

    Documentation for forensic tools

  • docs://id_generatorsdocs://id_generators

    Documentation for id_generators tools

  • docs://mathdocs://math

    Documentation for math tools

  • docs://networkdocs://network

    Documentation for network tools

  • docs://physicsdocs://physics

    Documentation for physics tools

  • docs://textdocs://text

    Documentation for text tools

  • docs://utilitydocs://utility

    Documentation for utility tools

  • logs://debuglogs://debug

    Debug information

  • logs://errorlogs://error

    Error log entries

  • logs://systemlogs://system

    System log entries

  • manifest://categoriesmanifest://categories

    Tool categories and descriptions

  • manifest://infomanifest://info

    Server information and capabilities

  • manifest://toolsmanifest://tools

    Complete list of available tools

  • readme://examplesreadme://examples

    Usage examples

  • readme://fullreadme://full

    Complete README documentation

  • readme://installationreadme://installation

    Installation instructions

  • readme://toolsreadme://tools

    Available tools overview

  • workspace-configconfig://workspace

    Current workspace configuration and environment settings

Resource templates 4

  • readmereadme://{section}

    Server documentation and usage guide

  • server-manifestmanifest://{type}

    Comprehensive server information, capabilities, and tool catalog

  • system-logslogs://{type}

    Access to system and application logs

  • tool-documentationdocs://{category}

    Documentation for available tools by category

Prompts 3

  • it-tools-workflowit-tools-workflow

    Guided workflow for common IT tasks using available tools

  • it-workflowit-workflow

    Guided workflow for common IT tasks using available tools

  • security-checksecurity-check

    Analyze data for security concerns before processing

Remote endpoints

EndpointTransportAuthenticationHealthObserved
No verified remote endpoint is linked.

IT Tools MCP Server questions

How do I install IT Tools MCP Server?

Install the selected package version with: npm install --save-exact it-tools-mcp@5.10.8

What tools does IT Tools MCP Server provide?

IT Tools MCP Server exposed 119 tools during independent protocol observation, including analyze_distinct_words, analyze_text_stats, calculate_ip_subnet, calculate_ipv4_subnet, calculate_ipv6_subnet, calculate_percentage, capitalize_text, cat, and others.

Is IT Tools MCP Server secure?

The selected current version does not yet have completed public verification. Unknown does not mean clean or vulnerable.

Explore related MCP server guides

Curated product and capability guides containing this catalog record.

Developer Tool MCP ServersOfficial vs Community MCP Servers

Let’s talk about MCP security.

Share your details and our security team will contact you.