Skip to main content
Glama
MCP Code Executor

MCP Code Executor

MCP-Code-Executor

Schmiedeabzeichen

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

Related MCP server: MCP Python Interpreter

Voraussetzungen

  • Node.js installiert

  • Eine der folgenden Möglichkeiten:

    • Conda installiert und gewünschte Conda-Umgebung erstellt

    • Python virtuelle Umgebung

    • UV-virtuelle Umgebung

Aufstellen

  1. Klonen Sie dieses Repository:

git clone https://github.com/bazinga012/mcp_code_executor.git
  1. Navigieren Sie zum Projektverzeichnis:

cd mcp_code_executor
  1. Installieren Sie die Node.js-Abhängigkeiten:

npm install
  1. 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:

  1. Initialisieren Sie eine Datei mit der Grundstruktur mithilfe von initialize_code_file

  2. Fügen Sie in nachfolgenden Aufrufen mit append_to_code_fileweiteren Code hinzu

  3. Überprüfen Sie den Dateiinhalt bei Bedarf mit read_code_file

  4. 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.

Available Tools

9 tools
append_to_code_fileA

Append content to an existing Python code file. Use this to add more code to a file created with initialize_code_file, allowing you to build up larger code bases in parts.

Inputs: file_path (required), content (required).

check_installed_packagesC

Check if packages are installed in the conda environment

Inputs: packages (required).

configure_environmentC

Change the environment configuration settings

Inputs: type (required), conda_name, venv_path, uv_venv_path.

execute_codeA

Execute Python code in the conda environment. For short code snippets only. For longer code, use initialize_code_file and append_to_code_file instead.

Inputs: code (required), filename.

execute_code_fileA

Execute an existing Python file. Use this as the final step after building up code with initialize_code_file and append_to_code_file.

Inputs: file_path (required).

get_environment_configB

Get the current environment configuration

Inputs: no named parameters.

initialize_code_fileA

Create a new Python file with initial content. Use this as the first step for longer code that may exceed token limits. Follow with append_to_code_file for additional code.

Inputs: content (required), filename.

install_dependenciesC

Install Python dependencies in the conda environment

Inputs: packages (required).

read_code_fileA

Read the content of an existing Python code file. Use this to verify the current state of a file before appending more content or executing it.

Inputs: file_path (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 9 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose with no ambiguity. For example, initialize_code_file, append_to_code_file, and read_code_file handle different file operations, while execute_code and execute_code_file target different execution methods. The descriptions explicitly differentiate tools like execute_code (for short snippets) versus the file-based workflow.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern using snake_case, such as append_to_code_file, check_installed_packages, and configure_environment. There are no deviations in naming style or convention across the set, making them predictable and readable.

    Tool Count5/5

    With 9 tools, the count is well-scoped for a code execution server. Each tool earns its place by covering distinct aspects like file management, environment configuration, dependency handling, and code execution, without being overly sparse or bloated.

    Completeness5/5

    The tool set provides complete coverage for the code execution domain, including CRUD-like operations for files (initialize, append, read), environment management (configure, get config, install dependencies), and execution (code snippets, files). There are no obvious gaps, and the workflow from file creation to execution is fully supported.

    Maintenance

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers