-
securityA
license-
qualityAn interactive Python code execution environment that allows users and LLMs to safely execute Python code and install packages in isolated Docker containers.
Last updated -
27
Apache 2.0
Enables secure execution of Python code in a sandboxed WebAssembly environment with automatic dependency management, capturing output and return values
Code is executed using Pyodide in Deno and is therefore isolated from the rest of the operating system.
Features
Secure Execution: Run Python code in a sandboxed WebAssembly environment
Package Management: Automatically detects and installs required dependencies
Complete Results: Captures standard output, standard error, and return values
Asynchronous Support: Runs async code properly
Error Handling: Provides detailed error reports for debugging
(This code was previously part of
Usage
To use this server, you must have both Python and Deno installed.
The server can be run with deno installed using uvx:
uvx mcp-run-python [-h] [--version] [--port PORT] [--deps DEPS] {stdio,streamable-http,example}
where:
stdioruns the server with the Stdio MCP transport — suitable for running the process as a subprocess locallystreamable-httpruns the server with the Streamable HTTP MCP transport - suitable for running the server as an HTTP server to connect locally or remotely. This supports stateful requests, but does not require the client to hold a stateful connection like SSEexamplewill run a minimal Python script usingnumpy, useful for checking that the package is working, for the code to run successfully, you'll need to installnumpyusinguvx mcp-run-python --deps numpy example
Usage with Pydantic AI
Then you can use mcp-run-python with Pydantic AI:
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerStdio
from mcp_run_python import deno_args_prepare
import logfire
logfire.configure()
logfire.instrument_mcp()
logfire.instrument_pydantic_ai()
server = MCPServerStdio('uvx', args=['mcp-run-python@latest', 'stdio'], timeout=10)
agent = Agent('claude-3-5-haiku-latest', toolsets=[server])
async def main():
async with agent:
result = await agent.run('How many days between 2000-01-01 and 2025-03-18?')
print(result.output)
#> There are 9,208 days between January 1, 2000, and March 18, 2025.w
if __name__ == '__main__':
import asyncio
asyncio.run(main())
Usage in codes as an MCP server
First install the mcp-run-python package:
pip install mcp-run-python
# or
uv add mcp-run-python
With mcp-run-python installed, you can also run deno directly with prepare_deno_env or async_prepare_deno_env
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerStdio
from mcp_run_python import async_prepare_deno_env
import logfire
logfire.configure()
logfire.instrument_mcp()
logfire.instrument_pydantic_ai()
async def main():
async with async_prepare_deno_env('stdio') as deno_env:
server = MCPServerStdio('deno', args=deno_env.args, cwd=deno_env.cwd, timeout=10)
agent = Agent('claude-3-5-haiku-latest', toolsets=[server])
async with agent:
result = await agent.run('How many days between 2000-01-01 and 2025-03-18?')
print(result.output)
#> There are 9,208 days between January 1, 2000, and March 18, 2025.w
if __name__ == '__main__':
import asyncio
asyncio.run(main())
Note: prepare_deno_env can take deps as a keyword argument to install dependencies.
As well as returning the args needed to run mcp_run_python, prepare_deno_env creates a new deno environment
and installs the dependencies so they can be used by the server.
Usage in code with code_sandbox
mcp-run-python includes a helper function code_sandbox to allow you to easily run code in a sandbox.
from mcp_run_python import code_sandbox
code = """
import numpy
a = numpy.array([1, 2, 3])
print(a)
a
"""
async def main():
async with code_sandbox(dependencies=['numpy']) as sandbox:
result = await sandbox.eval(code)
print(result)
if __name__ == '__main__':
import asyncio
asyncio.run(main())
Under the hood, code_sandbox runs an MCP server using stdio. You can run multiple code blocks with a single sandbox.
Logging
MCP Run Python supports emitting stdout and stderr from the python execution as MCP logging messages.
For logs to be emitted you must set the logging level when connecting to the server. By default, the log level is set to the highest level, emergency.
Dependencies
mcp_run_python uses a two step process to install dependencies while avoiding any risk that sandboxed code can
edit the filesystem.
denois first run with write permissions to thenode_modulesdirectory and dependencies are installed, causing wheels to be written to ``denois then run with read-only permissions to thenode_modulesdirectory to run untrusted code.
Dependencies must be provided when initializing the server so they can be installed in the first step.
This server cannot be installed
hybrid server
The server is able to function both locally and remotely, depending on the configuration or use case.
Enables secure execution of Python code in a sandboxed WebAssembly environment using Pyodide and Deno. Automatically handles package management and captures complete execution results including stdout, stderr, and return values.
Related MCP Servers
- -securityAlicense-qualityAn interactive Python code execution tool that allows users and LLMs to safely execute Python code and install packages in isolated Docker containers.Last updated -27Apache 2.0
- -securityFlicense-qualityA secure Node.js execution environment that allows coding agents and LLMs to run JavaScript dynamically, install NPM packages, and retrieve results while adhering to the Model Control Protocol.Last updated -7244
- AsecurityAlicenseAqualityA Python code execution sandbox based on IPython and Docker. Stateful code execution, file transfer between host and container, configurable network access.Last updated -440Apache 2.0