Daytona

by daytonaio

335 downloads

Not rated

GitHub

Other

About

Daytona is an MCP server that enables AI agents to manage Daytona sandboxes, execute shell commands, perform file operations, clone Git repositories, and generate preview links for web applications running in sandboxes. It is intended for users of compatible AI agents such as…

Details

Author: daytonaio
Downloads: 335
Categories: Other

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Daytona

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

From the repository

Install the Daytona CLI (brew install daytonaio/cli/daytona on Mac/Linux, a PowerShell command on Windows), log in with daytona login, then run daytona mcp init [claude/cursor/windsurf] to configure the server for a specific agent. For other agents, run daytona mcp config and paste the resulting JSON into the agent’s MCP configuration.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "daytona": {
            "daytona-mcp": {
                "command": "daytona",
                "args": [
                    "mcp",
                    "start"
                ],
                "env": {
                    "HOME": "${HOME}",
                    "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
                },
                "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
            }
        }
    }
}

McpServers

{
    "daytona-mcp": {
        "command": "daytona",
        "args": [
            "mcp",
            "start"
        ],
        "env": {
            "HOME": "${HOME}",
            "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
        },
        "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
    }
}

Daytona MCP (Model Context Protocol) Server

Daytona MCP Server allows AI agents to utilize:

- Daytona Sandbox Management (Create, Destroy)
- Execute commands in Daytona Sandboxes
- File Operations in Daytona sandboxes
- Generate preview links for web applications running in Daytona Sandboxes

Prerequisites

- Daytona account
- Daytona CLI installed
- A compatible AI agent (Claude Desktop App, Claude Code, Cursor, Windsurf)

Steps to Integrate Daytona MCP Server with an AI Agent

1. Install the Daytona CLI:

Mac/Linux

brew install daytonaio/cli/daytona

Windows

powershell -Command "irm https://get.daytona.io/windows | iex"

2. Log in to your Daytona account:

daytona login

3. Initialize the Daytona MCP server with Claude Desktop/Claude Code/Cursor/Windsurf:

daytona mcp init [claude/cursor/windsurf]

4. Open Agent App

Integrating with Other AI Agents Apps

Run the following command to get a JSON Daytona MCP configuration which you can c/p to your agent configuration:

daytona mcp config

Command outputs the following:

{
  "mcpServers": {
    "daytona-mcp": {
      "command": "daytona",
      "args": ["mcp", "start"],
      "env": {
        "HOME": "${HOME}",
        "PATH": "${HOME}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin"
      },
      "logFile": "${HOME}/Library/Logs/daytona/daytona-mcp-server.log"
    }
  }
}

Note: if you are running Daytona MCP Server on Windows OS, add the following to the env field of the configuration:

"APPDATA": "${APPDATA}"

Finally, open or restart your AI agent

Available Tools

Sandbox Management

- create_sandbox: Create a new sandbox with Daytona

- Parameters:
- target (default: "us"): Target region of the sandbox
- image: Image of the sandbox (optional)
- auto_stop_interval (default: "15"): Auto-stop interval in minutes (0 means disabled)

- destroy_sandbox: Destroy a sandbox with Daytona

File Operations

- upload_file: Upload a file to the Daytona sandbox

- Files can be text or base64-encoded binary content
- Creates necessary parent directories automatically
- Files persist during the session and have appropriate permissions
- Supports overwrite controls and maintains original files formats
- Parameters:
- file_path: Path to the file to upload
- content: Content of the file to upload
- encoding: Encoding of the file to upload
- overwrite: Overwrite the file if it already exists

- download_file: Download a file from the Daytona sandbox

- Returns file content as text or base64 encoded image
- Handles special cases like matplotlib plots stored as JSON
- Parameters:
- file_path: Path to the file to download

- create_folder: Create a new folder in the Daytona sandbox

- Parameters:
- folder_path: Path to the folder to create
- mode: Mode of the folder to create (defaults to 0755)

- get_file_info: Get information about a file in the Daytona workspace

- Parameters:
- file_path: Path to the file to get information about

- list_files: List files in a directory in the Daytona workspace

- Parameters:
- path: Path to the directory to list files from (defaults to current directory)

- move_file: Move or rename a file in the Daytona workspace

- Parameters:
- source_path: Source path of the file to move
- dest_path: Destination path where to move the file

- delete_file: Delete a file or directory in the Daytona workspace

- Parameters:
- file_path: Path to the file or directory to delete

Git Operations

- git_clone: Clone a Git repository into the Daytona workspace

- Parameters:
- url: URL of the Git repository to clone
- path: Directory to clone the repository into (defaults to current directory)
- branch: Branch to clone
- commit_id: Commit ID to clone
- username: Username to clone the repository with
- password: Password to clone the repository with

Command Execution

- execute_command: Execute shell commands in the ephemeral Daytona Linux environment

- Returns full stdout and stderr output with exit codes
- Commands have sandbox user permissions
- Parameters:
- command: Command to execute

Preview

- preview_link: Generate accessible preview URLs for web applications running in the Daytona sandbox

- Creates a secure tunnel to expose local ports externally without configuration
- Validates if a server is actually running on the specified port
- Provides diagnostic information for troubleshooting
- Supports custom descriptions and metadata for better organization of multiple services
- Parameters:
- port: Port to expose
- description: Description of the service
- check_server: Check if a server is running

Troubleshooting

- Authentication issues: Run daytona login to refresh your credentials
- Connection errors: Ensure that the Daytona MCP Server is properly configured
- Sandbox errors: Check sandbox status with daytona sandbox list

Support

For more information, visit daytona.io or contact support at support@daytona.io.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Daytona MCP (Model Context Protocol) Server

Prerequisites

Steps to Integrate Daytona MCP Server with an AI Agent

Integrating with Other AI Agents Apps

Available Tools

Sandbox Management

File Operations

Git Operations

Command Execution

Preview

Troubleshooting

Support

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

Reactive Resume

FastMCP v2 🚀