docker-compose.yml

# Full-stack deployment: backend + frontend + redis + postgres + neo4j + qdrant + minio
# Usage:
#   docker compose up -d --build
#   open http://localhost:5183         (frontend)
#   open http://localhost:8110/docs    (backend API)
#   open http://localhost:7475         (neo4j browser; neo4j / neo4jpass)
#   open http://localhost:9011         (minio console; minioadmin / minioadmin)

services:
  redis:
    image: redis:7-alpine
    container_name: kp-redis
    volumes:
      - redis_data:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 10

  postgres:
    image: postgres:16-alpine
    container_name: kp-postgres
    environment:
      POSTGRES_USER: kp
      POSTGRES_PASSWORD: kp
      POSTGRES_DB: kp
      POSTGRES_INITDB_ARGS: "--encoding=UTF8"
    ports:
      - "127.0.0.1:5433:5432"
    volumes:
      - pg_data:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U kp -d kp"]
      interval: 5s
      timeout: 3s
      retries: 20

  neo4j:
    image: neo4j:5.20-community
    container_name: kp-neo4j
    environment:
      NEO4J_AUTH: neo4j/neo4jpass
      NEO4J_server_memory_pagecache_size: "256M"
      NEO4J_server_memory_heap_max__size: "512M"
      NEO4J_PLUGINS: '[]'
    ports:
      - "127.0.0.1:7475:7474"
      - "127.0.0.1:7688:7687"
    volumes:
      - neo4j_data:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "cypher-shell -u neo4j -p neo4jpass 'RETURN 1' || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 20
      start_period: 40s

  qdrant:
    image: qdrant/qdrant:latest
    container_name: kp-qdrant
    ports:
      - "127.0.0.1:6335:6333"
    volumes:
      - qdrant_data:/qdrant/storage
    restart: unless-stopped

  minio:
    image: quay.io/minio/minio:latest
    container_name: kp-minio
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: minioadmin
    ports:
      - "127.0.0.1:9010:9000"
      - "127.0.0.1:9011:9001"
    volumes:
      - minio_data:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 10s
      timeout: 5s
      retries: 15
      start_period: 20s

  backend:
    # pyqlib 0.9.7 publishes Linux wheels for x86_64, not arm64.
    # Keep the backend runtime on amd64 so RD-Agent and Qlib share one Docker env.
    platform: linux/amd64
    build:
      context: .
      dockerfile: backend/Dockerfile
    image: knowledge-pipeline-backend:${KP_BACKEND_IMAGE_TAG:-local}
    container_name: kp-backend
    ports:
      - "127.0.0.1:8110:8100"
    env_file:
      # Safe defaults with empty optional API keys. Local secrets may override
      # these values, but the stack must not require a private .env to boot.
      - path: backend/.env.example
        required: true
      - path: backend/.env
        required: false
    environment:
      DATABASE_URL: postgresql+asyncpg://kp:kp@postgres:5432/kp
      KG_STORAGE_MODE: production
      KG_ENABLED: "true"
      KG_INTERNAL_TOKEN: "local-dev-token"
      KG_PG_DSN: postgresql://kp:kp@postgres:5432/kp
      KG_NEO4J_URI: bolt://neo4j:7687
      KG_NEO4J_USER: neo4j
      KG_NEO4J_PASSWORD: neo4jpass
      KG_QDRANT_URL: http://qdrant:6333
      KG_REDIS_URL: redis://redis:6379/0
      KG_MINIO_ENDPOINT: minio:9000
      KG_MINIO_ACCESS_KEY: minioadmin
      KG_MINIO_SECRET_KEY: minioadmin
      KG_MINIO_BUCKET_RAW: kg-raw
      API_PORT: "8100"
      REDIS_URL: redis://redis:6379/0
      CELERY_BROKER_URL: redis://redis:6379/0
      CELERY_RESULT_BACKEND: redis://redis:6379/1
      # ── Market data connectors ──
      TUSHARE_TOKEN: ${TUSHARE_TOKEN:-placeholder}
      GITHUB_TOKEN: ${GITHUB_TOKEN:-}
      FMP_API_KEY: ${FMP_API_KEY:-}
      STOCK_AUTOCN_API_URL: ${STOCK_AUTOCN_API_URL:-http://host.docker.internal:8000}
      # ── Storage services (app-level) ──
      NEO4J_URI: bolt://neo4j:7687
      NEO4J_USER: neo4j
      NEO4J_PASSWORD: neo4jpass
      QDRANT_URL: http://qdrant:6333
      MINIO_ENDPOINT: minio:9000
      MINIO_ACCESS_KEY: minioadmin
      MINIO_SECRET_KEY: minioadmin
      LIFECYCLE_REGISTRY_ROOT: /app/outputs
      # Must equal `docker image inspect ... --format '{{.Id}}'` before a
      # pending Provider Qualification activation can receive runtime acks.
      PROVIDER_QUALIFICATION_IMAGE_ID: ${KP_PROVIDER_RUNTIME_IMAGE_ID:-}
      PROVIDER_QUALIFICATION_PROCESS_ROLE: backend
      PROVIDER_QUALIFICATION_ARTIFACT_ROOT: /app/outputs/provider_qualification
      PROVIDER_RAW_ENVELOPE_ROOT: /app/provider_raw_envelopes
    volumes:
      - kg_data:/app/data
      - ./outputs:/app/outputs:ro
      - ./outputs/provider_raw_envelopes:/app/provider_raw_envelopes
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy
      minio:
        condition: service_healthy
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-fsS", "http://localhost:8100/health"]
      interval: 10s
      timeout: 3s
      retries: 10
      start_period: 30s

  frontend:
    build:
      context: .
      dockerfile: frontend/Dockerfile
    container_name: kp-frontend
    ports:
      - "127.0.0.1:5183:80"
    depends_on:
      backend:
        condition: service_healthy
    restart: unless-stopped

  celery-worker:
    platform: linux/amd64
    build:
      context: .
      dockerfile: backend/Dockerfile
    image: knowledge-pipeline-backend:${KP_BACKEND_IMAGE_TAG:-local}
    container_name: kp-celery-worker
    command: ["celery", "-A", "scheduler.celery_app:app", "worker", "--loglevel=info", "--concurrency=2"]
    env_file:
      - path: backend/.env.example
        required: true
      - path: backend/.env
        required: false
    environment:
      DATABASE_URL: postgresql+asyncpg://kp:kp@postgres:5432/kp
      KG_STORAGE_MODE: production
      KG_ENABLED: "true"
      KG_INTERNAL_TOKEN: "local-dev-token"
      KG_PG_DSN: postgresql://kp:kp@postgres:5432/kp
      KG_REDIS_URL: redis://redis:6379/0
      REDIS_URL: redis://redis:6379/0
      CELERY_BROKER_URL: redis://redis:6379/0
      CELERY_RESULT_BACKEND: redis://redis:6379/1
      TUSHARE_TOKEN: ${TUSHARE_TOKEN:-placeholder}
      GITHUB_TOKEN: ${GITHUB_TOKEN:-}
      FMP_API_KEY: ${FMP_API_KEY:-}
      STOCK_AUTOCN_API_URL: ${STOCK_AUTOCN_API_URL:-http://host.docker.internal:8000}
      PROVIDER_QUALIFICATION_IMAGE_ID: ${KP_PROVIDER_RUNTIME_IMAGE_ID:-}
      PROVIDER_QUALIFICATION_PROCESS_ROLE: celery-worker
      PROVIDER_QUALIFICATION_ARTIFACT_ROOT: /app/outputs/provider_qualification
      PROVIDER_RAW_ENVELOPE_ROOT: /app/provider_raw_envelopes
    volumes:
      - ./outputs:/app/outputs
      - ./outputs/provider_qualification:/app/outputs/provider_qualification:ro
      - ./outputs/provider_raw_envelopes:/app/provider_raw_envelopes
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "celery -A scheduler.celery_app:app inspect ping -d celery@$$HOSTNAME --timeout=3 | grep -q OK"]
      interval: 20s
      timeout: 10s
      retries: 5
      start_period: 30s

  celery-beat:
    platform: linux/amd64
    build:
      context: .
      dockerfile: backend/Dockerfile
    image: knowledge-pipeline-backend:${KP_BACKEND_IMAGE_TAG:-local}
    container_name: kp-celery-beat
    command: ["celery", "-A", "scheduler.celery_app:app", "beat", "--loglevel=info"]
    env_file:
      - path: backend/.env.example
        required: true
      - path: backend/.env
        required: false
    environment:
      DATABASE_URL: postgresql+asyncpg://kp:kp@postgres:5432/kp
      KG_STORAGE_MODE: production
      KG_ENABLED: "true"
      KG_PG_DSN: postgresql://kp:kp@postgres:5432/kp
      KG_REDIS_URL: redis://redis:6379/0
      REDIS_URL: redis://redis:6379/0
      CELERY_BROKER_URL: redis://redis:6379/0
      CELERY_RESULT_BACKEND: redis://redis:6379/1
      PROVIDER_QUALIFICATION_IMAGE_ID: ${KP_PROVIDER_RUNTIME_IMAGE_ID:-}
      PROVIDER_QUALIFICATION_PROCESS_ROLE: celery-beat
      PROVIDER_QUALIFICATION_ARTIFACT_ROOT: /app/outputs/provider_qualification
    volumes:
      - ./outputs:/app/outputs:ro
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "python -c \"from pathlib import Path; cmd = Path('/proc/1/cmdline').read_bytes().decode(); raise SystemExit(0 if 'beat' in cmd else 1)\""]
      interval: 20s
      timeout: 5s
      retries: 5
      start_period: 20s

  lightpanda:
    image: lightpanda/browser:nightly
    container_name: kp-lightpanda
    ports:
      - "127.0.0.1:9222:9222"
    environment:
      LIGHTPANDA_DISABLE_TELEMETRY: "true"
    restart: unless-stopped
    profiles: ["browser"]

volumes:
  redis_data:
  kg_data:
  pg_data:
  neo4j_data:
  qdrant_data:
  minio_data: