Skip to main content
Glama
MCP Code Executor

MCP Code Executor

Ejecutor de código MCP

insignia de herrería

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

  1. Clonar este repositorio:

git clone https://github.com/bazinga012/mcp_code_executor.git
  1. Navegue hasta el directorio del proyecto:

cd mcp_code_executor
  1. Instalar las dependencias de Node.js:

npm install
  1. Construir el proyecto:

npm run build

Configuració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 en conda

    • CONDA_ENV_NAME : Nombre del entorno Conda a utilizar

  • Para entorno virtual estándar:

    • ENV_TYPE : Establecer en venv

    • VENV_PATH : Ruta al directorio virtualenv

  • Para UV Virtualenv:

    • ENV_TYPE : Establecer en venv-uv

    • UV_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:

  1. Inicialice un archivo con la estructura básica usando initialize_code_file

  2. Agregue más código en llamadas posteriores usando append_to_code_file

  3. Verifique el contenido del archivo si es necesario usando read_code_file

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