docker-compose.yml

services:
  # PostgreSQL with TimescaleDB extension
  postgres:
    image: timescale/timescaledb:latest-pg17
    container_name: cryptofunk-postgres
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD environment variable is required}
      POSTGRES_DB: cryptofunk
      PGDATA: /var/lib/postgresql/data/pgdata
    ports:
      - "127.0.0.1:5432:5432"
    deploy:
      resources:
        limits:
          memory: 2G
          cpus: '2.0'
    volumes:
      - postgres-data:/var/lib/postgresql/data
      - ./migrations:/docker-entrypoint-initdb.d
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    networks:
      - cryptofunk
    restart: unless-stopped

  # Redis for caching and pub/sub
  redis:
    image: redis:7-alpine
    container_name: cryptofunk-redis
    ports:
      - "127.0.0.1:6379:6379"
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: '1.0'
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes --maxmemory 512mb --maxmemory-policy allkeys-lru
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 5s
    networks:
      - cryptofunk
    restart: unless-stopped

  # NATS for message streaming
  nats:
    image: nats:2-alpine
    container_name: cryptofunk-nats
    ports:
      - "127.0.0.1:4222:4222"  # Client connections
      - "127.0.0.1:8222:8222"  # HTTP monitoring
      - "127.0.0.1:6222:6222"  # Cluster routing
    volumes:
      - nats-data:/data
    command: ["-js", "-sd", "/data", "-m", "8222"]  # Enable JetStream with persistent storage and monitoring
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: '1.0'
    healthcheck:
      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8222/healthz"]
      interval: 10s
      timeout: 3s
      retries: 5
      start_period: 5s
    networks:
      - cryptofunk
    restart: unless-stopped

  # NATS Prometheus Exporter
  nats-exporter:
    image: natsio/prometheus-nats-exporter:latest
    container_name: cryptofunk-nats-exporter
    command:
      - "-varz"
      - "-connz"
      - "-routez"
      - "-subz"
      - "-jsz=all"
      - "http://nats:8222"
    ports:
      - "7777:7777"
    deploy:
      resources:
        limits:
          memory: 256M
          cpus: '0.25'
    depends_on:
      nats:
        condition: service_healthy
    networks:
      - cryptofunk
    restart: unless-stopped

  # HashiCorp Vault for secrets management
  vault:
    image: hashicorp/vault:latest
    container_name: cryptofunk-vault
    ports:
      - "127.0.0.1:8200:8200"
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    environment:
      VAULT_DEV_ROOT_TOKEN_ID: ${VAULT_DEV_TOKEN:-cryptofunk-dev-token}
      VAULT_DEV_LISTEN_ADDRESS: "0.0.0.0:8200"
      VAULT_ADDR: "http://0.0.0.0:8200"
    cap_add:
      - IPC_LOCK
    volumes:
      - vault-data:/vault/data
    command: server -dev -dev-root-token-id=${VAULT_DEV_TOKEN:-cryptofunk-dev-token}
    healthcheck:
      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8200/v1/sys/health"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    networks:
      - cryptofunk
    restart: unless-stopped

  # Bifrost LLM Gateway
  bifrost:
    image: maximhq/bifrost:latest
    container_name: cryptofunk-bifrost
    environment:
      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY}
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      GEMINI_API_KEY: ${GEMINI_API_KEY:-}
      BIFROST_PORT: 8080
      REDIS_URL: redis://redis:6379
    ports:
      - "8080:8080"
    volumes:
      - ./configs/bifrost.yaml:/etc/bifrost/config.yaml:ro
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: '1.0'
    depends_on:
      redis:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8080/api/v1/health"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    networks:
      - cryptofunk
    restart: unless-stopped

  # Prometheus for metrics
  prometheus:
    image: prom/prometheus:latest
    container_name: cryptofunk-prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./deployments/prometheus/prometheus-docker.yml:/etc/prometheus/prometheus.yml:ro
      - ./deployments/prometheus/alerts:/etc/prometheus/alerts:ro
      - prometheus-data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
      - '--web.console.libraries=/usr/share/prometheus/console_libraries'
      - '--web.console.templates=/usr/share/prometheus/consoles'
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: '1.0'
    # Allow Prometheus container to scrape metrics from host-bound agent services via host.docker.internal
    extra_hosts:
      - "host.docker.internal:host-gateway"
    networks:
      - cryptofunk
    restart: unless-stopped

  # AlertManager for alert routing and notification
  alertmanager:
    image: prom/alertmanager:latest
    container_name: cryptofunk-alertmanager
    ports:
      - "9093:9093"
    volumes:
      - ./deployments/prometheus/alertmanager.yml:/etc/alertmanager/alertmanager.yml:ro
      - alertmanager-data:/alertmanager
    command:
      - '--config.file=/etc/alertmanager/alertmanager.yml'
      - '--storage.path=/alertmanager'
      - '--log.level=info'
    environment:
      # Slack webhook URL
      SLACK_WEBHOOK_URL: ${SLACK_WEBHOOK_URL:-https://hooks.slack.com/services/YOUR/WEBHOOK/URL}
      # SMTP configuration
      SMTP_HOST: ${SMTP_HOST:-smtp.gmail.com}
      SMTP_PORT: ${SMTP_PORT:-587}
      SMTP_FROM: ${SMTP_FROM:-cryptofunk-alerts@example.com}
      SMTP_USERNAME: ${SMTP_USERNAME:-}
      SMTP_PASSWORD: ${SMTP_PASSWORD:-}
      # Alert recipients
      ALERT_EMAIL_TO: ${ALERT_EMAIL_TO:-team@example.com}
      CRITICAL_ALERT_EMAIL_TO: ${CRITICAL_ALERT_EMAIL_TO:-oncall@example.com}
    deploy:
      resources:
        limits:
          memory: 256M
          cpus: '0.25'
    networks:
      - cryptofunk
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:9093/-/healthy"]
      interval: 10s
      timeout: 5s
      retries: 3

  # Grafana for visualization
  grafana:
    image: grafana/grafana:latest
    container_name: cryptofunk-grafana
    environment:
      GF_SECURITY_ADMIN_USER: ${GRAFANA_ADMIN_USER:-admin}
      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD:?GRAFANA_ADMIN_PASSWORD environment variable is required}
      GF_INSTALL_PLUGINS: grafana-clock-panel,grafana-simple-json-datasource
    ports:
      - "3030:3000"
    volumes:
      - grafana-data:/var/lib/grafana
      - ./grafana/dashboards:/etc/grafana/provisioning/dashboards:ro
      - ./grafana/datasources.yml:/etc/grafana/provisioning/datasources/datasources.yml:ro
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      - prometheus
    networks:
      - cryptofunk
    restart: unless-stopped

  # ========================================
  # Application Services
  # ========================================

  # Database Migration (one-shot)
  migrate:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.migrate
    container_name: cryptofunk-migrate
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
    depends_on:
      postgres:
        condition: service_healthy
    deploy:
      resources:
        limits:
          memory: 256M
          cpus: '0.25'
    networks:
      - cryptofunk
    command: ["up"]
    restart: on-failure

  # MCP Orchestrator
  orchestrator:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.orchestrator
    container_name: cryptofunk-orchestrator
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      BIFROST_URL: http://bifrost:8080
      LOG_LEVEL: ${LOG_LEVEL:-info}
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: '1.0'
    ports:
      - "8081:8080"
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      nats:
        condition: service_healthy
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # MCP Server: Market Data
  market-data-server:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.mcp-server
      args:
        SERVER_NAME: market-data
    container_name: cryptofunk-market-data-server
    command: ["--metrics-port", "9110"]
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      COINGECKO_API_KEY: ${COINGECKO_API_KEY:-}
      LOG_LEVEL: ${LOG_LEVEL:-info}
      MCP_ALLOW_NO_AUTH: "true"
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # MCP Server: Technical Indicators
  technical-indicators-server:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.mcp-server
      args:
        SERVER_NAME: technical-indicators
    container_name: cryptofunk-technical-indicators-server
    command: ["--metrics-port", "9113"]
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      LOG_LEVEL: ${LOG_LEVEL:-info}
      MCP_ALLOW_NO_AUTH: "true"
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # MCP Server: Risk Analyzer
  risk-analyzer-server:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.mcp-server
      args:
        SERVER_NAME: risk-analyzer
    container_name: cryptofunk-risk-analyzer-server
    command: ["--metrics-port", "9112"]
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      LOG_LEVEL: ${LOG_LEVEL:-info}
      MCP_ALLOW_NO_AUTH: "true"
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # MCP Server: Order Executor
  order-executor-server:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.mcp-server
      args:
        SERVER_NAME: order-executor
    container_name: cryptofunk-order-executor-server
    command: ["--metrics-port", "9111"]
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      BINANCE_API_KEY: ${BINANCE_API_KEY:-}
      BINANCE_API_SECRET: ${BINANCE_API_SECRET:-}
      TRADING_MODE: ${TRADING_MODE:-PAPER}
      LOG_LEVEL: ${LOG_LEVEL:-info}
      MCP_ALLOW_NO_AUTH: "true"
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # Trading Agent: Technical Analysis
  technical-agent:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.agent
      args:
        AGENT_NAME: technical-agent
    container_name: cryptofunk-technical-agent
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      BIFROST_URL: http://bifrost:8080
      ORCHESTRATOR_URL: http://orchestrator:8080
      LOG_LEVEL: ${LOG_LEVEL:-info}
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      nats:
        condition: service_healthy
      orchestrator:
        condition: service_started
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # Trading Agent: Order Book Analysis
  orderbook-agent:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.agent
      args:
        AGENT_NAME: orderbook-agent
    container_name: cryptofunk-orderbook-agent
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      BIFROST_URL: http://bifrost:8080
      ORCHESTRATOR_URL: http://orchestrator:8080
      LOG_LEVEL: ${LOG_LEVEL:-info}
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      nats:
        condition: service_healthy
      orchestrator:
        condition: service_started
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # Trading Agent: Sentiment Analysis
  sentiment-agent:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.agent
      args:
        AGENT_NAME: sentiment-agent
    container_name: cryptofunk-sentiment-agent
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      BIFROST_URL: http://bifrost:8080
      ORCHESTRATOR_URL: http://orchestrator:8080
      LOG_LEVEL: ${LOG_LEVEL:-info}
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      nats:
        condition: service_healthy
      orchestrator:
        condition: service_started
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # Trading Agent: Trend Following
  trend-agent:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.agent
      args:
        AGENT_NAME: trend-agent
    container_name: cryptofunk-trend-agent
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      BIFROST_URL: http://bifrost:8080
      ORCHESTRATOR_URL: http://orchestrator:8080
      LOG_LEVEL: ${LOG_LEVEL:-info}
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      nats:
        condition: service_healthy
      orchestrator:
        condition: service_started
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # Trading Agent: Mean Reversion
  reversion-agent:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.agent
      args:
        AGENT_NAME: reversion-agent
    container_name: cryptofunk-reversion-agent
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      BIFROST_URL: http://bifrost:8080
      ORCHESTRATOR_URL: http://orchestrator:8080
      LOG_LEVEL: ${LOG_LEVEL:-info}
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      nats:
        condition: service_healthy
      orchestrator:
        condition: service_started
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # Trading Agent: Risk Management
  risk-agent:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.agent
      args:
        AGENT_NAME: risk-agent
    container_name: cryptofunk-risk-agent
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      BIFROST_URL: http://bifrost:8080
      ORCHESTRATOR_URL: http://orchestrator:8080
      LOG_LEVEL: ${LOG_LEVEL:-info}
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      nats:
        condition: service_healthy
      orchestrator:
        condition: service_started
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # Outcome Resolver (runs once and exits; schedule via cron or restart policy)
  # To run periodically: use `docker compose run --rm outcome-resolver` in a cron job
  # Example crontab: */30 * * * * cd /path/to/cryptofunk && docker compose run --rm outcome-resolver
  outcome-resolver:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.migrate
    container_name: cryptofunk-outcome-resolver
    entrypoint: ["/app/outcome-resolver"]
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      LOG_LEVEL: ${LOG_LEVEL:-info}
    depends_on:
      postgres:
        condition: service_healthy
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: "no"
    profiles:
      - tools

  # REST/WebSocket API Server
  api:
    build:
      context: .
      dockerfile: deployments/docker/Dockerfile.api
    container_name: cryptofunk-api
    environment:
      DATABASE_URL: postgresql://postgres:${POSTGRES_PASSWORD}@postgres:5432/cryptofunk?sslmode=disable
      REDIS_URL: redis://redis:6379
      NATS_URL: nats://nats:4222
      ORCHESTRATOR_URL: http://orchestrator:8080
      API_PORT: 8080
      CRYPTOFUNK_TRADING_MODE: ${TRADING_MODE:-PAPER}
      JWT_SECRET: ${JWT_SECRET:?JWT_SECRET environment variable is required}
      CORS_ORIGINS: ${CORS_ORIGINS:-http://localhost:3000,http://localhost:3001,http://localhost:3333}
      LOG_LEVEL: ${LOG_LEVEL:-info}
    ports:
      - "8082:8080"
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      nats:
        condition: service_healthy
      orchestrator:
        condition: service_started
      migrate:
        condition: service_completed_successfully
    networks:
      - cryptofunk
    restart: unless-stopped

  # Next.js Dashboard
  dashboard:
    build:
      context: web/dashboard
      dockerfile: ../../deployments/docker/Dockerfile.dashboard
      args:
        NEXT_PUBLIC_API_URL: http://api:8080
    container_name: cryptofunk-dashboard
    environment:
      NEXT_PUBLIC_API_URL: http://api:8080
    ports:
      - "3001:3000"
    depends_on:
      api:
        condition: service_started
    networks:
      - cryptofunk
    restart: unless-stopped

networks:
  cryptofunk:
    driver: bridge
    name: cryptofunk-network

volumes:
  postgres-data:
    name: cryptofunk-postgres-data
  redis-data:
    name: cryptofunk-redis-data
  prometheus-data:
    name: cryptofunk-prometheus-data
  alertmanager-data:
    name: cryptofunk-alertmanager-data
  grafana-data:
    name: cryptofunk-grafana-data
  vault-data:
    name: cryptofunk-vault-data
  nats-data:
    name: cryptofunk-nats-data