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

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

Navegue hasta el directorio del proyecto:

cd mcp_code_executor

Instalar las dependencias de Node.js:

npm install

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:

Inicialice un archivo con la estructura básica usando initialize_code_file
Agregue más código en llamadas posteriores usando append_to_code_file
Verifique el contenido del archivo si es necesario usando read_code_file
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.

You must be authenticated.

security – no known vulnerabilities

license - permissive license

quality - confirmed to work

local-only server

The server can only run on the client's local machine because it depends on local resources.

Tools

execute_code

Permite a los LLM ejecutar código Python en un entorno Conda específico, lo que habilita el acceso a las bibliotecas y dependencias necesarias para una ejecución eficiente del código.

Related Resources

Reddit Discussion about this server

Related MCP Servers

mcp-pyodide
yonaka15
A
security
A
license
A
quality
A Pyodide server for executing Python code by Large Language Models (LLMs) via the Model Context Protocol (MCP).
Last updated -
5
8
10
TypeScript
MIT License
Fused MCP Agentsofficial
fusedio
-
security
A
license
-
quality
A Python-based MCP server that allows Claude and other LLMs to execute arbitrary Python code directly through your desktop Claude app, enabling data scientists to connect LLMs to APIs and executable code.
Last updated -
23
MIT License
MCP Server for continue.dev
alexsmirnov
A
security
F
license
A
quality
A Python server implementing the Model Context Protocol to provide customizable prompt templates, resources, and tools that enhance LLM interactions in the continue.dev environment.
Last updated -
2
Python
MCP Python Interpreter
yzfly
A
security
F
license
A
quality
A Model Context Protocol server that allows LLMs to interact with Python environments, execute code, and manage files within a specified working directory.
Last updated -
9
37
Python

View all related MCP servers

MCP Code Executor