Servers Playground How we check Submit a server

APIShed

Working · 2.1 s

com.apished/apishedv1.3.0 Domain verified

Validates PESEL/NIP/REGON/IBAN/Luhn/ISBN/EAN/BIC/VAT; RPN, dates, hash, tokens, random, encode, time

Utilities

Website Registry entry

Try it

Call this server's tools from your browser. Nothing to install.

https://apished.com/mcp

Requests go through mcptry because browsers can't call most MCP servers directly. Header values are sent to the server for that request only and are never stored or logged.

Tool list from our last check. Connect live to refresh it.

color_contrast

Computes the WCAG 2.1 contrast ratio between two hex colors. Alpha, if present, is composited over white first.

colorAstring, required

colorBstring, required

This tool isn't marked read-only, so it may change something on the server or in an account you connected.

I understand, run it anyway

APIShed MCP server | mcptry

Tools (52)

color_contrast

Computes the WCAG 2.1 contrast ratio between two hex colors. Alpha, if present, is composited over white first.

Argument	Type	Description
colorA*	string
colorB*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "colorA",
    "colorB"
  ],
  "properties": {
    "colorA": {
      "type": "string"
    },
    "colorB": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

color_convert

Converts a color between hex, rgb, hsl, and hsv. value's shape depends on from/to: a string for hex, an object ({r,g,b,a?} etc.) otherwise.

Argument	Type	Description
to*	string	hex, rgb, hsl, or hsv
from*	string	hex, rgb, hsl, or hsv
value*	any	a hex string, or an {r,g,b,a?}/{h,s,l,a?}/{h,s,v,a?} object per from

Input schema (JSON)

{
  "type": "object",
  "required": [
    "from",
    "to",
    "value"
  ],
  "properties": {
    "to": {
      "type": "string",
      "description": "hex, rgb, hsl, or hsv"
    },
    "from": {
      "type": "string",
      "description": "hex, rgb, hsl, or hsv"
    },
    "value": {
      "description": "a hex string, or an {r,g,b,a?}/{h,s,l,a?}/{h,s,v,a?} object per from"
    }
  },
  "additionalProperties": false
}

csv_from_json

Converts JSON records to CSV text. columns is the explicit, ordered header — JSON object key order can't be relied on to infer it.

Argument	Type	Description
columns*	null \| array
records*	null \| array
delimiter	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "columns",
    "records"
  ],
  "properties": {
    "columns": {
      "type": [
        "null",
        "array"
      ],
      "items": {
        "type": "string"
      }
    },
    "records": {
      "type": [
        "null",
        "array"
      ],
      "items": {
        "type": "object",
        "additionalProperties": {
          "type": "string"
        }
      }
    },
    "delimiter": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

csv_parse

Parses CSV text into rows of string fields (no type guessing). Ragged rows are tolerated — use csv_validate to detect them.

Argument	Type	Description
text*	string
delimiter	string	a single character, default ','

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    },
    "delimiter": {
      "type": "string",
      "description": "a single character, default ','"
    }
  },
  "additionalProperties": false
}

csv_stats

Parses CSV text (header row required) and reports per-column non-empty/empty value counts across the data rows. No numeric aggregation.

Argument	Type	Description
text*	string
delimiter	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    },
    "delimiter": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

csv_to_json

Converts CSV text to JSON: header=true (default) returns one object per data row keyed by the header row; header=false returns raw rows. Every value is a string.

Argument	Type	Description
text*	string
header	boolean	default true
delimiter	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    },
    "header": {
      "type": "boolean",
      "description": "default true"
    },
    "delimiter": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

csv_validate

Reports whether CSV text is structurally well-formed: every row has the same field count as the first.

Argument	Type	Description
text*	string
delimiter	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    },
    "delimiter": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

datemath_add

Adds years/months/days to date. years/months are applied together with end-of-month clamping — e.g. 2026-01-31 + 1 month = 2026-02-28, not an overflowed 2026-03-03. days is then applied as plain calendar-day arithmetic.

Argument	Type	Description
date*	string	YYYY-MM-DD
days	integer
years	integer
months	integer

Input schema (JSON)

{
  "type": "object",
  "required": [
    "date"
  ],
  "properties": {
    "date": {
      "type": "string",
      "description": "YYYY-MM-DD"
    },
    "days": {
      "type": "integer"
    },
    "years": {
      "type": "integer"
    },
    "months": {
      "type": "integer"
    }
  },
  "additionalProperties": false
}

datemath_age

Age in whole years as of asOf (optional, defaults to the current UTC date). A Feb-29 birthDate is treated as falling on March 1 in a non-leap asOf year.

Argument	Type	Description
asOf	string	YYYY-MM-DD, defaults to today
birthDate*	string	YYYY-MM-DD

Input schema (JSON)

{
  "type": "object",
  "required": [
    "birthDate"
  ],
  "properties": {
    "asOf": {
      "type": "string",
      "description": "YYYY-MM-DD, defaults to today"
    },
    "birthDate": {
      "type": "string",
      "description": "YYYY-MM-DD"
    }
  },
  "additionalProperties": false
}

datemath_businessdays

Counts days in [from, to] (inclusive on both ends) whose weekday is in weekdays (default mon-fri) and which aren't in holidays.

Argument	Type	Description
to*	string	YYYY-MM-DD
from*	string	YYYY-MM-DD
holidays	null \| array	YYYY-MM-DD dates to exclude
weekdays	null \| array	sun/mon/tue/wed/thu/fri/sat, default mon-fri

Input schema (JSON)

{
  "type": "object",
  "required": [
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string",
      "description": "YYYY-MM-DD"
    },
    "from": {
      "type": "string",
      "description": "YYYY-MM-DD"
    },
    "holidays": {
      "type": [
        "null",
        "array"
      ],
      "items": {
        "type": "string"
      },
      "description": "YYYY-MM-DD dates to exclude"
    },
    "weekdays": {
      "type": [
        "null",
        "array"
      ],
      "items": {
        "type": "string"
      },
      "description": "sun/mon/tue/wed/thu/fri/sat, default mon-fri"
    }
  },
  "additionalProperties": false
}

datemath_dayofweek

Day of the week for date: both the weekday name and its ISO 8601 weekday number (1=Monday..7=Sunday).

Argument	Type	Description
date*	string	YYYY-MM-DD

Input schema (JSON)

{
  "type": "object",
  "required": [
    "date"
  ],
  "properties": {
    "date": {
      "type": "string",
      "description": "YYYY-MM-DD"
    }
  },
  "additionalProperties": false
}

datemath_diff

Day difference between two YYYY-MM-DD dates: to minus from, in whole days. Negative if to is before from.

Argument	Type	Description
to*	string	YYYY-MM-DD
from*	string	YYYY-MM-DD

Input schema (JSON)

{
  "type": "object",
  "required": [
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string",
      "description": "YYYY-MM-DD"
    },
    "from": {
      "type": "string",
      "description": "YYYY-MM-DD"
    }
  },
  "additionalProperties": false
}

datemath_leapyear

Checks whether year is a leap year in the Gregorian calendar.

Argument	Type	Description
year*	integer

Input schema (JSON)

{
  "type": "object",
  "required": [
    "year"
  ],
  "properties": {
    "year": {
      "type": "integer"
    }
  },
  "additionalProperties": false
}

datetime_now

Returns the actual current date/time — an LLM has a training cutoff and no live clock, so it can't know what time it actually is right now.

Argument	Type	Description
format	string	iso8601 (default), unix, unixmilli, or rfc1123
timezone	string	IANA timezone name, e.g. Europe/Warsaw; default UTC

Input schema (JSON)

{
  "type": "object",
  "properties": {
    "format": {
      "type": "string",
      "description": "iso8601 (default), unix, unixmilli, or rfc1123"
    },
    "timezone": {
      "type": "string",
      "description": "IANA timezone name, e.g. Europe/Warsaw; default UTC"
    }
  },
  "additionalProperties": false
}

ean_validate

Validates an 8-digit (EAN-8), 12-digit (UPC-A), 13-digit (EAN-13), or 14-digit (GTIN-14) barcode checksum: alternating weights 1 3 applied right-to-left, check digit is (10 - sum mod 10) mod 10.

Argument	Type	Description
value*	string	identifier or value to check

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "identifier or value to check"
    }
  },
  "additionalProperties": false
}

email_validate

Checks value is a single, bare RFC 5322 email address — syntax only, not a deliverability check. user@localhost is valid (no TLD required). "Name <email>" display syntax is rejected.

Argument	Type	Description
value*	string	identifier or value to check

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "identifier or value to check"
    }
  },
  "additionalProperties": false
}

encode_decode

Decodes rot13, base64, base64url, base32, hex, uuencode, urlcomponent, urlform, or html text back to the original. encoding in the result is "text" if the decoded bytes are valid UTF-8, or "base64" if they're binary.

Argument	Type	Description
input*	string	encoded text to decode
format*	string	rot13, base64, base64url, base32, hex, uuencode, urlcomponent, urlform, or html

Input schema (JSON)

{
  "type": "object",
  "required": [
    "format",
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "encoded text to decode"
    },
    "format": {
      "type": "string",
      "description": "rot13, base64, base64url, base32, hex, uuencode, urlcomponent, urlform, or html"
    }
  },
  "additionalProperties": false
}

encode_encode

Encodes plain UTF-8 text into rot13, base64, base64url, base32, hex, uuencode, urlcomponent (RFC 3986 percent-encoding, space -> %20), urlform (application/x-www-form-urlencoded, space -> +), or html (entity-escapes < > & ' "). Returns plain ASCII.

Argument	Type	Description
input*	string	plain UTF-8 text to encode
format*	string	rot13, base64, base64url, base32, hex, uuencode, urlcomponent, urlform, or html

Input schema (JSON)

{
  "type": "object",
  "required": [
    "format",
    "input"
  ],
  "properties": {
    "input": {
      "type": "string",
      "description": "plain UTF-8 text to encode"
    },
    "format": {
      "type": "string",
      "description": "rot13, base64, base64url, base32, hex, uuencode, urlcomponent, urlform, or html"
    }
  },
  "additionalProperties": false
}

hash_digest

Computes a hash digest of input (decoded per encoding: "text" default, "base64", or "hex") using algo: md5, sha1, sha256, sha512, or crc32. Returns the digest as lowercase hex.

Argument	Type	Description
algo*	string	md5, sha1, sha256, sha512, or crc32
input*	string	data to hash, encoded per encoding
encoding	string	text (default), base64, or hex

Input schema (JSON)

{
  "type": "object",
  "required": [
    "algo",
    "input"
  ],
  "properties": {
    "algo": {
      "type": "string",
      "description": "md5, sha1, sha256, sha512, or crc32"
    },
    "input": {
      "type": "string",
      "description": "data to hash, encoded per encoding"
    },
    "encoding": {
      "type": "string",
      "description": "text (default), base64, or hex"
    }
  },
  "additionalProperties": false
}

hash_hmac

Computes an HMAC of input (decoded per encoding) using algo: md5, sha1, sha256, or sha512 (crc32 isn't offered — it's a checksum, not a cryptographic primitive HMAC composes with). key is used as its raw UTF-8 bytes, not decoded per encoding. Returns the MAC as lowercase hex.

Argument	Type	Description
key*	string	secret key, used as raw UTF-8 bytes
algo*	string	md5, sha1, sha256, or sha512
input*	string	data to authenticate, encoded per encoding
encoding	string	text (default), base64, or hex

Input schema (JSON)

{
  "type": "object",
  "required": [
    "algo",
    "key",
    "input"
  ],
  "properties": {
    "key": {
      "type": "string",
      "description": "secret key, used as raw UTF-8 bytes"
    },
    "algo": {
      "type": "string",
      "description": "md5, sha1, sha256, or sha512"
    },
    "input": {
      "type": "string",
      "description": "data to authenticate, encoded per encoding"
    },
    "encoding": {
      "type": "string",
      "description": "text (default), base64, or hex"
    }
  },
  "additionalProperties": false
}

iban_validate

Validates an IBAN's length for its issuing country (per the SWIFT IBAN registry) and its mod-97 checksum. Does not decompose the BBAN into a bank code/account number or resolve a BIC.

Argument	Type	Description
value*	string	identifier or value to check

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "identifier or value to check"
    }
  },
  "additionalProperties": false
}

isbn_validate

Validates a 10- or 13-character ISBN. ISBN-10 uses weights 10..1 over 10 characters (last may be X, worth 10), sum mod 11 must be 0. ISBN-13 uses the same GTIN checksum as barcodes.

Argument	Type	Description
value*	string	identifier or value to check

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "identifier or value to check"
    }
  },
  "additionalProperties": false
}

jsonschema_validate

Validates document against schema (JSON Schema draft-07 or 2020-12). Reports one specific violation per call, not an aggregated list.

Argument	Type	Description
schema*	any	a JSON Schema (draft-07 or 2020-12)
document*	any	the JSON value to validate against schema

Input schema (JSON)

{
  "type": "object",
  "required": [
    "schema",
    "document"
  ],
  "properties": {
    "schema": {
      "description": "a JSON Schema (draft-07 or 2020-12)"
    },
    "document": {
      "description": "the JSON value to validate against schema"
    }
  },
  "additionalProperties": false
}

luhn_validate

Validates a numeric string against the Luhn (mod-10) checksum — payment card numbers, IMEI numbers, and similar identifiers.

Argument	Type	Description
value*	string	identifier or value to check

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "identifier or value to check"
    }
  },
  "additionalProperties": false
}

network_cidr_contains

Reports whether a CIDR block contains an address. Different address families (IPv4 vs IPv6) never match.

Argument	Type	Description
cidr*	string
address*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "cidr",
    "address"
  ],
  "properties": {
    "cidr": {
      "type": "string"
    },
    "address": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

network_cidr_info

Parses a CIDR block and reports its network address, address range, and address count. An address with host bits set (e.g. 10.14.32.17/21) is normalized to its network address in the result.

Argument	Type	Description
cidr*	string	an IPv4 or IPv6 CIDR block, e.g. 10.14.32.17/21

Input schema (JSON)

{
  "type": "object",
  "required": [
    "cidr"
  ],
  "properties": {
    "cidr": {
      "type": "string",
      "description": "an IPv4 or IPv6 CIDR block, e.g. 10.14.32.17/21"
    }
  },
  "additionalProperties": false
}

network_cidr_overlaps

Reports whether two CIDR blocks share any address.

Argument	Type	Description
cidrA*	string
cidrB*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "cidrA",
    "cidrB"
  ],
  "properties": {
    "cidrA": {
      "type": "string"
    },
    "cidrB": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

nip_validate

Validates the checksum of a 10-digit Polish tax identification number (NIP). Checksum uses weights 6 5 7 2 3 4 5 6 7 over the first 9 digits; sum mod 11 must equal the 10th digit. A sum mod 11 of 10 is itself invalid.

Argument	Type	Description
value*	string	digits-only identifier to validate (no spaces or dashes)

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "digits-only identifier to validate (no spaces or dashes)"
    }
  },
  "additionalProperties": false
}

pesel_validate

Validates the checksum of an 11-digit Polish national identification number (PESEL). Checksum uses weights 1 3 7 9 1 3 7 9 1 3 over the first 10 digits; control digit is (10 - sum mod 10) mod 10. On success also decodes the date of birth and sex embedded in the number; a checksum-valid number with an impossible calendar date (e.g. Feb 30) is still reported invalid.

Argument	Type	Description
value*	string	digits-only identifier to validate (no spaces or dashes)

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "digits-only identifier to validate (no spaces or dashes)"
    }
  },
  "additionalProperties": false
}

pipe_run

Runs a short ordered chain of existing apished operations in one call (same as POST /v1/pipe/run), passing one named field of each step's result into the next step's args. Stops at the first failing step.

Argument	Type	Description
steps*	null \| array

Input schema (JSON)

{
  "type": "object",
  "required": [
    "steps"
  ],
  "properties": {
    "steps": {
      "type": [
        "null",
        "array"
      ],
      "items": {
        "type": "object",
        "required": [
          "path"
        ],
        "properties": {
          "args": {
            "description": "that operation's normal JSON request body"
          },
          "from": {
            "type": [
              "null",
              "object"
            ],
            "required": [
              "field",
              "as"
            ],
            "properties": {
              "as": {
                "type": "string",
                "description": "field name to set it as in this step's args"
              },
              "field": {
                "type": "string",
                "description": "field name to read from the previous step's result"
              }
            },
            "description": "carries one field of the previous step's result into this step's args",
            "additionalProperties": false
          },
          "path": {
            "type": "string",
            "description": "canonical REST path of the operation, e.g. /v1/hash/digest"
          }
        },
        "additionalProperties": false
      }
    }
  },
  "additionalProperties": false
}

random_int

Generates cryptographically random integers in [min, max] (inclusive), using crypto/rand — an actual random value, not a guess. count defaults to 1, max 1000.

Argument	Type	Description
max*	integer	upper bound, inclusive; must be >= min
min*	integer	lower bound, inclusive
count	integer	how many numbers to generate, 1-1000, default 1

Input schema (JSON)

{
  "type": "object",
  "required": [
    "min",
    "max"
  ],
  "properties": {
    "max": {
      "type": "integer",
      "description": "upper bound, inclusive; must be >= min"
    },
    "min": {
      "type": "integer",
      "description": "lower bound, inclusive"
    },
    "count": {
      "type": "integer",
      "description": "how many numbers to generate, 1-1000, default 1"
    }
  },
  "additionalProperties": false
}

regex_extract

Extracts up to maxMatches non-overlapping regex matches from input, using Go's RE2-based regexp engine (linear-time, no backreferences/lookaround). Named groups (?P<name>...) are reported in namedGroups.

Argument	Type	Description
input*	string
pattern*	string	an RE2 regex pattern
maxMatches	integer	stop after this many matches; omitted/<=0 means no limit

Input schema (JSON)

{
  "type": "object",
  "required": [
    "pattern",
    "input"
  ],
  "properties": {
    "input": {
      "type": "string"
    },
    "pattern": {
      "type": "string",
      "description": "an RE2 regex pattern"
    },
    "maxMatches": {
      "type": "integer",
      "description": "stop after this many matches; omitted/<=0 means no limit"
    }
  },
  "additionalProperties": false
}

regex_match

Tests input against pattern (Go's regexp package: RE2 syntax, not PCRE — no backreferences or lookaround; use inline flags like (?i) for case-insensitive matching). Returns the full match and captured groups.

Argument	Type	Description
input*	string
pattern*	string	RE2 syntax

Input schema (JSON)

{
  "type": "object",
  "required": [
    "pattern",
    "input"
  ],
  "properties": {
    "input": {
      "type": "string"
    },
    "pattern": {
      "type": "string",
      "description": "RE2 syntax"
    }
  },
  "additionalProperties": false
}

regex_replace

Replaces every regex match of pattern in input with replacement, which may reference capture groups as $1, $name, etc. (Go's Regexp.Expand syntax).

Argument	Type	Description
input*	string
pattern*	string
replacement*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "pattern",
    "input",
    "replacement"
  ],
  "properties": {
    "input": {
      "type": "string"
    },
    "pattern": {
      "type": "string"
    },
    "replacement": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

regex_split

Splits input around regex matches of pattern, returning at most limit substrings (the last holds the unsplit remainder). limit<=0 means no limit.

Argument	Type	Description
input*	string
limit	integer
pattern*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "pattern",
    "input"
  ],
  "properties": {
    "input": {
      "type": "string"
    },
    "limit": {
      "type": "integer"
    },
    "pattern": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

regon_validate

Validates the checksum of a 9- or 14-digit Polish business registry number (REGON). 9-digit: weights 8 9 2 3 4 5 6 7 over the first 8 digits, sum mod 11 (10 mapped to 0) must equal the 9th digit. 14-digit: the first 9 digits must themselves be a valid 9-digit REGON, and weights 2 4 8 5 0 9 7 3 6 1 2 4 8 over the first 13 digits (sum mod 11, 10 mapped to 0) must equal the 14th digit.

Argument	Type	Description
value*	string	digits-only identifier to validate (no spaces or dashes)

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "digits-only identifier to validate (no spaces or dashes)"
    }
  },
  "additionalProperties": false
}

rpncalc_eval

Evaluates a Reverse Polish Notation (postfix) expression: whitespace-separated tokens, each a number or an operator/function that pops its operands off a stack and pushes the result. Supports arithmetic, exponentiation/modulo, roots, trigonometry, logarithms, rounding, bitwise ops, and constants (pi, e, phi). Always returns the decimal result — for hex/bin/oct rendering, convert the returned number yourself.

Argument	Type	Description
expr*	string	space-separated RPN expression, e.g. "3 4 + 2 *"

Input schema (JSON)

{
  "type": "object",
  "required": [
    "expr"
  ],
  "properties": {
    "expr": {
      "type": "string",
      "description": "space-separated RPN expression, e.g. \"3 4 + 2 *\""
    }
  },
  "additionalProperties": false
}

swiftbic_validate

Structural format validation only for a SWIFT/BIC code: 8 or 11 characters (4 letters bank code + 2 letters country code + 2 alphanumeric location code + optional 3 alphanumeric branch code). The country code is not cross-checked against ISO 3166-1.

Argument	Type	Description
value*	string	identifier or value to check

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "identifier or value to check"
    }
  },
  "additionalProperties": false
}

text_charat

Returns the 0-indexed character (rune) at index in text.

Argument	Type	Description
text*	string
index*	integer	0-indexed

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text",
    "index"
  ],
  "properties": {
    "text": {
      "type": "string"
    },
    "index": {
      "type": "integer",
      "description": "0-indexed"
    }
  },
  "additionalProperties": false
}

text_count

Counts non-overlapping occurrences of substring in text (rune-safe, not byte-based).

Argument	Type	Description
text*	string
substring*	string	must be non-empty

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text",
    "substring"
  ],
  "properties": {
    "text": {
      "type": "string"
    },
    "substring": {
      "type": "string",
      "description": "must be non-empty"
    }
  },
  "additionalProperties": false
}

text_palindrome

Checks whether text reads the same forwards and backwards. ignoreCase/ignoreNonAlnum default false (strict, literal comparison); set both true for phrase-style palindromes like "A man, a plan, a canal: Panama".

Argument	Type	Description
text*	string
ignoreCase	boolean
ignoreNonAlnum	boolean

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    },
    "ignoreCase": {
      "type": "boolean"
    },
    "ignoreNonAlnum": {
      "type": "boolean"
    }
  },
  "additionalProperties": false
}

text_reverse

Reverses text by Unicode code point (rune), not grapheme cluster.

Argument	Type	Description
text*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

text_sort

Sorts text's characters or words alphabetically. by: "chars" (default, sorts runes, no separator) or "words" (splits on whitespace, rejoins with a single space).

Argument	Type	Description
by	string	chars (default) or words
text*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "by": {
      "type": "string",
      "description": "chars (default) or words"
    },
    "text": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

text_stats

Descriptive statistics for text: rune/byte/word/line counts, a unique-rune count, a letters/digits/spaces/punctuation/other breakdown, an exact per-character frequency table, and word-length min/max/average plus the actual shortest/longest word (ties resolve to the first occurrence).

Argument	Type	Description
text*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

text_wordcount

Counts whitespace-delimited words in text.

Argument	Type	Description
text*	string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    }
  },
  "additionalProperties": false
}

tokens_count

Counts tokens under an OpenAI-compatible (tiktoken) encoding. Provide exactly one of model (e.g. "gpt-4o") or encoding ("o200k_base" or "cl100k_base"). No Claude/Anthropic tokenizer.

Argument	Type	Description
text*	string
model	string	e.g. gpt-4o; exactly one of model/encoding
encoding	string	o200k_base or cl100k_base; exactly one of model/encoding

Input schema (JSON)

{
  "type": "object",
  "required": [
    "text"
  ],
  "properties": {
    "text": {
      "type": "string"
    },
    "model": {
      "type": "string",
      "description": "e.g. gpt-4o; exactly one of model/encoding"
    },
    "encoding": {
      "type": "string",
      "description": "o200k_base or cl100k_base; exactly one of model/encoding"
    }
  },
  "additionalProperties": false
}

units_convert_datasize

Converts a data-size value (decimal string) between bit, Kbit, Mbit, Gbit, Tbit (SI bits), B, KB, MB, GB, TB, PB (SI bytes), and KiB, MiB, GiB, TiB, PiB (IEC bytes). Always exact.

Argument	Type	Description
to*	string
from*	string
value*	string	decimal string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string"
    },
    "from": {
      "type": "string"
    },
    "value": {
      "type": "string",
      "description": "decimal string"
    }
  },
  "additionalProperties": false
}

units_convert_temperature

Converts a temperature value (decimal string) between C, F, and K. Offset-aware, not a bare multiplier.

Argument	Type	Description
to*	string	C, F, or K
from*	string	C, F, or K
value*	string	decimal string

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value",
    "from",
    "to"
  ],
  "properties": {
    "to": {
      "type": "string",
      "description": "C, F, or K"
    },
    "from": {
      "type": "string",
      "description": "C, F, or K"
    },
    "value": {
      "type": "string",
      "description": "decimal string"
    }
  },
  "additionalProperties": false
}

url_validate

Checks value is a well-formed absolute URL (has both a scheme and a host) — syntax only, not a reachability check.

Argument	Type	Description
value*	string	identifier or value to check

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "identifier or value to check"
    }
  },
  "additionalProperties": false
}

uuid_generate

Generates count (default 1, max 1000) random version-4 UUIDs from crypto/rand-backed entropy.

Argument	Type	Description
count	integer	default 1, max 1000

Input schema (JSON)

{
  "type": "object",
  "properties": {
    "count": {
      "type": "integer",
      "description": "default 1, max 1000"
    }
  },
  "additionalProperties": false
}

uuid_validate

Parses value as a UUID and reports its version/variant if well-formed.

Argument	Type	Description
value*	string	digits-only identifier to validate (no spaces or dashes)

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "digits-only identifier to validate (no spaces or dashes)"
    }
  },
  "additionalProperties": false
}

vateu_validate

Format validation only (no VIES lookup) for an EU VAT number: checks the 2-letter member-state prefix (EL for Greece, XI for Northern Ireland) against that country's digit/letter pattern. A format-valid result does not mean the number is actually registered.

Argument	Type	Description
value*	string	identifier or value to check

Input schema (JSON)

{
  "type": "object",
  "required": [
    "value"
  ],
  "properties": {
    "value": {
      "type": "string",
      "description": "identifier or value to check"
    }
  },
  "additionalProperties": false
}