MCP Code Executor MCP Server

Was macht der “MCP Code Executor” MCP Server?

Der MCP Code Executor ist ein MCP (Model Context Protocol) Server, der Sprachmodellen (LLMs) erlaubt, Python-Code in einer bestimmten Python-Umgebung wie Conda, virtualenv oder UV-virtualenv auszuführen. Indem KI-Assistenten mit echten, ausführbaren Python-Umgebungen verbunden werden, können sie eine Vielzahl von Entwicklungsaufgaben erledigen, die Code-Ausführung, Bibliotheksmanagement und die dynamische Einrichtung von Umgebungen erfordern. Dieser Server unterstützt inkrementelle Codegenerierung, um Token-Limitierungen zu umgehen, ermöglicht die Installation von Abhängigkeiten im laufenden Betrieb und die Konfiguration der Ausführungsumgebung zur Laufzeit. Entwickler können dieses Tool nutzen, um Codebewertung zu automatisieren, mit neuen Paketen zu experimentieren und Berechnungen in einer kontrollierten und sicheren Umgebung zu verwalten.

Liste der Prompts

Im Repository oder in der Dokumentation sind keine expliziten Prompt-Vorlagen aufgeführt.

Bereit, Ihr Geschäft zu erweitern?

Starten Sie heute Ihre kostenlose Testversion und sehen Sie innerhalb weniger Tage Ergebnisse.

Demo anfragen Anmelden

Liste der Ressourcen

Im Repository oder in der Dokumentation sind keine spezifischen Ressourcen beschrieben.

Liste der Tools

• execute_code
  • Führt Python-Code in der konfigurierten Umgebung aus. Geeignet zum Ausführen von kurzen Codeschnipseln und Skripten.
• install_dependencies
  • Installiert angegebene Python-Pakete in der aktuellen Umgebung und ermöglicht so die dynamische Einbindung von Bibliotheken nach Bedarf.
• check_installed_packages
  • Prüft, welche Python-Pakete aktuell in der Umgebung installiert sind.

Abonnieren Sie unseren Newsletter

Erhalten Sie die neuesten Tipps, Trends und Angebote kostenlos.

E-Mail-Adresse

Abonnieren

Anwendungsfälle dieses MCP Servers

• Automatisierte Codebewertung
  • LLMs können Python-Codeschnipsel direkt ausführen und testen – hilfreich in Bildungs-, Review- oder Debugging-Kontexten.
• Dynamisches Abhängigkeitsmanagement
  • Installiert benötigte Pakete im laufenden Betrieb, sodass LLMs die Ausführungsumgebung für spezielle Aufgaben oder Bibliotheken anpassen können.
• Umgebungsisolation
  • Führt Code in isolierten Conda- oder virtualenv-Umgebungen aus. Dies gewährleistet Reproduzierbarkeit und verhindert Konflikte zwischen Abhängigkeiten.
• Inkrementelle Codegenerierung
  • Unterstützt inkrementelle Code-Ausführung, damit auch große Codeblöcke verarbeitet werden können, die die Token-Grenzen einer LLM-Antwort überschreiten würden.
• Data Science und Analyse
  • Ermöglicht KI-Agenten die Durchführung von Datenanalysen, das Ausführen von Simulationen oder das Visualisieren von Ergebnissen mit gängigen wissenschaftlichen Python-Bibliotheken.

Einrichtung

Windsurf

1. Stellen Sie sicher, dass Node.js installiert ist.
2. Klonen Sie das MCP Code Executor Repository und bauen Sie das Projekt.
3. Suchen Sie Ihre MCP-Server-Konfigurationsdatei.
4. Fügen Sie den MCP Code Executor Server mit folgendem JSON-Snippet hinzu:

   {
     "mcpServers": {
       "mcp-code-executor": {
         "command": "node",
         "args": [
           "/path/to/mcp_code_executor/build/index.js"
         ],
         "env": {
           "CODE_STORAGE_DIR": "/path/to/code/storage",
           "ENV_TYPE": "conda",
           "CONDA_ENV_NAME": "your-conda-env"
         }
       }
     }
   }
   

5. Speichern Sie die Datei und starten Sie Windsurf neu. Überprüfen Sie, ob der Server erreichbar ist.

API-Schlüssel absichern (Beispiel für Umgebungsvariablen)

{
  "mcpServers": {
    "mcp-code-executor": {
      "env": {
        "CODE_STORAGE_DIR": "/path/to/code/storage",
        "ENV_TYPE": "conda",
        "CONDA_ENV_NAME": "your-conda-env",
        "MY_SECRET_API_KEY": "${MY_SECRET_API_KEY}"
      },
      "inputs": {
        "apiKey": "${MY_SECRET_API_KEY}"
      }
    }
  }
}

Claude

1. Stellen Sie sicher, dass Node.js installiert ist.
2. Bauen Sie den MCP Code Executor gemäß den Repository-Anweisungen.
3. Öffnen Sie die Konfigurationsdatei für Claudes MCP-Server.
4. Fügen Sie die folgende Konfiguration ein:

   {
     "mcpServers": {
       "mcp-code-executor": {
         "command": "node",
         "args": [
           "/path/to/mcp_code_executor/build/index.js"
         ],
         "env": {
           "CODE_STORAGE_DIR": "/path/to/code/storage",
           "ENV_TYPE": "conda",
           "CONDA_ENV_NAME": "your-conda-env"
         }
       }
     }
   }
   

5. Speichern und starten Sie Claude neu. Überprüfen Sie, ob der Server aufgeführt ist.

Cursor

1. Installieren Sie Node.js.
2. Klonen und bauen Sie das MCP Code Executor Repository.
3. Bearbeiten Sie die MCP-Konfiguration von Cursor.
4. Fügen Sie Folgendes hinzu:

   {
     "mcpServers": {
       "mcp-code-executor": {
         "command": "node",
         "args": [
           "/path/to/mcp_code_executor/build/index.js"
         ],
         "env": {
           "CODE_STORAGE_DIR": "/path/to/code/storage",
           "ENV_TYPE": "conda",
           "CONDA_ENV_NAME": "your-conda-env"
         }
       }
     }
   }
   

5. Speichern und starten Sie Cursor neu. Testen Sie die Ausführung eines Beispielcodes.

Cline

1. Stellen Sie sicher, dass Node.js verfügbar ist.
2. Bauen Sie den MCP Code Executor gemäß der README-Anleitung.
3. Suchen Sie die Konfigurationsdatei für MCP-Server von Cline.
4. Fügen Sie Folgendes hinzu:

   {
     "mcpServers": {
       "mcp-code-executor": {
         "command": "node",
         "args": [
           "/path/to/mcp_code_executor/build/index.js"
         ],
         "env": {
           "CODE_STORAGE_DIR": "/path/to/code/storage",
           "ENV_TYPE": "conda",
           "CONDA_ENV_NAME": "your-conda-env"
         }
       }
     }
   }
   

5. Speichern und starten Sie Cline neu. Überprüfen Sie, ob der MCP Server aktiv ist.

Hinweis: Sie können auch Docker verwenden. Das bereitgestellte Dockerfile ist getestet für den Umgebungs-Typ venv-uv:

{
  "mcpServers": {
    "mcp-code-executor": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "mcp-code-executor"
      ]
    }
  }
}

Wie Sie dieses MCP in Flows nutzen

MCP in FlowHunt verwenden

Um MCP-Server in Ihren FlowHunt-Workflow zu integrieren, fügen Sie zunächst die MCP-Komponente zu Ihrem Flow hinzu und verbinden Sie diese mit Ihrem KI-Agenten:

Klicken Sie auf die MCP-Komponente, um das Konfigurationspanel zu öffnen. In der System-MCP-Konfiguration tragen Sie die Details Ihres MCP-Servers in folgendem JSON-Format ein:

{
  "mcp-code-executor": {
    "transport": "streamable_http",
    "url": "https://yourmcpserver.example/pathtothemcp/url"
  }
}

Nach der Konfiguration kann der KI-Agent dieses MCP als Tool mit Zugriff auf alle Funktionen und Fähigkeiten nutzen. Denken Sie daran, “mcp-code-executor” durch den tatsächlichen Namen Ihres MCP-Servers und die URL durch die Adresse Ihres eigenen MCP-Servers zu ersetzen.

Übersicht

Unsere Meinung

Dieser MCP Server bietet essenzielle und robuste Funktionalität für die Code-Ausführung mit LLM-Integration sowie klare Anleitungen zur Einrichtung und Tooling. Allerdings fehlen Prompt-Vorlagen, explizite Ressourcen und Informationen zu Roots oder Sampling Support. Für einen MCP mit Fokus auf Code-Ausführung ist er sehr solide, erzielt hohe Werte für praktische Nutzbarkeit und einfache Integration, verliert aber einige Punkte aufgrund fehlender fortgeschrittener MCP-Features und unvollständiger Dokumentation.

MCP Score