docker-compose.yml

services:
  aiden_app:
    build:
      context: ./
      dockerfile: ./aiden-web/Dockerfile
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.aiden.rule=Host(`aiden.dev.localhost`)"
      - "traefik.http.services.aiden.loadbalancer.server.port=8000"
    networks:
      - aiden_network
    volumes:
      - ./aiden-web/aiden_app:/app/aiden_app
      - ./aiden-web/aiden_project:/app/aiden_project
      - ./aiden-web/manage.py:/app/manage.py
      - ./aiden-web/media:/app/media

    env_file:
      - .env
    environment:
      - DATABASE_URL=postgres://${DATABASE_USER}:${DATABASE_PASSWORD}@${DATABASE_HOST}:${DATABASE_PORT}/${DATABASE_NAME}
    depends_on:
      db:
        condition: service_healthy
      recommender:
        condition: service_healthy
    deploy:
      resources:
        limits:
          memory: 1g
  db:
    image: postgres
    environment:
      - POSTGRES_DB=${DATABASE_NAME}
      - POSTGRES_USER=${DATABASE_USER}
      - POSTGRES_PASSWORD=${DATABASE_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data/
    networks:
      - aiden_network
    ports:
      - 5432:5432
    expose:
      - "5432"
    healthcheck:
      test:
        [
          "CMD",
          "pg_isready",
          "-U",
          "${DATABASE_USER}",
          "-d",
          "${DATABASE_NAME}"
        ]
      interval: 10s
      timeout: 5s
      retries: 5
    deploy:
      resources:
        limits:
          memory: 512m

  traefik:
    image: "traefik:v2.9"
    command:
      - --entrypoints.web.address=:80
      - --providers.docker=true
      - --api.insecure # Don't do that in production
      - --log
    ports:
      - "80:80"
      - "8080:8080"
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
    networks:
      - aiden_network
    deploy:
      resources:
        limits:
          memory: 512m

  pgweb:
    image: sosedoff/pgweb
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.pgweb.rule=Host(`pgweb.dev.localhost`)"
      - "traefik.http.services.pgweb.loadbalancer.server.port=8081"
    environment:
      - PGWEB_DATABASE_URL=postgres://${DATABASE_USER}:${DATABASE_PASSWORD}@db:5432/${DATABASE_NAME}?sslmode=disable
      - DATABASE_READ_ONLY=true
    networks:
      - aiden_network
    depends_on:
      db:
        condition: service_healthy
    deploy:
      resources:
        limits:
          memory: 512m

  qdrant:
    image: qdrant/qdrant
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.qdrant.rule=Host(`qdrant.dev.localhost`)"
      - "traefik.http.services.qdrant.loadbalancer.server.port=6333" # Adjust port as needed
    networks:
      - aiden_network
    environment:
      - QDRANT_STORAGE_DIR=/qdrant/storage # Adjust path if needed
    volumes:
      - qdrant_data:/qdrant/storage
    deploy:
      resources:
        limits:
          memory: 4g
  recommender:
    build:
      context: ./
      dockerfile: ./aiden-recommender/Dockerfile
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.recommender.rule=Host(`recommender.dev.localhost`)"
      - "traefik.http.services.recommender.loadbalancer.server.port=8082"
    networks:
      - aiden_network
    env_file:
      - .env
    volumes:
      - ./aiden-recommender/aiden_recommender:/app/aiden_recommender
      - ./.env:/app/.env
    command:
      [
        "poetry",
        "run",
        "uvicorn",
        "aiden_recommender.main:app",
        "--host",
        "0.0.0.0",
        "--port",
        "8082",
        "--reload"
      ]

    healthcheck:
      test:
        [
          "CMD-SHELL",
          "curl -f http://localhost:8082/health || exit 1"
        ]
      interval: 10s
      timeout: 5s
      retries: 5
    deploy:
      replicas: 1
      resources:
        limits:
          memory: 1g
    depends_on:
      qdrant:
        condition: service_started
      redis:
        condition: service_healthy

  redis:
    image: redis:alpine
    command:
      [
        "redis-server",
        "--appendonly",
        "no",
        "--maxmemory",
        "118mb",
        "--maxmemory-policy",
        "allkeys-lru"
      ]
    networks:
      - aiden_network
    volumes:
      - redis_data:/data
    healthcheck:
      test: [ "CMD-SHELL", "redis-cli ping" ]
      interval: 10s
      timeout: 5s
      retries: 5
    deploy:
      replicas: 1
      resources:
        limits:
          memory: 128M
  minio:
    image: minio/minio:latest
    ports:
      - 9000:9000
      - 9001:9001
    environment:
      MINIO_ACCESS_KEY: ${AWS_ACCESS_KEY_ID}
      MINIO_SECRET_KEY: ${AWS_SECRET_ACCESS_KEY}
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.minio.rule=Host(`minio.dev.localhost`)"
      - "traefik.http.services.minio.loadbalancer.server.port=9001"
    command: server /data --console-address ":9001"
    volumes:
      - minio_data:/data
    networks:
      - aiden_network

  # Just to initialize an empty media bucket at the start of minio
  minio-client:
    image: minio/mc:latest
    entrypoint: >
      /bin/sh -c "
      /usr/bin/mc config host add --api s3v4 local ${AWS_S3_ENDPOINT_URL} ${AWS_ACCESS_KEY_ID} ${AWS_SECRET_ACCESS_KEY};
      if ! /usr/bin/mc ls local/${AWS_STORAGE_BUCKET_NAME} >/dev/null 2>&1; then
        /usr/bin/mc mb local/${AWS_STORAGE_BUCKET_NAME};
      /usr/bin/mc anonymous set public local/${AWS_STORAGE_BUCKET_NAME};
      else
        echo 'Bucket already exists. Skipping creation.';
      fi;
      "
    depends_on:
      - minio
    networks:
      - aiden_network

volumes:
  postgres_data:
  qdrant_data:
  redis_data:
  minio_data:

networks:
  aiden_network:
    driver: bridge