version: "3"

services:
  db:
    image: postgres:15
    container_name: db
    restart: always
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
      POSTGRES_DB: trieve
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 10
    volumes:
      - pgdata:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    networks:
      - app-network

  redis:
    image: redis:7.2.2
    container_name: redis
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 10
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    networks:
      - app-network
    command: redis-server --requirepass ${REDIS_PASSWORD}

  qdrant-database:
    image: qdrant/qdrant:v1.7.0
    container_name: qdrant-database
    environment:
      - QDRANT__SERVICE__API_KEY=${QDRANT_API_KEY}
    ports:
      - 6333:6333
      - 6334:6334
    volumes:
      - qdrant_data:/qdrant/storage
    networks:
      - app-network

  s3:
    image: minio/minio:RELEASE.2023-09-27T15-22-50Z
    container_name: s3
    ports:
      - 9000:9000
      - 42625:42625
    environment:
      - MINIO_ROOT_USER=${MINIO_ROOT_USER}
      - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://s3:9000/minio/health/live"]
      interval: 10s
      timeout: 5s
      retries: 10
    volumes:
      - s3-data:/data
    command: server --console-address ":42625" /data
    networks:
      - app-network

  s3-client:
    image: minio/mc
    container_name: s3-client
    depends_on:
      s3:
        condition: service_healthy
    restart: on-failure
    networks:
      - app-network
    entrypoint: >
      /bin/sh -c "
      mc config host add myminio http://s3:9000 ${MINIO_ROOT_USER} ${MINIO_ROOT_PASSWORD};
      mc alias set myminio http://s3:9000 ${MINIO_ROOT_USER} ${MINIO_ROOT_PASSWORD};

      mc admin user add myminio ${S3_ACCESS_KEY} ${S3_SECRET_KEY};
      mc admin policy attach myminio readwrite --user ${S3_ACCESS_KEY};

      mc mb myminio/${S3_BUCKET};


      exit 0;
      "

  tika:
    image: apache/tika:2.9.1.0-full
    container_name: tika
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "wget --spider -S 'http://tika:9998/version' 2>&1 | grep 'HTTP/' | awk '{print $2}' | grep 200 || exit 1",
        ]
      interval: 10s
      timeout: 5s
      retries: 10
    networks:
      - app-network
    ports:
      - 9998:9998

  server:
    image: arguflow/server:no-ocr
    container_name: server
    build:
      context: ./server/
      dockerfile: Dockerfile.no-ocr
    depends_on:
      tika:
        condition: service_healthy
      db:
        condition: service_healthy
      qdrant-database:
        condition: service_started
      redis:
        condition: service_healthy
      keycloak:
        condition: service_healthy
    networks:
      - app-network
    ports:
      - 8090:8090
    environment:
      - ADMIN_API_KEY=${ADMIN_API_KEY}
      - BASE_SERVER_URL=${BASE_SERVER_URL}
      - REDIS_URL=${REDIS_URL}
      - QDRANT_URL=${QDRANT_URL}
      - QDRANT_API_KEY=${QDRANT_API_KEY}
      - DATABASE_URL=${DATABASE_URL}
      - SMTP_RELAY=${SMTP_RELAY}
      - SMTP_USERNAME=${SMTP_USERNAME}
      - SMTP_PASSWORD=${SMTP_PASSWORD}
      - SMTP_EMAIL_ADDRESS=${SMTP_EMAIL_ADDRESS}
      - LLM_API_KEY=${LLM_API_KEY}
      - SECRET_KEY=${SECRET_KEY}
      - SALT=${SALT}
      - S3_ENDPOINT=${S3_ENDPOINT}
      - S3_ACCESS_KEY=${S3_ACCESS_KEY}
      - S3_SECRET_KEY=${S3_SECRET_KEY}
      - S3_BUCKET=${S3_BUCKET}
      - COOKIE_SECURE=${COOKIE_SECURE}
      - QDRANT_COLLECTION=${QDRANT_COLLECTION}
      - TIKA_URL=${TIKA_URL}
      - OPENAI_BASE_URL=${OPENAI_BASE_URL}
      - STRIPE_SECRET=${STRIPE_SECRET}
      - STRIPE_WEBHOOK_SECRET=${STRIPE_WEBHOOK_SECRET}
      - ADMIN_DASHBOARD_URL=${ADMIN_DASHBOARD_URL}
      - PARSER_COMMAND=${PARSER_COMMAND}
      - OIDC_CLIENT_SECRET=${OIDC_CLIENT_SECRET}
      - OIDC_CLIENT_ID=${OIDC_CLIENT_ID}
      - OIDC_AUTH_REDIRECT_URL=${OIDC_AUTH_REDIRECT_URL}
      - OIDC_ISSUER_URL=${OIDC_ISSUER_URL}
      - GPU_SERVER_ORIGIN=${GPU_SERVER_ORIGIN}
      - AWS_REGION=${AWS_REGION}
      - UNLIMITED=${UNLIMITED}

  ingestion-service:
    image: arguflow/ingest
    container_name: ingestion-service 
    build:
      context: ./server/
      dockerfile: Dockerfile.microservice
    depends_on:
      tika:
        condition: service_healthy
      db:
        condition: service_healthy
      qdrant-database:
        condition: service_started
      redis:
        condition: service_healthy
      keycloak:
        condition: service_healthy
    env_file:
      .env

  chat:
    image: arguflow/chat
    container_name: chat
    build: ./chat/
    networks:
      - app-network
    ports:
      - 3000:3000
    environment:
      - VITE_API_HOST=${VITE_API_HOST}

  search:
    image: arguflow/search:no-ocr
    container_name: search
    build: ./search/
    networks:
      - app-network
    ports:
      - 3001:3000
    environment:
      - VITE_API_HOST=${VITE_API_HOST}

  splade-embeddings:
    image: arguflow/splade-embeddings
    container_name: splade-embeddings
    build: ./embedding-server/
    networks:
      - app-network
    ports:
      - 7070:7070
    environment:
      - HF_TOKEN=${HF_TOKEN}

  keycloak:
    image: quay.io/keycloak/keycloak:23.0.1
    container_name: keycloak
    depends_on:
      keycloak-db:
        condition: service_healthy
    environment:
      - KEYCLOAK_ADMIN=admin
      - KEYCLOAK_ADMIN_PASSWORD=aintsecure
      - KC_DATABASE=postgres
      - KC_DATABASE_URL=jdbc:postgresql://keycloak-db:5432/keycloak
      - KC_DB_USERNAME=postgres
      - KC_DB_PASSWORD=password
      - KC_HEALTH_ENABLED=true
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "exec 3<>/dev/tcp/127.0.0.1/8080;echo -e \"GET /health/ready HTTP/1.1\r\nhost: http://localhost\r\nConnection: close\r\n\r\n\" >&3;grep \"HTTP/1.1 200 OK\" <&3",
        ]
      interval: 10s
      timeout: 5s
      retries: 20 # Account for keycloak db starting up and taking time.
    entrypoint: "/opt/keycloak/bin/kc.sh start-dev --import-realm --spi-theme-static-max-age=-1 --spi-theme-cache-themes=false --spi-theme-cache-templates=false"
    volumes:
      - keycloak-data:/opt/keycloak/data
      - ./keycloak/realm-export.json:/opt/keycloak/data/import/realm-export.json
      - ./keycloak/themes/arguflow:/opt/keycloak/themes/arguflow
    ports:
      - 8080:8080
    networks:
      - app-network

  keycloak-db:
    image: postgres:15
    container_name: keycloak-db
    restart: always
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: password
      POSTGRES_DB: keycloak
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres -d keycloak"]
      interval: 10s
      timeout: 5s
      retries: 10
    volumes:
      - pg-keycloak-data:/var/lib/postgresql/data
    ports:
      - "5434:5432"
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

volumes:
  redis-data:
  script-redis-data:
  pgdata:
  qdrant_data:
  s3-data:
  keycloak-data:
  pg-keycloak-data: