ARIA-AGENT/xtts/docker-compose.yml

# ════════════════════════════════════════════════
#  ARIA Gamebox Stack — GPU F5-TTS + Whisper STT
#  Laeuft auf dem Gaming-PC (RTX 3060)
#  Verbindet sich zum RVS fuer TTS/STT-Requests
#
#  FLUX-Bildgenerierung liegt im /flux Verzeichnis im Repo-Root —
#  eigener Compose-Stack, kann auch auf einer anderen Maschine laufen.
# ════════════════════════════════════════════════
#
#  Voraussetzungen:
#    - Docker Desktop mit WSL2
#    - NVIDIA Container Toolkit
#    - .env mit RVS-Verbindungsdaten
#
#  Start: docker compose up -d
# ════════════════════════════════════════════════

services:

  # ─── F5-TTS Bridge (GPU) ──────────────────────
  # Ersetzt den frueheren XTTS-Stack. Empfaengt xtts_request via RVS,
  # rendert via F5-TTS mit Voice-Cloning, streamt PCM an die App.
  # Voice-Upload: speichert WAV und laesst whisper-bridge den Referenz-
  # text transkribieren — der User muss nichts eintippen.
  f5tts-bridge:
    build: ./f5tts
    container_name: aria-f5tts-bridge
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ["0"]      # TTS → GPU 0 (8 GB; F5 ist klein)
              capabilities: [gpu]
    volumes:
      - ./voices:/voices                         # WAV + TXT Referenz
      - ./hf-cache:/root/.cache/huggingface      # HF-Cache als Bind-Mount.
                                                 # Direkt sichtbar im xtts/hf-cache/,
                                                 # einfach manuell zu loeschen, kein
                                                 # Docker-Desktop .vhdx Bloat.
                                                 # Wird mit whisper-bridge geteilt.
    environment:
      # Bootstrap-only — alle anderen F5-TTS-Settings (Modell, cfg_strength,
      # nfe_step, Custom-Checkpoint) kommen ueber Diagnostic via RVS-config.
      - RVS_HOST=${RVS_HOST}
      - RVS_PORT=${RVS_PORT:-443}
      - RVS_TLS=${RVS_TLS:-true}
      - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
      - RVS_TOKEN=${RVS_TOKEN}
      - F5TTS_DEVICE=${F5TTS_DEVICE:-cuda}
      - VOICES_DIR=/voices
    restart: unless-stopped

  # ─── Whisper STT (GPU) ────────────────────────
  # Faster-Whisper auf der Gamebox statt auf der VM (CPU) —
  # deutlich schneller. Verbindet sich selbst per WebSocket an
  # den RVS und nimmt dort stt_request Nachrichten der aria-bridge
  # entgegen, antwortet mit stt_response. Zusaetzlich nutzt die
  # f5tts-bridge Whisper intern fuer die Referenz-Transkription bei
  # Voice-Uploads. Laedt das Modell beim Start vor; auf Config-
  # Broadcasts (Diagnostic → whisperModel) wird zur Laufzeit hot-
  # swapped.
  whisper-bridge:
    build: ./whisper
    container_name: aria-whisper-bridge
    profiles: ["whisper"]        # Fallback-STT — startet nur mit --profile whisper
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ["1"]      # STT/groesstes Modell → GPU 1 (12 GB; spaeter Voxtral-STT-3B ~9 GB)
              capabilities: [gpu]
    environment:
      - RVS_HOST=${RVS_HOST}
      - RVS_PORT=${RVS_PORT:-443}
      - RVS_TLS=${RVS_TLS:-true}
      - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
      - RVS_TOKEN=${RVS_TOKEN}
      - WHISPER_MODEL=${WHISPER_MODEL:-small}
      - WHISPER_DEVICE=${WHISPER_DEVICE:-cuda}
      - WHISPER_COMPUTE_TYPE=${WHISPER_COMPUTE_TYPE:-float16}
      - WHISPER_LANGUAGE=${WHISPER_LANGUAGE:-de}
    volumes:
      - ./hf-cache:/root/.cache/huggingface      # gleicher Cache wie f5tts-bridge —
                                                 # ein Modell muss nur einmal pro
                                                 # Maschine geladen werden, kein
                                                 # Re-Download bei Container-Restart.
      - ./voice-id:/voice-id                     # Speaker-ID-Fingerprint (Stefans
                                                 # Stimm-Embedding) persistent zwischen
                                                 # Container-Restarts.
    restart: unless-stopped

  # ─── Lokales LLM (Plan B, B0.5) — llama-swap (GPU) ────────────
  # llama-swap laedt/swappt mehrere Modelle on-demand (nur eins passt gleich-
  # zeitig in die 12 GB). Welches geladen wird, bestimmt das `model`-Feld im
  # Request — das Brain schickt es aus local_llm.json mit. Erster Load eines
  # Modells zieht das GGUF via -hf von HF (Cache unter /models, persistent).
  # OpenAI-kompatibel auf :8080, nur im Compose-Netz; die Bruecke macht der
  # llm-adapter. Modell-Liste: ./llama-swap/config.yaml.
  #
  # BLIND GEBAUT (kein Gamebox-Test hier): beim ersten Start
  # `docker logs -f aria-llama-swap` pruefen. Image bundelt llama-server.
  llama-swap:
    image: ghcr.io/mostlygeek/llama-swap:unified-cuda
    container_name: aria-llama-swap
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ["0"]      # LLM → GPU 0 (8 GB, teilt sich mit TTS)
              capabilities: [gpu]
    volumes:
      - ./models:/models                                   # HF-Download-Cache (persistent)
      - ./llama-swap/config.yaml:/app/config.yaml:ro       # Modell-Liste
    environment:
      - LLAMA_CACHE=/models                                # llama-server legt -hf-Downloads hier ab
    command: ["--config", "/app/config.yaml", "--listen", "0.0.0.0:8080"]
    restart: unless-stopped

  # ─── Local-LLM-Adapter — RVS <-> llama.cpp (Plan B, B0) ──────
  # Verbindet sich per Token an den RVS (wie f5tts/whisper), nimmt
  # llm_request entgegen, ruft llama.cpp lokal, antwortet llm_response.
  llm-adapter:
    build: ./llm-adapter
    container_name: aria-llm-adapter
    depends_on:
      - llama-swap
    environment:
      - RVS_HOST=${RVS_HOST}
      - RVS_PORT=${RVS_PORT:-443}
      - RVS_TLS=${RVS_TLS:-true}
      - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
      - RVS_TOKEN=${RVS_TOKEN}
      - LLAMA_URL=http://llama-swap:8080
      - LLM_MODEL=${LLM_MODEL:-qwen3-8b}
      # Erster Load eines Modells kann ein GGUF ziehen (mehrere GB) — grosszuegig.
      - LLM_TIMEOUT_SEC=${LLM_TIMEOUT_SEC:-600}
    restart: unless-stopped

  # ─── Voxtral STT-3B (Transformers, GPU) — DEFAULT-STT ─────────
  # Ersetzt whisper als STT. Laeuft auf Treiber 550/CUDA 12.4 (torch cu124, KEIN
  # Treiber-Upgrade noetig). Modell Voxtral-Mini-3B-2507 (~9 GB bf16) → GPU 1.
  # Startet bei jedem `docker compose up -d`. Whisper ist der opt-in Fallback
  # (Profil "whisper") — beide zusammen wuerden stt_* doppelt beantworten, also
  # immer nur EINEN STT laufen lassen.
  voxtral-bridge:
    build: ./voxtral
    container_name: aria-voxtral-bridge
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ["1"]      # 12-GB-Karte (STT-3B ~9 GB); GPU 0 (8 GB) bleibt fuer F5/LLM
              capabilities: [gpu]
    volumes:
      - ./hf-cache:/root/.cache/huggingface      # gleicher Modell-Cache wie whisper/f5
      - ./voice-id:/voice-id                     # Speaker-Fingerprint (wie whisper)
    environment:
      - RVS_HOST=${RVS_HOST}
      - RVS_PORT=${RVS_PORT:-443}
      - RVS_TLS=${RVS_TLS:-true}
      - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
      - RVS_TOKEN=${RVS_TOKEN}
      - VOXTRAL_MODEL=mistralai/Voxtral-Mini-3B-2507
      - VOXTRAL_LANGUAGE=${WHISPER_LANGUAGE:-de}
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN:-}   # falls das Modell HF-gated ist
      - PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True   # weniger VRAM-Fragmentierung
    restart: unless-stopped