Tokenectomy Razor

Tokenectomy Razor

Behebe Claude Code & Cursor Rate Limits: Lokales AI-Gateway mit Null-Latenz & Context-Surgery-MCP-Server in Rust

Hör auf, 20.000 Tokens für node_modules-Stacktraces zu verbrennen. Tokenectomy Razor ist ein lokales AI-Gateway-Reverse-Proxy mit Sub-Millisekunden-Latenz (127.0.0.1:8080) und ein begleitender MCP-Server, geschrieben in sicherem Rust. Entfernt 41,7 %–99,7 % Framework-Rauschen aus Terminal-Fehlerprotokollen, schwärzt durchgesickerte DB-Zugangsdaten/JWTs und cached Prompts kostenlos.

Schnellstart (10 s) • Architektur • Das Problem • Vorher & Nachher • Live-Interaktive Demo • Benchmarks

                                 ┌────────────────────────────────────────────────────────┐
                                 │                   Autonomous Agents                    │
                                 │  Claude Code • Cursor • Antigravity • Cline • Windsurf │
                                 └───────────────────────────┬────────────────────────────┘
                                                             │
                                                             ▼ (HTTP / SSE Outbound Prompts)
   ┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
   │                                 ⚡ TOKENECTOMY AI GATEWAY (127.0.0.1:8080)                                       │
   │                                                                                                                  │
   │  ┌─────────────────────────┐   ┌───────────────────────────┐   ┌──────────────────────────────────────────────┐  │
   │  │   Zero-Cost Prompt      │   │   Zero-Leak Credential    │   │         Polyglot Trace Surgery               │  │
   │  │         Cache           │   │         Redaction         │   │            (9 Languages)                     │  │
   │  │  <1ms Hit • 100% Free   │   │  API Keys • JWTs • DB URIs│   │  node_modules • site-packages • .cargo       │  │
   │  └───────────┬─────────────┘   └─────────────┬─────────────┘   └──────────────────────┬───────────────────────┘  │
   │              │                               │                                        │                          │
   │              └───────────────────────────────┼────────────────────────────────────────┘                          │
   │                                              ▼                                                                   │
   │                                 Smart Upstream Auto-Router                                                       │
   │                         (Anthropic • OpenAI • Groq • Ollama Local)                                               │
   └──────────────────────────────────────────────┬───────────────────────────────────────────────────────────────────┘
                                                  │
                 ┌────────────────────────────────┼────────────────────────────────┐
                 ▼                                ▼                                ▼
       api.anthropic.com                  api.openai.com                   localhost:11434
    (Claude 3.5 / 3.7 Sonnet)         (GPT-4o / o1 / o3-mini)              (DeepSeek / Llama)

⚡ Schnellstart (10 s)

0. Zero-Config-Einzeiler-Wrapper (wrap)

Führe jeden Coding-Agenten oder jede Testsuite direkt hinter Tokenextomy's Privacy- und Caching-Gateway aus, ohne manuelle Umgebungsvariablen-Konfiguration:

# Wrap Claude Code CLI
razor wrap -- claude

# Wrap Aider with DeepSeek or Ollama (Auto-Transpiled on the fly!)
razor wrap -- aider --model deepseek/deepseek-chat

# Wrap test runs to scrub logs and prevent accidental credential leakage
razor wrap npm test

1. Starte das eigenständige AI-Gateway (Manueller Modus)

npx -y tokenectomy-razor --proxy

💡 Intelligentes Multi-Provider-Auto-Routing & universeller LLM-Transpiler standardmäßig AKTIVIERT! Tokenectomy analysiert automatisch Anfragepfade und -header. Du möchtest Claude Code gegen DeepSeek oder Ollama ausführen? Tokenectomy transpiliert transparent das Anthropic-/v1/messages-Format in das OpenAI-/v1/chat/completions-Format on-the-fly und umgekehrt.

2. Verbinde deinen bevorzugten Agenten

Richte deinen Coding-Agenten oder deine CLI auf das lokale Gateway unter 127.0.0.1:8080 aus:

3. Echtzeit-FinOps- & Sicherheits-Dashboard

Öffne http://127.0.0.1:8080/dashboard in deinem Browser, um Live-Token-Reduktionen, Prompt-Cache-Treffer, Dollar-Ersparnisse und geschwärzte Zugangsdaten in Echtzeit zu beobachten.

4. Einrichtung des begleitenden MCP-Servers (Sub-Cortex)

Für Agenten, die tiefgehende Diagnose-Tools aufrufen (get_error_context, analyze_code, apply_code_patch):

Claude Code CLI

claude mcp add tokenectomy npx -y tokenectomy-razor --mcp

Google Antigravity / Gemini CLI

agy mcp add tokenectomy-razor -- npx -y tokenectomy-razor --mcp

Cursor Composer (.cursor/mcp.json)

{
  "mcpServers": {
    "tokenectomy": {
      "command": "npx",
      "args": ["-y", "tokenectomy-razor", "--mcp"]
    }
  }
}

Claude Desktop (claude_desktop_config.json)

{
  "mcpServers": {
    "tokenectomy": {
      "command": "npx",
      "args": ["-y", "tokenectomy-razor", "--mcp"]
    }
  }
}

5. Terminal-Piping & CLI-Bereinigung

npm test 2>&1 | npx tokenectomy-razor

🛑 Das Problem: Warum deine KI Rate Limits erreicht & halluziniert

Wenn deine App während der Entwicklung abstürzt (Next.js, Express, FastAPI, Tokio), gibt die Laufzeit hunderte Zeilen Drittanbieter-Code aus node_modules oder site-packages aus.

Wenn du diesen rohen Absturz-Dump in Cursor oder Claude einfügst:

1. Frisst dein 5-Stunden-Rate-Limit: Ein einzelner Express/Prisma-Fehler kann 5.000 bis 45.000 Tokens an Drittanbieter-Bibliothekscode ausgeben, den du nie geschrieben hast. Ein paar Absturzschleifen verbrennen schnell dein Sitzungslimit.
2. Löst KI-Halluzinationen aus: Claude verliert sich in Framework-Interna (node_modules/express/lib/router/layer.js oder starlette/routing.py) und versucht, Bibliotheksdateien zu bearbeiten, anstatt deinen tatsächlichen Anwendungscode.
3. Leakt Geheimnisse & Zugangsdaten: Verbindungsstrings mit rohen Datenbank-Passwörtern, JWT-Bearer-Tokens und Cloud-Schlüssel, die in Fehler-Traces eingebettet sind, werden an externe Modellserver weitergeleitet.

Raw Terminal Crash (45,820 tokens + Leaked Secrets)
     │
     ▼  <0.2ms Local Rust DFA Engine
[Redact Passwords & Keys] ──► [Strip Third-Party Framework Frames] ──► [Isolate Root Cause]
     │
     ▼
Clean Context (118 tokens • Zero Secrets • Sub-millisecond)

🔍 Vorher & Nachher-Vergleich

❌ Ohne Tokenectomy: KI halluziniert & verbrennt Kontext

TypeError: Cannot read properties of undefined (reading 'token')
    at loadComponents (/app/node_modules/next/dist/server/load-components.js:14:2)
    at renderToHTML (/app/node_modules/next/dist/server/render.js:50:5)
    at nextServer (/app/node_modules/next/dist/server/next-server.js:80:12)
    at processTicksAndRejections (node:internal/process/task_queues:95:5)
    at runMicrotasks (node:internal/process/task_queues:120:3)
    at checkoutHandler (/app/pages/api/checkout.ts:42:15)
Database connection failed: postgresql://admin:super_secret_password@db.prod.internal:5432/primary
API key leaked: sk-ant-api03-abcdef1234567890abcdef1234567890

Was Claude tut: Analysiert load-components.js und next-server.js, spekuliert über Webpack-/Next.js-Interna und leakt Verbindungszugangsdaten an Remote-Inferenzprotokolle.

✅ Mit Tokenectomy: Sauberer Kontext & sofortige Lösung

// [Tokenectomy Surgery: 5 internal framework frames pruned (83.3%)]
// Source: /app/pages/api/checkout.ts:42:15
42 |   const sessionToken = req.headers.authorization.token;
   |                                                  ^ TypeError: Cannot read properties of undefined (reading 'token')
🛡️ [CONNECTION_STRING_REDACTED]
🛡️ [ANTHROPIC_KEY_REDACTED]

Was Claude tut: Erkennt sofort, dass Zeile 42 in checkout.ts versucht hat, auf .token bei undefinierten Headern zuzugreifen. Schlägt sofort optionale Verkettung req.headers.authorization?.token vor. Zugangsdaten werden vor der Übertragung geschwärzt.

🔬 Überprüfbare Benchmarks

Alle Leistungsangaben sind hardwaregestützt und unabhängig auf physischer Hardware reproduzierbar (gemessen auf 10-Kern Intel Core i5-1235U @ 15 W unter Arch Linux, Kernel 6.13):

Hinweis zur Hardware-Abhängigkeit: Die Leistung ist hardwareabhängig; die gemeldeten Durchsatzwerte repräsentieren Messergebnisse auf der angegebenen Testhardware (10-Kern Intel Core i5-1235U @ 15 W TDP). Der Durchsatz skaliert mit höheren TDP-Desktop-/Server-CPUs und schnelleren Speicherbussen. Entwickler werden ermutigt, die Leistung unabhängig mit dem untenstehenden Reproduktionsbefehl zu prüfen.

$ cargo test --release --test stress_benchmark -- --nocapture

=====================================================================================
🧪 TOKENECTOMY OSS VERIFIABLE HEAVY STRESS BENCHMARK (100% REPRODUCIBLE IN OSS)
   Hardware: 10-Core / 12-Thread Intel Core i5-1235U | OS: Arch Linux | Kernel Telemetry Active
   Initial Baseline Process Memory (VmRSS): 3.45 MB
=====================================================================================

🔥 [TEST 1/3] QUARTER-MILLION LINES LOG REDACTION TORTURE (250,000 LINES / 25MB+ BUFFER)
  ├── Buffer Size: 24.44 MB (250000 lines)
  ├── Redaction Latency: 471.05ms (51.9 MB/sec)
  ├── Line Throughput: 530,735 lines/sec
  ├── Peak Memory (VmRSS): 76.05 MB (Delta: +72.60 MB)
  └── Status: ✅ PASSED (100% of 250,000 lines sanitized, zero memory balloon)

🔥 [TEST 2/3] REDOS CATASTROPHIC BACKTRACKING TORTURE (50,000 CHARS PAYLOAD)
  ├── Attack Payload Size: 50,082 characters
  ├── Execution Latency: 1.165 ms
  └── Status: ✅ PASSED (Linear O(N) evaluation, ReDoS-resistant on tested payloads)

🔥 [TEST 3/3] HIGH-CONCURRENCY TORTURE (100 PARALLEL OS THREADS)
  ├── Thread Concurrency: 100 concurrent OS threads
  ├── Successful Operations: 100/100 (100.0%)
  ├── Total Elapsed: 11.31ms
  ├── Concurrency Throughput: 17,688 ops/sec
  ├── Final VmRSS: 78.99 MB
  └── Status: ✅ PASSED (Zero race condition, zero deadlock)

=====================================================================================
🏆 TOKENECTOMY OSS STRESS BENCHMARK: 3/3 PASSED (100% GREEN)
   Total Suite Duration: 580.83ms
   Bounded Final VmRSS: 78.99 MB
=====================================================================================
test test_oss_heavy_stress_benchmark ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.58s

🛡️ Automatisierte Schwärzungs- & Geheimnis-Sanitisierungs-Benchmark

Bewertet über eine interne Benchmark-Testvorrichtung (tests/fixtures/) von 12 polyglotten Absturz-Traces (Rust, Python, TypeScript, Go, YAML), die 22 Ground-Truth-Zugangsdaten und saubere Negativkontrollen enthalten. Head-to-Head bewertet gegen Gitleaks v8.30.1 (Standard-Regelsatz).

Architektonischer Hinweis: Gitleaks ist in erster Linie als Repository-Commit-/Diff-Scanner konzipiert, nicht als In-Memory-Laufzeit-Trace-Schwärzer. Tokenectomy Razor ist speziell für Laufzeit-Stream-Sanitisierung und Stack-Trace-Chirurgie entwickelt.

1. Präzision, Recall & F1-Score pro Kategorie

2. Head-to-Head-Leistungs- & Architekturzusammenfassung

3. Token-Reduktion & LLM-Kontext-Ersparnisse (tiktoken cl100k_base)

🔌 Erweiterte Agenten- & Gateway-Konfiguration

1. Multi-Provider-AI-Gateway-Optionen (--proxy)

Tokenextomy's Gateway läuft lokal auf 127.0.0.1:8080 ohne manuelle Konfiguration. In komplexen Entwicklungsumgebungen oder containerisierten Agenten-Topologien kannst du Bindung und Routing anpassen:

# Default Smart Auto-Routing (routes Anthropic, OpenAI, and Ollama requests dynamically):
razor --proxy

# Safety Circuit Breaker: Prevent runaway agent loops from burning your hourly budget or 5-hour window:
razor --proxy --max-hourly-tokens 200000

# Resilient 429 Auto-Retry: Automatically pause and retry when hitting upstream rate limits (default: on):
razor --proxy --max-retries 5

# Explicit upstream override (e.g. Groq, vLLM, or OpenRouter):
razor --proxy --upstream-url https://api.groq.com/openai/v1

# Secure remote container binding with mandatory bearer token:
razor --proxy --proxy-bind 0.0.0.0:8080 --allow-remote --proxy-token "$MY_GATEWAY_TOKEN"

Echtzeit-Metriken & Prometheus-Export

Tokenectomy stellt Live-FinOps- und Token-Ökonomie-Daten über JSON bereit:

curl http://127.0.0.1:8080/v1/metrics

Liefert sofortige Telemetrie für rate_limits_mitigated, circuit_breaker_trips, last_latency_ms, current_hourly_tokens, cache_hits, cache_tokens_saved und estimated_cost_saved_usd.

2. Eigenständige CLI & Terminal-Bereinigung

Beim Debuggen oder direkten Weiterleiten von Terminal-Testausgaben:

# Pipe terminal test failures through the surgical redactor:
npm test 2>&1 | razor --scrub

# Sanitize a specific raw log file:
razor --scrub --file /var/log/app/error.log > sanitized.log

# Offline local air-gapped mode (zero external network calls):
cat failure.log | razor --scrub --local-only

🛠️ Verfügbare MCP-Tools

Tokenectomy Razor erfüllt den Glama Grade A Tool Definition Quality Score (TDQS) mit expliziten Parameter-Grenzen:

🌐 Unterstützte Polyglot-Ökosysteme

📦 Installationsoptionen

Methode 1: Sofort per npx (Null-Toolchain-Setup)

npx -y tokenectomy-razor --mcp

Methode 2: Cargo (crates.io)

cargo install tokenectomy

Methode 3: Vorkompilierte eigenständige Binärdateien

Null-Abhängigkeits-, eigenständige Release-Binärdateien verfügbar auf GitHub Releases:

• Linux: x86_64-unknown-linux-gnu, x86_64-unknown-linux-musl, aarch64-unknown-linux-gnu
• macOS: aarch64-apple-darwin (Apple Silicon M1/M2/M3/M4), x86_64-apple-darwin (Intel)
• Windows: x86_64-pc-windows-msvc.exe

Methode 4: Multi-Arch-Docker-Container (GHCR)

docker pull ghcr.io/tokenectomy-labs/razor:latest
docker run -i ghcr.io/tokenectomy-labs/razor:latest --mcp

⚖️ Editionsvergleich

Benötigen Sie Enterprise-AST-Selbstheilung? Entdecken Sie die Sentinel-Stufe

🗺️ Roadmap & Meilensteine

🔒 Sicherheit & Invarianten

• Lokale Ausführung standardmäßig: Die gesamte Stacktrace-Analyse, Frame-Bereinigung und Geheimnis-Schwärzung erfolgt lokal auf physischer Hardware.
• Dokumentierter Netzwerk-Ausgang: Im MCP-Server-Modus ist search_stack_overflow das einzige Tool mit ausgehendem Netzwerkverkehr (HTTPS zu api.stackexchange.com). Die Nutzlast ist strikt auf bereinigten, geschwärzten Fehlersignaturtext beschränkt (keine Codezeilen, keine lokalen Pfade, null Anmeldedaten). In luftdichten Umgebungen verwenden Sie --local-only, um die Netzwerksuche vollständig zu deaktivieren.
• Deterministische lineare Zeitmustererkennung: Alle Mustererkennungsmodule verwenden nicht-backtrackende DFA-Regex-Engines ($O(N)$ lineare Zeit) und Aho-Corasick-Automaten-Auswertung.
• Pfad-Traversal-Grenzisolierung: Dateioperationen sind strikt auf das aktive Arbeitsbereichs-Root beschränkt (CWD). Pfad-Traversals (../) und nicht autorisierte Symlinks werden blockiert.
• Sichere Rust-Implementierung: Kernausführungspfade erzwingen sichere Rust-Speichergarantien mit begrenzten Stream-Readern (.take()), die Ressourcenerschöpfung verhindern.

Für Schwachstellenmeldungen lesen Sie bitte unsere Sicherheitsrichtlinie.

⚖️ Rechtlicher Hinweis & Downstream-Fork-Haftungsausschluss

Tokenectomy Razor wird ausschließlich für legitime Entwicklerproduktivität, Beobachtbarkeit, Log-Chirurgie und defensive Anmeldedaten-Schwärzung bereitgestellt. Alle Downstream-Forks, Klone, Weiterverbreitungen oder privaten Bereitstellungen funktionieren vollständig unabhängig von den ursprünglichen Autoren. Tokenectomy Labs und seine Betreuer übernehmen keinerlei Haftung für rechtswidrige, böswillige oder nicht autorisierte Handlungen Dritter, die diese Codebasis oder Ableitungen davon verwenden. Alle Downstream-Betreiber tragen 100 % individuelle Verantwortung für die Einhaltung lokaler und internationaler Cybersicherheitsgesetze. Siehe DISCLAIMER.md für die vollständigen rechtlichen Bedingungen.

❓ Häufig gestellte Fragen (FAQ)

Wie verhindert Tokenectomy Razor, dass Claude Code & Cursor Ratenlimits erreichen?

Wenn Tests oder Terminal-Builds abstürzen, geben Frameworks wie Next.js, Express, Jest und Django Tausende interner Stack-Frames aus (node_modules, site-packages). Das Senden roher 5.000-Zeilen-Absturzprotokolle verbraucht 15.000 bis 45.000 Token pro Prompt und erschöpft Ihr 5-Stunden-Sitzungslimit in Minuten. Tokenectomy Razor fängt Protokolle ab und entfernt 95 % des nicht handlungsrelevanten Framework-Rauschens, wodurch ein 40.000-Zeichen-Absturzprotokoll in <0,2 ms auf unter 200 wesentliche Token reduziert wird.

Wie verhindere ich, dass Cursor node_modules-Fehlerprotokolle an LLMs sendet?

Führen Sie Tokenectomy Razor als lokalen AI-Gateway-Reverse-Proxy aus (npx -y tokenectomy-razor --proxy). Zeigen Sie in den Cursor-Einstellungen Ihre OpenAI-Basis-URL auf http://127.0.0.1:8080/v1. Jede Terminal-Fehlerausgabe, die von Composer eingefügt oder referenziert wird, wird automatisch bereinigt, geschwärzt und im laufenden Betrieb zwischengespeichert, bevor sie Modellserver erreicht.

Wie verhindert Tokenectomy Anmeldedaten-Leaks in Fehlerprotokollen?

Die gesamte Log-Chirurgie und Geheimnis-Schwärzung erfolgt zu 100 % lokal auf Ihrem Rechner im Speicher, bevor eine ausgehende Übertragung stattfindet. Razor verwendet deterministische lineare Regex- und Aho-Corasick-Automaten, um PostgreSQL/MongoDB-Verbindungs-URIs, JWT-Bearer-Tokens und Cloud-API-Schlüssel mit [REDACTED]-Tokens zu erkennen und zu schwärzen. Für die Bereinigung ist kein Cloud-Ausgang erforderlich.

🤝 Community & Ressourcen

• 🌐 Offizielle Website
• 📖 Dokumentation
• 🏗️ Systemarchitektur
• 📋 Changelog
• 🤝 Beitragsrichtlinien
• 🔒 Sicherheitsrichtlinie
• ⚖️ Haftungsausschluss & Verantwortlichkeit