MCP Code Executor MCP Server

What does “MCP Code Executor” MCP Server do?

The MCP Code Executor is an MCP (Model Context Protocol) server that enables language models (LLMs) to execute Python code within a designated Python environment, such as Conda, virtualenv, or UV virtualenv. By connecting AI assistants to real, executable Python environments, it empowers them to perform a wide range of development tasks that require code execution, library management, and dynamic environment setup. This server supports incremental code generation to overcome token limitations, allows for on-the-fly installation of dependencies, and facilitates runtime configuration of the execution environment. Developers can leverage this tool to automate code evaluation, experiment with new packages, and manage computation within a controlled and secure environment.

List of Prompts

No explicit prompt templates are listed in the repository or documentation.

List of Resources

No specific resources are described in the repository or documentation.

List of Tools

• execute_code
  • Executes Python code in the configured environment. Suitable for running short code snippets and scripts.
• install_dependencies
  • Installs specified Python packages in the current environment, enabling dynamic inclusion of libraries as needed.
• check_installed_packages
  • Checks which Python packages are currently installed within the environment.

Use Cases of this MCP Server

• Automated Code Evaluation
  • LLMs can execute and test Python code snippets directly, which is useful in educational, review, or debugging contexts.
• Dynamic Dependency Management
  • Installs required packages on the fly, allowing LLMs to adapt the execution environment for specialized tasks or libraries.
• Environment Isolation
  • Runs code inside isolated Conda or virtualenv environments, ensuring reproducibility and preventing conflicts between dependencies.
• Incremental Code Generation
  • Supports incremental code execution, making it possible to handle large code blocks that might exceed token limits in a single LLM response.
• Data Science and Analysis
  • Enables AI agents to perform data analysis, run simulations, or visualize results by executing code with common scientific Python libraries.

How to set it up

Windsurf

1. Ensure Node.js is installed.
2. Clone the MCP Code Executor repository and build the project.
3. Locate your MCP servers configuration file.
4. Add the MCP Code Executor server using the following JSON snippet:

   {
     "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. Save the file and restart Windsurf. Verify the server is reachable.

Securing API Keys (Environment Variables Example)

{
  "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. Ensure Node.js is installed.
2. Build the MCP Code Executor following repository instructions.
3. Open the configuration file for Claude’s MCP servers.
4. Insert the following configuration:

   {
     "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. Save and restart Claude. Confirm the server is listed.

Cursor

1. Install Node.js.
2. Clone and build the MCP Code Executor repository.
3. Edit Cursor’s MCP configuration.
4. Add:

   {
     "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. Save and restart Cursor. Test by running a sample code execution.

Cline

1. Make sure Node.js is available.
2. Build the MCP Code Executor using the README instructions.
3. Locate Cline’s configuration file for MCP servers.
4. Add:

   {
     "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. Save and restart Cline. Verify the MCP server is active.

Note: You can also use Docker. The provided Dockerfile is tested for venv-uv environment type:

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

How to use this MCP inside flows

Using MCP in FlowHunt

To integrate MCP servers into your FlowHunt workflow, start by adding the MCP component to your flow and connecting it to your AI agent:

Click on the MCP component to open the configuration panel. In the system MCP configuration section, insert your MCP server details using this JSON format:

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

Once configured, the AI agent is now able to use this MCP as a tool with access to all its functions and capabilities. Remember to change “mcp-code-executor” to whatever the actual name of your MCP server is and replace the URL with your own MCP server URL.

Overview

Our opinion

This MCP server provides essential and robust functionality for code execution with LLM integration, along with clear setup instructions and tooling. However, it lacks prompt templates, explicit resources, and information on roots or sampling support. For a code-execution-focused MCP, it is very solid, scoring high for practical utility and ease of integration, but loses some points for missing advanced MCP features and documentation completeness.

MCP Score