MCP Code Executor
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
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
Klonen Sie dieses Repository:
git clone https://github.com/bazinga012/mcp_code_executor.gitNavigieren Sie zum Projektverzeichnis:
cd mcp_code_executorInstallieren Sie die Node.js-Abhängigkeiten:
npm installErstellen Sie das Projekt:
npm run buildKonfiguration
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: AufcondasetzenCONDA_ENV_NAME: Name der zu verwendenden Conda-Umgebung
Für Standard-Virtualenv:
ENV_TYPE: AufvenvsetzenVENV_PATH: Pfad zum Virtualenv-Verzeichnis
Für UV Virtualenv:
ENV_TYPE: Aufvenv-uveinstellenUV_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_fileFügen Sie in nachfolgenden Aufrufen mit
append_to_code_fileweiteren Code hinzuÜberprüfen Sie den Dateiinhalt bei Bedarf mit
read_code_fileFühren Sie den gesamten Code mit
execute_code_fileaus
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 toolsappend_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
Scored across 9 tools
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.
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.
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.
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
Related MCP Connectors
Operate Linux, macOS and Windows from your LLM. Every action runs through an auditable allowlist.
Run Python and install PyPI packages from natural language. Hosted at https://cloudish.ai.
Build Apps and run code in 30 languages — sandboxed, with persistent sessions for agent loops.
I do everything related to coding and execution tasks
Related MCP Servers
- FlicenseNot gradedqualityNot gradedmaintenanceEnables LLMs to interact with Python environments, execute code or scripts, manage packages, and read/write files within an isolated working directory.-
- FlicenseNot gradedqualityAmaintenanceEnables LLMs to interact with Python environments, execute code, manage packages, and perform file operations within a configurable working directory.-
- FlicenseNot gradedqualityAmaintenanceEnables LLMs to interact with Python environments, execute code or scripts, manage packages, and read/write files within an isolated working directory.-
- FlicenseNot gradedqualityAmaintenanceEnables LLMs to execute Python code and scripts across system and conda environments, manage installed packages, and read or write text and binary files within an isolated working directory.-