regexforge

Ein MCP-Server (Model Context Protocol), der produktionsreife Regexes aus beschrifteten Beispielen synthetisiert. Null LLM zur Laufzeit – reine symbolische Synthese über eine Vorlagenbank mit einem Fallback für die Inferenz von Zeichenklassen. Jede Antwort enthält eine Prüfmatrix und eine Prüfung auf Backtracking-Risiken.

• MCP-Transport: HTTP (streamfähig) · Protokollversion: 2024-11-05

• MCP-Endpunkt: https://regexforge.jason-12c.workers.dev/mcp

• MCP-Manifest: https://regexforge.jason-12c.workers.dev/.well-known/mcp.json

Das MCP-Tool

regexforge stellt ein einzelnes MCP-Tool bereit. Ein KI-Client (Claude Desktop, Cline, Continue, Cursor oder jeder MCP-fähige Agent) ruft es auf die gleiche Weise auf wie jedes andere MCP-Tool — tools/call über JSON-RPC 2.0.

regexforge_synth

Synthetisieren Sie einen kampferprobten Regex aus beschrifteten Beispielen.

Eingabeschema (was das Modell liefert):

{
  "type": "object",
  "required": ["examples"],
  "properties": {
    "description": {
      "type": "string",
      "description": "Optional natural-language description of the target pattern. Used only for tie-breaking when multiple templates fit."
    },
    "examples": {
      "type": "array",
      "minItems": 2,
      "maxItems": 100,
      "items": {
        "type": "object",
        "required": ["text", "match"],
        "properties": {
          "text":  { "type": "string", "maxLength": 2048 },
          "match": { "type": "boolean", "description": "true if the regex should match this string; false if it should NOT match." }
        }
      }
    }
  }
}

Ausgabeschema:

{
  "regex": "string",
  "flags": "string",
  "source": "template | char_class",
  "template_name": "string (if source=template)",
  "test_matrix": [
    { "text": "string", "expected": "boolean", "actual": "boolean", "pass": "boolean" }
  ],
  "all_pass": "boolean",
  "backtrack_risk": "none | low | high",
  "backtrack_reasons": [ "string" ],
  "candidates_considered": "integer",
  "candidates_passing": "integer",
  "notes": [ "string" ]
}

Fehler geben JSON-RPC-Fehlerobjekte mit strukturierter Behebung zurück:

• not_expressible (HTTP 422) — Beispiele implizieren eine nicht-reguläre Sprache (ausgeglichene Klammern, Zählen usw.).

• no_credits (HTTP 402) — Wallet leer, Kauf über /v1/credits.

• missing_input (HTTP 400) — Das Feld fix sagt Ihnen genau, was fehlt.

Verbindung von MCP-Clients

Claude Desktop

Hinzufügen zu ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) oder %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "regexforge": {
      "transport": {
        "type": "http",
        "url": "https://regexforge.jason-12c.workers.dev/mcp"
      },
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY_HERE"
      }
    }
  }
}

Erhalten Sie einen API-Schlüssel mit: curl -X POST https://regexforge.jason-12c.workers.dev/v1/keys (kostenlos, 50 Credits bei der Registrierung).

Python (offizielles mcp SDK)

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async def main():
    url = "https://regexforge.jason-12c.workers.dev/mcp"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    async with streamablehttp_client(url, headers=headers) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            result = await session.call_tool(
                "regexforge_synth",
                arguments={
                    "description": "ISO 8601 date like 2024-12-30",
                    "examples": [
                        {"text": "2024-12-30", "match": True},
                        {"text": "2023-01-01", "match": True},
                        {"text": "12/30/2024", "match": False},
                        {"text": "abc",        "match": False},
                    ],
                },
            )
            print(result.content[0].text)

TypeScript (offizielles @modelcontextprotocol/sdk)

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://regexforge.jason-12c.workers.dev/mcp"),
  { requestInit: { headers: { Authorization: "Bearer YOUR_API_KEY" } } }
);
const client = new Client({ name: "demo", version: "1.0.0" }, { capabilities: {} });
await client.connect(transport);

const res = await client.callTool({
  name: "regexforge_synth",
  arguments: {
    description: "ethereum wallet address",
    examples: [
      { text: "0x8ABCE477e22B76121f04c6c6a69eE2e6a12De53e", match: true },
      { text: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", match: true },
      { text: "0x123", match: false },
      { text: "xyz",   match: false },
    ],
  },
});
console.log(res.content[0].text);

Raw JSON-RPC über HTTP

Wenn Sie das Protokoll lieber direkt ansprechen möchten:

# 1. initialize
curl -X POST https://regexforge.jason-12c.workers.dev/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize"}'

# 2. list tools
curl -X POST https://regexforge.jason-12c.workers.dev/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

# 3. call the tool
curl -X POST https://regexforge.jason-12c.workers.dev/mcp \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_KEY" \
  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"regexforge_synth","arguments":{"examples":[{"text":"2024-12-30","match":true},{"text":"abc","match":false}]}}}'

Was passiert unter der Haube

1. Vorlagenbank-Abgleich — testet ca. 65 vorkompilierte, kampferprobte Regex-Vorlagen (E-Mail, UUID v4, ISO-Datum, Semver, ETH-Adresse, US-Telefonnummer, SHA-256, Base64, US-Postleitzahl, MAC-Adresse usw.) gegen jedes Beispiel. Jede Vorlage, die alle Beispiele korrekt klassifiziert, ist ein Kandidat.

2. Entscheidungsfindung — wenn mehrere Vorlagen passen, wird diejenige ausgewählt, deren Schlüsselwörter am besten zur description des Aufrufers passen, wobei weitere Gleichstände durch die Musterlänge aufgelöst werden.

3. Fallback für Zeichenklassen-Inferenz — wenn keine Vorlage passt, werden das längste gemeinsame Präfix und Suffix aus den positiven Beispielen extrahiert, die Mitte als Vereinigung von Zeichenklassen [a-z0-9-]{n,m} mit Längenbegrenzungen abgeleitet und dann überprüft, ob das synthetisierte Muster jedes negative Beispiel ablehnt.

4. Rückgabe mit Nachweis — die Antwort enthält die vollständige test_matrix, sodass der Aufrufer (Modell) überprüfen kann, ob jedes Beispiel korrekt klassifiziert wird, bevor der Regex im Code verwendet wird.

5. Backtracking-Audit — ein statischer Durchlauf über den zurückgegebenen Regex markiert verschachtelte Quantoren, Rückwärtsreferenzen und Lookarounds, die katastrophales Backtracking verursachen könnten.

Alles deterministisch. Kein LLM-Aufruf zur Laufzeit. Typische Latenz <100 ms.

Beispiel-Agent-Workflow

Ein KI-Agent, der Code schreibt, der vom Benutzer bereitgestellte Zeichenfolgen parsen muss, ruft regexforge_synth auf, anstatt den Regex selbst zu generieren (was schwächere Modelle ständig falsch machen):

Modell denkt: "Ich muss dieses SKU-1234-AB-Muster parsen. Ich sollte keinen Regex halluzinieren."

Ruft auf: regexforge_synth({ description: "SKU wie SKU-1234-AB", examples: [<3 positive, 5 negative>] })

Erhält zurück: { regex: "^SKU-[-0-9A-Z]{7}$", all_pass: true, backtrack_risk: "none", source: "char_class" }

Fügt "^SKU-[-0-9A-Z]{7}$" mit der Gewissheit in seinen Code ein, dass jedes bekannte Beispiel korrekt klassifiziert wird.

Dies ist ein einzelner Tool-Aufruf anstelle von: (a) LLM schreibt einen Regex, (b) LLM schreibt Testfälle, (c) LLM simuliert die Regex-Ausführung, (d) LLM überdenkt und schreibt neu, … was 10x mehr Token verbraucht und es trotzdem falsch macht.

Authentifizierung & Preisgestaltung

• Programmatische Schlüsselausgabe: POST /v1/keys → { key, credits: 50 }. Keine E-Mail. Kein Captcha. Agenten erstellen ihre eigenen.

• Kosten pro Aufruf: $0,002. Pakete: Starter ($5 / 2.500), Scale ($50 / 30k), Bulk ($500 / 350k).

• Zahlung (agentenautonom): POST /v1/credits { "pack": "starter" } gibt eine echte Stripe-Checkout-URL + x402 USDC-on-Base-Header zurück. Schließen Sie die Zahlung ab, dann schreibt POST /v1/credits/verify { "session_id": "cs_..." } dem Schlüssel die Credits gut.

• Jede Fehlerantwort enthält ein strukturiertes fix-Feld, das dem Agenten genau sagt, was zu ändern ist.

Andere Discovery-Oberflächen (nur für Agenten, maschinenlesbar)

Implementierung

• Transport: HTTP streamfähig (MCP-Spezifikation 2024-11-05), JSON-RPC 2.0

• Bereitstellung: Cloudflare Workers (Kaltstart <10 ms)

• Aufgebaut auf: @walko/agent-microsaas — ein Grundgerüst, das den MCP-Transport, Discovery-Manifeste, Bearer-Key-Authentifizierung und das Credit-Ledger verwaltet. regexforge selbst besteht aus ca. 300 Zeilen reiner Syntheselogik.

Lizenz

Apache-2.0.