Daytona MCP Interpreter Server

Daytona MCP Interpreter lets you run Python code and shell commands inside secure, ephemeral Daytona sandboxes via the Model Context Protocol (MCP). It exposes tools for code execution, shell access, file transfer, Git operations, and web previews, all in isolated workspaces that are automatically cleaned up after use. This enables AI assistants to perform complex, real-world tasks safely and reproducibly.

How to use

You connect your MCP-compatible client to the Daytona interpreter to run code, manage files, clone repositories, and preview web servers inside temporary sandboxes. Each operation happens in a Daytona workspace that is created on demand and cleaned up after the task completes. Use the provided tools to execute Python code or shell commands, upload and download files, clone Git repositories, and generate web previews for running servers.

Common usage patterns include: running a Python snippet or script directly in the sandbox, performing exploratory data work, uploading configuration files, cloning a repository to inspect code, and launching a local web server inside the sandbox to generate a preview link. All interactions happen through the MCP client you use, which talks to the Daytona MCP Interpreter server over your chosen connection method.

How to install

Prerequisites: Ensure you have a runtime that can host MCP clients and a tool to run MCP servers locally. You will also need an API key for Daytona and access to the Daytona server URL if you intend to use the HTTP-based path.

1. Install uv if you haven’t already. Use the installer provided by the Daytona ecosystem.

curl -LsSf https://astral.sh/uv/install.sh | sh

2. Create and activate a virtual environment for your Python dependencies. If you have an existing environment, deactivate and remove it first.

deactivate
rm -rf .venv
uv venv
source .venv/bin/activate
(On Windows: .venv\Scripts\activate)

3. Install the MCP client and Daytona SDK dependencies.

uv add "mcp[cli]" pydantic python-dotenv "daytona-sdk>=0.10.5"

4. Set up environment variables for proper operation. The following variables are required or recommended.

MCP_DAYTONA_API_KEY=your_api_key
MCP_DAYTONA_SERVER_URL=https://app.daytona.io/api
MCP_DAYTONA_TIMEOUT=180.0
MCP_DAYTONA_TARGET=eu
MCP_VERIFY_SSL=false

Starting the Daytona MCP Interpreter server

Run the interpreter as a local stdio server. This starts the MCP server in a way that your MCP client can connect directly for command execution and tool operations.

uv run src/daytona_mcp_interpreter/server.py

Testing the server with an inspector

If you want to verify the server is reachable and responding, you can test it with an MCP inspector tool from your development environment.

npx @modelcontextprotocol/inspector \
  uv \
  --directory . \
  run \
  src/daytona_mcp_interpreter/server.py

Logs and troubleshooting

View runtime logs to diagnose startup issues or failed operations. Logs are typically written to a log file in /tmp.

tail -f /tmp/daytona-interpreter.log

Integration with Claude Desktop

Configure your MCP client to connect to the Daytona interpreter by providing the runtime command, arguments, and environment variables. This enables Claude Desktop or other MCP-compatible clients to access the Daytona Python interpreter tools.

{
  "mcpServers": {
    "daytona-interpreter": {
      "command": "/Users/USER/.local/bin/uv",
      "args": [
        "run",
        "src/daytona_mcp_interpreter/server.py"
      ],
      "env": {
        "PYTHONUNBUFFERED": "1",
        "MCP_DAYTONA_API_KEY": "api_key",
        "MCP_DAYTONA_SERVER_URL": "api_server_url",
        "MCP_DAYTONA_TIMEOUT": "30.0",
        "MCP_VERIFY_SSL": "false",
        "PATH": "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
      }
    }
  }
}

Security and best practices

All executions happen inside ephemeral Daytona workspaces that are automatically cleaned up after use. Treat the environment as isolated per task, and avoid transferring secrets unless you encrypt or securely manage them within the sandbox.

Available tools

shell_exec

Executes shell commands inside the Daytona workspace

file_upload

Uploads files to the Daytona workspace, supporting text and binary content

file_download

Downloads files from the Daytona workspace with options for large files, partial content, or text extraction

git_clone

Clones a Git repository into the Daytona workspace with options for branch, depth, and LFS support

web_preview

Generates a preview URL for web servers running inside the Daytona workspace