← IT Tools MCP Server

IT Tools MCP Server 5.10.8

npm · it-tools-mcp · current release

119
Tools
25
Resources
4
Templates
3
Prompts

Observation

Observed 2026-08-15T20:20:49.214Z using mcpSecurity-inventory. Status: succeeded. Negotiated protocol: 2025-06-18.

Server capabilities
{
  "tools": {
    "listChanged": true
  },
  "resources": {
    "listChanged": true
  },
  "prompts": {
    "listChanged": true
  },
  "logging": {},
  "completions": {}
}

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

Resource templates 4

Prompts 3

Let’s talk about MCP security.

Share your details and our security team will contact you.