docker-compose.yml

# ============================================================================
# Future AGI — self-hosted OSS stack
#
# Project name is pinned to `futureagi` so volumes / containers are stable
# regardless of the directory you cloned into and don't collide with other
# `future-agi` worktrees on the same host.
#
# Two modes, gated by COMPOSE_PROFILES (set in .env):
#
#   • light (default, COMPOSE_PROFILES unset)
#       Everything you need to run the app: frontend, backend, worker,
#       agentcc-gateway, serving, code-executor, postgres, clickhouse, redis,
#       minio, temporal. ~12 containers. Analytics views (Observe / Trace
#       drilldowns) will show empty data — they're fed by PeerDB, which is
#       only on in `full` mode.
#
#   • full (COMPOSE_PROFILES=full)
#       Adds the PeerDB CDC stack (10 containers) so transactional Postgres
#       data streams into ClickHouse and analytics views populate. ~22
#       containers. Use this for a real self-host.
#
# Quick start:
#   cp .env.example .env       # optional — empty .env works fine
#   docker compose up                                    # light
#   COMPOSE_PROFILES=full docker compose up              # full
#
# Open http://localhost:3000 once the frontend logs "ready".
# First boot pulls images from Docker Hub (~30s). No source builds.
#
# Each image is independently versioned. Defaults to `:latest`. Pin per
# service in .env for production: FUTURE_AGI_VERSION (backend + worker),
# FRONTEND_VERSION, AGENTCC_GATEWAY_VERSION, SERVING_VERSION,
# CODE_EXECUTOR_VERSION.
#
# For hot-reload development (build from source, volume mounts, per-queue
# workers, exposed DB ports, Temporal UI), layer the dev overlay:
#   docker compose -f docker-compose.yml -f docker-compose.dev.yml up
#
# For production deployments, see ./deploy/README.md.
# ============================================================================

name: futureagi

# PeerDB CDC shared config — used by 5 PeerDB containers
x-peerdb-catalog: &peerdb-catalog
  PEERDB_CATALOG_HOST: peerdb-catalog
  PEERDB_CATALOG_PORT: 5432
  PEERDB_CATALOG_USER: postgres
  PEERDB_CATALOG_PASSWORD: postgres
  PEERDB_CATALOG_DATABASE: postgres

x-peerdb-flow-env: &peerdb-flow-env
  TEMPORAL_HOST_PORT: peerdb-temporal:7233
  PEERDB_TEMPORAL_NAMESPACE: default

x-peerdb-minio-env: &peerdb-minio-env
  PEERDB_CLICKHOUSE_AWS_CREDENTIALS_AWS_ACCESS_KEY_ID: _peerdb_minioadmin
  PEERDB_CLICKHOUSE_AWS_CREDENTIALS_AWS_SECRET_ACCESS_KEY: _peerdb_minioadmin
  PEERDB_CLICKHOUSE_AWS_CREDENTIALS_AWS_REGION: us-east-1
  PEERDB_CLICKHOUSE_AWS_CREDENTIALS_AWS_ENDPOINT_URL_S3: http://peerdb-minio:9000
  PEERDB_CLICKHOUSE_AWS_S3_BUCKET_NAME: peerdbbucket

x-backend-env: &backend-env
  # Local-only defaults. deploy/docker-compose.production.yml re-binds these
  # with ${VAR:?error} guards so prod refuses to boot on the dev values.
  SECRET_KEY: ${SECRET_KEY:-local-dev-only-not-for-production-replace-me}
  ENV_TYPE: ${ENV_TYPE:-development}
  DJANGO_SETTINGS_MODULE: tfc.settings.settings
  FAST_STARTUP: ${FAST_STARTUP:-false}
  OTEL_ENABLED: ${OTEL_ENABLED:-false}

  # LLM gateway + code sandbox + embedding service
  AGENTCC_INTERNAL_URL: http://agentcc-gateway:8090
  AGENTCC_GATEWAY_INTERNAL_URL: http://agentcc-gateway:8090
  AGENTCC_INTERNAL_API_KEY: ${AGENTCC_INTERNAL_API_KEY:-local-dev-only-shared-secret-replace-me}
  AGENTCC_ADMIN_TOKEN: ${AGENTCC_ADMIN_TOKEN:-local-dev-only-admin-token-replace-me}
  RECAPTCHA_ENABLED: ${RECAPTCHA_ENABLED:-false}
  RECAPTCHA_SECRET_KEY: ${RECAPTCHA_SECRET_KEY:-}
  MAILGUN_API_KEY: ${MAILGUN_API_KEY:-}
  MAILGUN_SENDER_DOMAIN: ${MAILGUN_SENDER_DOMAIN:-}
  DEFAULT_FROM_EMAIL: ${DEFAULT_FROM_EMAIL:-}
  SERVER_EMAIL: ${SERVER_EMAIL:-}
  CODE_EXECUTOR_URL: http://code-executor:8060
  SERVING_URL: http://serving:8080

  # Database — point Django's pgbouncer-aware config at postgres directly.
  # Single-instance self-host doesn't need connection pooling; layer pgbouncer
  # back in for multi-backend production if you want it.
  PG_HOST: postgres
  PG_PORT: 5432
  PG_USER: ${PG_USER:-futureagi}
  PG_PASSWORD: ${PG_PASSWORD:-futureagi}
  PG_DB: ${PG_DB:-futureagi}
  PGBOUNCER_HOST: postgres
  PGBOUNCER_PORT: 5432

  # ClickHouse
  CH_HOST: clickhouse
  CH_PORT: 9000
  CH_HTTP_PORT: 8123
  CH_USER: default
  CH_PASSWORD: ""
  CH_DATABASE: default
  CH_USE_REPLICATED_ENGINES: ${CH_USE_REPLICATED_ENGINES:-false}

  # Redis
  REDIS_HOST: redis
  REDIS_PORT: 6379
  REDIS_URL: redis://redis:6379/0
  REDIS_CACHE_URL: redis://redis:6379/1
  REDIS_LOCK_URL: redis://redis:6379/2
  REDIS_STATE_URL: redis://redis:6379/2

  # RabbitMQ for Django Channels / Celery compatibility
  CELERY_BROKER_URL: amqp://${RABBITMQ_USER:-user}:${RABBITMQ_PASSWORD:-password}@rabbitmq:5672//

  # Object storage (MinIO)
  # STORAGE_BACKEND drives URL routing: "minio" for the OSS local stack,
  # "s3" for AWS S3, "gcs" for GCS S3-interop.
  # S3_ENDPOINT_URL is the internal hostname the backend uses to reach
  # MinIO. MINIO_URL is what gets baked into URLs returned to the
  # browser — must be reachable from the user's machine. Override
  # MINIO_URL when accessing the host from outside localhost.
  STORAGE_BACKEND: ${STORAGE_BACKEND:-minio}
  S3_ENDPOINT_URL: http://minio:9000
  MINIO_URL: ${MINIO_URL:-http://localhost:${MINIO_API_PORT:-9005}}
  S3_ACCESS_KEY: ${MINIO_ROOT_USER:-futureagi}
  S3_SECRET_KEY: ${MINIO_ROOT_PASSWORD:-futureagi}
  S3_BUCKET: futureagi

  # Temporal
  TEMPORAL_HOST: temporal:7233
  TEMPORAL_NAMESPACE: ${TEMPORAL_NAMESPACE:-default}

  # BYOK LLM provider keys (optional)
  OPENAI_API_KEY: ${OPENAI_API_KEY:-}
  ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
  GOOGLE_API_KEY: ${GOOGLE_API_KEY:-}
  AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID:-}
  AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY:-}
  AWS_REGION: ${AWS_REGION:-us-east-1}

  # Future AGI Cloud API (optional)
  FUTURE_AGI_CLOUD_API_KEY: ${FUTURE_AGI_CLOUD_API_KEY:-}
  FUTURE_AGI_CLOUD_API_URL: ${FUTURE_AGI_CLOUD_API_URL:-https://api.futureagi.com}


services:
  # ==========================================================================
  # Application
  # ==========================================================================

  frontend:
    image: futureagi/frontend:${FRONTEND_VERSION:-latest}
    ports:
      - "${FRONTEND_PORT:-3000}:80"
    environment:
      # Empty -> SPA falls back through src/config-global.js: import.meta.env
      # -> API_HOST_MAP[hostname] -> http://localhost:8000. Override per
      # deployment (e.g. https://api.example.com for split-domain).
      VITE_HOST_API: ${VITE_HOST_API:-}
    depends_on:
      - backend
    restart: unless-stopped

  backend:
    image: futureagi/future-agi:${FUTURE_AGI_VERSION:-latest}
    ports:
      - "${BACKEND_PORT:-8000}:80"
    env_file:
      - path: .env
        required: false
    environment:
      <<: *backend-env
      SERVICE_TYPE: backend
      GRANIAN_WORKERS: ${GRANIAN_WORKERS:-1}
      GRANIAN_THREADS: ${GRANIAN_THREADS:-2}
      ENABLE_HTTP: ${ENABLE_HTTP:-true}
      ENABLE_GRPC: ${ENABLE_GRPC:-true}
    depends_on:
      postgres:
        condition: service_healthy
      clickhouse:
        condition: service_healthy
      redis:
        condition: service_healthy
      rabbitmq:
        condition: service_healthy
      temporal:
        condition: service_healthy
      agentcc-gateway:
        condition: service_started
    restart: unless-stopped

  worker:
    image: futureagi/future-agi:${FUTURE_AGI_VERSION:-latest}
    env_file:
      - path: .env
        required: false
    environment:
      <<: *backend-env
      SERVICE_TYPE: temporal-worker
      TEMPORAL_ALL_QUEUES: ${TEMPORAL_ALL_QUEUES:-true}
      TEMPORAL_MAX_CONCURRENT_ACTIVITIES: ${TEMPORAL_MAX_CONCURRENT_ACTIVITIES:-50}
      TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASKS: ${TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASKS:-50}
    depends_on:
      temporal:
        condition: service_healthy
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      rabbitmq:
        condition: service_healthy
    restart: unless-stopped

  # LLM gateway. Provider creds live in agentcc-gateway/config.yaml (override
  # the shipped example via AGENTCC_CONFIG_PATH).
  agentcc-gateway:
    image: futureagi/agentcc-gateway:${AGENTCC_GATEWAY_VERSION:-latest}
    ports:
      - "${AGENTCC_GATEWAY_PORT:-8090}:8080"
    env_file:
      - path: .env
        required: false
    environment:
      AGENTCC_INTERNAL_API_KEY: ${AGENTCC_INTERNAL_API_KEY:-local-dev-only-shared-secret-replace-me}
      AGENTCC_ADMIN_TOKEN: ${AGENTCC_ADMIN_TOKEN:-local-dev-only-admin-token-replace-me}
      OPENAI_API_KEY: ${OPENAI_API_KEY:-}
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
      GEMINI_API_KEY: ${GOOGLE_API_KEY:-}
      AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID:-}
      AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY:-}
    volumes:
      - ./${AGENTCC_CONFIG_PATH:-agentcc-gateway/config.example.yaml}:/app/config.yaml:ro
    restart: unless-stopped

  serving:
    image: futureagi/serving:${SERVING_VERSION:-latest}
    ports:
      - "${SERVING_PORT:-8080}:8080"
    env_file:
      - path: .env
        required: false
    environment:
      <<: *backend-env
    depends_on:
      - backend
    restart: unless-stopped

  # Requires privileged: true for nsjail namespaces — won't run on Fargate /
  # managed platforms that disallow privileged containers.
  code-executor:
    image: futureagi/code-executor:${CODE_EXECUTOR_VERSION:-latest}
    ports:
      - "${CODE_EXECUTOR_PORT:-8060}:8060"
    privileged: true
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: "2"
    restart: unless-stopped

  # ==========================================================================
  # Data stores — bound to 127.0.0.1 so only the host can reach them.
  # Put a reverse proxy in front of `frontend` to expose publicly.
  # ==========================================================================

  postgres:
    image: postgres:16
    # wal_level=logical + slots enable PeerDB CDC replication.
    command: >
      postgres
      -c wal_level=logical
      -c max_wal_senders=25
      -c max_replication_slots=25
    environment:
      POSTGRES_USER: ${PG_USER:-futureagi}
      POSTGRES_PASSWORD: ${PG_PASSWORD:-futureagi}
      POSTGRES_DB: ${PG_DB:-futureagi}
    ports:
      - "127.0.0.1:${PG_PORT:-5432}:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${PG_USER:-futureagi} -d ${PG_DB:-futureagi}"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  clickhouse:
    image: clickhouse/clickhouse-server:24.10.2.80
    ports:
      - "127.0.0.1:${CH_HTTP_PORT:-8123}:8123"
      - "127.0.0.1:${CH_PORT:-9000}:9000"
    volumes:
      - clickhouse-data:/var/lib/clickhouse
    ulimits:
      nofile:
        soft: 262144
        hard: 262144
    healthcheck:
      test: ["CMD", "clickhouse-client", "--query", "SELECT 1"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
    ports:
      - "127.0.0.1:${REDIS_PORT:-6379}:6379"
    volumes:
      - redis-data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  rabbitmq:
    image: rabbitmq:3-management
    environment:
      RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER:-user}
      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASSWORD:-password}
    volumes:
      - rabbitmq-data:/var/lib/rabbitmq
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "check_running"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  minio:
    image: minio/minio:RELEASE.2025-02-07T23-21-09Z
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: ${MINIO_ROOT_USER:-futureagi}
      MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-futureagi}
    ports:
      - "127.0.0.1:${MINIO_API_PORT:-9005}:9000"
      - "127.0.0.1:${MINIO_CONSOLE_PORT:-9006}:9001"
    volumes:
      - minio-data:/data
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  # ==========================================================================
  # Temporal — durable workflow engine. Shares the main Postgres.
  # ==========================================================================

  temporal:
    image: temporalio/auto-setup:1.29.1
    environment:
      DB: postgres12
      DB_PORT: 5432
      POSTGRES_USER: ${PG_USER:-futureagi}
      POSTGRES_PWD: ${PG_PASSWORD:-futureagi}
      POSTGRES_SEEDS: postgres
      DBNAME: ${PG_DB:-futureagi}
      ENABLE_ES: "false"
      LOG_LEVEL: info
    ports:
      - "127.0.0.1:${TEMPORAL_PORT:-7233}:7233"
    depends_on:
      postgres:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "pgrep -x temporal-server"]
      interval: 10s
      timeout: 5s
      # First-boot schema setup against postgres can take 60-90s on slow
      # disks. start_period=90s + 15 retries × 10s = up to ~240s before
      # marked unhealthy.
      retries: 15
      start_period: 90s
    restart: unless-stopped

  # ==========================================================================
  # PeerDB — Postgres → ClickHouse change-data-capture. Syncs transactional
  # data to the analytics store so Observe/Trace views work.
  #
  # After first `docker compose up`, register mirrors:
  #   docker compose exec peerdb-init bash /setup.sh
  # PeerDB UI → http://localhost:3001 (creds: peerdb / peerdb)
  # ==========================================================================

  peerdb-catalog:
    image: postgres:16-alpine
    profiles: ["full"]
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: postgres
    volumes:
      - peerdb-catalog-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  peerdb-temporal:
    image: temporalio/auto-setup:1.29
    profiles: ["full"]
    environment:
      DB: postgres12
      DB_PORT: 5432
      POSTGRES_USER: postgres
      POSTGRES_PWD: postgres
      POSTGRES_SEEDS: peerdb-catalog
      DYNAMIC_CONFIG_FILE_PATH: config/dynamicconfig/development-sql.yaml
    volumes:
      - ./futureagi/config/peerdb/temporal-dynamicconfig.yaml:/etc/temporal/config/dynamicconfig/development-sql.yaml
    depends_on:
      peerdb-catalog:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "pgrep -x temporal-server"]
      interval: 10s
      timeout: 5s
      retries: 10
      start_period: 30s
    restart: unless-stopped

  peerdb-minio:
    image: minio/minio:latest
    profiles: ["full"]
    environment:
      MINIO_ROOT_USER: _peerdb_minioadmin
      MINIO_ROOT_PASSWORD: _peerdb_minioadmin
    volumes:
      - peerdb-minio-data:/data
    entrypoint: >
      /bin/sh -c "
      minio server /data --console-address=:36987 &
      sleep 2;
      mc alias set myminiopeerdb http://localhost:9000 _peerdb_minioadmin _peerdb_minioadmin;
      mc mb --ignore-existing myminiopeerdb/peerdbbucket;
      wait
      "
    restart: unless-stopped

  peerdb-flow-api:
    image: ghcr.io/peerdb-io/flow-api:stable-v0.36.9
    profiles: ["full"]
    environment:
      <<: [*peerdb-catalog, *peerdb-flow-env, *peerdb-minio-env]
      PEERDB_ALLOWED_TARGETS:
    depends_on:
      peerdb-temporal:
        condition: service_healthy
    restart: unless-stopped

  peerdb-flow-worker:
    image: ghcr.io/peerdb-io/flow-worker:stable-v0.36.9
    profiles: ["full"]
    environment:
      <<: [*peerdb-catalog, *peerdb-flow-env, *peerdb-minio-env]
    depends_on:
      peerdb-temporal:
        condition: service_healthy
    restart: unless-stopped

  peerdb-flow-snapshot-worker:
    image: ghcr.io/peerdb-io/flow-snapshot-worker:stable-v0.36.9
    profiles: ["full"]
    environment:
      <<: [*peerdb-catalog, *peerdb-flow-env, *peerdb-minio-env]
    depends_on:
      peerdb-temporal:
        condition: service_healthy
    restart: unless-stopped

  peerdb-server:
    image: ghcr.io/peerdb-io/peerdb-server:stable-v0.36.9
    profiles: ["full"]
    stop_signal: SIGINT
    environment:
      <<: *peerdb-catalog
      PEERDB_PASSWORD: peerdb
      PEERDB_FLOW_SERVER_ADDRESS: grpc://peerdb-flow-api:8112
      RUST_LOG: info
    ports:
      - "127.0.0.1:${PEERDB_PORT:-9900}:9900"
    depends_on:
      peerdb-catalog:
        condition: service_healthy
    restart: unless-stopped

  peerdb-ui:
    image: ghcr.io/peerdb-io/peerdb-ui:stable-v0.36.9
    profiles: ["full"]
    environment:
      <<: *peerdb-catalog
      PEERDB_FLOW_SERVER_HTTP: http://peerdb-flow-api:8113
      NEXTAUTH_SECRET: peerdb-local-dev
      NEXTAUTH_URL: http://localhost:${PEERDB_UI_PORT:-3001}
      PEERDB_ALLOWED_TARGETS:
      PEERDB_CLICKHOUSE_ALLOWED_DOMAINS:
    ports:
      - "${PEERDB_UI_PORT:-3001}:3000"
    depends_on:
      - peerdb-flow-api
    restart: unless-stopped

  peerdb-temporal-init:
    image: temporalio/admin-tools
    profiles: ["full"]
    restart: "no"
    environment:
      TEMPORAL_CLI_ADDRESS: peerdb-temporal:7233
    depends_on:
      peerdb-temporal:
        condition: service_healthy
    # Modern temporalio/admin-tools ships `temporal` CLI; `tctl` was removed.
    # `|| true` keeps this idempotent across reboots (second run reports
    # "already exists" and exits non-zero).
    entrypoint: >
      /bin/sh -c "
      echo 'Registering MirrorName search attribute...' &&
      temporal operator search-attribute create --name MirrorName --type Text --namespace default --address peerdb-temporal:7233 || true;
      echo 'Done'
      "

  peerdb-init:
    image: postgres:16-alpine
    profiles: ["full"]
    restart: "no"
    environment:
      SRC_PG_HOST: postgres
      SRC_PG_PORT: 5432
      SRC_PG_USER: ${PG_USER:-futureagi}
      SRC_PG_PASSWORD: ${PG_PASSWORD:-futureagi}
      SRC_PG_DB: ${PG_DB:-futureagi}
      DST_CH_HOST: clickhouse
      DST_CH_PORT: 9000
      DST_CH_USER: default
      DST_CH_PASSWORD: ""
      DST_CH_DB: default
      PEERDB_HOST: peerdb-server
      PEERDB_PORT: 9900
    volumes:
      - ./futureagi/scripts/peerdb-setup-mirrors.sh:/setup.sh:ro
    entrypoint: ["bash", "/setup.sh"]
    depends_on:
      peerdb-temporal-init:
        condition: service_completed_successfully
      peerdb-server:
        condition: service_started
      peerdb-flow-api:
        condition: service_started
      postgres:
        condition: service_healthy
      clickhouse:
        condition: service_healthy


volumes:
  postgres-data:
  clickhouse-data:
  redis-data:
  rabbitmq-data:
  minio-data:
  peerdb-catalog-data:
  peerdb-minio-data:


# Compose auto-names the default network ${PROJECT_NAME}_default
# (i.e. `futureagi_default`). Don't pin a custom name — it collides
# with networks left over from older project-name configurations.