Servidor MCP Code Executor MCP

¿Qué hace el servidor MCP Code Executor “MCP Server”?

El MCP Code Executor es un servidor MCP (Model Context Protocol) que permite a los modelos de lenguaje (LLMs) ejecutar código Python dentro de un entorno Python designado, como Conda, virtualenv o UV virtualenv. Al conectar asistentes de IA con entornos Python reales y ejecutables, les da la capacidad de realizar una amplia gama de tareas de desarrollo que requieren ejecución de código, gestión de librerías y configuración dinámica de entornos. Este servidor soporta generación incremental de código para superar limitaciones de tokens, permite la instalación dinámica de dependencias y facilita la configuración en tiempo de ejecución del entorno de ejecución. Los desarrolladores pueden aprovechar esta herramienta para automatizar la evaluación de código, experimentar con nuevos paquetes y gestionar el cómputo en un entorno controlado y seguro.

Lista de prompts

No se listan plantillas de prompts explícitas en el repositorio ni en la documentación.

¿Listo para hacer crecer tu negocio?

Comienza tu prueba gratuita hoy y ve resultados en días.

Solicitar demo Iniciar sesión

Lista de recursos

No se describen recursos específicos en el repositorio ni en la documentación.

Lista de herramientas

• execute_code
  • Ejecuta código Python en el entorno configurado. Adecuado para ejecutar fragmentos de código cortos y scripts.
• install_dependencies
  • Instala los paquetes de Python especificados en el entorno actual, permitiendo la inclusión dinámica de librerías según se necesiten.
• check_installed_packages
  • Verifica qué paquetes de Python están actualmente instalados en el entorno.

Únete a nuestro boletín

Obtén los últimos consejos, tendencias y ofertas gratis.

Dirección de correo electrónico

Suscribirse

Casos de uso de este servidor MCP

• Evaluación automatizada de código
  • Los LLMs pueden ejecutar y probar fragmentos de código Python directamente, lo cual es útil en contextos educativos, de revisión o depuración.
• Gestión dinámica de dependencias
  • Instala los paquetes necesarios sobre la marcha, permitiendo que los LLMs adapten el entorno de ejecución para tareas o librerías especializadas.
• Aislamiento de entornos
  • Ejecuta el código dentro de entornos aislados de Conda o virtualenv, garantizando la reproducibilidad y evitando conflictos de dependencias.
• Generación incremental de código
  • Soporta la ejecución incremental de código, haciendo posible manejar bloques grandes de código que podrían exceder los límites de tokens en una sola respuesta LLM.
• Ciencia de datos y análisis
  • Permite a los agentes de IA realizar análisis de datos, ejecutar simulaciones o visualizar resultados ejecutando código con librerías científicas comunes de Python.

Cómo configurarlo

Windsurf

1. Asegúrate de que Node.js esté instalado.
2. Clona el repositorio de MCP Code Executor y construye el proyecto.
3. Ubica el archivo de configuración de tus servidores MCP.
4. Agrega el servidor MCP Code Executor usando el siguiente fragmento JSON:

   {
     "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"
         }
       }
     }
   }
   

5. Guarda el archivo y reinicia Windsurf. Verifica que el servidor sea accesible.

Protección de claves API (Ejemplo de variables de entorno)

{
  "mcpServers": {
    "mcp-code-executor": {
      "env": {
        "CODE_STORAGE_DIR": "/path/to/code/storage",
        "ENV_TYPE": "conda",
        "CONDA_ENV_NAME": "your-conda-env",
        "MY_SECRET_API_KEY": "${MY_SECRET_API_KEY}"
      },
      "inputs": {
        "apiKey": "${MY_SECRET_API_KEY}"
      }
    }
  }
}

Claude

1. Asegúrate de que Node.js esté instalado.
2. Construye MCP Code Executor siguiendo las instrucciones del repositorio.
3. Abre el archivo de configuración de los servidores MCP de Claude.
4. Inserta la siguiente configuración:

   {
     "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"
         }
       }
     }
   }
   

5. Guarda y reinicia Claude. Confirma que el servidor esté listado.

Cursor

1. Instala Node.js.
2. Clona y construye el repositorio de MCP Code Executor.
3. Edita la configuración MCP de Cursor.
4. Agrega:

   {
     "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"
         }
       }
     }
   }
   

5. Guarda y reinicia Cursor. Prueba ejecutando un código de ejemplo.

Cline

1. Asegúrate de que Node.js esté disponible.
2. Construye MCP Code Executor usando las instrucciones del README.
3. Ubica el archivo de configuración MCP de Cline.
4. Agrega:

   {
     "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"
         }
       }
     }
   }
   

5. Guarda y reinicia Cline. Verifica que el servidor MCP esté activo.

Nota: También puedes usar Docker. El Dockerfile proporcionado está probado para el tipo de entorno venv-uv:

{
  "mcpServers": {
    "mcp-code-executor": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "mcp-code-executor"
      ]
    }
  }
}

Cómo usar este MCP dentro de los flujos

Uso de MCP en FlowHunt

Para integrar servidores MCP en tu flujo de trabajo de FlowHunt, comienza agregando el componente MCP a tu flujo y conectándolo con tu agente de IA:

Haz clic en el componente MCP para abrir el panel de configuración. En la sección de configuración MCP del sistema, introduce los detalles de tu servidor MCP usando este formato JSON:

{
  "mcp-code-executor": {
    "transport": "streamable_http",
    "url": "https://yourmcpserver.example/pathtothemcp/url"
  }
}

Una vez configurado, el agente de IA podrá usar este MCP como herramienta con acceso a todas sus funciones y capacidades. Recuerda cambiar “mcp-code-executor” por el nombre real de tu servidor MCP y reemplazar la URL por la de tu propio servidor MCP.

Resumen

Nuestra opinión

Este servidor MCP proporciona funcionalidad esencial y robusta para la ejecución de código con integración LLM, junto con instrucciones de configuración y herramientas claras. Sin embargo, carece de plantillas de prompts, recursos explícitos e información sobre roots o soporte de muestreo. Para un MCP enfocado en la ejecución de código, es muy sólido, obteniendo una puntuación alta en utilidad práctica y facilidad de integración, aunque pierde algunos puntos por la falta de características MCP avanzadas y la completitud de la documentación.

Puntuación MCP