Server definition

Hash: sha256:66c1938afd34c6fad7db101b54dfd2b4dfa87a501fa2b1ec0cee6e529705c1b7
What it is: What a remote MCP server returned when asked what it offers: 14 tools

The blob, as servednamed by its sha256

{
  "instructions": "The small deterministic operations an agent needs mid-task, when no human is watching: convert JSON↔YAML, check that generated JSON is valid and has the keys you expect, diff two outputs line by line, test a regex before wiring it in, look inside a JWT (signature NOT verified — say so), translate SQL between dialects, convert times and units, and strip secrets out of text before sending it to a model. Agent frameworks do not ship these — you either write code or go without. All are keyless, millisecond, and free of any third-party dependency, so they cannot break because someone else changed an API.",
  "tools": [
    {
      "description": "Returns which lines were added and which were removed, with line numbers — computed with a longest-common-subsequence, not guessed by a model. Use to compare two versions of a config, a document, or any command output, instead of asking an LLM to eyeball two blobs and hoping it notices.",
      "inputSchema": {
        "properties": {
          "a": {
            "description": "The first (before) text.",
            "type": "string"
          },
          "b": {
            "description": "The second (after) text.",
            "type": "string"
          }
        },
        "required": [
          "a",
          "b"
        ],
        "type": "object"
      },
      "name": "diff_text",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Validate and pretty-print JSON (2-space indent). Reports the error location if invalid.",
      "inputSchema": {
        "additionalProperties": true,
        "properties": {
          "indent": {
            "type": "number"
          },
          "json": {},
          "url": {}
        },
        "type": "object"
      },
      "name": "json_format",
      "outputSchema": null
    },
    {
      "description": "Converts JSON to YAML or YAML to JSON. It works out which one you gave it, so you do not have to say. A parse failure comes back with the parser message instead of silently producing something that looks fine and is not. Use when a config, a CI file, or a Kubernetes manifest needs to be in the other format.",
      "inputSchema": {
        "properties": {
          "text": {
            "description": "The JSON or YAML content.",
            "type": "string"
          },
          "to": {
            "description": "Optional: \"json\" or \"yaml\" to force the direction.",
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "json_yaml",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Decodes the header and payload of a JWT and reports issued-at / expiry as readable timestamps plus seconds remaining. The signature is NOT verified and the response says so — decoding is fine for debugging a token you already hold, but never treat these values as proof of anything; verification needs the secret and belongs in your own service.",
      "inputSchema": {
        "properties": {
          "token": {
            "description": "The JWT string.",
            "type": "string"
          }
        },
        "required": [
          "token"
        ],
        "type": "object"
      },
      "name": "jwt_decode",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Any text or URL → a QR code PNG you can embed or download. Stateless URL form: https://ainetcafe.com/i/qr/<text>",
      "inputSchema": {
        "properties": {
          "text": {
            "description": "The text or URL to encode.",
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "make_qr",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Strip emails, phone numbers, ID numbers, API keys, private keys, JWTs, card numbers and IPs out of text, returning the redacted text plus a mapping table to restore them afterwards. Rule-based only — no model sees the input. The same value always maps to the same placeholder, so the answer can be restored.",
      "inputSchema": {
        "properties": {
          "only": {
            "description": "Optional comma-separated subset, e.g. \"EMAIL,API_KEY,PRIVATE_KEY\".",
            "type": "string"
          },
          "text": {
            "description": "The text to redact.",
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "redact_text",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Runs a regular expression against sample text and returns every match with its position and capture groups (named groups included). Use before wiring a pattern into code, instead of guessing whether the escaping survived the trip through JSON and the shell.",
      "inputSchema": {
        "properties": {
          "flags": {
            "description": "Optional flags, e.g. \"gi\". Default \"g\".",
            "type": "string"
          },
          "pattern": {
            "description": "The regular expression, without surrounding slashes.",
            "type": "string"
          },
          "text": {
            "description": "The text to test against.",
            "type": "string"
          }
        },
        "required": [
          "pattern",
          "text"
        ],
        "type": "object"
      },
      "name": "regex_test",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Full-page screenshot of any URL → PNG. The same job screenshot APIs charge $7-79/month for.",
      "inputSchema": {
        "additionalProperties": true,
        "properties": {
          "url": {},
          "width": {
            "type": "number"
          }
        },
        "type": "object"
      },
      "name": "screenshot_url",
      "outputSchema": null
    },
    {
      "description": "Plain-language request + table schema → ready-to-run .sql file with comments.",
      "inputSchema": {
        "additionalProperties": true,
        "properties": {
          "dialect": {},
          "request": {},
          "schema": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "sql_from_description",
      "outputSchema": null
    },
    {
      "description": "Convert a time between time zones, or get current time in any zone. from/to = IANA zone (Asia/Shanghai), time = YYYY-MM-DDTHH:mm (default now).",
      "inputSchema": {
        "additionalProperties": true,
        "properties": {
          "from": {
            "type": "string"
          },
          "time": {
            "type": "string"
          },
          "to": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "name": "timezone_convert",
      "outputSchema": null
    },
    {
      "description": "Convert a SQL statement from one dialect to another — mysql, postgres, sqlite, tsql, oracle, snowflake, bigquery, redshift, spark, hive, presto, trino, duckdb, clickhouse, databricks, doris, starrocks and more. Deterministic parser (sqlglot), not an LLM: the same input always produces the same output, and syntax errors come back with the exact line and column. Use it when migrating queries between databases or debugging dialect-specific syntax.",
      "inputSchema": {
        "properties": {
          "read": {
            "description": "Source dialect, e.g. \"mysql\". Omit to auto-detect from generic SQL.",
            "type": "string"
          },
          "sql": {
            "description": "The SQL statement (or several, separated by semicolons).",
            "type": "string"
          },
          "write": {
            "description": "Target dialect, e.g. \"postgres\", \"bigquery\", \"doris\".",
            "type": "string"
          }
        },
        "required": [
          "sql",
          "write"
        ],
        "type": "object"
      },
      "name": "transpile_sql",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Convert units: length, weight, temperature, area, volume, speed, data size. value + from + to (e.g. 100 km mi, 25 c f).",
      "inputSchema": {
        "additionalProperties": true,
        "properties": {
          "from": {
            "type": "string"
          },
          "to": {
            "type": "string"
          },
          "value": {
            "type": "number"
          }
        },
        "type": "object"
      },
      "name": "unit_convert",
      "outputSchema": null
    },
    {
      "description": "Checks that text parses as JSON, and optionally that required keys are present with the right top-level types. Returns the specific violations, not just true/false. Checks required + types only — not full JSON Schema, and it says so rather than pretending. Use before feeding generated JSON into something that will fail on it.",
      "inputSchema": {
        "properties": {
          "schema": {
            "description": "Optional JSON Schema (as JSON text) — required[] and properties[].type are checked.",
            "type": "string"
          },
          "text": {
            "description": "The JSON to validate.",
            "type": "string"
          }
        },
        "required": [
          "text"
        ],
        "type": "object"
      },
      "name": "validate_json",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    },
    {
      "description": "Describe a task in plain language (any language) and get back exactly which tools on this server do it, with ready-to-run example calls — instead of reading the whole catalogue and guessing. Also returns multi-step recipes when a task needs several tools chained (invoices to a ledger, a bank statement reconciled, a messy CSV turned into a deliverable). Deterministic and free: it calls no model, costs nothing, and never runs out of quota. Call this FIRST when you are not sure what this server offers.",
      "inputSchema": {
        "properties": {
          "task": {
            "description": "What you are trying to do, e.g. \"reconcile a bank statement against my books\" or \"把一堆发票整理成能入账的表格\"",
            "type": "string"
          }
        },
        "required": [
          "task"
        ],
        "type": "object"
      },
      "name": "what_can_you_do",
      "outputSchema": {
        "additionalProperties": true,
        "type": "object"
      }
    }
  ]
}

Verify it yourself

curl -s https://api.teppi.xyz/v1/evidence/sha256:66c1938afd34c6fad7db101b54dfd2b4dfa87a501fa2b1ec0cee6e529705c1b7 | sha256sum