Deployment

Install and run Mycel in production

Prerequisites

Required:

• Python 3.11+
• uv package manager — installation guide
• Node.js 18+ (for the Web UI)
• Git

Optional (by sandbox provider):

• Docker daemon — for the Docker sandbox provider
• E2B API key — e2b.dev
• Daytona API key — daytona.io or self-hosted instance
• AgentBay API key and region access

Installation

1. Clone the repository

   git clone https://github.com/OpenDCAI/Mycel.git
   cd Mycel
   
2. Install Python dependencies

   # Core dependencies
   uv sync
   
   # With specific sandbox providers
   uv sync --extra e2b        # E2B
   uv sync --extra daytona    # Daytona
   uv sync --extra sandbox    # AgentBay
   uv sync --extra all        # Everything
   

   Docker works out of the box — just needs Docker installed.

3. Install frontend dependencies

   cd frontend/app && npm install && cd ../..
   

Configuration

Runtime configuration

Mycel service configuration comes from process environment variables and explicit server configuration. Agent configs, Skills, threads, Library resources, and user profiles are product state and are stored through the configured backend storage.

Quick setup

Export variables in the shell or point ENV_FILE at an explicit env file:

ANTHROPIC_API_KEY=sk-ant-xxx
# Or use OpenAI-compatible format:
# OPENAI_API_KEY=your-key
# OPENAI_BASE_URL=https://api.openai.com/v1
# MODEL_NAME=gpt-4o

Starting services

Local communication backend

The previous deploy/local-communication/compose.yml path has been removed because it booted from a hand-written schema fork. Treat it as historical proof only, not as a valid self-hosting contract.

deploy/cli-minimal/compose.yml is the current CLI-minimal local communication profile. It reuses the formal Mycel app schema/init path, runs PostgreSQL plus PostgREST, exposes /rest/v1/* through a thin nginx gateway, and starts the backend with MYCEL_RUNTIME_PROFILE=communication.

It is not the full Mycel platform. Full deployment is still represented by the root docker-compose.yml plus operator-managed Supabase/Coolify configuration, not by a deploy/full public self-hosting contract.

Start the local-only profile:

python3 deploy/cli-minimal/generate-env.py > deploy/cli-minimal/.env
docker compose --env-file deploy/cli-minimal/.env -f deploy/cli-minimal/compose.yml up

To let another machine connect, publish an explicit URL and point cel at it:

python3 deploy/cli-minimal/generate-env.py \
  --bind-host 0.0.0.0 \
  --public-url http://<host-or-lan-ip>:8042 \
  > deploy/cli-minimal/.env
docker compose --env-file deploy/cli-minimal/.env -f deploy/cli-minimal/compose.yml up
cel connect http://<host-or-lan-ip>:8042

Full development stack

# Terminal 1: backend
uv run python -m backend.web.main
# → http://localhost:8001

# Terminal 2: frontend
cd frontend/app && npm run dev
# → http://localhost:5173

Override the backend port:

PORT=9000 uv run python -m backend.web.main
# or
LEON_BACKEND_PORT=9000 uv run python -m backend.web.main

Sandbox provider setup

See Sandbox for full provider configuration. Quick reference:

Docker

Set LEON_SANDBOXES_DIR to your sandbox provider config directory, then create docker.json in that directory:

{
  "provider": "docker",
  "on_exit": "pause",
  "docker": {
    "image": "python:3.12-slim",
    "mount_path": "/workspace"
  }
}

E2B

{
  "provider": "e2b",
  "on_exit": "pause",
  "e2b": {
    "api_key": "${E2B_API_KEY}",
    "template": "base",
    "cwd": "/home/user",
    "timeout": 300
  }
}

Daytona (SaaS)

{
  "provider": "daytona",
  "on_exit": "pause",
  "daytona": {
    "api_key": "${DAYTONA_API_KEY}",
    "api_url": "https://app.daytona.io/api",
    "cwd": "/home/daytona"
  }
}

Daytona (self-hosted)

{
  "provider": "daytona",
  "on_exit": "pause",
  "daytona": {
    "api_key": "${DAYTONA_API_KEY}",
    "api_url": "http://localhost:3986/api",
    "target": "us",
    "cwd": "/workspace"
  }
}

Self-hosted requirements:

1. Runner container image must have bash at /usr/bin/bash
2. Workspace image must have bash at /usr/bin/bash
3. Runner must be on both the compose network and the default Docker bridge network

Docker Compose network configuration:

services:
  daytona-runner:
    image: your-runner-image-with-bash
    environment:
      - RUNNER_DOMAIN=runner  # NOT localhost
    networks:
      - default
      - bridge

networks:
  bridge:
    external: true

Add to /etc/hosts on the runner:

127.0.0.1 proxy.localhost

Daytona Proxy (port 4000) must be accessible from the runner for file operations.

AgentBay

{
  "provider": "agentbay",
  "on_exit": "pause",
  "agentbay": {
    "api_key": "${AGENTBAY_API_KEY}",
    "region_id": "ap-southeast-1",
    "context_path": "/home/wuying"
  }
}

Verification

Open the Web UI at http://localhost:5173, register an account, and confirm the agent responds.

Production notes

Database

Mycel runtime storage is explicit. Full production deployments should provide their own managed Supabase-compatible storage and secrets.

Back up the configured database with the tools for that database.

Security

• Store API keys in the deployment secret store or an explicit env file, never in code or version control
• Use ${VAR} substitution in JSON config files instead of hardcoding keys
• Restrict env file permissions when using one: chmod 600 /path/to/mycel.env
• The block_dangerous_commands setting (default: true) prevents rm -rf and similar shell commands

Proxy environments

If your environment uses an HTTP proxy:

# Prevent proxy from affecting the LLM client or Docker CLI
env -u ALL_PROXY -u all_proxy uv run python -m backend.web.main

Troubleshooting

"Could not import module" on backend startup

• Confirm you’re in the correct directory
• Confirm the virtual environment is active: source .venv/bin/activate
• Try using the full path: .venv/bin/python -m backend.web.main

"SOCKS proxy error" from LLM client

Your shell has all_proxy=socks5://... set. Unset before starting:

env -u ALL_PROXY -u all_proxy uv run python -m backend.web.main

Docker provider hangs

Proxy environment variables inherited by the Docker CLI. Mycel strips these automatically, but if issues persist, check the docker_host config field in $LEON_SANDBOXES_DIR/docker.json.

Daytona PTY bootstrap fails

Check each of these in order:

1. Workspace image has bash at /usr/bin/bash — test with docker run <image> /usr/bin/bash -c "echo ok"
2. Runner has bash at /usr/bin/bash
3. Runner is on the Docker bridge network (see Docker Compose config above)
4. Daytona Proxy (port 4000) is accessible from the runner — test with curl http://proxy.localhost:4000

Common error messages:

• fork/exec /usr/bin/bash: no such file or directory → workspace image missing bash
• Failed to create sandbox within 60s → network isolation, check runner networks
• File operations fail silently → Daytona Proxy unreachable