the0 is an open-source algorithmic trading execution engine that provides production-grade infrastructure for deploying and managing trading bots across multiple markets. Build strategies in your preferred language—Python, TypeScript, Rust, C++, C#, Scala, or Haskell—then deploy them to a self-hosted execution engine with real-time monitoring and custom React dashboards.

Status: Beta - Active development. Not production-ready. Contributions and feedback welcome.

• Multi-Language Support - Build bots in Python, TypeScript, Rust, C++, C#, Scala, or Haskell
• Custom Frontends - Create React dashboards tailored to your trading strategies
• Real-time Execution - Deploy scheduled or continuous trading bots with isolated execution
• Self-Hosted - Full control over your infrastructure and data
• Docker Ready - Streamlined deployment with Docker Compose
• CLI-First Workflow - Efficient bot management via command-line interface
• Exchange Agnostic - Design your bots to work with any trading platform

Deploy the0 locally:

• Docker 20.10+ with Compose plugin (the CLI uses Docker Compose under the hood)
• At least 4GB RAM available for containers

# Install the CLI
curl -sSL https://install.the0.app | sh

# Initialize local compose and configure the root admin
the0 local init --email [email protected] --password testuse123

# Start all services
the0 local start

# Access the platform
open http://localhost:3001/login  # Frontend
open http://localhost:3000  # API
open http://localhost:9001  # MinIO Console (admin/the0password)

Kubernetes is not a one-command install. A production deployment needs operator-managed backing services and secrets for PostgreSQL, MongoDB, S3-compatible object storage, JWT signing, and the deployment-managed root admin. The chart can run NATS in the cluster, or you can point it at an external NATS service.

The Helm chart is published for production use, but prepare a values file and Secret workflow first:

helm repo add the0 https://alexanderwanyoike.github.io/the0
helm repo update

Local development with Minikube:

cd k8s
make minikube-up
make setup-hosts

See Kubernetes Deployment for the full guide, including the external services and root admin configuration the chart expects.

The the0 CLI tool provides a local development interface for managing your bots.

curl -sSL https://install.the0.app | sh

This detects your OS and architecture, downloads the latest release binary, verifies its checksum, and installs it to ~/.the0/bin/the0. Make sure ~/.the0/bin is in your PATH.

# Clone the repository if you haven't already
git clone https://github.com/alexanderwanyoike/the0.git
cd the0/cli

# Build and install the CLI
make install

# Verify installation
the0 --help

The source build installs to ~/bin/the0. Make sure ~/bin is in your PATH.

• Go 1.21+ - Required for building the CLI
• Git - For cloning the repository

Configure API endpoint for local deployments:

# For Docker Compose deployment
export THE0_API_URL=http://localhost:3000

# For Kubernetes deployment  
export THE0_API_URL=http://api.the0.local:3000

For CLI bot usage instructions, visit the official documentation:

📖 the0 CLI Documentation

the0 includes a built-in MCP (Model Context Protocol) server that enables AI assistants like Claude Code to interact directly with the platform. This allows you to manage bots, view logs, and deploy configurations using natural language.

MCP tools require authentication via API key. Generate one from the web dashboard (Settings → API Keys) or via the CLI (the0 auth login).

Option 1: CLI Command

claude mcp add the0 --transport http http://localhost:3000/mcp \
  --header "x-api-key: YOUR_API_KEY"

Option 2: Configuration File

Add to your .mcp.json in the project root:

{
  "mcpServers": {
    "the0": {
      "type": "http",
      "url": "http://localhost:3000/mcp",
      "headers": {
        "x-api-key": "YOUR_API_KEY"
      }
    }
  }
}

For team environments, use environment variable expansion to avoid committing secrets:

{
  "mcpServers": {
    "the0": {
      "type": "http",
      "url": "http://localhost:3000/mcp",
      "headers": {
        "x-api-key": "${THE0_API_KEY}"
      }
    }
  }
}

Restart Claude Code after configuring, then verify with /mcp — you should see the0 server as connected.

Once configured, ask Claude Code:

• "List my deployed bots"
• "Show me the logs for my trading bot"
• "What custom bots are available?"
• "Deploy a new scheduled bot with this configuration"

For detailed MCP documentation including all tool parameters and troubleshooting, see MCP Integration Guide.

the0 is built as a microservices execution engine that enables algorithmic trading bot deployment and management:

graph TB
    subgraph "Users"
        DEV[👨‍💻 Bot Developer<br/>Creates & tests bots]
        TRADER[📊 Trader<br/>Deploys & monitors]
    end
    
    subgraph "the0 Platform"
        subgraph "Client Layer"
            WEB[🌐 Web Dashboard<br/>Next.js 15, React 19<br/>Bot management & monitoring]
            CLI[🛠️ CLI Tool<br/>Go, Cobra<br/>Local development]
        end
        
        subgraph "API Layer"
            API[🚀 API Server<br/>NestJS, TypeScript<br/>REST API & orchestration]
        end
        
        subgraph "Runtime Services"
            BR[⚡ Bot Runner<br/>Go, gRPC<br/>Real-time execution]
            BS[⏰ Bot Scheduler<br/>Go, gRPC<br/>Cron execution]
        end

        subgraph "Data Layer"
            PG[(🐘 PostgreSQL<br/>Users, bots, auth)]
            MONGO[(🍃 MongoDB<br/>Runtime state, logs)]
            NATS[📨 NATS JetStream<br/>Event streaming]
            MINIO[📦 MinIO<br/>Code & log storage]
        end
    end
    
    %% User interactions
    DEV -.->|HTTPS| WEB
    DEV -.->|CLI| CLI
    TRADER -.->|HTTPS| WEB
    
    %% Client to API
    WEB -->|REST + JWT| API
    CLI -->|REST + API Key| API
    API -->|SSE| WEB
    
    %% API to databases
    API -->|SQL| PG
    API -->|Events| NATS
    API -->|S3 API| MINIO
    
    %% Runtime services
    NATS -->|Events| BR
    NATS -->|Events| BS

    BR -->|State| MONGO
    BS -->|Schedules| MONGO

    BR -->|Logs| MINIO
    
    %% Styling
    classDef userClass fill:#e1f5fe,stroke:#0277bd,stroke-width:2px
    classDef clientClass fill:#e8f5e8,stroke:#388e3c,stroke-width:2px
    classDef apiClass fill:#f3e5f5,stroke:#7b1fa2,stroke-width:2px
    classDef runtimeClass fill:#fff8e1,stroke:#f57c00,stroke-width:2px
    classDef dataClass fill:#e0f2f1,stroke:#00695c,stroke-width:2px

    class DEV,TRADER userClass
    class WEB,CLI clientClass
    class API apiClass
    class BR,BS runtimeClass
    class PG,MONGO,NATS,MINIO dataClass

🌐 Web Dashboard - Next.js frontend for bot management, real-time monitoring, and documentation system

🛠️ CLI Tool - Go-based command-line interface for local bot development, testing, and deployment automation

🚀 API Server - NestJS backend providing REST APIs, JWT authentication, and event orchestration across all services

⚙️ Runtime Services - Specialized Go microservices using master-worker patterns for different execution models:

• Bot Runner: Real-time trading bot execution
• Bot Scheduler: Cron-based scheduled execution

💾 Data Architecture - Multi-database approach:

• PostgreSQL: User accounts, bot definitions, authentication
• MongoDB: Runtime state, job queues, execution logs
• MinIO: Bot code storage and logs
• NATS JetStream: Event streaming and service coordination

• Isolated: Each bot runs in isolation with resource management
• Fast: Real-time execution with live market data
• Scalable: Handles multiple bots and users across distributed infrastructure

Build trading bots in any of these languages with official SDK support:

from typing import Dict, Any
from alpaca.trading.client import TradingClient

def main(id: str, config: Dict[str, Any]) -> Dict[str, Any]:
    """Dollar Cost Averaging bot - buys a fixed amount regularly"""
    
    # Initialize trading client
    client = TradingClient(
        api_key=config["api_key"],
        secret_key=config["secret_key"],
        paper=config.get("paper", True)
    )
    
    # Calculate and execute purchase
    symbol = config["symbol"]
    amount = config["amount"]
    
    # Place market buy order
    order = client.submit_order(
        symbol=symbol,
        notional=amount,
        side=OrderSide.BUY,
        type=OrderType.MARKET,
        time_in_force=TimeInForce.DAY
    )
    
    return {
        "status": "success",
        "message": f"Purchased ${amount} of {symbol}",
        "order_id": order.id
    }