docker-compose.yml

services:
  # PlantUML server for generating UML diagrams
  plantuml:
    image: plantuml/plantuml-server:jetty
    container_name: plantuml-server
    ports:
      - "8085:8080"
    restart: unless-stopped

  postgres:
    image: postgres:15-alpine
    container_name: haif-postgres
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-haif}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-haifpass}
      POSTGRES_DB: ${POSTGRES_DB:-haif}
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-haif} -d ${POSTGRES_DB:-haif} -h localhost"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    container_name: haif-redis
    command: ["redis-server","--appendonly","yes"]
    volumes:
      - redisdata:/data
    ports:
      - "6379:6379"
    restart: unless-stopped

  gateway:
    build:
      context: .
      dockerfile: CI/dockerfiles/Dockerfile.gateway
    container_name: haif-gateway
    environment:
      NODE_ENV: production
      SERVICE_NAME: gateway
      PORT: 3000
      REDIS_URL: redis://haif-redis:6379
      # Deprecated HTTP path; gateway now uses RPC internally
      ORCHESTRATOR_PUBLIC_KEY: ${ORCHESTRATOR_PUBLIC_KEY}
      OTEL_PROMETHEUS_PORT: 9464
      OTEL_PROMETHEUS_ENDPOINT: /metrics
      # Use internal DNS of the otel-collector service to avoid host port requirements
      OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: http://otel-collector:4318/v1/traces
    depends_on:
      orchestrator:
        condition: service_healthy
      redis:
        condition: service_started
    ports:
      - "3000:3000"
    healthcheck:
      test: ["CMD-SHELL", "node -e \"process.exit(0)\""]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - haif-net
    restart: unless-stopped

  orchestrator:
    build:
      context: .
      dockerfile: CI/dockerfiles/Dockerfile.orchestrator
    container_name: haif-orchestrator
    environment:
      NODE_ENV: production
      SERVICE_NAME: orchestrator
      PORT: 4000
      # Deterministic key pair for RPC (provide via .env in development)
      ORCHESTRATOR_PUBLIC_KEY: ${ORCHESTRATOR_PUBLIC_KEY}
      ORCHESTRATOR_SECRET_KEY: ${ORCHESTRATOR_SECRET_KEY}
      ORCHESTRATOR_SEED: ${ORCHESTRATOR_SEED}
      ORCHESTRATOR_PK_FILE: /shared/orchestrator_pk.txt
      DATABASE_URL: postgresql://${POSTGRES_USER:-haif}:${POSTGRES_PASSWORD:-haifpass}@haif-postgres:5432/${POSTGRES_DB:-haif}
      REDIS_URL: redis://haif-redis:6379
      WORKER_URL: http://worker:6000
      OTEL_PROMETHEUS_PORT: 9464
      OTEL_PROMETHEUS_ENDPOINT: /metrics
      OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: http://otel-collector:4318/v1/traces
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    ports:
      - "4000:4000"
    volumes:
      - shareddata:/shared
    healthcheck:
      test: ["CMD-SHELL", "node -e \"require('http').get('http://localhost:4000/health', res => { process.exit(res.statusCode===200?0:1) }).on('error', () => process.exit(1))\""]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - haif-net
    restart: unless-stopped

  registry:
    build:
      context: .
      dockerfile: CI/dockerfiles/Dockerfile.registry
    container_name: haif-registry
    environment:
      NODE_ENV: production
      SERVICE_NAME: registry
      PORT: 5000
      DATABASE_URL: postgresql://${POSTGRES_USER:-haif}:${POSTGRES_PASSWORD:-haifpass}@haif-postgres:5432/${POSTGRES_DB:-haif}
      OTEL_PROMETHEUS_PORT: 9464
      OTEL_PROMETHEUS_ENDPOINT: /metrics
      OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: http://otel-collector:4318/v1/traces
    depends_on:
      - postgres
    ports:
      - "5000:5000"
    healthcheck:
      test: ["CMD-SHELL", "node -e \"process.exit(0)\""]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - haif-net
    restart: unless-stopped

  worker:
    build:
      context: .
      dockerfile: CI/dockerfiles/Dockerfile.worker
    container_name: haif-worker
    environment:
      SERVICE_NAME: worker
      WORKER_PORT: 6000
      MODEL_ID: ${MODEL_ID:-HuggingFaceTB/SmolLM3-3B-Base}
      MODEL_DTYPE: ${MODEL_DTYPE:-q8}
      HF_TOKEN: ${HF_TOKEN}
      ORCHESTRATOR_PUBLIC_KEY: ${ORCHESTRATOR_PUBLIC_KEY}
      ORCHESTRATOR_PK_FILE: /shared/orchestrator_pk.txt
      OTEL_PROMETHEUS_PORT: 9464
      OTEL_PROMETHEUS_ENDPOINT: /metrics
      OTEL_EXPORTER_OTLP_TRACES_ENDPOINT: http://otel-collector:4318/v1/traces
    depends_on:
      orchestrator:
        condition: service_healthy
      redis:
        condition: service_started
    ports:
      - "6000:6000"
    volumes:
      - shareddata:/shared
      - transformers_cache:/data/transformers-cache
    healthcheck:
      test: ["CMD-SHELL", "node -e \"process.exit(0)\""]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    networks:
      - haif-net

  web-chat:
    build:
      context: examples/web-chat
      dockerfile: Dockerfile
    container_name: haif-web-chat
    environment:
      GATEWAY_URL: http://http-bridge:8080
    depends_on:
      gateway:
        condition: service_healthy
      http-bridge:
        condition: service_started
    ports:
      - "5173:5173"
    healthcheck:
      test: ["CMD", "node", "-e", "fetch('http://localhost:5173').then(r=>process.exit(r.status===200?0:1)).catch(()=>process.exit(1))"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - haif-net
    restart: unless-stopped

  http-bridge:
    build:
      context: .
      dockerfile: CI/dockerfiles/Dockerfile.http-bridge
    container_name: haif-http-bridge
    environment:
      NODE_ENV: production
      SERVICE_NAME: http-bridge
      PORT: 8080
      ORCHESTRATOR_PUBLIC_KEY: ${ORCHESTRATOR_PUBLIC_KEY}
      TENANT_RATE_LIMIT_RPS: 5
      TENANT_MAX_CONCURRENT: 2
    depends_on:
      orchestrator:
        condition: service_healthy
    ports:
      - "8080:8080"
    networks:
      - haif-net
    restart: unless-stopped

  # Observability stack
  prometheus:
    image: prom/prometheus:latest
    container_name: haif-prometheus
    volumes:
      - ./observability/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - ./observability/alerts.yml:/etc/prometheus/alerts.yml:ro
    command: ["--config.file=/etc/prometheus/prometheus.yml", "--web.enable-lifecycle"]
    ports:
      - "9090:9090"
    networks:
      - haif-net
    restart: unless-stopped

  loki:
    image: grafana/loki:2.9.0
    container_name: haif-loki
    volumes:
      - ./observability/loki-config.yml:/etc/loki/local-config.yaml:ro
      - lokidata:/loki
    command: ["-config.file=/etc/loki/local-config.yaml"]
    ports:
      - "3100:3100"
    networks:
      - haif-net
    restart: unless-stopped

  promtail:
    image: grafana/promtail:2.9.0
    container_name: haif-promtail
    volumes:
      - /var/lib/docker/containers:/var/lib/docker/containers:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./observability/promtail-config.yml:/etc/promtail/config.yml:ro
    command: ["-config.file=/etc/promtail/config.yml"]
    networks:
      - haif-net
    depends_on:
      - loki
    restart: unless-stopped

  jaeger:
    image: jaegertracing/all-in-one:1.46
    container_name: haif-jaeger
    environment:
      COLLECTOR_OTLP_ENABLED: "true"
    ports:
      - "16686:16686" # Jaeger UI
      - "4317:4317"   # OTLP gRPC (optional)
      - "4318:4318"   # OTLP HTTP
    networks:
      - haif-net
    restart: unless-stopped

  grafana:
    image: grafana/grafana:10.4.0
    container_name: haif-grafana
    ports:
      - "3001:3000"
    volumes:
      - ./observability/grafana/datasources:/etc/grafana/provisioning/datasources:ro
      - ./observability/grafana/dashboards/dashboards.yml:/etc/grafana/provisioning/dashboards/dashboards.yml:ro
      - ./observability/grafana/dashboards:/var/lib/grafana/dashboards:ro
    networks:
      - haif-net
    depends_on:
      - prometheus
      - loki
      - jaeger
    restart: unless-stopped

  alertmanager:
    image: prom/alertmanager:latest
    container_name: haif-alertmanager
    volumes:
      - ./observability/alertmanager.yml:/etc/alertmanager/alertmanager.yml:ro
    ports:
      - "9093:9093"
    networks:
      - haif-net
    restart: unless-stopped

  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    container_name: haif-otel-collector
    command: ["--config=/etc/otelcol/config.yaml"]
    volumes:
      - ./observability/otel-collector-config.yaml:/etc/otelcol/config.yaml:ro
    networks:
      - haif-net
    restart: unless-stopped

volumes:
  pgdata:
  redisdata:
  lokidata:
  shareddata:
  transformers_cache:

networks:
  haif-net:
    name: haif-net