MCP Code Executor

Permite a los LLMs ejecutar código Python dentro de un entorno Python especificado y configurable.

Documentación

MCP Code Executor

El MCP Code Executor es un servidor MCP que permite a los LLMs ejecutar código Python dentro de un entorno Python especificado. Esto permite a los LLMs ejecutar código con acceso a bibliotecas y dependencias definidas en el entorno. También admite la generación incremental de código para manejar bloques de código grandes que pueden exceder los límites de tokens.

Características

Ejecutar código Python desde indicaciones de LLM
Soporte para generación incremental de código para superar limitaciones de tokens
Ejecutar código dentro de un entorno especificado (Conda, virtualenv o UV virtualenv)
Instalar dependencias cuando sea necesario
Verificar si los paquetes ya están instalados
Configurar dinámicamente el entorno en tiempo de ejecución
Directorio de almacenamiento de código configurable

Requisitos previos

Node.js instalado
Uno de los siguientes:
- Conda instalado con el entorno Conda deseado creado
- virtualenv de Python
- virtualenv de UV

Instalación

Clona este repositorio:

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

Navega al directorio del proyecto:

cd mcp_code_executor

Instala las dependencias de Node.js:

npm install

Compila el proyecto:

npm run build

Configuración

Para configurar el servidor MCP Code Executor, agrega lo siguiente a tu archivo de configuración de 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 ha sido probado solo con el tipo de entorno venv-uv. Otros tipos de entorno pueden requerir configuración adicional.

Variables de entorno

Variables requeridas

CODE_STORAGE_DIR: Directorio donde se almacenará el código generado

Tipo de entorno (elige una configuración)

Para Conda:
- ENV_TYPE: Establecer a conda
- CONDA_ENV_NAME: Nombre del entorno Conda a utilizar
Para virtualenv estándar:
- ENV_TYPE: Establecer a venv
- VENV_PATH: Ruta al directorio del virtualenv
Para virtualenv de UV:
- ENV_TYPE: Establecer a venv-uv
- UV_VENV_PATH: Ruta al directorio del virtualenv de UV

Herramientas disponibles

El MCP Code Executor proporciona las siguientes herramientas a los LLMs:

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 Python en el entorno.

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

3. `check_installed_packages`

Verifica 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 actual del entorno.

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

6. `initialize_code_file`

Crea un nuevo archivo Python con contenido inicial. Úsalo 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`

Agrega 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. Úsalo como paso final después de construir 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. Úsalo para verificar el estado actual de un archivo antes de agregar 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 MCP Code Executor permitirá a los LLMs ejecutar código Python generando un archivo en el CODE_STORAGE_DIR especificado y ejecutándolo dentro del entorno configurado.

Los LLMs pueden generar y ejecutar código haciendo referencia a este servidor MCP en sus indicaciones.

Manejo de bloques de código grandes

Para bloques de código más grandes que puedan exceder los límites de tokens del LLM, utiliza el enfoque de generación incremental de código:

Inicializa un archivo con la estructura básica usando initialize_code_file
Agrega más código en llamadas posteriores usando append_to_code_file
Verifica el contenido del archivo si es necesario usando read_code_file
Ejecuta el código completo usando execute_code_file

Este enfoque permite a los LLMs escribir código complejo de múltiples partes sin encontrarse con limitaciones de tokens.

Compatibilidad hacia atrás

Este paquete mantiene compatibilidad hacia atrás con versiones anteriores. Los usuarios de versiones anteriores que solo especificaron un entorno Conda seguirán funcionando sin ningún cambio en su configuración.

Contribuciones

¡Las contribuciones son bienvenidas! Por favor, abre un issue o envía una solicitud de extracción (pull request).

Licencia

Este proyecto está licenciado bajo la Licencia MIT.

MCP Code Executor

Documentación