MCP MeasureMCP Measure

índice observado

ToolAPI

Free public MCP for AI agents — 193 tools, 44 workflows. No API key.

¿Debería usar esto?

Calidad y seguridad

B
Calidad de la descripción
86%
Integridad del esquema
79%
Calidad de los nombres
81%
Riesgo de envenenamiento
40%
Coincidencia de permisos
100%
Cumplimiento del protocolo
100%

Hallazgos (57)

  • HIGHTool poisoning patterns detected
  • MEDIUMTool 'text_lorem' description contains placeholder texten text_lorem
  • MEDIUMTool 'template_fill' description contains placeholder texten template_fill
  • MEDIUMTool 'todo_comment_extract' description contains placeholder texten todo_comment_extract
  • LOWTool 'xml_format' description lacks action verben xml_format
  • LOWTool 'json_pretty_diff' description lacks action verben json_pretty_diff
  • LOWTool 'github_actions_lint' description lacks action verben github_actions_lint
  • LOWTool 'json_schema_validate_batch' description lacks action verben json_schema_validate_batch
  • LOWTool 'json_schema_infer' description lacks action verben json_schema_infer
  • LOWTool 'time_now' description lacks action verben time_now

Basado en el análisis automatizado de las definiciones de herramientas y el cumplimiento del protocolo.

Costo de contexto

~11,632Tokens (definiciones de herramientas)
~352 BTamaño de respuesta típico
Impacto significativo en la atención (9.09% del contexto de 128k)

Este es el número aproximado de tokens que se consumen cada vez que las herramientas del servidor se cargan en el contexto de un modelo. Los recuentos más altos reducen la atención disponible para otras tareas.

Instalar

Instalación con un clic

Agrega esto a tu archivo `claude_desktop_config.json`:

{
  "mcpServers": {
    "hub": {
      "url": "https://toolapi.org/sse"
    }
  }
}

Puntos de conexión remotos

https://toolapi.org/ssesse
https://toolapi.org/mcpstreamable-http

Qué puede hacer

Inventario de herramientas

Herramientas (193)

🟢 Solo lectura🟡 Escritura🔴 Eliminación⚪ Desconocido
⚪json_validate(text)

Validate JSON text; return parsed object or error.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪json_format(text, indent)

Pretty-print JSON with indent. When: Pretty-print JSON when the agent needs readable output.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "indent": {
      "type": "integer",
      "default": 2
    }
  },
  "required": [
    "text"
  ]
}
⚪json_minify(text)

Minify JSON (remove whitespace). When: Minify JSON for compact payloads or size checks.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪csv_to_json(text)

Convert CSV text to JSON array of row objects. When: Convert CSV rows → JSON array of objects.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪json_to_csv(text)

Convert JSON array of objects to CSV text.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪yaml_validate(text)

Validate YAML text; return parsed object or error.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢yaml_to_json(text)

Parse YAML and return JSON-compatible object.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪json_to_yaml(text)

Convert JSON text to YAML string. When: Convert JSON → YAML for config files agents write.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪xml_validate(text)

Validate XML markup (well-formed check).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪xml_format(text)

Pretty-print XML with indentation. When: Pretty-print XML after the agent edits markup.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢jsonpath_query(text, path)

Query JSON with JSONPath expression; returns matching values.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "JSON text"
    },
    "path": {
      "type": "string",
      "description": "e.g. $.store.book[*].author"
    }
  },
  "required": [
    "text",
    "path"
  ]
}
⚪json_merge(a, b)

Deep-merge two JSON objects (second overlays first).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}
⚪json_flatten(text, separator)

Flatten nested JSON to dot-key map. When: Flatten nested JSON keys before comparing or exporting.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "separator": {
      "type": "string",
      "default": "."
    }
  },
  "required": [
    "text"
  ]
}
⚪json_pretty_diff(a, b)

Unified diff of two JSON documents (pretty-printed).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}
⚪json_sort_keys(text)

Recursively sort JSON object keys. When: Canonicalize JSON key order for stable diffs/hashes.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪json_type_summary(text)

Summarize JSON value types (counts per type in tree).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪json_schema_validate(data, schema, max_errors)

Validate JSON data against JSON Schema (Draft 7).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string",
      "description": "JSON document text"
    },
    "schema": {
      "type": "string",
      "description": "JSON Schema (Draft 7)"
    },
    "max_errors": {
      "type": "integer",
      "default": 20,
      "minimum": 1,
      "maximum": 50
    }
  },
  "required": [
    "data",
    "schema"
  ]
}
⚪toml_validate(text)

Validate TOML text; return parsed object or error.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢toml_to_json(text)

Parse TOML and return JSON-compatible object.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪json_to_toml(text)

Convert JSON object text to TOML string.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪toml_schema_validate(toml, schema, max_errors)

Validate TOML config against JSON Schema (Draft 7) in one step.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "toml": {
      "type": "string",
      "description": "TOML document text"
    },
    "schema": {
      "type": "string",
      "description": "JSON Schema (Draft 7)"
    },
    "max_errors": {
      "type": "integer",
      "default": 20,
      "minimum": 1,
      "maximum": 50
    }
  },
  "required": [
    "toml",
    "schema"
  ]
}
⚪sql_format(text, keyword_case, reindent)

Format SQL text (never executed; reindent + keyword case).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "keyword_case": {
      "type": "string",
      "enum": [
        "upper",
        "lower",
        "capitalize"
      ],
      "default": "upper"
    },
    "reindent": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "text"
  ]
}
🟢graphql_validate(text)

Validate GraphQL query or schema SDL syntax (parse only).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪openapi_validate(text)

Validate OpenAPI 3.x document (JSON or YAML snippet).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪openapi_diff(old, new)

Compare two OpenAPI specs and flag breaking vs non-breaking API changes.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "old": {
      "type": "string",
      "description": "Previous OpenAPI JSON/YAML"
    },
    "new": {
      "type": "string",
      "description": "New OpenAPI JSON/YAML"
    }
  },
  "required": [
    "old",
    "new"
  ]
}
⚪package_manifest_audit(text, kind)

Audit package.json or pyproject.toml — license, risky scripts, loose ranges; emit semver_checks for batch. Note: best-effort / heuristic — not a full language parser.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Manifest file contents"
    },
    "kind": {
      "type": "string",
      "enum": [
        "auto",
        "npm",
        "pyproject"
      ],
      "default": "auto"
    }
  },
  "required": [
    "text"
  ]
}
⚪graphql_schema_diff(old, new)

Diff two GraphQL schemas for removed types/fields (breaking changes).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "old": {
      "type": "string"
    },
    "new": {
      "type": "string"
    }
  },
  "required": [
    "old",
    "new"
  ]
}
⚪compose_validate(text)

Validate docker-compose YAML and flag privileged/host-network/secret env issues.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪github_actions_lint(text)

Lint GitHub Actions workflow YAML (triggers, unpinned actions, curl|bash).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪requirements_audit(text)

Audit Python requirements.txt for unpinned/VCS/deprecated packages.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪json_schema_validate_batch(items, max_errors)

Batch JSON Schema (Draft 7) validation — up to 25 documents (agent favorite).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array",
      "maxItems": 25,
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "data": {
            "type": "string"
          },
          "schema": {
            "type": "string"
          }
        },
        "required": [
          "data",
          "schema"
        ]
      }
    },
    "max_errors": {
      "type": "integer",
      "default": 10
    }
  },
  "required": [
    "items"
  ]
}
⚪json_assert_paths(data, assertions)

Assert JSONPath expressions against JSON (exists/equals/type) — agent self-check.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string"
    },
    "assertions": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string"
          },
          "exists": {
            "type": "boolean"
          },
          "equals": {},
          "type": {
            "type": "string"
          }
        },
        "required": [
          "path"
        ]
      }
    }
  },
  "required": [
    "data",
    "assertions"
  ]
}
🟢json_equal(a, b)

Deep-compare two JSON documents and list differing paths.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}
🟢yaml_schema_validate(yaml, schema, max_errors)

Parse YAML then validate against JSON Schema (Draft 7).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "yaml": {
      "type": "string"
    },
    "schema": {
      "type": "string"
    },
    "max_errors": {
      "type": "integer",
      "default": 20
    }
  },
  "required": [
    "yaml",
    "schema"
  ]
}
⚪tsconfig_lint(text)

Lint tsconfig.json structure (compilerOptions, strict hints).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢json_pointer_get(data, pointer)

Get value by RFC 6901 JSON Pointer (e.g. /user/id). When: Read one field by RFC 6901 pointer without full walk in the agent.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string"
    },
    "pointer": {
      "type": "string",
      "default": ""
    }
  },
  "required": [
    "data"
  ]
}
🟡json_patch_apply(data, patch)

Apply RFC 6902 JSON Patch ops (add/remove/replace/test/move/copy). When: Apply RFC 6902 ops (add/remove/replace/test/move/copy).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string"
    },
    "patch": {
      "type": "string"
    }
  },
  "required": [
    "data",
    "patch"
  ]
}
⚪json_schema_infer(data, title)

Infer a Draft-7 JSON Schema from a sample JSON document (agent favorite).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "data": {
      "type": "string"
    },
    "title": {
      "type": "string",
      "default": "Inferred"
    }
  },
  "required": [
    "data"
  ]
}
⚪jsonl_validate(text, schema, max_lines)

Validate JSON Lines (NDJSON); optional per-line JSON Schema. When: Validate NDJSON / JSON Lines logs or datasets.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "schema": {
      "type": "string"
    },
    "max_lines": {
      "type": "integer",
      "default": 200
    }
  },
  "required": [
    "text"
  ]
}
⚪xml_to_json(text)

Convert XML document to JSON (attributes as @attr). When: Convert XML → JSON for agents that prefer JSON tools.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟡json_merge_patch(target, patch)

Apply RFC 7396 JSON Merge Patch (null deletes keys). When: RFC 7396 merge patch — use when patching JSON configs.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "target": {
      "type": "string"
    },
    "patch": {
      "type": "string"
    }
  },
  "required": [
    "target",
    "patch"
  ]
}
🟢csv_validate(text, delimiter, has_header)

Validate CSV structure — consistent column counts / header. When: Check CSV column consistency before import.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "delimiter": {
      "type": "string",
      "default": ","
    },
    "has_header": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "text"
  ]
}
🟢ini_parse(text)

Parse INI / simple key=value config into sections. When: Parse INI/section configs into structured maps.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢openapi_operations_list(text)

List OpenAPI path operations (method, path, operationId, tags). When: List OpenAPI operations before validate/diff.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢graphql_operations_list(text)

List GraphQL query/mutation/subscription names and type defs. When: List GraphQL ops/types from a document (best-effort).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢properties_parse(text)

Parse Java .properties key=value file. When: Parse Java .properties key=value configs (best-effort).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪time_now

Current UTC unix timestamp and ISO-8601.

Esquema de entrada

{
  "type": "object",
  "properties": {}
}
⚪time_convert(value)

Convert unix seconds or ISO-8601 to both formats.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string"
    }
  },
  "required": [
    "value"
  ]
}
⚪timezone_convert(value, from_timezone, to_timezone)

Convert datetime between IANA timezones (e.g. UTC to Asia/Shanghai).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string",
      "description": "Unix seconds or ISO datetime"
    },
    "from_timezone": {
      "type": "string",
      "default": "UTC"
    },
    "to_timezone": {
      "type": "string",
      "description": "e.g. Asia/Shanghai"
    }
  },
  "required": [
    "value",
    "to_timezone"
  ]
}
🟢timezone_list

List common IANA timezone names for conversion.

Esquema de entrada

{
  "type": "object",
  "properties": {}
}
🟢datetime_parse(value)

Parse unix timestamp or ISO-8601 into UTC ISO + unix.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string"
    }
  },
  "required": [
    "value"
  ]
}
🟢duration_parse(value)

Parse duration (ISO-8601 PnDTnHnMnS or human 1h30m / 90s) to seconds. When: Parse ISO-8601 / human durations to seconds.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string"
    }
  },
  "required": [
    "value"
  ]
}
⚪regex_test(pattern, text, flags)

Test regex pattern; returns match, groups, span.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string"
    },
    "text": {
      "type": "string"
    },
    "flags": {
      "type": "string",
      "description": "i, m, s"
    }
  },
  "required": [
    "pattern",
    "text"
  ]
}
⚪regex_replace(pattern, replacement, text, flags, global_replace, ...)

Replace regex matches in text (supports backreferences in replacement).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string"
    },
    "replacement": {
      "type": "string"
    },
    "text": {
      "type": "string"
    },
    "flags": {
      "type": "string",
      "description": "i, m, s"
    },
    "global_replace": {
      "type": "boolean",
      "default": true
    },
    "count": {
      "type": "integer",
      "description": "Max replacements when global",
      "default": 0
    }
  },
  "required": [
    "pattern",
    "replacement",
    "text"
  ]
}
⚪text_diff(left, right)

Unified line diff between two texts (like git diff).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "left": {
      "type": "string"
    },
    "right": {
      "type": "string"
    }
  },
  "required": [
    "left",
    "right"
  ]
}
⚪text_slugify(text)

URL-safe slug from title or heading. When: Make URL-safe slugs from titles/filenames.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢text_stats(text)

Count chars, words, lines, sentences; estimate reading time.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪text_case_convert(text, mode)

Convert case: lower, upper, title, snake, kebab, camel, pascal.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "mode": {
      "type": "string",
      "enum": [
        "lower",
        "upper",
        "title",
        "snake",
        "kebab",
        "camel",
        "pascal"
      ]
    }
  },
  "required": [
    "text",
    "mode"
  ]
}
⚪text_lorem(paragraphs)

Generate lorem ipsum placeholder paragraphs.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "paragraphs": {
      "type": "integer",
      "default": 1,
      "minimum": 1,
      "maximum": 10
    }
  }
}
⚪color_convert(color, to_format)

Convert color between hex, rgb(), and hsl().

Esquema de entrada

{
  "type": "object",
  "properties": {
    "color": {
      "type": "string",
      "description": "hex, rgb(), or hsl()"
    },
    "to_format": {
      "type": "string",
      "enum": [
        "all",
        "hex",
        "rgb",
        "hsl"
      ],
      "default": "all"
    }
  },
  "required": [
    "color"
  ]
}
⚪unit_convert(value, from_unit, to_unit, category)

Convert units: length, weight, temperature, data, speed, time.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "value": {
      "type": "number"
    },
    "from_unit": {
      "type": "string"
    },
    "to_unit": {
      "type": "string"
    },
    "category": {
      "type": "string",
      "description": "optional: length, weight, temperature, data, speed, time"
    }
  },
  "required": [
    "value",
    "from_unit",
    "to_unit"
  ]
}
🟢unit_list

List supported units per category for unit_convert.

Esquema de entrada

{
  "type": "object",
  "properties": {}
}
⚪markdown_to_html(text)

Convert Markdown text to HTML. When: Render markdown → HTML for previews or emails.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪html_to_markdown(html)

Convert HTML to Markdown text. When: Convert HTML → markdown for docs the agent edits.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "html": {
      "type": "string"
    }
  },
  "required": [
    "html"
  ]
}
🟢pick_choice(items, seed)

Pick one item from a list (optional seed for reproducibility).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array"
    },
    "seed": {
      "type": "integer",
      "description": "Optional RNG seed"
    }
  },
  "required": [
    "items"
  ]
}
⚪string_truncate(text, max_length, ellipsis)

Truncate text with ellipsis. When: Truncate long strings with ellipsis for UI/logs.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "max_length": {
      "type": "integer",
      "default": 80
    },
    "ellipsis": {
      "type": "string",
      "default": "..."
    }
  },
  "required": [
    "text"
  ]
}
🟢extract_urls(text)

Extract HTTP/HTTPS URLs from arbitrary text.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢extract_emails(text)

Extract email addresses from text. When: Pull email addresses from free text / logs.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢email_validate(email)

Validate email address format. When: Syntax-check a single email address.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "email": {
      "type": "string"
    }
  },
  "required": [
    "email"
  ]
}
⚪text_wrap(text, width)

Wrap text to a maximum line width. When: Hard-wrap text to a column width.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "width": {
      "type": "integer",
      "default": 80
    }
  },
  "required": [
    "text"
  ]
}
🟢list_unique(items)

Deduplicate list items preserving order.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "items": {
      "type": "array"
    }
  },
  "required": [
    "items"
  ]
}
⚪template_fill(template, variables)

Fill {{variable}} placeholders in a template string.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "template": {
      "type": "string"
    },
    "variables": {
      "type": "object"
    }
  },
  "required": [
    "template",
    "variables"
  ]
}
⚪unicode_normalize(text, form)

Unicode normalization (NFC/NFD/NFKC/NFKD).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "form": {
      "type": "string",
      "enum": [
        "NFC",
        "NFD",
        "NFKC",
        "NFKD"
      ],
      "default": "NFC"
    }
  },
  "required": [
    "text"
  ]
}
🟢user_agent_parse(user_agent)

Parse User-Agent string into browser, OS, and device hints.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "user_agent": {
      "type": "string"
    }
  },
  "required": [
    "user_agent"
  ]
}
⚪secrets_scan(text, min_entropy)

Scan text for hardcoded secrets (API keys, tokens, private keys). Returns redacted findings.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "min_entropy": {
      "type": "number",
      "default": 3.5,
      "description": "Entropy threshold for heuristic strings"
    }
  },
  "required": [
    "text"
  ]
}
⚪dockerfile_lint(text)

Lint Dockerfile for common security/style issues (root user, curl|sh, secrets).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢env_required_check(text, required)

Check .env text contains required keys (and non-empty values).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "required": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "text",
    "required"
  ]
}
🟢path_safety_check(path, allow_absolute)

Check filesystem path for traversal / absolute / sensitive system paths.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "path": {
      "type": "string"
    },
    "allow_absolute": {
      "type": "boolean",
      "default": false
    }
  },
  "required": [
    "path"
  ]
}
🟢spdx_license_check(expression)

Validate SPDX license expression against common license IDs.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "expression": {
      "type": "string"
    }
  },
  "required": [
    "expression"
  ]
}
⚪robots_txt_validate(text)

Validate robots.txt syntax and User-agent rules.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢csp_parse(header)

Parse Content-Security-Policy header and flag unsafe directives.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "header": {
      "type": "string"
    }
  },
  "required": [
    "header"
  ]
}
🟢cors_check(origin, allow_origin, allow_credentials)

Check CORS Allow-Origin vs credentials for unsafe combinations.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "origin": {
      "type": "string"
    },
    "allow_origin": {
      "type": "string"
    },
    "allow_credentials": {
      "type": "boolean",
      "default": false
    }
  },
  "required": [
    "allow_origin"
  ]
}
🟢markdown_link_extract(text)

Extract markdown/bare links and flag javascript: URLs.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢gitignore_check(text)

Review .gitignore for common missing ignores (.env, node_modules, keys).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪editorconfig_validate(text)

Validate .editorconfig syntax and common keys.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪nginx_config_lint(text)

Lint nginx config snippets (braces, SSLv3, server_tokens, HSTS hints).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪sql_danger_scan(text)

Scan SQL text for dangerous patterns (DROP/TRUNCATE/DELETE without WHERE). Note: best-effort / heuristic — not a full language parser.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪html_security_scan(text)

Scan HTML for XSS-prone patterns (javascript: URLs, inline handlers, eval). Note: best-effort / heuristic — not a full language parser.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪conventional_commit_lint(message)

Lint Conventional Commits message (feat/fix/chore…).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "message": {
      "type": "string"
    }
  },
  "required": [
    "message"
  ]
}
🟢changelog_parse(text)

Parse Keep-a-Changelog style markdown into version sections.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢todo_comment_extract(text)

Extract TODO/FIXME/HACK/XXX comments with line numbers.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢code_fence_extract(text)

Extract fenced code blocks from markdown (language + code).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢unified_diff_parse(text)

Parse unified diff — files changed, lines added/removed.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪glob_match_batch(paths, patterns)

Match paths against glob patterns (gitignore-style fnmatch).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "paths": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "patterns": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "paths",
    "patterns"
  ]
}
⚪identifier_validate(name, language)

Validate identifier for python/javascript/typescript (keywords + syntax).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string"
    },
    "language": {
      "type": "string",
      "enum": [
        "python",
        "javascript",
        "typescript"
      ],
      "default": "python"
    }
  },
  "required": [
    "name"
  ]
}
⚪text_similarity(a, b)

SequenceMatcher similarity ratio between two texts.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}
🟢import_list_analyze(text, language)

List imports from python/js source and flag duplicates. Note: best-effort / heuristic — not a full language parser.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "language": {
      "type": "string",
      "enum": [
        "python",
        "javascript"
      ],
      "default": "python"
    }
  },
  "required": [
    "text"
  ]
}
🟢frontmatter_parse(text)

Parse YAML frontmatter from markdown (--- ... ---). When: Split YAML frontmatter from markdown body.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪markdown_toc(text, max_level)

Build a table of contents from markdown headings. When: Build heading TOC from markdown docs.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "max_level": {
      "type": "integer",
      "default": 3,
      "minimum": 1,
      "maximum": 6
    }
  },
  "required": [
    "text"
  ]
}
⚪gitignore_match(paths, gitignore)

Match paths against .gitignore rules (ignore / negate). When: Test paths against .gitignore rules (best-effort).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "paths": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "gitignore": {
      "type": "string"
    }
  },
  "required": [
    "paths",
    "gitignore"
  ]
}
⚪shell_escape(text, shell)

Shell-escape a string for posix/powershell/cmd (safe quoting). When: Safely quote strings for posix/powershell/cmd.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "shell": {
      "type": "string",
      "enum": [
        "posix",
        "powershell",
        "cmd"
      ],
      "default": "posix"
    }
  },
  "required": [
    "text"
  ]
}
⚪path_normalize(path, style)

Normalize filesystem path (resolve . and ..) for posix or windows. When: Resolve . and .. in filesystem paths.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "path": {
      "type": "string"
    },
    "style": {
      "type": "string",
      "enum": [
        "posix",
        "windows"
      ],
      "default": "posix"
    }
  },
  "required": [
    "path"
  ]
}
⚪env_diff(a, b)

Diff two .env files — only_in_a / only_in_b / changed values. When: Diff two .env files for missing/changed keys.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}
🟢package_scripts_list(text, kind)

List scripts from package.json or pyproject.toml (poetry/PEP 621). When: List npm/poetry/PEP 621 scripts from manifests.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "kind": {
      "type": "string",
      "enum": [
        "auto",
        "npm",
        "pyproject"
      ],
      "default": "auto"
    }
  },
  "required": [
    "text"
  ]
}
⚪line_ending_normalize(text, style)

Detect and normalize line endings to lf/crlf/cr. When: Detect/normalize CRLF vs LF.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "style": {
      "type": "string",
      "enum": [
        "lf",
        "crlf",
        "cr"
      ],
      "default": "lf"
    }
  },
  "required": [
    "text"
  ]
}
🟢shebang_parse(text)

Parse #! shebang line — interpreter and args. When: Parse #! interpreter lines in scripts.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪trailing_whitespace_scan(text)

Scan text for trailing whitespace and tab characters. Note: best-effort / heuristic — not a full language parser.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢sql_tables_extract(text)

Extract table names from SQL (FROM/JOIN/INTO/UPDATE/TABLE). When: Heuristic extract of SQL table names (best-effort).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢dependency_versions_extract(text, ecosystem)

Extract name@version from requirements/lockfile/go.mod/Cargo snippets. When: Extract name@version from lock/requirements snippets (best-effort).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "ecosystem": {
      "type": "string",
      "enum": [
        "auto",
        "pip",
        "npm",
        "go",
        "cargo"
      ],
      "default": "auto"
    }
  },
  "required": [
    "text"
  ]
}
⚪color_contrast(fg, bg)

WCAG contrast ratio between two hex colors (AA/AAA). When: WCAG contrast ratio for UI color pairs.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "fg": {
      "type": "string"
    },
    "bg": {
      "type": "string"
    }
  },
  "required": [
    "fg",
    "bg"
  ]
}
🟢human_bytes(value, text, precision)

Format bytes to human size, or parse '1.5 GB' to bytes. When: Format or parse human byte sizes (1.5 GB).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "value": {
      "type": "number"
    },
    "text": {
      "type": "string"
    },
    "precision": {
      "type": "integer",
      "default": 2
    }
  }
}
⚪password_strength(password)

Offline password strength heuristic (length/classes/common). When: Offline password strength heuristic (not a cracker).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "password": {
      "type": "string"
    }
  },
  "required": [
    "password"
  ]
}
🟢hosts_file_parse(text)

Parse /etc/hosts style file into IP → hostnames entries. When: Parse /etc/hosts style IP→hostname maps.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪hash_md5(text)

MD5 hex digest of UTF-8 text. When: MD5 digest (non-crypto integrity / legacy checksums).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪hash_sha256(text)

SHA256 hex digest.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪hash_sha512(text)

SHA512 hex digest.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪base64_encode(text)

Base64-encode UTF-8.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪base64_decode(text)

Base64-decode to UTF-8.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪base64url_encode(text)

Base64url-encode UTF-8 (no padding, URL-safe).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪base64url_decode(text)

Base64url-decode to UTF-8.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪url_encode(text)

Percent-encode URL component.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪url_decode(text)

Decode percent-encoded string.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪html_encode(text)

Escape HTML entities.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪html_decode(text)

Unescape HTML entities.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪hex_encode(text)

UTF-8 text to hex string.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪hex_decode(text)

Hex string to UTF-8 text.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪uuid_generate(version, count, name, namespace, namespace_type)

Generate UUID v1/v3/v4/v5 (batch supported). v3/v5 need name + namespace.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "version": {
      "type": "integer",
      "enum": [
        1,
        3,
        4,
        5
      ],
      "default": 4
    },
    "count": {
      "type": "integer",
      "default": 1,
      "minimum": 1,
      "maximum": 20
    },
    "name": {
      "type": "string",
      "description": "Required for v3/v5"
    },
    "namespace": {
      "type": "string",
      "description": "UUID string for v3/v5 namespace"
    },
    "namespace_type": {
      "type": "string",
      "enum": [
        "dns",
        "url",
        "oid",
        "x500"
      ]
    }
  }
}
🟢uuid_parse(uuid)

Parse UUID string: version, variant, hex bytes.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "uuid": {
      "type": "string"
    }
  },
  "required": [
    "uuid"
  ]
}
⚪nanoid_generate(size)

Generate URL-friendly nanoid (like npm nanoid).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "size": {
      "type": "integer",
      "default": 21,
      "minimum": 1,
      "maximum": 64
    }
  }
}
⚪password_generate(length, symbols)

Cryptographically secure random password.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "length": {
      "type": "integer",
      "default": 16,
      "minimum": 8,
      "maximum": 64
    },
    "symbols": {
      "type": "boolean",
      "default": true
    }
  }
}
⚪jwt_decode(token)

Decode JWT payload and header (no signature verification).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string"
    }
  },
  "required": [
    "token"
  ]
}
⚪jwt_verify(token, secret, public_key, algorithms)

Verify JWT signature (HS* with secret, RS* with public_key PEM).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string"
    },
    "secret": {
      "type": "string",
      "description": "For HS256/384/512"
    },
    "public_key": {
      "type": "string",
      "description": "PEM public key for RS algorithms"
    },
    "algorithms": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "e.g. [\"HS256\"]"
    }
  },
  "required": [
    "token"
  ]
}
⚪jwt_sign(payload, secret, private_key, algorithm, header)

Sign JWT payload (HS* with secret, RS* with private_key PEM).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "payload": {
      "type": "object",
      "description": "Claims object or JSON string"
    },
    "secret": {
      "type": "string"
    },
    "private_key": {
      "type": "string",
      "description": "PEM private key for RS algorithms"
    },
    "algorithm": {
      "type": "string",
      "default": "HS256"
    },
    "header": {
      "type": "object",
      "description": "Optional extra JWT header fields"
    }
  },
  "required": [
    "payload"
  ]
}
⚪hmac_sign(message, secret, algorithm, encoding)

HMAC sign message (sha1/sha256/sha512); hex or base64 output.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "message": {
      "type": "string"
    },
    "secret": {
      "type": "string"
    },
    "algorithm": {
      "type": "string",
      "default": "sha256"
    },
    "encoding": {
      "type": "string",
      "enum": [
        "hex",
        "base64"
      ],
      "default": "hex"
    }
  },
  "required": [
    "message",
    "secret"
  ]
}
⚪hmac_verify(message, secret, signature, algorithm)

Verify HMAC signature (hex or base64).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "message": {
      "type": "string"
    },
    "secret": {
      "type": "string"
    },
    "signature": {
      "type": "string"
    },
    "algorithm": {
      "type": "string",
      "default": "sha256"
    }
  },
  "required": [
    "message",
    "secret",
    "signature"
  ]
}
⚪bcrypt_hash(password, rounds)

Bcrypt-hash a password for storage.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "password": {
      "type": "string"
    },
    "rounds": {
      "type": "integer",
      "default": 12,
      "minimum": 4,
      "maximum": 15
    }
  },
  "required": [
    "password"
  ]
}
⚪bcrypt_verify(password, hash)

Verify password against bcrypt hash.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "password": {
      "type": "string"
    },
    "hash": {
      "type": "string"
    }
  },
  "required": [
    "password",
    "hash"
  ]
}
⚪radix_convert(value, from_base, to_base)

Convert number between bases 2-36 (binary, octal, decimal, hex).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "value": {
      "type": "string"
    },
    "from_base": {
      "type": "string",
      "description": "2-36 or binary/octal/decimal/hex"
    },
    "to_base": {
      "type": "string"
    }
  },
  "required": [
    "value",
    "from_base",
    "to_base"
  ]
}
⚪qr_generate(text, border)

Generate QR code as SVG (base64 data URI included).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    },
    "border": {
      "type": "integer",
      "default": 4,
      "minimum": 1,
      "maximum": 10
    }
  },
  "required": [
    "text"
  ]
}
⚪random_int(min_val, max_val, seed)

Random integer in inclusive range (optional seed).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "min_val": {
      "type": "integer"
    },
    "max_val": {
      "type": "integer"
    },
    "seed": {
      "type": "integer"
    }
  },
  "required": [
    "min_val",
    "max_val"
  ]
}
⚪random_string(length, charset, seed)

Random string (alphanumeric, hex, base64 charset or custom).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "length": {
      "type": "integer",
      "default": 16
    },
    "charset": {
      "type": "string",
      "default": "alphanumeric"
    },
    "seed": {
      "type": "integer"
    }
  }
}
⚪hash_compare(a, b)

Compare two hash digests (case-insensitive).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}
⚪jwt_claims_audit(token)

Decode JWT header/claims (no verify) and flag alg=none, missing exp, privileged roles.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "token": {
      "type": "string"
    }
  },
  "required": [
    "token"
  ]
}
⚪remote_matrix

Remote desktop tools comparison JSON for AI citation.

Esquema de entrada

{
  "type": "object",
  "properties": {}
}
🟢url_parse(url)

Parse URL into scheme, host, path, query components.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    }
  },
  "required": [
    "url"
  ]
}
🟢http_status_lookup(code)

Explain HTTP status code (e.g. 404, 429, 503).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "code": {
      "type": "integer"
    }
  },
  "required": [
    "code"
  ]
}
🟢semver_parse(version)

Parse semver string into major, minor, patch, prerelease.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "version": {
      "type": "string"
    }
  },
  "required": [
    "version"
  ]
}
⚪semver_compare(a, b)

Compare two semver strings (less / equal / greater).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "a": {
      "type": "string"
    },
    "b": {
      "type": "string"
    }
  },
  "required": [
    "a",
    "b"
  ]
}
🟢semver_satisfies(version, range)

Check if version satisfies npm-style range (^ ~ >= <= > <).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "version": {
      "type": "string"
    },
    "range": {
      "type": "string"
    }
  },
  "required": [
    "version",
    "range"
  ]
}
⚪semver_satisfies_batch(checks)

Batch semver range checks for dependency audits (max 50).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "checks": {
      "type": "array",
      "maxItems": 50,
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string"
          },
          "version": {
            "type": "string"
          },
          "range": {
            "type": "string"
          }
        },
        "required": [
          "version",
          "range"
        ]
      }
    }
  },
  "required": [
    "checks"
  ]
}
🟢semver_range_intersects(range_a, range_b, samples)

Heuristic check whether two semver ranges share any sample versions (conflict hint).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "range_a": {
      "type": "string"
    },
    "range_b": {
      "type": "string"
    },
    "samples": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "range_a",
    "range_b"
  ]
}
🟢semver_sort(versions, reverse)

Sort a list of semver versions ascending or descending. When: Sort semver lists before picking latest/oldest.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "versions": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "reverse": {
      "type": "boolean",
      "default": false
    }
  },
  "required": [
    "versions"
  ]
}
⚪semver_max_satisfying(versions, range)

Pick the highest version that satisfies a semver range (npm-style).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "versions": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "range": {
      "type": "string"
    }
  },
  "required": [
    "versions",
    "range"
  ]
}
⚪semver_inc(version, release)

Bump a semver version by major/minor/patch. When: Bump major/minor/patch when cutting a release.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "version": {
      "type": "string"
    },
    "release": {
      "type": "string",
      "enum": [
        "major",
        "minor",
        "patch"
      ],
      "default": "patch"
    }
  },
  "required": [
    "version"
  ]
}
🟢cidr_calc(cidr)

Calculate IPv4/IPv6 network info from CIDR (hosts, broadcast, private).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "cidr": {
      "type": "string",
      "description": "e.g. 192.168.1.0/24"
    }
  },
  "required": [
    "cidr"
  ]
}
🟢cidr_contains(cidr, ip)

Check if IP address falls within a CIDR range.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "cidr": {
      "type": "string"
    },
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "cidr",
    "ip"
  ]
}
⚪ip_geolocation(ip)

Geolocate public IP: country, city, lat/lon, timezone, ISP.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "ip"
  ]
}
🟢env_parse(text)

Parse .env / dotenv text into key-value variables.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢pem_decode(text)

List PEM blocks in text (label, DER size, SHA256 fingerprint).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
🟢x509_parse(pem)

Parse X.509 certificate PEM: subject, issuer, validity, SAN, fingerprint.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "pem": {
      "type": "string"
    }
  },
  "required": [
    "pem"
  ]
}
⚪dns_lookup(domain, record_type)

DNS lookup for domain (A, AAAA, MX, TXT, NS, CNAME, SOA).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string"
    },
    "record_type": {
      "type": "string",
      "enum": [
        "A",
        "AAAA",
        "MX",
        "TXT",
        "NS",
        "CNAME",
        "SOA",
        "ANY"
      ],
      "default": "A"
    }
  },
  "required": [
    "domain"
  ]
}
⚪whois_lookup(domain)

Domain registration lookup via RDAP (registrar, dates, nameservers).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string"
    }
  },
  "required": [
    "domain"
  ]
}
🟢ssl_cert_fetch(host, port)

Fetch live TLS certificate from host:port (expiry, issuer, SAN).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "host": {
      "type": "string"
    },
    "port": {
      "type": "integer",
      "default": 443,
      "minimum": 1,
      "maximum": 65535
    }
  },
  "required": [
    "host"
  ]
}
⚪reverse_dns(ip)

Reverse DNS (PTR) lookup for IP address.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "ip"
  ]
}
🟢port_check(host, port)

TCP port open/closed check with latency ms.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "host": {
      "type": "string"
    },
    "port": {
      "type": "integer",
      "minimum": 1,
      "maximum": 65535
    }
  },
  "required": [
    "host",
    "port"
  ]
}
🟢http_headers_fetch(url, method, follow_redirects)

Fetch HTTP response headers (HEAD/GET) for URL.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "method": {
      "type": "string",
      "enum": [
        "HEAD",
        "GET"
      ],
      "default": "HEAD"
    },
    "follow_redirects": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "url"
  ]
}
🟢currency_list

List supported fiat currencies (Frankfurter/ECB, no API key).

Esquema de entrada

{
  "type": "object",
  "properties": {}
}
⚪currency_rates(base, symbols)

Latest exchange rates (Frankfurter ECB data, no API key).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "base": {
      "type": "string",
      "default": "USD"
    },
    "symbols": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional target currencies e.g. CNY, EUR"
    }
  }
}
⚪currency_convert(amount, from_currency, to_currency)

Convert amount between currencies using latest ECB rates.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "amount": {
      "type": "number"
    },
    "from_currency": {
      "type": "string"
    },
    "to_currency": {
      "type": "string"
    }
  },
  "required": [
    "amount",
    "from_currency",
    "to_currency"
  ]
}
🟢url_ssrf_check(url)

Check URL for SSRF risk (localhost, private IP, metadata hosts).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    }
  },
  "required": [
    "url"
  ]
}
🟢ipv4_private_check(ip)

Classify IP as private/loopback/link-local/global (SSRF helper).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "ip"
  ]
}
🔴url_normalize(url, sort_query, drop_fragment)

Normalize URL (lowercase host, sort query, drop fragment).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    },
    "sort_query": {
      "type": "boolean",
      "default": true
    },
    "drop_fragment": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "url"
  ]
}
🟢content_type_parse(header)

Parse Content-Type header into mime/charset/params.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "header": {
      "type": "string"
    }
  },
  "required": [
    "header"
  ]
}
⚪http_status_classify(codes)

Classify HTTP status codes into 2xx/3xx/4xx/5xx buckets.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "codes": {
      "type": "array",
      "items": {
        "type": [
          "integer",
          "string"
        ]
      }
    }
  },
  "required": [
    "codes"
  ]
}
🟢query_string_parse(query)

Parse URL query string into key/value map (supports multi-values). When: Parse URL query strings into maps.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string"
    }
  },
  "required": [
    "query"
  ]
}
🟢query_string_build(params, doseq)

Build URL query string from params object. When: Build query strings from param objects.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "params": {
      "type": "object"
    },
    "doseq": {
      "type": "boolean",
      "default": true
    }
  },
  "required": [
    "params"
  ]
}
🟢cookie_header_parse(header)

Parse Cookie request header into name/value map. When: Parse Cookie request headers.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "header": {
      "type": "string"
    }
  },
  "required": [
    "header"
  ]
}
⚪mime_lookup(path_or_ext, mime)

Lookup MIME type by file extension/path, or extensions by MIME. When: Map file extension ↔ MIME type.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "path_or_ext": {
      "type": "string"
    },
    "mime": {
      "type": "string"
    }
  }
}
⚪url_join(base, path)

Join base URL with relative path (urllib urljoin). When: Join base URL + relative path correctly.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "base": {
      "type": "string"
    },
    "path": {
      "type": "string"
    }
  },
  "required": [
    "base",
    "path"
  ]
}
🟢domain_parse(domain)

Parse domain into labels, TLD, registrable domain, subdomain. When: Split domain into subdomain/registrable/TLD (best-effort eTLD).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string"
    }
  },
  "required": [
    "domain"
  ]
}
🟢git_url_parse(url)

Parse git remote URL (ssh/https) into host/owner/repo. When: Parse git@ / https remotes into owner/repo.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "url": {
      "type": "string"
    }
  },
  "required": [
    "url"
  ]
}
🟢http_headers_parse(text)

Parse raw HTTP request/response header block into map. When: Parse raw HTTP header blocks.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "required": [
    "text"
  ]
}
⚪ip_version_detect(ip)

Detect IPv4/IPv6 and classify private/loopback/global. When: Classify IPv4/IPv6 and private/global.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "ip": {
      "type": "string"
    }
  },
  "required": [
    "ip"
  ]
}
🟢cron_parse(expr)

Parse 5-field cron into named fields (minute hour dom month dow).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    }
  },
  "required": [
    "expr"
  ]
}
🟢cron_validate(expr)

Check cron string has exactly five fields.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    }
  },
  "required": [
    "expr"
  ]
}
⚪cron_semantic_validate(expr)

Validate cron field syntax and value ranges (minute 0-59, hour 0-23, etc.).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    }
  },
  "required": [
    "expr"
  ]
}
⚪cron_next_runs(expr, count, from_time, timezone)

Preview next N execution times for a 5-field cron expression.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    },
    "count": {
      "type": "integer",
      "default": 5,
      "minimum": 1,
      "maximum": 20
    },
    "from_time": {
      "type": "string",
      "description": "Optional unix or ISO start time"
    },
    "timezone": {
      "type": "string",
      "default": "UTC"
    }
  },
  "required": [
    "expr"
  ]
}
🟢cron_describe(expr)

Human-readable natural language description of cron expression (EN + ZH).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    }
  },
  "required": [
    "expr"
  ]
}
🟢cron_matches(expr, at_time, timezone)

Check if a cron expression matches a specific datetime (ISO-8601).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "expr": {
      "type": "string"
    },
    "at_time": {
      "type": "string",
      "description": "ISO-8601 datetime"
    },
    "timezone": {
      "type": "string",
      "default": "UTC"
    }
  },
  "required": [
    "expr",
    "at_time"
  ]
}
⚪cron_validate_batch(expressions)

Batch semantic validate of 5-field cron expressions.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "expressions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "maxItems": 30
    }
  },
  "required": [
    "expressions"
  ]
}
🟡mail_inbox_create(prefix)

Create disposable receive-only inbox @mail.toolapi.org (24h TTL). Returns address + secret token.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "prefix": {
      "type": "string",
      "description": "Optional local-part prefix (alphanumeric)"
    }
  }
}
🟢mail_inbox_list(inbox_id, address, token)

List messages in a temp inbox (requires token from mail_inbox_create).

Esquema de entrada

{
  "type": "object",
  "properties": {
    "inbox_id": {
      "type": "string"
    },
    "address": {
      "type": "string"
    },
    "token": {
      "type": "string"
    }
  },
  "required": [
    "token"
  ]
}
🟢mail_inbox_read(message_id, inbox_id, address, token)

Read full message body from temp inbox.

Esquema de entrada

{
  "type": "object",
  "properties": {
    "message_id": {
      "type": "string"
    },
    "inbox_id": {
      "type": "string"
    },
    "address": {
      "type": "string"
    },
    "token": {
      "type": "string"
    }
  },
  "required": [
    "message_id",
    "token"
  ]
}

Comunidad

Califica este servidor

Evidencia

Observaciones recientes

verificadoversión no registrada193 herramientas
observación fallidaversión no registrada—
verificadoversión no registrada193 herramientas