Code Sandbox MCP Server

Instructions

Implementation Reference

• src/code_sandbox_mcp/server.py:21-40 (handler)

  The handler function for the 'run_python_code' tool. It uses @mcp.tool() decorator for registration, defines the input schema via Annotated Field, executes the code using the run_code helper, handles output and errors, returning TextContent.

  @mcp.tool()
  def run_python_code(
      code: Annotated[
          str,
          Field(
              description=f"The Python code to execute, included libraries are {DEFAULT_ENVIRONMENT_MAP['python']['installed_libraries']}",
          ),
      ],
  ) -> TextContent:
      """Execute Python code in the sandbox environment and captures the standard output and error."""
      try:
          result = run_code(code, language="python")
          if len(result) == 0:
              result = ExecutionResult(
                  exit_code=1, stderr="No output, forgot print()?"
              ).to_json()
          return TextContent(text=result, type="text")
      except Exception as e:
          result = ExecutionResult(exit_code=1, stderr=str(e)).to_json()
          return TextContent(text=result, type="text")

• src/code_sandbox_mcp/server.py:23-28 (schema)

  Input schema for the tool: 'code' parameter as annotated string with description listing pre-installed Python libraries from const.

  code: Annotated[
      str,
      Field(
          description=f"The Python code to execute, included libraries are {DEFAULT_ENVIRONMENT_MAP['python']['installed_libraries']}",
      ),
  ],

• src/code_sandbox_mcp/server.py:21-21 (registration)

  @mcp.tool() decorator registers the function as an MCP tool named 'run_python_code'.

  @mcp.tool()

• src/code_sandbox_mcp/utils.py:25-78 (helper)

  Supporting utility that performs the actual code execution in a secure sandbox environment using llm_sandbox.SandboxSession, handling configuration from constants and env vars.

  def run_code(
      code: str,
      language: Literal["python", "javascript"] = DEFAULT_LANGUAGE,
      image: str | None = None,
      libraries: list[str] | None = None,
      timeout: int = EXECUTION_TIMEOUT,
  ) -> str:
      """Execute code in a secure sandbox environment and automatic visualization capture.
  
      Args:
          code: The code to execute
          language: Programming language (python, javascript, go)
          libraries: List of libraries/packages to install
          image: Docker image to use for the sandbox session
          timeout: Execution timeout in seconds (default: 30)
  
      Returns:
          List of content items including execution results and any generated visualizations
  
      """
      if language not in DEFAULT_ENVIRONMENT_MAP:
          raise ValueError(f"Language {language} not supported")
  
      session_args = {
          "lang": language,
          "keep_template": True,
          "verbose": VERBOSE,
          "backend": _get_backend(),
          "session_timeout": timeout,
          "image": DEFAULT_ENVIRONMENT_MAP[language]["image"],
      }
  
      if os.getenv("PASSTHROUGH_ENV", None):
          env_vars = {}
          for var in os.getenv("PASSTHROUGH_ENV", None).split(","):
              env_vars[var] = os.getenv(var)
          session_args["runtime_configs"] = {"environment": env_vars}
  
      if os.getenv("CONTAINER_IMAGE", None) and os.getenv("CONTAINER_LANGUAGE", None):
          session_args["lang"] = os.getenv("CONTAINER_LANGUAGE")
          session_args["image"] = os.getenv("CONTAINER_IMAGE")
  
      if libraries:
          session_args["libraries"] = libraries
  
      with SandboxSession(**session_args) as session:
          result = session.run(
              code=code,
              libraries=libraries or [],
              timeout=timeout,
          )
      if result.exit_code != 0:
          raise Exception(result.stderr.strip())
      return result.stdout.strip()