MCP Code Executor
Ejecutor de código MCP
El Ejecutor de Código MCP es un servidor MCP que permite a los LLM ejecutar código Python en un entorno Python específico. Esto permite a los LLM ejecutar código con acceso a las bibliotecas y dependencias definidas en el entorno. También admite la generación incremental de código para gestionar grandes bloques de código que pueden superar los límites de tokens.
Características
Ejecutar código Python desde las indicaciones de LLM
Soporte para la generación de código incremental para superar las limitaciones de tokens
Ejecutar código dentro de un entorno específico (Conda, virtualenv o UV virtualenv)
Instalar dependencias cuando sea necesario
Comprobar si los paquetes ya están instalados
Configurar dinámicamente el entorno en tiempo de ejecución
Directorio de almacenamiento de código configurable
Related MCP server: MCP Python Interpreter
Prerrequisitos
Node.js instalado
Uno de los siguientes:
Conda instalado con el entorno Conda deseado creado
Entorno virtual de Python
Entorno virtual UV
Configuración
Clonar este repositorio:
git clone https://github.com/bazinga012/mcp_code_executor.gitNavegue hasta el directorio del proyecto:
cd mcp_code_executorInstalar las dependencias de Node.js:
npm installConstruir el proyecto:
npm run buildConfiguración
Para configurar el servidor MCP Code Executor, agregue lo siguiente al archivo de configuración de sus servidores MCP:
Usando 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"
}
}
}
}Usando Docker
{
"mcpServers": {
"mcp-code-executor": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"mcp-code-executor"
]
}
}
}Nota: El Dockerfile se ha probado únicamente con el tipo de entorno venv-uv. Otros tipos de entorno podrían requerir configuración adicional.
Variables de entorno
Variables requeridas
CODE_STORAGE_DIR: Directorio donde se almacenará el código generado
Tipo de entorno (elija una configuración)
Para Conda:
ENV_TYPE: Establecer encondaCONDA_ENV_NAME: Nombre del entorno Conda a utilizar
Para entorno virtual estándar:
ENV_TYPE: Establecer envenvVENV_PATH: Ruta al directorio virtualenv
Para UV Virtualenv:
ENV_TYPE: Establecer envenv-uvUV_VENV_PATH: Ruta al directorio del entorno virtual UV
Herramientas disponibles
El Ejecutor de Código MCP proporciona las siguientes herramientas a los LLM:
1. execute_code
Ejecuta código Python en el entorno configurado. Ideal para fragmentos de código cortos.
{
"name": "execute_code",
"arguments": {
"code": "import numpy as np\nprint(np.random.rand(3,3))",
"filename": "matrix_gen"
}
}2. install_dependencies
Instala paquetes de Python en el entorno.
{
"name": "install_dependencies",
"arguments": {
"packages": ["numpy", "pandas", "matplotlib"]
}
}3. check_installed_packages
Comprueba si los paquetes ya están instalados en el entorno.
{
"name": "check_installed_packages",
"arguments": {
"packages": ["numpy", "pandas", "non_existent_package"]
}
}4. configure_environment
Cambia dinámicamente la configuración del entorno.
{
"name": "configure_environment",
"arguments": {
"type": "conda",
"conda_name": "new_env_name"
}
}5. get_environment_config
Obtiene la configuración del entorno actual.
{
"name": "get_environment_config",
"arguments": {}
}6. initialize_code_file
Crea un nuevo archivo Python con el contenido inicial. Úselo como primer paso para código más largo que pueda exceder los límites de tokens.
{
"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
Añade contenido a un archivo de código Python existente. Úsalo para añadir más código a un archivo creado con initialize_code_file.
{
"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
Ejecuta un archivo Python existente. Úselo como último paso tras compilar el código con initialize_code_file y append_to_code_file.
{
"name": "execute_code_file",
"arguments": {
"file_path": "/path/to/code/storage/my_script_abc123.py"
}
}9. read_code_file
Lee el contenido de un archivo de código Python existente. Úselo para verificar el estado actual de un archivo antes de añadir más contenido o ejecutarlo.
{
"name": "read_code_file",
"arguments": {
"file_path": "/path/to/code/storage/my_script_abc123.py"
}
}Uso
Una vez configurado, el Ejecutor de código MCP permitirá a los LLM ejecutar código Python generando un archivo en el CODE_STORAGE_DIR especificado y ejecutándolo dentro del entorno configurado.
Los LLM pueden generar y ejecutar código haciendo referencia a este servidor MCP en sus indicaciones.
Manejo de grandes bloques de código
Para bloques de código más grandes que puedan superar los límites de tokens LLM, utilice el enfoque de generación de código incremental:
Inicialice un archivo con la estructura básica usando
initialize_code_fileAgregue más código en llamadas posteriores usando
append_to_code_fileVerifique el contenido del archivo si es necesario usando
read_code_fileEjecute el código completo usando
execute_code_file
Este enfoque permite a los LLM escribir código complejo de varias partes sin encontrarse con limitaciones de tokens.
Compatibilidad con versiones anteriores
Este paquete mantiene la compatibilidad con versiones anteriores. Los usuarios de versiones anteriores que solo especificaron un entorno Conda seguirán trabajando sin cambios en su configuración.
Contribuyendo
¡Agradecemos sus contribuciones! Abra un problema o envíe una solicitud de incorporación de cambios.
Licencia
Este proyecto está licenciado bajo la licencia MIT.
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.-