docker-compose.yml

services:
  meilisearch:
    image: getmeili/meilisearch:v1.16
    ports:
      - "7700:7700"
    environment:
      - MEILI_MASTER_KEY=${MEILI_KEY}
    volumes:
      - meili_data:/meili_data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:7700/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  meili-init:
    image: curlimages/curl:8.4.0
    depends_on:
      meilisearch:
        condition: service_healthy
    environment:
      - MEILI_KEY=${MEILI_KEY}
      - EMBED_DIM=${EMBED_DIM}
    volumes:
      - ./scripts/meili-init.sh:/meili-init.sh
    command: ["/bin/sh", "/meili-init.sh"]
    restart: "no"

  tei-embeddings:
    image: ghcr.io/huggingface/text-embeddings-inference:cpu-latest
    platform: linux/amd64
    environment:
      - HF_HUB_ENABLE_HF_TRANSFER=1
      - HUGGINGFACE_HUB_CACHE=/data
      - HF_HOME=/data
    volumes:
      - tei_model_cache:/data
    command: ["--model-id", "sentence-transformers/all-MiniLM-L6-v2", "--hostname", "0.0.0.0"]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:80/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  litellm:
    image: ghcr.io/berriai/litellm:main-stable
    environment:
      - LITELLM_PROXY_MASTER_KEY=${PROXY_KEY}
      - GROQ_API_KEY=${GROQ_API_KEY}
      - LANGSMITH_API_KEY=${LANGSMITH_API_KEY}     
      - LANGSMITH_PROJECT=${LANGSMITH_PROJECT:-ragops}
      - LANGSMITH_BASE_URL=${LANGSMITH_BASE_URL}
    volumes:
      - ./litellm/config.yaml:/app/config.yaml
    command: ["--config", "/app/config.yaml"]
    depends_on:
      - tei-embeddings
      - redis
    restart: always
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:4000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  redis:
    image: redis:7-alpine
    command: ["redis-server", "--save", "60", "1", "--loglevel", "warning"]
    volumes:
      - redis_data:/data
    restart: unless-stopped

  backend:
    build: ./backend
    command: uvicorn app.main:app --host 0.0.0.0 --port 8000
    environment:
      - MEILI_URL=${MEILI_URL}
      - MEILI_KEY=${MEILI_KEY}
      - PROXY_URL=${PROXY_URL}
      - PROXY_KEY=${PROXY_KEY}
      - REDIS_URL=${REDIS_URL}
      - LITELLM_MODEL=${LITELLM_MODEL}
      - EMBEDDING_MODEL_NAME=${EMBEDDING_MODEL_NAME}
      - POSTGRES_URL=${POSTGRES_URL}
      - MINIO_ENDPOINT=${MINIO_ENDPOINT}
      - MINIO_ACCESS_KEY=${MINIO_ACCESS_KEY}
      - MINIO_SECRET_KEY=${MINIO_SECRET_KEY}
      - MINIO_BUCKET=${MINIO_BUCKET}
    depends_on:
      - meilisearch
      - meili-init
      - litellm
      - tei-embeddings
      - redis
      - postgres
      - minio
    restart: unless-stopped
    volumes:
      - ./tests:/app/tests
    ports:
      - "18000:8000"
    healthcheck:
      test: ["CMD", "python", "-c", "import httpx,sys; sys.exit(0) if httpx.get('http://localhost:8000/health',timeout=5).status_code==200 else sys.exit(1)"]
      interval: 20s
      timeout: 5s
      retries: 5

  seed:
    build: ./backend
    command: ["python", "seed_data.py"]
    environment:
      - MEILI_URL=${MEILI_URL}
      - MEILI_KEY=${MEILI_KEY}
      - PROXY_URL=${PROXY_URL}
      - PROXY_KEY=${PROXY_KEY}
    depends_on:
      meilisearch:
        condition: service_healthy
      backend:
        condition: service_healthy
      litellm:
        condition: service_started
      tei-embeddings:
        condition: service_started
    restart: "on-failure"
    profiles: ["manual"]  # only run manually when needed

  ragas_eval:
    build: ./backend
    command: ["python", "-m", "app.eval.ragas_eval"] # Command to run the script
    environment:
      - PROXY_URL=${PROXY_URL}
      - PROXY_KEY=${PROXY_KEY} 
      - MEILI_URL=${MEILI_URL}
      - MEILI_KEY=${MEILI_KEY}
      - LITELLM_MODEL=${LITELLM_MODEL}
      - REDIS_URL=${REDIS_URL}
      - EMBEDDING_MODEL_NAME=${EMBEDDING_MODEL_NAME}
    depends_on:
      meilisearch:
        condition: service_healthy
      litellm:
        condition: service_started
      tei-embeddings:
        condition: service_started
      redis:
        condition: service_started
    restart: "on-failure"
    profiles: ["eval"] 
  
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./monitoring/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
    ports:
      - "9090:9090"
    restart: unless-stopped
    depends_on:
      - backend

  grafana:
    image: grafana/grafana:9.0.0
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
      - GF_USERS_ALLOW_SIGN_UP=false
    volumes:
      - ./monitoring/grafana/provisioning:/etc/grafana/provisioning:ro
      - ./monitoring/grafana/dashboards:/var/lib/grafana/dashboards:ro
    restart: unless-stopped
    depends_on:
      - prometheus

  postgres:
    image: postgres:15
    restart: always
    environment:
      POSTGRES_USER: ragops
      POSTGRES_PASSWORD: ragops
      POSTGRES_DB: metadata
    volumes:
      - ./db/init.sql:/docker-entrypoint-initdb.d/init.sql
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ragops -d metadata"]
      interval: 10s
      timeout: 5s
      retries: 5

  minio:
    image: minio/minio
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: minioadmin
    ports:
      - "9000:9000"
      - "9001:9001"
    volumes: 
      - minio_data:/data
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 10s
      timeout: 5s
      retries: 5


volumes:
  meili_data:
  redis_data:
  tei_model_cache:
  postgres_data:
  minio_data:

  # nginx:  # Optional: behind Traefik or other ingress; enable and map ports only if needed
  #   image: nginx:alpine
  #   volumes:
  #     - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
  #  volumes:
  #    - ./tests:/app/tests
  #   ports:
  #     - "8443:443"
  #   depends_on:
  #     - backend
  #   restart: unless-stopped