mcpcodeserver

mcpcodeserver

Ein Model Context Protocol (MCP) Proxy-Server, der Werkzeugaufrufe in TypeScript-Codegenerierung übersetzt. Anstatt mehrere Werkzeugaufrufe hin und her zu senden, können LLMs TypeScript-Code schreiben, der mehrere Werkzeuge auf natürliche Weise aufruft, wodurch der Token-Overhead reduziert und die überlegenen Codegenerierungsfähigkeiten des LLM genutzt werden.

❌ Ohne mcpcodeserver

LLMs führen mehrere sequenzielle Werkzeugaufrufe durch, verbrauchen Tokens und haben Schwierigkeiten mit komplexen Arbeitsabläufen:

• ❌ Mehrere Roundtrips zwischen LLM und Werkzeugen
• ❌ Komplexe Werkzeugaufrufsequenzen sind fehleranfällig
• ❌ Daten können nicht einfach zwischen Werkzeugen übergeben werden
• ❌ Eingeschränkte Fehlerbehandlung und Ablaufsteuerung

✅ Mit mcpcodeserver

LLMs schreiben TypeScript-Code, der mehrere Werkzeuge auf natürliche Weise aufruft:

• ✅ Code schreiben, um mehrere Werkzeuge nacheinander aufzurufen
• ✅ Variablen, Schleifen und Bedingungen auf natürliche Weise verwenden
• ✅ Bessere Fehlerbehandlung mit try/catch
• ✅ Token-Verbrauch durch Kombinieren von Operationen reduzieren
• ✅ Die starken Codegenerierungsfähigkeiten des LLM nutzen

Schnellstart

1. Installieren Sie mcpcodeserver in Ihrem MCP-Client (siehe Installationsabschnitt unten)
2. Erstellen Sie eine mcp.json-Konfigurationsdatei mit Ihren untergeordneten MCP-Servern
3. Beginnen Sie mit der Nutzung – Ihr LLM kann nun TypeScript-Code generieren und ausführen, der Ihre Werkzeuge aufruft

// Instead of multiple tool calls, write code like this:
const files = await filesystem.list_directory({ path: "/tmp" });
const results = await Promise.all(
  files.map(file => filesystem.read_file({ path: file.path }))
);
return results.filter(content => content.includes("important"));

Überblick

mcpcodeserver ist ein einzigartiger MCP-Server, der:

• Als MCP-Client fungiert, um sich mit einem oder mehreren untergeordneten MCP-Servern zu verbinden
• Alle Werkzeuge von untergeordneten Servern entdeckt
• Übergeordneten LLM-Clients drei leistungsstarke Werkzeuge zur Verfügung stellt:
  1. list_servers – Listet alle verfügbaren Unterserver auf, die mit diesem MCP-Server verbunden sind
  2. get_tool_definitions – Gibt TypeScript-Typdefinitionen für entdeckte Werkzeuge zurück (optional nach Server filterbar)
  3. generate_and_execute_code – Generiert und führt TypeScript-Code aus, der diese Werkzeuge in einer Sandbox aufruft

Diese Architektur ermöglicht es LLMs, komplexe Multi-Werkzeug-Workflows zu orchestrieren, indem sie Code schreiben, anstatt sequenzielle Werkzeugaufrufe zu tätigen, was für moderne Sprachmodelle oft effizienter und natürlicher ist.

Verwandte Arbeiten & Forschung

Dieser Ansatz ist inspiriert von aktuellen Forschungsergebnissen, die zeigen, dass LLMs besser abschneiden, wenn sie ausführbaren Code generieren, anstatt direkte Werkzeugaufrufe zu tätigen:

• CodeAct: Your LLM Agent Acts Better when Generating Code (Apple, ICML 2024) – Zeigt, dass LLM-Agenten bis zu 20 % höhere Erfolgsraten erzielen, wenn sie ausführbaren Python-Code als einheitlichen Aktionsraum anstelle von vordefinierten Werkzeugaufrufformaten verwenden.

• Cloudflare Code Mode – Eine ähnliche Implementierung, die MCP-Werkzeuge in TypeScript-APIs umwandelt und zeigt, dass „LLMs besser darin sind, Code zum Aufrufen von MCP zu schreiben, als MCP direkt aufzurufen.“

Die zentrale Erkenntnis aus dieser Forschung ist, dass LLMs umfangreich mit realem Code trainiert wurden, aber nur begrenzt mit synthetischen Werkzeugaufrufformaten in Berührung kamen, was die Codegenerierung zu einem natürlicheren und effektiveren Ansatz für komplexe Agenten-Workflows macht.

Warum dies nutzen?

Traditionelle Probleme bei Werkzeugaufrufen

• Mehrere Roundtrips zwischen LLM und Werkzeugen verbrauchen Tokens
• LLMs haben oft Schwierigkeiten mit komplexen Werkzeugaufrufsequenzen
• Jeder Werkzeugaufruf erfordert Verständnis und Formatierung des JSON-Schemas
• Daten können nicht einfach zwischen Werkzeugen übergeben werden, ohne das LLM zu durchlaufen

Lösung durch Codegenerierung

• TypeScript-Code schreiben, um mehrere Werkzeuge nacheinander aufzurufen
• Variablen, Schleifen und Bedingungen auf natürliche Weise verwenden
• Bessere Fehlerbehandlung mit try/catch
• Token-Verbrauch durch Kombinieren von Operationen reduzieren
• Die starken Codegenerierungsfähigkeiten des LLM nutzen

Dynamische Werkzeugerkennung

mcpcodeserver überwacht automatisch untergeordnete MCP-Server auf Werkzeugänderungen und benachrichtigt übergeordnete Clients, wenn Werkzeuge hinzugefügt, entfernt oder geändert werden:

• Automatische Aktualisierung: Überprüft alle 30 Sekunden auf Werkzeugänderungen
• Echtzeit-Benachrichtigungen: Sendet notifications/tools/list_changed an übergeordnete Clients
• Dynamische Updates: Werkzeugdefinitionen und Zusammenfassungen werden automatisch aktualisiert
• Keine manuelle Aktualisierung: Übergeordnete LLMs erhalten Benachrichtigungen, um ihr Werkzeugwissen zu aktualisieren

Dies stellt sicher, dass übergeordnete LLMs stets die aktuellsten Werkzeugdefinitionen haben, ohne dass ein manuelles Eingreifen erforderlich ist.

Server-Filterung

Um die Nutzung des Kontextfensters zu reduzieren und die Fokussierung zu verbessern, unterstützt mcpcodeserver die Filterung von Werkzeugdefinitionen nach bestimmten Servern:

• Verfügbare Server auflisten: Verwenden Sie list_servers, um alle verbundenen Unterserver anzuzeigen
• Gefilterte Werkzeugdefinitionen: Verwenden Sie get_tool_definitions mit dem Parameter server_names, um nur Werkzeuge von bestimmten Servern zu erhalten
• Reduzierte Ausführlichkeit: Erhalten Sie fokussierte TypeScript-Definitionen, ohne das Kontextfenster des LLM zu überfordern
• Methoden-Namensräume: Alle generierten Funktionen werden mit Servernamen als Präfix versehen (z. B. pizzashop_create_pizza, filesystem_read_file)

Beispielverwendung:

// List available servers
const servers = await list_servers({});
// Returns: ["pizzashop", "filesystem", "memory"]

// Get all tool definitions
const allTools = await get_tool_definitions({});

// Get only pizzashop tools
const pizzashopTools = await get_tool_definitions({
  server_names: ["pizzashop"]
});

Erweiterte MCP-Funktionen

mcpcodeserver unterstützt die Durchleitung erweiterter MCP-Protokollfunktionen, wenn sowohl übergeordnete als auch untergeordnete Server diese unterstützen:

• Elicitation: Untergeordnete Server können während der Werkzeugausführung Benutzereingaben anfordern, die an übergeordnete Clients weitergeleitet werden
• Roots: Listet und aggregiert Roots von allen untergeordneten Servern und bietet eine einheitliche Ansicht der verfügbaren Ressourcen
• Sampling: Ermöglicht die Weiterleitung von LLM-Sampling-Anfragen an untergeordnete Server für erweiterte KI-Fähigkeiten

Diese Funktionen werden übergeordneten Clients automatisch angeboten und funktionieren nahtlos, wenn sie von den zugrunde liegenden untergeordneten MCP-Servern unterstützt werden.

Schnellstart

Sofort mit npx ausprobieren (keine Installation erforderlich):

# From GitHub
npx github:zbowling/mcpcodeserver --help

# Or when published to npm
npx mcpcodeserver --help

🛠️ Installation

Voraussetzungen

• Node.js >= v18.0.0
• Cursor, Claude Code, VSCode, Windsurf oder ein anderer MCP-Client

Installation über Smithery

Um mcpcodeserver automatisch für jeden Client über Smithery zu installieren:

npx -y @smithery/cli@latest install mcpcodeserver --client <client-name> --key <smithery-key>

In Cursor installieren

Gehen Sie zu: Settings -> Cursor Settings -> MCP -> Add new global MCP server

Das Einfügen der folgenden Konfiguration in Ihre Cursor-~/.cursor/mcp.json-Datei ist der empfohlene Ansatz. Sie können die Installation auch in einem bestimmten Projekt vornehmen, indem Sie .cursor/mcp.json in Ihrem Projektordner erstellen.

Cursor Ein-Klick-Installation

Cursor Lokale Serververbindung

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Cursor Remote-Serververbindung (wenn Sie HTTP-Transport eingerichtet haben)

{
  "mcpServers": {
    "mcpcodeserver": {
      "url": "http://localhost:3000/mcp"
    }
  }
}

In Claude Code installieren

Führen Sie diesen Befehl aus. Weitere Informationen finden Sie in der Claude Code MCP-Dokumentation.

Claude Code Lokale Serververbindung

claude mcp add mcpcodeserver -- npx -y mcpcodeserver --config /path/to/your/mcp.json

Claude Code Remote-Serververbindung

claude mcp add --transport http mcpcodeserver http://localhost:3000/mcp

In VSCode installieren

VSCode Ein-Klick-Installation

VSCode Manuelle Konfiguration

Fügen Sie zu Ihren VSCode MCP-Einstellungen hinzu:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

In Windsurf installieren

Windsurf Ein-Klick-Installation

In KI-Codierungsassistenten installieren

Für Continue, Cline und RooCode fügen Sie zu Ihrer Konfiguration hinzu:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

In Amp installieren

Führen Sie diesen Befehl in Ihrem Terminal aus. Weitere Informationen finden Sie in der Amp MCP-Dokumentation.

amp mcp add mcpcodeserver -- npx -y mcpcodeserver --config /path/to/your/mcp.json

In Texteditoren installieren

Für Aider, Codium, Zed, Nova und Sublime Text fügen Sie zu Ihrer Konfiguration hinzu:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

In Neovim installieren

Fügen Sie zu Ihrer Neovim MCP-Konfiguration hinzu:

{
  mcpServers = {
    mcpcodeserver = {
      command = "npx",
      args = {"-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"}
    }
  }
}

In Emacs installieren

Fügen Sie zu Ihrer Emacs MCP-Konfiguration hinzu:

(setq mcp-servers
      '((mcpcodeserver
         :command "npx"
         :args ("-y" "mcpcodeserver" "--config" "/path/to/your/mcp.json"))))

In JetBrains-IDEs installieren

Für IntelliJ IDEA, WebStorm, PyCharm und Android Studio fügen Sie zu Ihren MCP-Einstellungen hinzu:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

In KI-Tools installieren

Für Codeium, Tabnine, GitHub Copilot und Amazon CodeWhisperer fügen Sie zu Ihren MCP-Einstellungen hinzu:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

In Cloud-IDEs installieren

Für Replit, CodeSandbox, StackBlitz, GitPod, GitHub Codespaces, GitLab Web IDE und Bitbucket Cloud fügen Sie zu Ihren MCP-Einstellungen hinzu:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

In anderen Tools installieren

Für Xcode, Fleet, Sourcegraph und JetBrains Gateway fügen Sie zu Ihrer MCP-Konfiguration hinzu:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

In Remote-Entwicklungsumgebungen installieren

Für Remote-Entwicklungsumgebungen können Sie auch HTTP-Transport verwenden:

{
  "mcpServers": {
    "mcpcodeserver": {
      "url": "http://your-server:3000/mcp"
    }
  }
}

Konfigurationsdatei

Erstellen Sie eine mcp.json-Konfigurationsdatei, um Ihre untergeordneten MCP-Server zu definieren:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      "env": { "DEBUG": "false" }
    },
    "memory": {
      "command": "npx", 
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": { "BRAVE_API_KEY": "your-api-key" }
    }
  }
}

Installation für die Entwicklung

# Install dependencies (using Bun for faster performance)
bun install

# Or with npm
npm install

# Build the project
bun run build

# Test the built server
bun dist/index.js --help

Hinweis: Dieses Projekt verwendet Bun für eine bessere Leistung, aber npm/node funktionieren ebenfalls einwandfrei.

🚨 Fehlerbehebung

Modul nicht gefunden Fehler

Wenn Sie auf ERR_MODULE_NOT_FOUND stoßen, versuchen Sie, bunx anstelle von npx zu verwenden:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "bunx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

ESM-Auflösungsprobleme

Bei Fehlern wie Error: Cannot find module versuchen Sie das Flag --experimental-vm-modules:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "--node-options=--experimental-vm-modules", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

TLS/Zertifikatsprobleme

Verwenden Sie das Flag --experimental-fetch, um TLS-bezogene Probleme zu umgehen:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "--node-options=--experimental-fetch", "mcpcodeserver", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Allgemeine MCP-Client-Fehler

1. Versuchen Sie, @latest zum Paketnamen hinzuzufügen
2. Verwenden Sie bunx als Alternative zu npx
3. Ziehen Sie deno als weitere Alternative in Betracht
4. Stellen Sie sicher, dass Sie Node.js v18 oder höher für native Fetch-Unterstützung verwenden

Konfigurationsprobleme

• Stellen Sie sicher, dass Ihre mcp.json-Datei gültiges JSON ist
• Überprüfen Sie, ob alle untergeordneten Serverbefehle in Ihrem PATH verfügbar sind
• Vergewissern Sie sich, dass untergeordnete Server unabhängig gestartet werden können
• Überprüfen Sie die Dateiberechtigungen für den Konfigurationsdateipfad

Testen mit MCP Inspector

npx -y @modelcontextprotocol/inspector npx mcpcodeserver --config /path/to/your/mcp.json

💻 Entwicklung

CLI-Argumente

mcpcodeserver akzeptiert die folgenden CLI-Flags:

• --config <path> – Pfad zur MCP-Konfigurationsdatei (Standard: ./mcp.json)
• --transport <stdio|http> – Zu verwendender Transport (standardmäßig stdio). Beachten Sie, dass der HTTP-Transport automatisch sowohl HTTP- als auch SSE-Endpunkte bereitstellt
• --port <number> – Port, auf dem bei Verwendung des http-Transports gelauscht wird (Standard 3000)
• --help – Hilfe-Nachricht anzeigen

Beispiel mit HTTP-Transport und Port 8080:

npx mcpcodeserver --config /path/to/mcp.json --transport http --port 8080

Beispiel mit stdio-Transport:

npx mcpcodeserver --config /path/to/mcp.json --transport stdio

Umgebungsvariablen

Sie können Umgebungsvariablen für die Konfiguration verwenden:

• MCP_CONFIG_PATH – Pfad zur MCP-Konfigurationsdatei (Alternative zu --config)
• MCP_TRANSPORT – Transporttyp (Alternative zu --transport)
• MCP_PORT – Portnummer für HTTP-Transport (Alternative zu --port)

Beispiel mit Umgebungsvariablen:

# .env
MCP_CONFIG_PATH=/path/to/your/mcp.json
MCP_TRANSPORT=stdio

Beispiel-MCP-Konfiguration mit Umgebungsvariablen:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver"],
      "env": {
        "MCP_CONFIG_PATH": "/path/to/your/mcp.json"
      }
    }
  }
}

Hinweis: CLI-Flags haben Vorrang vor Umgebungsvariablen, wenn beide angegeben sind.

Lokale Entwicklungskonfiguration

Für die lokale Entwicklung können Sie den TypeScript-Quellcode direkt ausführen:

{
  "mcpServers": {
    "mcpcodeserver": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcpcodeserver/src/index.ts", "--config", "/path/to/your/mcp.json"]
    }
  }
}

Ausführungsmodi

Stdio-Modus (Standard)

Der Server läuft standardmäßig im Stdio-Modus, was ideal für die Integration mit MCP-Clients wie Claude Desktop ist:

# Run in stdio mode
npx mcpcodeserver --config mcp.json

# Or with custom config path
npx mcpcodeserver --config /path/to/your/mcp.json

HTTP-Modus

Zum Debuggen, Testen oder zur Integration mit webbasierten MCP-Clients können Sie den Server im HTTP-Modus ausführen:

# Run in HTTP mode on default port 3000
npx mcpcodeserver --http --config mcp.json

# Run on custom port and host
npx mcpcodeserver --http --port 8080 --host 0.0.0.0 --config mcp.json

Im HTTP-Modus ist der Server verfügbar unter:

• Server-URL: http://localhost:3000/mcp (oder Ihr benutzerdefinierter Host:Port)
• MCP Inspector: Verwenden Sie npx @modelcontextprotocol/inspector http://localhost:3000/mcp zum Debuggen und Testen

MCP Inspector Integration

Der MCP Inspector ist ein leistungsstarkes Werkzeug zum Debuggen und Testen von MCP-Servern. Im HTTP-Modus können Sie ihn verwenden, um:

• Verfügbare Werkzeuge und ihre Schemas zu inspizieren
• Werkzeugaufrufe interaktiv zu testen
• Ressourcenzugriff und Prompts zu debuggen
• Echtzeit-Benachrichtigungen zu überwachen

# Start the server in HTTP mode
npx mcpcodeserver --http --config mcp.json

# In another terminal, start the MCP Inspector
npx @modelcontextprotocol/inspector http://localhost:3000/mcp

# Or use the shorthand script (includes all example servers)
npm run inspector

Der Inspector öffnet sich in Ihrem Browser und bietet eine vollständige Oberfläche zum Erkunden und Testen Ihres MCP-Servers.

Hinweis: Der Befehl npm run inspector verwendet mcp-test.json, das 8 MCP-Server (insgesamt 67 Werkzeuge) aus den offiziellen Beispielen enthält, einschließlich sowohl TypeScript- (npx) als auch Python-basierter (uvx) Server.

Konfiguration

Erstellen Sie eine mcp.json-Datei, die definiert, mit welchen untergeordneten MCP-Servern eine Verbindung hergestellt werden soll. Diese folgt dem standardmäßigen MCP-Client-Konfigurationsformat:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
      "env": {
        "DEBUG": "false"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    },
    "weather": {
      "url": "http://localhost:3000/mcp",
      "transport": "sse"
    }
  }
}

Konfigurationsoptionen

Jeder Servereintrag unterstützt:

Für stdio-Transport:

• command (erforderlich) – Der auszuführende Befehl (z. B. "node", "python", "npx")
• args (optional) – Array von Argumenten, die dem Befehl übergeben werden
• env (optional) – Umgebungsvariablen für den Kindprozess

Für HTTP/SSE-Transport:

• url (erforderlich) – Die HTTP-Endpunkt-URL
• transport – Auf "sse" setzen für Server-Sent Events

Verwendung

Starten des Servers

# Use default config (./mcp.json)
mcpcodeserver

# Use custom config location
mcpcodeserver --config /path/to/custom-mcp.json

# Show help
mcpcodeserver --help

Verwendung als MCP-Server

Konfigurieren Sie mcpcodeserver in Ihrem MCP-Client (wie Claude Desktop, Claude Code, Cline usw.):

Mit npx (empfohlen – keine Installation erforderlich):

{
  "mcpServers": {
    "codeserver": {
      "command": "npx",
      "args": ["-y", "mcpcodeserver", "--config", "/path/to/mcp.json"]
    }
  }
}

Von GitHub (funktioniert sofort):

{
  "mcpServers": {
    "codeserver": {
      "command": "npx",
      "args": ["-y", "github:zbowling/mcpcodeserver", "--config", "/path/to/mcp.json"]
    }
  }
}

Mit anderen Paketmanagern:

// yarn
{ "command": "yarn", "args": ["dlx", "mcpcodeserver", "--config", "/path/to/mcp.json"] }

// pnpm
{ "command": "pnpm", "args": ["dlx", "mcpcodeserver", "--config", "/path/to/mcp.json"] }

// bun
{ "command": "bunx", "args": ["mcpcodeserver", "--config", "/path/to/mcp.json"] }

Siehe examples/ für weitere Konfigurationsbeispiele und MCP-Client-spezifische Einrichtungen.

Werkzeug 1: get_tool_definitions

Dieses Werkzeug gibt TypeScript-Typdefinitionen für alle entdeckten Werkzeuge von untergeordneten Servern zurück.

Eingabe:

• include_examples (optionaler Boolean) – Ob Nutzungsbeispiele enthalten sein sollen

Beispiel:

// Call the tool (in your MCP client)
get_tool_definitions({ include_examples: true })

Ausgabe: Gibt TypeScript-Code mit Schnittstellen und Funktionsdeklarationen zurück:

/**
 * Auto-generated TypeScript definitions for MCP tools
 */

interface ToolResult {
  content: Array<{
    type: string;
    text?: string;
    // ...
  }>;
  isError?: boolean;
}

/**
 * Read contents of a file
 * Server: filesystem
 * Tool: read_file
 */
interface ReadFileParams {
  path: string;
}

declare function filesystem_read_file(params: ReadFileParams): Promise<ToolResult>;

// ... more tool definitions

Werkzeug 2: generate_and_execute_code

Dieses Werkzeug führt TypeScript-Code in einer Sandbox mit Zugriff auf alle entdeckten Werkzeugfunktionen aus.

Eingabe:

• code (erforderlicher String) – Auszuführender TypeScript-/JavaScript-Code
• timeout (optionale Zahl) – Maximale Ausführungszeit in Millisekunden (Standard: 30000, Maximum: 300000)

Beispiel:

// Call the tool with TypeScript code
generate_and_execute_code({
  code: `
    // Read multiple files and combine them
    const file1 = await filesystem_read_file({ path: "/tmp/file1.txt" });
    const file2 = await filesystem_read_file({ path: "/tmp/file2.txt" });

    const text1 = file1.content[0].text;
    const text2 = file2.content[0].text;

    console.log("File 1 length:", text1.length);
    console.log("File 2 length:", text2.length);

    return {
      combined: text1 + text2,
      totalLength: text1.length + text2.length
    };
  `
})

Ausgabe:

=== Console Output ===
File 1 length: 42
File 2 length: 38

=== Result ===
{
  "combined": "...",
  "totalLength": 80
}

Sandbox-Umgebung

Die TypeScript-Ausführungs-Sandbox bietet:

Verfügbar:

• Alle entdeckten Werkzeugfunktionen (als asynchrone Funktionen)
• Konsolenmethoden: console.log(), console.error(), console.warn(), console.info()
• Grundlegende JavaScript-Globals: Math, JSON, Date, Array, Object, String, Number, Boolean
• Promise- und async/await-Unterstützung
• Fehlerbehandlung mit try/catch
• Timer: setTimeout, setInterval, clearTimeout, clearInterval

Nicht verfügbar:

• Node.js-Module (fs, http, child_process usw.)
• Dateisystemzugriff (außer über MCP-Werkzeuge)
• Netzwerkzugriff (außer über MCP-Werkzeuge)
• Prozessinformationen

Sicherheitshinweis: Dies ist keine vollständig sichere Sandbox. Der VM-Kontext bietet Isolation, ist aber nicht unüberwindbar. Führen Sie nur vertrauenswürdigen Code aus.

Fehlerbehandlung

Fehler in der Sandbox werden abgefangen und mit Stack-Traces zurückgegeben:

generate_and_execute_code({
  code: `
    try {
      const result = await filesystem_read_file({ path: "/nonexistent" });
      return result;
    } catch (error) {
      console.error("Failed to read file:", error.message);
      throw error; // Re-throw to surface to parent
    }
  `
})

Testen mit Claude Code

Möchten Sie mcpcodeserver mit Claude Code ausprobieren? Verwenden Sie das Ein-Befehl-Setup:

./setup-claude-code-test.sh

Dies baut das Projekt, installiert Testabhängigkeiten und zeigt Ihnen genau, was Sie zu Ihrer Claude-Code-Konfiguration hinzufügen müssen. Siehe TESTING_WITH_CLAUDE.md für detaillierte Anweisungen.

Entwicklung

# Install dependencies
bun install

# Build the project
bun run build

# Watch mode for development
bun run dev

# Run the server
bun start

# Run tests
bun test                # All tests
bun run test:unit       # Unit tests only
bun run test:integration # Integration tests (requires Python)

# Code quality
bun run lint            # Check linting
bun run format          # Format code
bun run typecheck       # Type checking

Projektstruktur

Siehe AGENTS.md für detaillierte Projektstruktur und Komponentendokumentation.

Anwendungsfälle

Multi-Datei-Operationen

Anstatt mehrere Werkzeugaufrufe über das LLM zu tätigen, schreiben Sie Code:

const files = ["/tmp/a.txt", "/tmp/b.txt", "/tmp/c.txt"];
const contents = await Promise.all(
  files.map(path => filesystem_read_file({ path }))
);
return contents.map(r => r.content[0].text);

Datentransformation

Verarbeiten Sie Daten zwischen Werkzeugaufrufen ohne LLM-Eingriff:

const data = await api_fetch({ url: "https://api.example.com/data" });
const json = JSON.parse(data.content[0].text);
const filtered = json.items.filter(item => item.active);
return filtered.length;

Bedingte Logik

Treffen Sie Entscheidungen basierend auf Werkzeugergebnissen:

const exists = await filesystem_read_file({ path: "/tmp/config.json" });
if (exists.isError) {
  console.log("Config doesn't exist, using defaults");
  return { source: "defaults" };
} else {
  return { source: "file", config: JSON.parse(exists.content[0].text) };
}

Fehlerbehebung

Behandeln Sie Fehler elegant, ohne den gesamten Arbeitsablauf abzubrechen:

const results = [];
for (const path of ["/tmp/a.txt", "/tmp/b.txt", "/tmp/c.txt"]) {
  try {
    const content = await filesystem_read_file({ path });
    results.push({ path, success: true, data: content });
  } catch (error) {
    results.push({ path, success: false, error: error.message });
  }
}
return results;

Integration von Upstream-MCP-Servern

mcpcodeserver kann mit offiziellen Upstream-MCP-Servern aus dem Model Context Protocol servers repository integriert werden. Dies ermöglicht Ihnen die Nutzung echter, produktionsreifer MCP-Server neben Ihren benutzerdefinierten Werkzeugen.

Unterstützte Upstream-Server

• filesystem: Dateisystemoperationen (Lesen, Schreiben, Verzeichnisse auflisten)
• memory: In-Memory-Schlüssel-Wert-Speicher
• sqlite: SQLite-Datenbankoperationen
• github: GitHub-API-Integration
• brave-search: Websuchfunktionen
• fetch: HTTP-Anfragefunktionen

Beispielkonfiguration

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "/tmp/test.db"]
    }
  }
}

Testen der Upstream-Integration

Das Projekt enthält umfassende Tests für die Upstream-Server-Integration:

# Run upstream servers integration tests
bun tests/integration/run-upstream-tests.ts

# Or manually test with upstream config
npx mcpcodeserver --config tests/integration/upstream-test-config.json

Serverübergreifende Arbeitsabläufe

Mit Upstream-Servern können Sie leistungsstarke serverübergreifende Arbeitsabläufe erstellen:

// Store database query results in memory and write to file
const queryResult = await sqlite_execute_sql({
  sql: "SELECT COUNT(*) as count FROM users"
});
const count = queryResult.content[0].text;

await memory_create({
  key: "user-count",
  value: count
});

await filesystem_write_file({
  path: "/tmp/user-count.txt",
  content: `Total users: ${count}`
});

Einschränkungen

• Ausführungszeitlimit: Maximal 5 Minuten (konfigurierbar, Standard 30 Sekunden)
• Speicher: Begrenzt durch den Node.js-VM-Kontext
• Kein persistenter Zustand zwischen Ausführungen
• Kein require/import externer Module
• Keine Sicherheitssandbox – führen Sie keinen nicht vertrauenswürdigen Code aus

Mitwirken

Beiträge sind willkommen! Dieses Projekt wurde erstellt mit:

• TypeScript 5.7+
• Node.js 18+
• MCP TypeScript SDK 1.20+
• Zod zur Validierung

Siehe CONTRIBUTING.md für detaillierte Beitragsrichtlinien.

Unterstützung

Wenn Sie dieses Projekt hilfreich finden, spendieren Sie mir doch einen Kaffee!

Lizenz

MIT

Ressourcen

• Model Context Protocol Specification
• MCP TypeScript SDK
• MCP Servers List