MCP-Code-Executor

Der MCP Code Executor ist ein MCP-Server, der es LLMs ermöglicht, Python-Code in einer festgelegten Python-Umgebung auszuführen. Dadurch können LLMs Code mit Zugriff auf die in der Umgebung definierten Bibliotheken und Abhängigkeiten ausführen. Er unterstützt außerdem die inkrementelle Codegenerierung für die Verarbeitung großer Codeblöcke, die Token-Limits überschreiten können.

Merkmale

Ausführen von Python-Code aus LLM-Eingabeaufforderungen
Unterstützung für inkrementelle Codegenerierung zur Überwindung von Token-Einschränkungen
Führen Sie Code in einer angegebenen Umgebung aus (Conda, virtualenv oder UV virtualenv).
Installieren Sie Abhängigkeiten bei Bedarf
Überprüfen Sie, ob Pakete bereits installiert sind
Dynamisches Konfigurieren der Umgebung zur Laufzeit
Konfigurierbares Code-Speicherverzeichnis

Voraussetzungen

Node.js installiert
Eine der folgenden Möglichkeiten:
- Conda installiert und gewünschte Conda-Umgebung erstellt
- Python virtuelle Umgebung
- UV-virtuelle Umgebung

Aufstellen

Klonen Sie dieses Repository:

git clone https://github.com/bazinga012/mcp_code_executor.git

Navigieren Sie zum Projektverzeichnis:

cd mcp_code_executor

Installieren Sie die Node.js-Abhängigkeiten:

npm install

Erstellen Sie das Projekt:

npm run build

Konfiguration

Um den MCP Code Executor-Server zu konfigurieren, fügen Sie Ihrer MCP-Server-Konfigurationsdatei Folgendes hinzu:

Verwenden von Node.js

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

Verwenden von Docker

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

Hinweis: Das Dockerfile wurde nur mit dem Umgebungstyp venv-uv getestet. Für andere Umgebungstypen sind möglicherweise zusätzliche Konfigurationen erforderlich.

Umgebungsvariablen

Erforderliche Variablen

CODE_STORAGE_DIR : Verzeichnis, in dem der generierte Code gespeichert wird

Umgebungstyp (wählen Sie eine Konfiguration aus)

Für Conda:
- ENV_TYPE : Auf conda setzen
- CONDA_ENV_NAME : Name der zu verwendenden Conda-Umgebung
Für Standard-Virtualenv:
- ENV_TYPE : Auf venv setzen
- VENV_PATH : Pfad zum Virtualenv-Verzeichnis
Für UV Virtualenv:
- ENV_TYPE : Auf venv-uv einstellen
- UV_VENV_PATH : Pfad zum UV-Virtualenv-Verzeichnis

Verfügbare Tools

Der MCP Code Executor stellt LLMs die folgenden Tools zur Verfügung:

1. `execute_code`

Führt Python-Code in der konfigurierten Umgebung aus. Am besten für kurze Codeausschnitte geeignet.

{
  "name": "execute_code",
  "arguments": {
    "code": "import numpy as np\nprint(np.random.rand(3,3))",
    "filename": "matrix_gen"
  }
}

2. `install_dependencies`

Installiert Python-Pakete in der Umgebung.

{
  "name": "install_dependencies",
  "arguments": {
    "packages": ["numpy", "pandas", "matplotlib"]
  }
}

3. `check_installed_packages`

Überprüft, ob in der Umgebung bereits Pakete installiert sind.

{
  "name": "check_installed_packages",
  "arguments": {
    "packages": ["numpy", "pandas", "non_existent_package"]
  }
}

4. `configure_environment`

Ändert die Umgebungskonfiguration dynamisch.

{
  "name": "configure_environment",
  "arguments": {
    "type": "conda",
    "conda_name": "new_env_name"
  }
}

5. `get_environment_config`

Ruft die aktuelle Umgebungskonfiguration ab.

{
  "name": "get_environment_config",
  "arguments": {}
}

6. `initialize_code_file`

Erstellt eine neue Python-Datei mit anfänglichem Inhalt. Verwenden Sie dies als ersten Schritt für längeren Code, der möglicherweise die Token-Grenze überschreitet.

{
  "name": "initialize_code_file",
  "arguments": {
    "content": "def main():\n    print('Hello, world!')\n\nif __name__ == '__main__':\n    main()",
    "filename": "my_script"
  }
}

7. `append_to_code_file`

Fügt Inhalt an eine vorhandene Python-Codedatei an. Verwenden Sie diese Option, um einer mit initialize_code_file erstellten Datei weiteren Code hinzuzufügen.

{
  "name": "append_to_code_file",
  "arguments": {
    "file_path": "/path/to/code/storage/my_script_abc123.py",
    "content": "\ndef another_function():\n    print('This was appended to the file')\n"
  }
}

8. `execute_code_file`

Führt eine vorhandene Python-Datei aus. Verwenden Sie dies als letzten Schritt, nachdem Sie den Code mit initialize_code_file und append_to_code_file erstellt haben.

{
  "name": "execute_code_file",
  "arguments": {
    "file_path": "/path/to/code/storage/my_script_abc123.py"
  }
}

9. `read_code_file`

Liest den Inhalt einer vorhandenen Python-Codedatei. Verwenden Sie diese Option, um den aktuellen Status einer Datei zu überprüfen, bevor Sie weiteren Inhalt anhängen oder die Datei ausführen.

{
  "name": "read_code_file",
  "arguments": {
    "file_path": "/path/to/code/storage/my_script_abc123.py"
  }
}

Verwendung

Nach der Konfiguration ermöglicht der MCP Code Executor LLMs die Ausführung von Python-Code, indem er eine Datei im angegebenen CODE_STORAGE_DIR generiert und sie innerhalb der konfigurierten Umgebung ausführt.

LLMs können Code generieren und ausführen, indem sie in ihren Eingabeaufforderungen auf diesen MCP-Server verweisen.

Umgang mit großen Codeblöcken

Verwenden Sie für größere Codeblöcke, die möglicherweise die LLM-Token-Grenzen überschreiten, den Ansatz der inkrementellen Codegenerierung:

Initialisieren Sie eine Datei mit der Grundstruktur mithilfe von initialize_code_file
Fügen Sie in nachfolgenden Aufrufen mit append_to_code_fileweiteren Code hinzu
Überprüfen Sie den Dateiinhalt bei Bedarf mit read_code_file
Führen Sie den gesamten Code mit execute_code_file aus

Dieser Ansatz ermöglicht es LLMs, komplexen, mehrteiligen Code zu schreiben, ohne auf Token-Einschränkungen zu stoßen.

Abwärtskompatibilität

Dieses Paket ist abwärtskompatibel mit früheren Versionen. Benutzer früherer Versionen, die nur eine Conda-Umgebung angegeben haben, können ohne Änderungen an ihrer Konfiguration weiterarbeiten.

Beitragen

Beiträge sind willkommen! Bitte melden Sie ein Problem oder senden Sie einen Pull Request.

Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert.

Install Server

HTTP connection URL

security – no known vulnerabilities

license - permissive license

quality - confirmed to work

How are these scores calculated?

local-only server

The server can only run on the client's local machine because it depends on local resources.

Tools

execute_code

Ermöglicht LLMs, Python-Code in einer angegebenen Conda-Umgebung auszuführen und ermöglicht den Zugriff auf die erforderlichen Bibliotheken und Abhängigkeiten für eine effiziente Codeausführung.

Related Resources

Reddit Discussion about this server

Related MCP Servers

mcp-pyodide
yonaka15
A
security
A
license
A
quality
A Pyodide server for executing Python code by Large Language Models (LLMs) via the Model Context Protocol (MCP).
Last updated -
5
8
10
TypeScript
MIT License
Fused MCP Agentsofficial
fusedio
-
security
A
license
-
quality
A Python-based MCP server that allows Claude and other LLMs to execute arbitrary Python code directly through your desktop Claude app, enabling data scientists to connect LLMs to APIs and executable code.
Last updated -
23
MIT License
MCP Server for continue.dev
alexsmirnov
A
security
F
license
A
quality
A Python server implementing the Model Context Protocol to provide customizable prompt templates, resources, and tools that enhance LLM interactions in the continue.dev environment.
Last updated -
2
1
Python
MCP Python Interpreter
yzfly
A
security
F
license
A
quality
A Model Context Protocol server that allows LLMs to interact with Python environments, execute code, and manage files within a specified working directory.
Last updated -
9
42
Python

View all related MCP servers

MCP Code Executor