HOPX MCP Server

Official

Execute code in isolated cloud containers

How to install ↓ Compare GitHub source repository ↗

Category: Dev Tools #227 of 438
Stars: ★ 156 Popular
Transport: stdio (local process)
Runtime: Python 3.14+
Credentials: API key / credential required
Last commit: 10 months ago ⚠
Tools: 19

52FMRS · D

An officially maintained MCP server for HOPX sandboxed code execution, using stdio transport. Supports Python, JavaScript, Bash, and Go with a comprehensive toolset (execution, files, commands, environment variables), good documentation, and an MIT license. Best for users who need to run AI-generated code in an isolated cloud environment, provided they accept third-party cloud execution and manage an API key.

Strongest · Setup experience 13/20 Weakest · Reliability 6/20

Reliability

6/20

Security and permissions

10/20

Maintenance

10/20

Documentation

13/20

Setup experience

13/20

Why each score

Reliability 6/20: Only server.json and the README are available as evidence — there is no CI workflow or test suite to confirm that the MCP init + tool-list handshake actually completes cleanly. More importantly, the manifest's capabilities.tools declares only 5 tools (execute_code_isolated, create_sandbox, execute_code, file_read, file_write), while the README documents nearly 20 tools (list_sandboxes, delete_sandbox, execute_code_background, run_command, env_get, etc.), a clear mismatch between declared and documented capabilities. Per the static calibration rule, reliability is capped at 12 without verifiable execution evidence (real CI plus committed tests); the additional manifest/README inconsistency pushes this down further to 6.
Security and permissions 10/20: Credentials are passed via the HOPX_API_KEY environment variable, a standard pattern, and no real secrets appear in examples. The README's Security section is reasonably transparent about data leaving the local machine (code runs in HOPX's cloud), containers having internet access by default, and per-sandbox isolation — a positive disclosure. However, the server's core functionality includes arbitrary code execution, shell command execution (run_command), file read/write, and sandbox deletion, none of which are described with least-privilege scoping, explicit confirmation gates, or enforced resource/rate limits beyond 'follow your own security policy.' These risks are inherent to a code-execution service rather than evidence of malicious intent, so this is not a red line, but incomplete permission scoping and confirmation flows keep the score at 10.
Maintenance 10/20: The license field is MIT, the repository is not archived, and issue/email support channels are listed; version 0.1.2 signals an early-stage project. The 155 stars and single open issue are discovery signals only and are not scored. No commit history, release cadence, or dependency-update evidence is present in the reviewed material, so sustained activity cannot be confirmed — only a clear license and basic support channel presence justify a moderate score of 10.
Documentation 13/20: The README is fairly comprehensive: installation, multi-IDE configuration examples (Claude Desktop/Cursor/VS Code), usage examples, environment variables, troubleshooting, stated limitations (300s sync execution cap, 10-minute default sandbox lifetime), and a security section are all present with reasonable layering. Two notable gaps remain: (1) the manifest's declared tool set does not match the README's documented tool set, leaving no clear authoritative source; (2) no cost/pricing information is disclosed at all for what is fundamentally a paid cloud-resource service, and individual tool parameters are shown only as code snippets rather than formal schemas. Overall scored 13.
Setup experience 13/20: Setup is straightforward: a single `uvx hopx-mcp` command plus concrete JSON configuration examples for Claude Desktop, Cursor, and VS Code, with the required HOPX_API_KEY environment variable clearly documented. It does require signing up externally at hopx.ai for an API key, an added manual step, and since this is a static-only review with no verifiable installation test or CI evidence, setup is capped at 15 per the calibration rule. Scored 13 overall.

Static review · not runListed 2026-09-07

Read the FMRS scoring method →

Fit and risk

What it can accessRuns commands or codeUses the network

Best for

Developers who need to run AI-generated code safely
Data scientists and analysts
Users of Claude Desktop, Cursor, or VS Code

Not for

Scenarios requiring fully local code execution
Organizations that cannot allow code to run on third-party cloud infrastructure
Simple tasks that don't need sandboxing

Required permissions

Requires HOPX_API_KEY (API key from hopx.ai)
Containers have internet access enabled by default
Code runs in the HOPX cloud, not locally

Risks and side effects

Containers have internet access by default
Code is executed in the HOPX cloud; follow your security policies for sensitive data
Synchronous execution maxes at 300 seconds; sandbox lifetime defaults to 10 minutes
Language support varies by template

Setup

Before you start

Runtime：Python 3.14+

HOPX_API_KEY requiredsecret Required API key for the HOPX platform, obtained by signing up at hopx.ai.

Other optional settings (1)

HOPX_BASE_URL optional Optional API base URL, defaults to https://api.hopx.dev.

Sign up at hopx.ai and get an API key
Run uvx hopx-mcp (requires uv)
Add the MCP server config to your IDE (claude_desktop_config., .cursor/mcp., or .vscode/mcp.) with the HOPX_API_KEY environment variable
Restart your IDE. Optionally set HOPX_BASE_URL (default https://api.hopx.dev).

claude_desktop_config.json

{"mcpServers":{"hopx-sandbox":{"command":"uvx","args":["hopx-mcp"],"env":{"HOPX_API_KEY":"your-api-key-here"}}}}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json

{
  "servers": {
    "hopx-sandbox": {
      "command": "uvx",
      "args": [
        "hopx-mcp"
      ],
      "env": {
        "HOPX_API_KEY": "your-api-key-here"
      }
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal

claude mcp add hopx-sandbox -e HOPX_API_KEY=your-api-key-here -- uvx hopx-mcp

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

After configuring and restarting the client, tools like execute_code_isolated and create_sandbox should appear in the tool list; calling execute_code_isolated with a print statement and getting stdout with exit_code 0 confirms the connection.

Troubleshooting

401 Unauthorized: verify HOPX_API_KEY is set and valid
Template not found: browse available templates with list_templates(limit=20)
Slow first execution: container initialization takes ~3 seconds (VM auth setup); subsequent operations are immediate

Things to try

Once connected, you can ask your AI assistant things like:

Run a Python snippet that prints Hello, World! using execute_code_isolated
Create a persistent sandbox, load data.csv with pandas, and summarize the results
Write /workspace/output.txt in a sandbox and read it back to verify the contents
List available sandbox templates with list_templates(limit=20)

Tools 19

execute_code_isolated writes

Execute code in an isolated sandbox with automatic cleanup

create_sandbox writes

Create a persistent sandbox for multi-step workflows

execute_code writes

Execute code in an existing sandbox

file_read read-only

Read files from sandbox filesystem

file_write writes

Write files to sandbox filesystem

file_list read-only

List files in the sandbox

file_exists read-only

Check whether a file exists

file_remove destructive

Remove a file

Show 11 more tools

file_mkdir writes

Create a directory

execute_code_background writes

Run long-running tasks in the background

execute_code_async writes

Execute 30+ minute tasks with webhook callbacks

list_sandboxes read-only

List sandboxes

delete_sandbox destructive

Terminate a sandbox

run_command writes

Execute shell commands

run_command_background writes

Run background processes

env_get read-only

Get environment variables

env_set writes

Set environment variables

env_clear writes

Clear environment variables

list_templates read-only

Browse available templates

Use cases

Data analysis with pandas/numpy/matplotlib

Persistent sandboxes for multi-step workflows

Running AI-generated code safely

Background and long-running task execution

Shell commands and file operations

Supported clients

Claude Desktop

Cursor

VS Code

Listed from the project's documentation, not tested by this site.

Overview

HOPX MCP Server is the official Model Context Protocol (MCP) server for HOPX, enabling AI assistants to execute code in isolated cloud containers. It supports Python, JavaScript, Bash, and Go, with pre-installed data analysis libraries like pandas, numpy, and matplotlib. It offers one-shot isolated execution and persistent sandboxes for multi-step workflows, with containers auto-destroyed after use. MIT-licensed, installed via the PyPI package hopx-mcp, runs over stdio, and requires an API key from hopx.ai.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 63.3k · Tools 2 Compare with this →

NPM Sentinel MCP Server 79 · B

AI-powered NPM package analysis MCP server

★ 18 · Tools 19 Compare with this →

MartinLoop MCP Server 79 · B

An independent control layer that gives AI coding agents budgets, brakes, and receipts

★ 413 Compare with this →

GitHub MCP Server 76 · B

GitHub's official MCP server for managing repos, issues, PRs, and workflows via natural language

★ 33.7k · Tools 15 Compare with this →

Compare with other MCP servers

Source revision 40662e29526c Data synced 2026-10-19 Read the FMRS scoring method