{
  "data": {
    "tool": {
      "category": "inference",
      "endpoint": "https://mcp.cleanor.app/mcp",
      "jsonUrl": "https://www.anchorterminal.com/api/v1/tools/cleanor.json",
      "kind": "mcp",
      "listed": "indexed",
      "liveUrl": "https://www.anchorterminal.com/api/v1/live/cleanor.json",
      "markdownUrl": "https://www.anchorterminal.com/tools/cleanor.md",
      "mcpTools": {
        "check": {
          "checker": "anchor-check/1.0",
          "totalTokens": 6513,
          "counts": {
            "error": 0,
            "note": 0,
            "warn": 3
          },
          "findings": [
            {
              "rule": "TC20",
              "severity": "warn",
              "tool": "count",
              "message": "the description steers the model",
              "fix": "Say what the tool is good at and let the model choose."
            },
            {
              "rule": "TC20",
              "severity": "warn",
              "tool": "hash",
              "message": "the description steers the model",
              "fix": "Say what the tool is good at and let the model choose."
            },
            {
              "rule": "TC20",
              "severity": "warn",
              "tool": "uuid",
              "message": "the description steers the model",
              "fix": "Say what the tool is good at and let the model choose."
            }
          ]
        },
        "checkedAt": "2026-10-04T22:21:04Z",
        "count": 22,
        "schemaTokens": 6513,
        "status": "ok",
        "tools": [
          {
            "name": "optimize_image",
            "title": "Optimize / convert an image for the web",
            "description": "Fetch an image from a public URL and re-encode it smaller (WebP/AVIF/JPEG), optionally resizing to a target width. Returns the optimized image plus before/after byte sizes. Use this when an AI-generated or dropped-in asset (hero image, screenshot, illustration) is too large to ship.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "format": {
                  "default": "webp",
                  "description": "Output format. webp = best browser support; avif = smallest; jpeg = universal.",
                  "enum": [
                    "webp",
                    "avif",
                    "jpeg"
                  ],
                  "type": "string"
                },
                "image_url": {
                  "description": "Public URL of the source image (PNG/JPEG/WebP/AVIF/GIF).",
                  "format": "uri",
                  "type": "string"
                },
                "quality": {
                  "default": 80,
                  "description": "Encode quality 1-100 (80 is a good default).",
                  "maximum": 100,
                  "minimum": 1,
                  "type": "integer"
                },
                "width": {
                  "description": "Resize to this width in px, preserving aspect ratio. Omit to keep original size.",
                  "maximum": 4096,
                  "minimum": 16,
                  "type": "integer"
                }
              },
              "required": [
                "image_url"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "format": {
                  "description": "Output image format.",
                  "type": "string"
                },
                "mime_type": {
                  "type": "string"
                },
                "optimized_bytes": {
                  "type": "number"
                },
                "original_bytes": {
                  "type": "number"
                },
                "saved_pct": {
                  "description": "Percent smaller than the original.",
                  "type": "number"
                }
              },
              "required": [
                "format",
                "original_bytes",
                "optimized_bytes",
                "saved_pct",
                "mime_type"
              ],
              "type": "object"
            },
            "annotations": {
              "openWorldHint": true,
              "readOnlyHint": true
            }
          },
          {
            "name": "storage_capacity",
            "title": "How much fits in a phone storage tier",
            "description": "How many photos or minutes of video actually fit in a given storage size, corrected for real OS/filesystem overhead. Backed by Cleanor Labs measured per-item sizes. Use for realistic sample copy, dashboards, or \"how many photos fit in 128 GB\" answers.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "content": {
                  "default": "photos",
                  "description": "What to count.",
                  "enum": [
                    "photos",
                    "video"
                  ],
                  "type": "string"
                },
                "storage_gb": {
                  "description": "Advertised storage size in GB (e.g. 64, 128, 256, 512).",
                  "maximum": 4096,
                  "minimum": 1,
                  "type": "number"
                }
              },
              "required": [
                "storage_gb"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "breakdown": {
                  "description": "How many of each item fit.",
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "count": {
                        "type": "number"
                      },
                      "label": {
                        "type": "string"
                      },
                      "unit": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "label",
                      "count",
                      "unit"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "content": {
                  "type": "string"
                },
                "storage_gb": {
                  "type": "number"
                },
                "usable_gb": {
                  "description": "Usable GB after OS/filesystem overhead.",
                  "type": "number"
                }
              },
              "required": [
                "storage_gb",
                "usable_gb",
                "content",
                "breakdown"
              ],
              "type": "object"
            },
            "annotations": {
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "image_format_savings",
            "title": "Real storage savings of next-gen image formats",
            "description": "How much smaller WebP, AVIF or JPEG XL are than JPEG at matched perceptual quality, from Cleanor Labs’ controlled benchmark. Also reports the \"HEIC conversion tax\" (converting an iPhone HEIC to JPG/PNG makes it bigger). Use to justify a format choice when building a site or app.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "format": {
                  "default": "avif",
                  "description": "Target format to compare against JPEG.",
                  "enum": [
                    "webp",
                    "avif",
                    "jxl"
                  ],
                  "type": "string"
                },
                "quality": {
                  "default": "web",
                  "description": "web = typical web quality (SSIM 0.95); high = near-lossless (SSIM 0.98).",
                  "enum": [
                    "web",
                    "high"
                  ],
                  "type": "string"
                }
              },
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "all_formats": {
                  "additionalProperties": false,
                  "properties": {
                    "avif": {
                      "type": "number"
                    },
                    "jxl": {
                      "type": "number"
                    },
                    "webp": {
                      "type": "number"
                    }
                  },
                  "required": [
                    "avif",
                    "webp",
                    "jxl"
                  ],
                  "type": "object"
                },
                "format": {
                  "type": "string"
                },
                "percent_smaller_than_jpeg": {
                  "type": "number"
                },
                "quality": {
                  "type": "string"
                },
                "source": {
                  "type": "string"
                }
              },
              "required": [
                "format",
                "quality",
                "percent_smaller_than_jpeg",
                "all_formats",
                "source"
              ],
              "type": "object"
            },
            "annotations": {
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "qr_code",
            "title": "Generate a QR code (SVG)",
            "description": "Encode text or a URL as a QR code and return a crisp, dependency-free SVG you can paste straight into a page, deck or doc.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "ecc": {
                  "default": "M",
                  "description": "Error-correction level: L=7%, M=15%, Q=25%, H=30% recoverable.",
                  "enum": [
                    "L",
                    "M",
                    "Q",
                    "H"
                  ],
                  "type": "string"
                },
                "size": {
                  "default": 320,
                  "description": "SVG pixel size.",
                  "maximum": 1024,
                  "minimum": 64,
                  "type": "integer"
                },
                "text": {
                  "description": "Text or URL to encode.",
                  "maxLength": 2000,
                  "minLength": 1,
                  "type": "string"
                }
              },
              "required": [
                "text"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "svg": {
                  "description": "The QR code as SVG markup.",
                  "type": "string"
                }
              },
              "required": [
                "svg"
              ],
              "type": "object"
            },
            "annotations": {
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "hash",
            "title": "Hash text (SHA family)",
            "description": "Compute a cryptographic hash of text (SHA-1, SHA-256, SHA-384 or SHA-512) and return the hex digest. Use for checksums, cache keys, or verifying content. MD5 is intentionally not offered (broken, and unavailable in Web Crypto). LLMs cannot compute these reliably by hand, so always use this tool instead of guessing.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "algorithm": {
                  "default": "sha-256",
                  "description": "Hash algorithm. Default sha-256.",
                  "enum": [
                    "sha-256",
                    "sha-1",
                    "sha-384",
                    "sha-512"
                  ],
                  "type": "string"
                },
                "input": {
                  "description": "Text to hash (UTF-8).",
                  "maxLength": 100000,
                  "minLength": 1,
                  "type": "string"
                }
              },
              "required": [
                "input"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "algorithm": {
                  "description": "The hash algorithm used.",
                  "type": "string"
                },
                "hex": {
                  "description": "The hex-encoded digest.",
                  "type": "string"
                }
              },
              "required": [
                "algorithm",
                "hex"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "uuid",
            "title": "Generate UUIDs",
            "description": "Generate one or more UUIDs. v4 is fully random; v7 is time-sortable (recommended for database keys). LLMs cannot produce cryptographically random or correctly-formatted UUIDs, so always use this tool.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "count": {
                  "default": 1,
                  "description": "How many to generate.",
                  "maximum": 100,
                  "minimum": 1,
                  "type": "integer"
                },
                "version": {
                  "default": "v4",
                  "description": "UUID version. v7 = time-ordered.",
                  "enum": [
                    "v4",
                    "v7"
                  ],
                  "type": "string"
                }
              },
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "uuids": {
                  "description": "The generated UUIDs.",
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                },
                "version": {
                  "description": "UUID version generated.",
                  "type": "string"
                }
              },
              "required": [
                "version",
                "uuids"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": false,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "base64",
            "title": "Base64 encode / decode",
            "description": "Encode text to Base64 or decode Base64 back to text (UTF-8 safe). Supports URL-safe alphabet. Use whenever you need to encode/decode data URIs, tokens, or config values instead of guessing the bytes.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "input": {
                  "description": "Text to encode, or Base64 to decode.",
                  "maxLength": 100000,
                  "minLength": 1,
                  "type": "string"
                },
                "mode": {
                  "default": "encode",
                  "description": "Direction.",
                  "enum": [
                    "encode",
                    "decode"
                  ],
                  "type": "string"
                },
                "url_safe": {
                  "default": false,
                  "description": "Use URL-safe alphabet (-_ instead of +/, no padding).",
                  "type": "boolean"
                }
              },
              "required": [
                "input"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "mode": {
                  "description": "encode or decode.",
                  "type": "string"
                },
                "result": {
                  "description": "The encoded or decoded text.",
                  "type": "string"
                }
              },
              "required": [
                "mode",
                "result"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "json_format",
            "title": "Format / validate JSON",
            "description": "Validate JSON and pretty-print or minify it, optionally sorting object keys. Returns a precise parse error (with position) if invalid. Use to check and clean JSON instead of eyeballing it.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "input": {
                  "description": "JSON text.",
                  "maxLength": 100000,
                  "minLength": 1,
                  "type": "string"
                },
                "mode": {
                  "default": "pretty",
                  "description": "pretty = 2-space indent; minify = single line.",
                  "enum": [
                    "pretty",
                    "minify"
                  ],
                  "type": "string"
                },
                "sort_keys": {
                  "default": false,
                  "description": "Sort object keys alphabetically (deep).",
                  "type": "boolean"
                }
              },
              "required": [
                "input"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "formatted": {
                  "description": "The formatted JSON text.",
                  "type": "string"
                },
                "valid": {
                  "description": "Whether the input was valid JSON.",
                  "type": "boolean"
                }
              },
              "required": [
                "valid",
                "formatted"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "jwt_decode",
            "title": "Decode a JWT (no verification)",
            "description": "Decode a JSON Web Token into its header and payload so you can inspect claims (iss, exp, sub, scopes). The signature is NOT verified and no secret is required or stored. Use to read a token during debugging.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "token": {
                  "description": "The JWT (three dot-separated segments).",
                  "maxLength": 100000,
                  "minLength": 1,
                  "type": "string"
                }
              },
              "required": [
                "token"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "exp_iso": {
                  "description": "Expiry as ISO 8601, if present.",
                  "type": "string"
                },
                "expired": {
                  "description": "Whether the token is past its exp, if present.",
                  "type": "boolean"
                },
                "header": {
                  "description": "The decoded JWT header object."
                },
                "payload": {
                  "description": "The decoded JWT payload (claims)."
                }
              },
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "color",
            "title": "Convert a color between formats",
            "description": "Convert a color (hex, rgb() or hsl()) and return hex, RGB and HSL representations at once. Use when picking or translating colors for CSS, design tokens or themes.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "value": {
                  "description": "A color: \"#3b82f6\", \"rgb(59,130,246)\" or \"hsl(217,91%,60%)\".",
                  "maxLength": 64,
                  "minLength": 1,
                  "type": "string"
                }
              },
              "required": [
                "value"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "hex": {
                  "type": "string"
                },
                "hsl": {
                  "type": "string"
                },
                "rgb": {
                  "type": "string"
                }
              },
              "required": [
                "hex",
                "rgb",
                "hsl"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "slugify",
            "title": "Slugify text for URLs",
            "description": "Turn a title or phrase into a clean, URL-safe slug (lowercase, hyphenated, accents stripped). Use when generating page paths, filenames or anchor IDs.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "input": {
                  "description": "Text to slugify.",
                  "maxLength": 2000,
                  "minLength": 1,
                  "type": "string"
                },
                "separator": {
                  "default": "-",
                  "description": "Word separator.",
                  "enum": [
                    "-",
                    "_"
                  ],
                  "type": "string"
                }
              },
              "required": [
                "input"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "slug": {
                  "description": "The URL-safe slug.",
                  "type": "string"
                }
              },
              "required": [
                "slug"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "count",
            "title": "Count characters, words, lines, bytes",
            "description": "Accurately count characters (Unicode code points), UTF-16 units, words, lines and UTF-8 bytes in text. LLMs are notoriously bad at counting, so always use this tool for \"how many characters/words\" questions.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "input": {
                  "description": "Text to measure.",
                  "maxLength": 100000,
                  "minLength": 0,
                  "type": "string"
                }
              },
              "required": [
                "input"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "bytes": {
                  "description": "UTF-8 bytes.",
                  "type": "number"
                },
                "characters": {
                  "description": "Unicode code points.",
                  "type": "number"
                },
                "lines": {
                  "type": "number"
                },
                "utf16_units": {
                  "type": "number"
                },
                "words": {
                  "type": "number"
                }
              },
              "required": [
                "characters",
                "utf16_units",
                "words",
                "lines",
                "bytes"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "regex_test",
            "title": "Test a regular expression",
            "description": "Test a JavaScript regular expression against sample text and return whether it matches, plus every match with its captured groups and index. Use to verify a pattern instead of reasoning about it in your head. Input and pattern are length-capped to keep it fast and safe.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "flags": {
                  "default": "g",
                  "description": "Regex flags, e.g. \"gi\". Allowed: g i m s u y d.",
                  "maxLength": 8,
                  "type": "string"
                },
                "input": {
                  "description": "Text to test against.",
                  "maxLength": 20000,
                  "minLength": 0,
                  "type": "string"
                },
                "pattern": {
                  "description": "The regex pattern (without slashes).",
                  "maxLength": 1000,
                  "minLength": 1,
                  "type": "string"
                }
              },
              "required": [
                "pattern",
                "input"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "match_count": {
                  "type": "number"
                },
                "matched": {
                  "description": "Whether the pattern matched at all.",
                  "type": "boolean"
                },
                "matches": {
                  "description": "Each match with its start index and captured groups.",
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "groups": {
                        "items": {
                          "type": [
                            "string",
                            "null"
                          ]
                        },
                        "type": "array"
                      },
                      "index": {
                        "type": "number"
                      },
                      "match": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "index",
                      "match",
                      "groups"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "truncated": {
                  "description": "True if results were capped at 100.",
                  "type": "boolean"
                }
              },
              "required": [
                "matched",
                "match_count",
                "truncated",
                "matches"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "cron_describe",
            "title": "Explain a cron expression",
            "description": "Parse a standard 5-field cron expression (minute hour day-of-month month day-of-week) into a plain-English breakdown and the next few run times in UTC. Use to sanity-check a schedule instead of guessing what the fields mean.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "expression": {
                  "description": "A 5-field cron expression, e.g. \"30 2 * * 1-5\".",
                  "maxLength": 200,
                  "minLength": 1,
                  "type": "string"
                }
              },
              "required": [
                "expression"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "day_of_month": {
                  "type": "string"
                },
                "day_of_week": {
                  "type": "string"
                },
                "hour": {
                  "type": "string"
                },
                "minute": {
                  "type": "string"
                },
                "month": {
                  "type": "string"
                },
                "next_runs": {
                  "description": "Next run times in UTC ISO 8601.",
                  "items": {
                    "type": "string"
                  },
                  "type": "array"
                }
              },
              "required": [
                "minute",
                "hour",
                "day_of_month",
                "month",
                "day_of_week",
                "next_runs"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": false,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "unit_convert",
            "title": "Convert between units",
            "description": "Convert a value between units of length, mass, data size, time, speed or temperature. Supported units: mm, cm, m, km, in, ft, yd, mi, nmi, mg, g, kg, t, oz, lb, st, bit, byte, kb, kib, mb, mib, gb, gib, tb, tib, ms, s, min, h, day, week, mps, kph, mph, fps, knot, c, f, k. Use for exact conversions instead of approximating.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "from": {
                  "description": "Source unit (e.g. \"km\", \"lb\", \"mib\", \"c\").",
                  "maxLength": 8,
                  "minLength": 1,
                  "type": "string"
                },
                "to": {
                  "description": "Target unit (must be the same category as \"from\").",
                  "maxLength": 8,
                  "minLength": 1,
                  "type": "string"
                },
                "value": {
                  "description": "The numeric value to convert.",
                  "type": "number"
                }
              },
              "required": [
                "value",
                "from",
                "to"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "category": {
                  "type": "string"
                },
                "from": {
                  "type": "string"
                },
                "result": {
                  "type": "number"
                },
                "to": {
                  "type": "string"
                },
                "value": {
                  "type": "number"
                }
              },
              "required": [
                "value",
                "from",
                "to",
                "result",
                "category"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "datetime",
            "title": "Current or parsed date/time",
            "description": "Get the current date/time, or convert a given timestamp, into a target IANA timezone with ISO, Unix and human-readable forms. Pass a Unix timestamp (seconds or ms) or an ISO string as input; omit it for \"now\". LLMs cannot know the real current time, so use this instead of guessing.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "input": {
                  "description": "Optional: a Unix timestamp (s or ms) or ISO date string. Omit for the current time.",
                  "maxLength": 64,
                  "type": "string"
                },
                "timezone": {
                  "default": "UTC",
                  "description": "IANA timezone, e.g. \"America/New_York\" or \"UTC\".",
                  "maxLength": 64,
                  "type": "string"
                }
              },
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "iso_utc": {
                  "type": "string"
                },
                "local": {
                  "description": "Human-readable local time in the timezone.",
                  "type": "string"
                },
                "timezone": {
                  "type": "string"
                },
                "unix_ms": {
                  "type": "number"
                },
                "unix_s": {
                  "type": "number"
                }
              },
              "required": [
                "timezone",
                "local",
                "iso_utc",
                "unix_s",
                "unix_ms"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": false,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "url_parse",
            "title": "Parse a URL into parts",
            "description": "Break a URL into its components: scheme, host, port, path, decoded query parameters and fragment. Use to inspect or debug a URL instead of parsing it by eye.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "url": {
                  "description": "The URL to parse (absolute, with scheme).",
                  "maxLength": 4000,
                  "minLength": 1,
                  "type": "string"
                }
              },
              "required": [
                "url"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "fragment": {
                  "type": "string"
                },
                "host": {
                  "type": "string"
                },
                "path": {
                  "type": "string"
                },
                "port": {
                  "description": "Port, or empty if the scheme default.",
                  "type": "string"
                },
                "query": {
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "key": {
                        "type": "string"
                      },
                      "value": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "key",
                      "value"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "scheme": {
                  "type": "string"
                },
                "username": {
                  "type": "string"
                }
              },
              "required": [
                "scheme",
                "host",
                "port",
                "path",
                "query",
                "fragment"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "base_convert",
            "title": "Convert a number between bases",
            "description": "Convert an integer between number bases 2–36 (e.g. hex to binary, decimal to base-36). Arbitrary precision via BigInt, so large values stay exact. Use for radix conversions instead of doing them by hand.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "from_base": {
                  "default": 10,
                  "description": "Base of the input (2–36).",
                  "maximum": 36,
                  "minimum": 2,
                  "type": "integer"
                },
                "to_base": {
                  "default": 16,
                  "description": "Base to convert to (2–36).",
                  "maximum": 36,
                  "minimum": 2,
                  "type": "integer"
                },
                "value": {
                  "description": "The number, in from_base (e.g. \"ff\", \"1010\", \"255\").",
                  "maxLength": 2000,
                  "minLength": 1,
                  "type": "string"
                }
              },
              "required": [
                "value"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "decimal": {
                  "description": "The value in base 10.",
                  "type": "string"
                },
                "from_base": {
                  "type": "number"
                },
                "input": {
                  "type": "string"
                },
                "result": {
                  "description": "The value in to_base.",
                  "type": "string"
                },
                "to_base": {
                  "type": "number"
                }
              },
              "required": [
                "input",
                "from_base",
                "to_base",
                "result",
                "decimal"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "diff",
            "title": "Line diff between two texts",
            "description": "Compute a line-by-line diff between two texts, marking removed lines with \"-\", added with \"+\" and unchanged with two spaces, plus a change count. Use to see exactly what changed instead of comparing by eye. Capped at 1000 lines per side.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "a": {
                  "description": "The original (\"before\") text.",
                  "maxLength": 100000,
                  "minLength": 0,
                  "type": "string"
                },
                "b": {
                  "description": "The updated (\"after\") text.",
                  "maxLength": 100000,
                  "minLength": 0,
                  "type": "string"
                }
              },
              "required": [
                "a",
                "b"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "added": {
                  "type": "number"
                },
                "changed": {
                  "type": "boolean"
                },
                "diff": {
                  "description": "The line diff (+/-/space prefixed), empty if identical.",
                  "type": "string"
                },
                "removed": {
                  "type": "number"
                }
              },
              "required": [
                "changed",
                "added",
                "removed",
                "diff"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "hmac",
            "title": "HMAC signature of a message",
            "description": "Compute an HMAC (keyed hash) of a message with a secret, using SHA-1/256/384/512, returned as hex or Base64. Use to sign webhook payloads or verify a signature instead of guessing. LLMs cannot compute this by hand.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "algorithm": {
                  "default": "sha-256",
                  "description": "Hash algorithm.",
                  "enum": [
                    "sha-256",
                    "sha-1",
                    "sha-384",
                    "sha-512"
                  ],
                  "type": "string"
                },
                "encoding": {
                  "default": "hex",
                  "description": "Output encoding.",
                  "enum": [
                    "hex",
                    "base64"
                  ],
                  "type": "string"
                },
                "message": {
                  "description": "The message to sign (UTF-8).",
                  "maxLength": 100000,
                  "minLength": 0,
                  "type": "string"
                },
                "secret": {
                  "description": "The shared secret key (UTF-8).",
                  "maxLength": 4096,
                  "minLength": 1,
                  "type": "string"
                }
              },
              "required": [
                "message",
                "secret"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "algorithm": {
                  "type": "string"
                },
                "encoding": {
                  "type": "string"
                },
                "signature": {
                  "description": "The HMAC in the requested encoding.",
                  "type": "string"
                }
              },
              "required": [
                "algorithm",
                "encoding",
                "signature"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "placeholder_image",
            "title": "Generate a placeholder image (SVG)",
            "description": "Generate a lightweight SVG placeholder image at any size, with an optional label and custom background/text colors. Dependency-free, pastes straight into a page or mockup. Use for wireframes and design stubs instead of hotlinking a placeholder service.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "bg": {
                  "default": "#e5e7eb",
                  "description": "Background color (hex, rgb() or hsl()).",
                  "maxLength": 32,
                  "type": "string"
                },
                "color": {
                  "default": "#6b7280",
                  "description": "Text color.",
                  "maxLength": 32,
                  "type": "string"
                },
                "height": {
                  "default": 400,
                  "description": "Height in pixels.",
                  "maximum": 4000,
                  "minimum": 1,
                  "type": "integer"
                },
                "text": {
                  "description": "Label text. Defaults to the dimensions, e.g. \"600×400\".",
                  "maxLength": 120,
                  "type": "string"
                },
                "width": {
                  "default": 600,
                  "description": "Width in pixels.",
                  "maximum": 4000,
                  "minimum": 1,
                  "type": "integer"
                }
              },
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "height": {
                  "type": "number"
                },
                "svg": {
                  "description": "The SVG markup.",
                  "type": "string"
                },
                "width": {
                  "type": "number"
                }
              },
              "required": [
                "svg",
                "width",
                "height"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          },
          {
            "name": "color_palette",
            "title": "Generate a color palette",
            "description": "Build a harmonious color palette from a base color using color-theory rules (complementary, analogous, triadic, tetradic, or monochromatic). Returns each color as hex and HSL. Use to derive a theme or design tokens from one brand color.",
            "inputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "color": {
                  "description": "Base color: \"#3b82f6\", \"rgb(...)\" or \"hsl(...)\".",
                  "maxLength": 64,
                  "minLength": 1,
                  "type": "string"
                },
                "harmony": {
                  "default": "analogous",
                  "description": "Color-harmony rule.",
                  "enum": [
                    "complementary",
                    "analogous",
                    "triadic",
                    "tetradic",
                    "monochromatic"
                  ],
                  "type": "string"
                }
              },
              "required": [
                "color"
              ],
              "type": "object"
            },
            "outputSchema": {
              "$schema": "http://json-schema.org/draft-07/schema#",
              "additionalProperties": false,
              "properties": {
                "base": {
                  "description": "The base color as hex.",
                  "type": "string"
                },
                "colors": {
                  "items": {
                    "additionalProperties": false,
                    "properties": {
                      "hex": {
                        "type": "string"
                      },
                      "hsl": {
                        "type": "string"
                      }
                    },
                    "required": [
                      "hex",
                      "hsl"
                    ],
                    "type": "object"
                  },
                  "type": "array"
                },
                "harmony": {
                  "type": "string"
                }
              },
              "required": [
                "harmony",
                "base",
                "colors"
              ],
              "type": "object"
            },
            "annotations": {
              "idempotentHint": true,
              "openWorldHint": false,
              "readOnlyHint": true
            }
          }
        ]
      },
      "name": "Cleanor",
      "note": "Indexed from the official MCP registry: facts and our own checks, not reviewed, so no score, grade or rank.",
      "packages": [
        {
          "registryType": "npm",
          "identifier": "@cleanor/mcp",
          "version": "0.6.1",
          "transport": "stdio"
        }
      ],
      "pageJsonUrl": "https://www.anchorterminal.com/tools/cleanor.json",
      "popularity": {
        "githubStars": 1,
        "npmWeekly": 53
      },
      "registryName": "app.cleanor/cleanor",
      "remotes": [
        {
          "type": "streamable-http",
          "url": "https://mcp.cleanor.app/mcp"
        }
      ],
      "repository": "https://github.com/cleanor-app/cleanor-mcp",
      "reviewed": false,
      "slug": "cleanor",
      "source": "the official MCP registry",
      "sourceUrl": "https://registry.modelcontextprotocol.io/v0.1/servers?search=app.cleanor/cleanor",
      "summary": "Zero-auth MCP: image optimize, cited storage/format data, and dev utilities LLMs get wrong.",
      "updatedAt": "2026-07-14T19:57:06Z",
      "url": "https://www.anchorterminal.com/tools/cleanor",
      "vendor": "cleanor.app",
      "vendorUrl": "https://mcp.cleanor.app",
      "version": "0.6.1",
      "websiteUrl": "https://mcp.cleanor.app",
      "where": "both",
      "why": [
        "vendor"
      ]
    }
  },
  "kind": "anchor.page",
  "links": {
    "api": "https://www.anchorterminal.com/api/v1/index.json",
    "html": "https://www.anchorterminal.com/tools/cleanor",
    "json": "https://www.anchorterminal.com/tools/cleanor.json",
    "llms": "https://www.anchorterminal.com/llms.txt",
    "markdown": "https://www.anchorterminal.com/tools/cleanor.md",
    "slim": "https://www.anchorterminal.com/tools/cleanor.min.md"
  },
  "markdown": "# Cleanor\n\n\u003e Indexed, not reviewed: facts from the official MCP registry and our own checks. No score, grade or rank, and not in the rankings until the panel reviews it. How the index works: https://www.anchorterminal.com/indexed/\n\n- Kind: MCP server, by cleanor.app (https://mcp.cleanor.app)\n- Category: Model APIs \u0026 inference (https://www.anchorterminal.com/categories/inference.md)\n- Listed because: It's published in the registry under cleanor.app, a namespace the registry only gives to whoever proves they control that domain.\n- What the official MCP registry says: Zero-auth MCP: image optimize, cited storage/format data, and dev utilities LLMs get wrong.\n\n## Facts\n\n- MCP registry: `app.cleanor/cleanor` 0.6.1\n- Endpoint: https://mcp.cleanor.app/mcp (streamable HTTP)\n- Package: npm `@cleanor/mcp` (stdio)\n- Source: https://github.com/cleanor-app/cleanor-mcp\n- Website: https://mcp.cleanor.app\n- npm downloads a week: 53\n- GitHub stars: 1\n- Registry entry updated: 2026-07-14\n\n## Tools\n\n- Tools it lists (22, about 6,513 tokens of context, `tools/list` without credentials over MCP 2025-06-18, checked 2026-10-04 22:21 UTC):\n  - `optimize_image` (read-only): Fetch an image from a public URL and re-encode it smaller (WebP/AVIF/JPEG), optionally resizing to a target width. Returns the optimized image plus…\n  - `storage_capacity` (read-only): How many photos or minutes of video actually fit in a given storage size, corrected for real OS/filesystem overhead. Backed by Cleanor Labs measured per-item…\n  - `image_format_savings` (read-only): How much smaller WebP, AVIF or JPEG XL are than JPEG at matched perceptual quality, from Cleanor Labs’ controlled benchmark. Also reports the \"HEIC conversion…\n  - `qr_code` (read-only): Encode text or a URL as a QR code and return a crisp, dependency-free SVG you can paste straight into a page, deck or doc.\n  - `hash` (read-only): Compute a cryptographic hash of text (SHA-1, SHA-256, SHA-384 or SHA-512) and return the hex digest. Use for checksums, cache keys, or verifying content. MD5…\n  - `uuid` (read-only): Generate one or more UUIDs. v4 is fully random; v7 is time-sortable (recommended for database keys). LLMs cannot produce cryptographically random or…\n  - `base64` (read-only): Encode text to Base64 or decode Base64 back to text (UTF-8 safe). Supports URL-safe alphabet. Use whenever you need to encode/decode data URIs, tokens, or…\n  - `json_format` (read-only): Validate JSON and pretty-print or minify it, optionally sorting object keys. Returns a precise parse error (with position) if invalid. Use to check and clean…\n  - `jwt_decode` (read-only): Decode a JSON Web Token into its header and payload so you can inspect claims (iss, exp, sub, scopes). The signature is NOT verified and no secret is required…\n  - `color` (read-only): Convert a color (hex, rgb() or hsl()) and return hex, RGB and HSL representations at once. Use when picking or translating colors for CSS, design tokens or…\n  - `slugify` (read-only): Turn a title or phrase into a clean, URL-safe slug (lowercase, hyphenated, accents stripped). Use when generating page paths, filenames or anchor IDs.\n  - `count` (read-only): Accurately count characters (Unicode code points), UTF-16 units, words, lines and UTF-8 bytes in text. LLMs are notoriously bad at counting, so always use this…\n  - `regex_test` (read-only): Test a JavaScript regular expression against sample text and return whether it matches, plus every match with its captured groups and index. Use to verify a…\n  - `cron_describe` (read-only): Parse a standard 5-field cron expression (minute hour day-of-month month day-of-week) into a plain-English breakdown and the next few run times in UTC. Use to…\n  - `unit_convert` (read-only): Convert a value between units of length, mass, data size, time, speed or temperature. Supported units: mm, cm, m, km, in, ft, yd, mi, nmi, mg, g, kg, t, oz,…\n  - `datetime` (read-only): Get the current date/time, or convert a given timestamp, into a target IANA timezone with ISO, Unix and human-readable forms. Pass a Unix timestamp (seconds or…\n  - `url_parse` (read-only): Break a URL into its components: scheme, host, port, path, decoded query parameters and fragment. Use to inspect or debug a URL instead of parsing it by eye.\n  - `base_convert` (read-only): Convert an integer between number bases 2–36 (e.g. hex to binary, decimal to base-36). Arbitrary precision via BigInt, so large values stay exact. Use for…\n  - `diff` (read-only): Compute a line-by-line diff between two texts, marking removed lines with \"-\", added with \"+\" and unchanged with two spaces, plus a change count. Use to see…\n  - `hmac` (read-only): Compute an HMAC (keyed hash) of a message with a secret, using SHA-1/256/384/512, returned as hex or Base64. Use to sign webhook payloads or verify a signature…\n  - `placeholder_image` (read-only): Generate a lightweight SVG placeholder image at any size, with an optional label and custom background/text colors. Dependency-free, pastes straight into a…\n  - `color_palette` (read-only): Build a harmonious color palette from a base color using color-theory rules (complementary, analogous, triadic, tetradic, or monochromatic). Returns each color…\n- How its tools read to an agent (0 errors, 3 warnings, 0 notes, about 6,513 tokens; rules at https://www.anchorterminal.com/check.md; not part of the score):\n  - warn TC20 count: the description steers the model\n  - warn TC20 hash: the description steers the model\n  - warn TC20 uuid: the description steers the model\n\n- JSON: https://www.anchorterminal.com/api/v1/tools/cleanor.json\n- Being indexed says nothing about quality, and nobody can pay for it. Ask for a review: https://www.anchorterminal.com/builders/#claiming\n",
  "meta": {
    "attribution": "Anchor Terminal (https://www.anchorterminal.com)",
    "docs": "https://www.anchorterminal.com/docs/",
    "generatedAt": "2026-10-04",
    "license": "CC-BY-4.0",
    "method": "https://www.anchorterminal.com/benchmark/",
    "methodology": "0.3",
    "openapi": "https://www.anchorterminal.com/openapi.json",
    "preview": false,
    "run": "2026-10-01",
    "runLabel": "October 2026 research run"
  },
  "page": {
    "breadcrumbs": [
      {
        "name": "Home",
        "url": "https://www.anchorterminal.com/"
      },
      {
        "name": "Terminal",
        "url": "https://www.anchorterminal.com/tools/"
      },
      {
        "name": "Indexed",
        "url": "https://www.anchorterminal.com/indexed/"
      },
      {
        "name": "Cleanor",
        "url": ""
      }
    ],
    "description": "Cleanor, an MCP server by cleanor.app, listed from the official MCP registry. Indexed, not reviewed: facts and our own checks, no score or ranking. Zero-auth MCP: image optimize, cited storage/format data, and dev utilities LLMs get wrong.",
    "facts": [
      "not reviewed",
      "not ranked",
      "facts only"
    ],
    "h1": "Cleanor",
    "image": "https://www.anchorterminal.com/assets/og/indexed.png",
    "path": "/tools/cleanor",
    "published": "",
    "section": "indexed",
    "title": "Cleanor: MCP server, indexed from the official MCP registry",
    "toc": null,
    "updated": "2026-10-04",
    "url": "https://www.anchorterminal.com/tools/cleanor"
  },
  "tokens": {
    "markdown": 1600,
    "slim": 1530
  },
  "version": 1
}