regexforge

Un servidor MCP (Model Context Protocol) que sintetiza expresiones regulares de calidad de producción a partir de ejemplos etiquetados. Cero LLM en tiempo de servicio: síntesis simbólica pura sobre un banco de plantillas con un respaldo de inferencia de clases de caracteres. Cada respuesta incluye una matriz de prueba y una auditoría de riesgo de backtracking.

• Transporte MCP: HTTP (transmisible) · Versión del protocolo: 2024-11-05

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

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

La herramienta MCP

regexforge expone una única herramienta MCP. Un cliente de IA (Claude Desktop, Cline, Continue, Cursor o cualquier agente compatible con MCP) la llama de la misma manera que llamaría a cualquier otra herramienta MCP: tools/call sobre JSON-RPC 2.0.

regexforge_synth

Sintetiza una expresión regular probada en batalla a partir de ejemplos etiquetados.

Esquema de entrada (lo que proporciona el modelo):

{
  "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." }
        }
      }
    }
  }
}

Esquema de salida:

{
  "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" ]
}

Los errores devuelven objetos de error JSON-RPC con remediación estructurada:

• not_expressible (HTTP 422) — los ejemplos implican un lenguaje no regular (paréntesis equilibrados, conteo, etc.).

• no_credits (HTTP 402) — billetera vacía, compra a través de /v1/credits.

• missing_input (HTTP 400) — el campo fix te dice exactamente qué falta.

Conexión desde clientes MCP

Claude Desktop

Añadir a ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o %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"
      }
    }
  }
}

Obtén una clave API con: curl -X POST https://regexforge.jason-12c.workers.dev/v1/keys (gratis, 50 créditos al registrarse).

Python (SDK oficial mcp)

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 (oficial @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);

JSON-RPC sin procesar sobre HTTP

Si prefieres hablar el protocolo directamente:

# 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}]}}}'

Lo que sucede bajo el capó

1. Coincidencia con banco de plantillas — prueba ~65 plantillas de expresiones regulares precompiladas y probadas en batalla (correo electrónico, UUID v4, fecha ISO, semver, dirección ETH, teléfono de EE. UU., SHA-256, base64, código postal de EE. UU., dirección MAC, etc.) contra cada ejemplo. Cualquier plantilla que clasifique todos los ejemplos correctamente es candidata.

2. Desempate — si varias plantillas pasan, elige aquella cuyas palabras clave coincidan mejor con la description del llamador, rompiendo más empates por la longitud del patrón.

3. Respaldo de inferencia de clases de caracteres — si ninguna plantilla encaja, extrae el prefijo y sufijo comunes más largos de los ejemplos positivos, infiere el medio como una unión de clases de caracteres [a-z0-9-]{n,m} con límites de longitud, luego verifica que el patrón sintetizado rechace cada ejemplo negativo.

4. Devolución con prueba — la respuesta incluye la test_matrix completa para que el llamador (modelo) pueda verificar que cada ejemplo se clasifica correctamente antes de usar la expresión regular en el código.

5. Auditoría de backtracking — una pasada estática sobre la expresión regular devuelta señala cuantificadores anidados, referencias inversas y lookaround que podrían causar un backtracking catastrófico.

Todo determinista. Sin llamadas a LLM en tiempo de servicio. Latencia típica <100 ms.

Ejemplo de flujo de trabajo del agente

Un agente de IA que escribe código que necesita analizar cadenas proporcionadas por el usuario llama a regexforge_synth en lugar de generar la expresión regular por sí mismo (lo cual los modelos más débiles hacen mal constantemente):

El modelo piensa: "Necesito analizar este patrón SKU-1234-AB. No voy a alucinar una expresión regular."

Llama a: `regexforge_synth({ description: "SKU como SKU-1234-AB", examples: [<3 positivos, 5 negativos>] })

Obtiene: { regex: "^SKU-[-0-9A-Z]{7}$", all_pass: true, backtrack_risk: "none", source: "char_class" }

Pega "^SKU-[-0-9A-Z]{7}$" en su código con la confianza de que cada ejemplo conocido se clasifica correctamente.

Esta es una sola llamada a herramienta en lugar de: (a) el LLM escribe una expresión regular, (b) el LLM escribe casos de prueba, (c) el LLM simula la ejecución de la expresión regular, (d) el LLM duda y reescribe, ... lo que consume 10 veces más tokens y aun así lo hace mal.

Autenticación y precios

• Emisión programática de claves: POST /v1/keys → { key, credits: 50 }. Sin correo electrónico. Sin captcha. Los agentes acuñan las suyas propias.

• Costo por llamada: $0.002. Paquetes: inicial ($5 / 2,500), escala ($50 / 30k), volumen ($500 / 350k).

• Pago (autónomo del agente): POST /v1/credits { "pack": "starter" } devuelve una URL de Stripe Checkout real + encabezados x402 USDC-on-Base. Completa el pago, luego POST /v1/credits/verify { "session_id": "cs_..." } acredita la clave.

• Cada respuesta de error incluye un campo fix estructurado que le dice al agente exactamente qué cambiar.

Otras superficies de descubrimiento (solo para agentes, legible por máquina)

Implementación

• Transporte: HTTP transmisible (especificación MCP 2024-11-05), JSON-RPC 2.0

• Despliegue: Cloudflare Workers (arranque en frío <10 ms)

• Construido sobre: @walko/agent-microsaas — un esqueleto que maneja el transporte MCP, manifiestos de descubrimiento, autenticación con clave de portador y libro mayor de créditos. regexforge en sí mismo son ~300 líneas de código de lógica de síntesis pura.

Licencia

Apache-2.0.