MCX - Modular Code Execution

███╗   ███╗ ██████╗██╗  ██╗
████╗ ████║██╔════╝╚██╗██╔╝
██╔████╔██║██║      ╚███╔╝
██║╚██╔╝██║██║      ██╔██╗
██║ ╚═╝ ██║╚██████╗██╔╝ ██╗
╚═╝     ╚═╝ ╚═════╝╚═╝  ╚═╝

MCP-Server, der es KI-Agenten ermöglicht, Code auszuführen, anstatt Tools direkt aufzurufen.

Basiert auf Anthropic's Artikel zur Code-Ausführung.

Das Problem

Traditionelles MCP hat zwei Ineffizienzen:

Überlastung der Tool-Definitionen - Das Laden aller Tool-Definitionen überflutet den Kontext
Aufblähung durch Zwischenergebnisse - Jede API-Antwort durchläuft das Modell

Die Lösung

Anstatt Tools direkt aufzurufen, schreibt der Agent Code, der in einer Sandbox ausgeführt wird:

const invoices = await api.getInvoices({ limit: 100 });
return {
  count: invoices.length,
  total: sum(invoices, 'amount'),
  byStatus: count(invoices, 'status')
};
// Returns ~50 tokens instead of 50,000

Ergebnis: 98% Token-Reduzierung durch Filtern von Daten innerhalb der Ausführungsumgebung.

Installation

# Install globally with bun
bun add -g @papicandela/mcx-cli

# Initialize global directory (~/.mcx/)
mcx init

Erfordert Bun: MCX verwendet Bun als Laufzeitumgebung. Installieren Sie Bun, falls Sie dies noch nicht getan haben.

Schnellstart

# 1. Initialize global MCX directory
mcx init

# 2. Generate adapters from API docs
mcx gen ./api-docs.md -n myapi

# 3. Add credentials to ~/.mcx/.env

# 4. Start server
mcx serve

Verzeichnisstruktur

~/.mcx/
├── adapters/           # Your adapters
│   ├── supabase.ts     # Supabase Management API
│   ├── chrome-devtools.ts  # Chrome DevTools Protocol
│   └── myapi.ts        # Generated from OpenAPI
├── skills/             # Reusable skills
├── mcx.config.ts       # Auto-loads all adapters
├── .env                # API credentials
└── package.json        # Dependencies

# Runtime (created automatically)
~/.mcx/
├── logs/               # Server logs (mcx logs to view)
└── .cache/             # FTS5 search index

Claude Code Integration

Fügen Sie dies zu Ihren Claude Code-Einstellungen hinzu (~/.claude.json oder .mcp.json des Projekts):

{
  "mcpServers": {
    "mcx": {
      "command": "mcx",
      "args": ["serve"]
    }
  }
}

Das war's! MCX verwendet automatisch ~/.mcx/ für Konfiguration und Adapter.

Claude Code Hooks (Optional)

Leiten Sie native Tools auf MCX-Alternativen um, um eine bessere Leistung zu erzielen:

~/.claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      { "matcher": "Grep", "hooks": [{ "type": "command", "command": "bun ~/.claude/hooks/mcx-redirect.js" }] },
      { "matcher": "Glob", "hooks": [{ "type": "command", "command": "bun ~/.claude/hooks/mcx-redirect.js" }] },
      { "matcher": "Edit", "hooks": [{ "type": "command", "command": "bun ~/.claude/hooks/mcx-redirect.js" }] },
      { "matcher": "Write", "hooks": [{ "type": "command", "command": "bun ~/.claude/hooks/mcx-redirect.js" }] },
      { "matcher": "Read", "hooks": [{ "type": "command", "command": "bun ~/.claude/hooks/mcx-read-check.js" }] },
      { "matcher": "Bash", "hooks": [{ "type": "command", "command": "bun ~/.claude/hooks/mcx-bash-check.js" }] }
    ]
  }
}

Natives Tool	MCX-Alternative	Vorteil
`Glob`	`mcx_find`	Frecency-Ranking, Git-Status, Proximity-Boost
`Grep`	`mcx_grep`	SIMD-beschleunigt, Fuzzy-Suche
`Edit`	`mcx_edit`	Keine "Read first"-Anforderung, CRLF-Normalisierung
`Write`	`mcx_write`	Keine "Read first"-Anforderung
`Read` (>50KB)	`mcx_file({ storeAs })`	Datei bleibt in der Sandbox, 99% Token-Einsparung
`Bash cat/grep/find`	`mcx_file/mcx_grep/mcx_find`	Leitet Shell-Befehle an MCX um

Siehe Hooks Integration für Hook-Skripte.

Hauptmerkmale

Merkmal	Beschreibung
Lazy Loading	Adapter aus `~/.mcx/adapters/` werden beim Start metadaten-gescannt und bei der ersten Verwendung vollständig geladen
Domain-Hinweise	Adapter sind nach Domänen gruppiert (Zahlungen, Datenbank, E-Mail usw.) für bessere Auffindbarkeit
Stumme Autokorrektur	`executeSql` wird automatisch zu `execute_sql` korrigiert (camelCase zu snake_case)
Kontexteffizienz	Filterung erfolgt in der Sandbox, das Modell sieht nur die Ergebnisse
Variablen-Persistenz	Ergebnisse als `$invoices`, `$customers` für spätere Verwendung speichern
Auto-Kompression	Veraltete Variablen (>5min, >1KB) werden automatisch komprimiert, um Kontext zu sparen
FTS5-Suche	Große Ausgaben werden automatisch indiziert, Suche mit `intent`-Parameter
FFF-Integration	Fast File Finder - SIMD-beschleunigte Fuzzy-Suche, Inhalts-Grep
Hintergrundaufgaben	`mcx_spawn` für lang laufende Operationen, Überprüfung mit `mcx_tasks`
Batch-Operationen	`mcx_batch` für mehrere Operationen in einem Aufruf
Dateiverarbeitung	`mcx_file` zur Verarbeitung lokaler Dateien mit `$file`-Injektion
Große Dateiverarbeitung	Dateien >50KB bleiben via `storeAs` in der Sandbox, Abfrage mit Hilfsmitteln
Dateibearbeitung	`mcx_edit` (String-/Zeilen-Modi), `mcx_write` - keine "Read first"-Anforderung
Datei-Abfrage-Helfer	`around()`, `lines()`, `block()`, `grep()`, `outline()` für gespeicherte Dateien
URL-Abruf	`mcx_fetch` mit HTML-zu-Markdown-Konvertierung (24h TTL-Cache)
Kontrollfluss	Schleifen, Bedingungen, Wiederholungsversuche laufen als nativer Code
Datenschutz	Zwischenergebnisse bleiben in der Sandbox
Sicherheit	Netzwerkisolierung, Schutz vor Pfad-Traversal, Verhinderung von Env-Injektion

MCP-Tools

Tool	Beschreibung
`mcx_execute`	Code mit Adapterzugriff ausführen, speichert automatisch als `$result`
`mcx_search`	3 Modi: Spezifikationserkundung, FTS5-Suche, Adapter-/Methodensuche
`mcx_batch`	Mehrere Ausführungen/Suchen in einem Aufruf (umgeht Drosselung)
`mcx_file`	Lokale Dateien mit `$file`-Injektion verarbeiten oder Nur-Speicher-Modus mit `storeAs`
`mcx_edit`	Dateien bearbeiten (String- oder Zeilenmodus) - umgeht die Leseanforderung von nativem Edit
`mcx_write`	Dateien erstellen/überschreiben - umgeht die Leseanforderung von nativem Write
`mcx_fetch`	URLs mit HTML-zu-Markdown und automatischer Indizierung abrufen (24h Cache)
`mcx_find`	Schnelle Fuzzy-Dateisuche mit Frecency + Proximity-Ranking
`mcx_grep`	SIMD-beschleunigte Inhaltssuche über Dateien hinweg
`mcx_related`	Verwandte Dateien durch Import-/Export-Analyse finden
`mcx_tree`	Große JSON-Ergebnisse navigieren, ohne den vollständigen Inhalt zu laden
`mcx_spawn`	Code im Hintergrund ausführen, gibt sofort Task-ID zurück
`mcx_tasks`	Hintergrundaufgaben und deren Ergebnisse auflisten/überprüfen
`mcx_list`	Verfügbare Adapter und Skills auflisten
`mcx_stats`	Sitzungsstatistiken (indizierter Inhalt, Variablen, Netzwerk)
`mcx_doctor`	Diagnosen ausführen (Bun, SQLite, Adapter, Sandbox, FFF)
`mcx_upgrade`	Befehl für Selbst-Upgrade auf die neueste Version abrufen
`mcx_run_skill`	Einen registrierten Skill ausführen

CLI-Befehle

Befehl	Beschreibung
`mcx serve`	MCP-Server starten (Standard)
`mcx gen`	Adapter aus OpenAPI-Spezifikationen generieren (mit TUI)
`mcx init`	Globales `~/.mcx/`-Verzeichnis initialisieren
`mcx update`	CLI und globale Installation aktualisieren
`mcx list`	Verfügbare Adapter und Skills auflisten
`mcx run`	Einen Skill direkt ausführen
`mcx logs`	Server-Logs anzeigen

Siehe CLI-Dokumentation für Details.

Enthaltene Adapter

Adapter	Methoden	Beschreibung
`supabase`	24	Supabase Management API (Projekte, Tabellen, Funktionen, Secrets)
`chrome-devtools`	25	Chrome DevTools Protocol (Screenshots, Navigation, DOM)

Generieren Sie Ihre eigenen Adapter aus OpenAPI-Dokumenten:

mcx gen ./api-docs.md -n myapi

Eingebaute Helfer

Funktionen, die in der Sandbox verfügbar sind:

pick(data, ['id', 'name'])     // Extract fields
first(data, 5)                  // First N items
sum(data, 'amount')             // Sum numeric field
count(data, 'status')           // Count by field
table(data, 10)                 // Markdown table

// Async helpers
await poll(fn, { interval: 2000, maxIterations: 5 })  // Poll until done
await waitFor(fn, { timeout: 30000 })                  // Wait for condition

Datei-Abfrage-Helfer

Bei Verwendung von mcx_file({ path, storeAs }) zum Laden von Dateien in die Sandbox:

// Load file without returning content to context (99% token savings)
mcx_file({ path: "src/large-file.ts", storeAs: "src" })

// Then query with helpers:
around($src, 150, 10)          // 10 lines around line 150
lines($src, 100, 120)          // Get lines 100-120 (1-indexed, inclusive)
block($src, 150)               // Extract code block by indentation
grep($src, "TODO", 3)          // Search with 3 lines context
outline($src)                  // Extract function/class signatures

Dokumentation

CLI-Befehle - Detaillierte Befehlsreferenz
Adapter - Erstellen und Generieren von Adaptern
Skills - Wiederverwendbare Operationen
Konfiguration - Referenz der Konfigurationsdatei
Programmatische API - MCX im Code verwenden
Sicherheit - Sandbox-Sicherheitsebenen

Entwicklung

git clone https://github.com/schizoidcock/mcx
cd mcx
bun install
bun run build

Lizenz

MIT

MCX (Modular Code Execution)