---
name: project-agent-gui-lam
description: "GUI pour agents IA avec avatars LAM 3D parlants en temps réel — état d'avancement complet"
metadata: 
  node_type: memory
  type: project
  originSessionId: 7de9b929-9050-430b-9b36-f74849c1c0a7
---

## Projet principal

`/mnt/DATA/WORK/agent-gui` — web app locale (Python stdlib + vanilla JS) pour piloter des agents LLM avec interface graphique. V1 fonctionnelle avec avatar ASCII, canvas pixel-art animé, chat, sessions JSONL, adaptateurs CLI.

**Why:** Créer une surcouche graphique universelle pour agents IA (Hermes, Claude Code, etc.) avec avatars visuels modélisables.

**How to apply:** Quand on reprend le travail, partir de cet état et continuer vers l'intégration LAM.

---

## Intégration LAM — état au 2026-06-15

### Objectif
Ajouter des avatars 3D photoréalistes parlants en temps réel dans agent-gui. Pipeline :
```
[Agent répond] → [TTS → audio 16kHz mono]
    → [Python: Audio2Expression → 52 blendshapes ARKit @ 30fps]
        → [WebSocket JSON] → [Browser: WebGL Gaussian Splatting renderer]
```

### Ce qui est installé et fonctionnel ✅

**Conda envs sur cette machine :**
- `lam` (Python 3.11) — pour LAM core (génération avatar depuis photo)
  - PyTorch 2.11+cu128, pytorch3d 0.7.9, diff-gaussian-rasterization, nvdiffrast, simple-knn
  - gcc 13 installé dans l'env (nécessaire pour compiler pytorch3d avec CUDA 12.8)
- `lam_a2e` (Python 3.10) — pour Audio2Expression (live talking)
  - PyTorch 2.11+cu128, transformers, librosa, gradio-gaussian-render

**Repos clonés :**
- `/mnt/DATA/WORK/LAM` — modèle LAM core (génère avatar 3D depuis photo)
- `/mnt/DATA/WORK/LAM_Audio2Expression` — Audio2Expression (audio → blendshapes)
  - Poids téléchargés et extraits : `pretrained_models/lam_audio2exp_flow/`
  - **Testé et fonctionnel** : 52 canaux ARKit, 30 FPS, 4ms/seconde d'audio après warm-up

**Résultat test Audio2Expression :**
- Input : `assets/sample_audio/BarackObama_english.wav`
- Output : `bsData.json` — 240 frames à 30fps, 52 blendshapes ARKit par frame
- Format : `{ "names": ["browDownLeft", "jawOpen", ...], "frames": [[...], ...], "metadata": {"fps": 30} }`

**Hardware :**
- GPU : RTX 5090, 32 Go VRAM
- Drivers NVIDIA : 595.71, CUDA 13.2 (max supporté)
- CUDA Toolkit 12.8 installé via conda dans les envs

---

### Ce qui reste à faire

**Étape 1 — Exporter l'avatar 3D (bloquant : nécessite Blender 4.0+)**
- Vérifier si Blender est installé : `blender --version`
- Si oui : lancer `app_lam.py` dans l'env `lam`, charger une photo portrait, exporter le ZIP avatar
- Le ZIP contient : `animation.glb`, `skin.glb`, `offset.ply`, `bsData.json`, `vertex_order.json`
- Des avatars sample sont déjà dispo dans `LAM_Audio2Expression/assets/sample_lam/` (barbara, james, status, vfhq_case1) — peut être utilisé pour tester sans Blender

**Étape 2 — Ajouter TTS dans agent-gui**
- Options légères : `pyttsx3` (offline, stdlib-like), `edge-tts` (Microsoft gratuit), `kokoro` (qualité)
- Output : fichier WAV 16kHz mono → passé à Audio2Expression

**Étape 3 — Ajouter WebSocket dans agent_gui/app.py**
- Ajouter endpoint WebSocket `/ws/avatar`
- Au moment où l'agent répond : TTS → Audio2Expression → stream blendshapes JSON à 30fps vers browser

**Étape 4 — Remplacer canvas pixel-art par renderer WebGL**
- Package npm : `gaussian-splat-renderer-for-lam` (repo : `aigc3d/LAM_WebRender`)
- API : charge le ZIP avatar une fois, polling `getExpressionData()` à chaque frame rAF
- Ou utiliser les avatars sample GLB directement si le format est compatible

**Alternative rapide sans Blender :**
Utiliser les avatars sample fournis (`barbara`, `james`) pour tester le pipeline complet avant d'avoir son propre avatar.

---

### Intégration RÉALISÉE dans agent-gui — 2026-06-16

Pipeline TTS→A2E→avatar 3DGS intégré et fonctionnel côté serveur. Avatar **barbara** (sample).

**Blender :** pas réinstallé — version 5.1.2 déjà extraite dans `~/Downloads/blender-5.1.2-linux-x64/blender` (fonctionne). Étape export avatar perso reste à faire ; on a utilisé le sample barbara pour l'instant.

**Nouveaux fichiers agent-gui :**
- `agent_gui/tts.py` — edge-tts (installé dans miniconda base) → mp3 → ffmpeg → WAV 16kHz mono
- `agent_gui/avatar_lam.py` — subprocess `conda run -n lam_a2e python run_inference.py` → bsData JSON
- `LAM_Audio2Expression/run_inference.py` — CLI wrapper (audio.wav → bsData.json), créé pour être appelé en subprocess
- `static/avatar.js` — module ES, utilise le renderer Gaussian Splat
- `static/lib_lam_renderer.js` — bundle npm `gaussian-splat-renderer-for-lam@0.0.9-alpha.2` (4MB, three.js inclus), téléchargé depuis jsdelivr
- `static/avatar/barbara.zip` — zip avatar (dossier `barbara/` + animation.glb, skin.glb, offset.ply, vertex_order.json, bsData.json)

**Modifs app.py :** thread background lancé après chaque réponse agent (TTS+A2E), endpoints `GET /api/avatar/anim?session_id=` (polling: pending/ready/error+bsData) et `GET /api/avatar/audio?session_id=` (WAV). Store `_anim_store` en mémoire protégé par lock.

**API renderer LAM (clé) :** `GaussianSplatRenderer.getInstance(containerDiv, '/path/avatar.zip', {getExpressionData, backgroundColor:'0x05080f', loadProgress, downloadProgress})`. Le zip DOIT contenir un dossier (nom=characterName) avec skin.glb/animation.glb/offset.ply/vertex_order.json. L'URL doit matcher `/([^/]+?)\.zip/`. `getExpressionData()` appelé chaque frame, retourne `{blendshapeName: weight}` ou null (pose repos). Format identique à `getArkitFaceFrame` du composant Gradio : `out[names[i]] = frames[frameIdx].weights[i]`.

**ATTENTION pièges rencontrés :**
- skin.glb seul = géométrie nue (pas normales/texture) → invisible en mesh Three.js standard. Le photoréalisme vient du Gaussian Splatting (offset.ply). NE PAS tenter de rendre via GLTFLoader simple.
- Éviter les guillemets courbes (' ') dans les edits de fichiers JS — ils cassent le parsing. Toujours des guillemets droits.

**Lancer :** `cd /mnt/DATA/WORK/agent-gui && $HOME/miniconda3/bin/python -m agent_gui.app` → http://127.0.0.1:8765

**Reste à faire :** confirmer rendu visuel navigateur ; exporter avatar perso via Blender + app_lam.py ; choix voix TTS (actuellement en-US-AriaNeural anglais — passer en français fr-FR-* selon besoin).

---

### Architecture finale visée

```
agent_gui/
  app.py          ← ajouter WebSocket + appel subprocess Audio2Expression
  avatar_lam.py   ← nouveau module : lance lam_a2e env, streame blendshapes
  tts.py          ← nouveau module : TTS → WAV 16kHz
static/
  app.js          ← remplacer canvas pixel-art par WebGL renderer LAM
  avatar.zip      ← avatar exporté depuis photo (ou sample barbara/james)
```

### Commandes utiles pour reprendre

```bash
# Tester Audio2Expression
cd /mnt/DATA/WORK/LAM_Audio2Expression
$HOME/miniconda3/bin/conda run -n lam_a2e python inference_streaming_audio.py

# Lancer app Gradio LAM (pour exporter avatar depuis photo, nécessite Blender)
cd /mnt/DATA/WORK/LAM
$HOME/miniconda3/bin/conda run -n lam python app_lam.py

# Lancer app Gradio Audio2Expression (demo complète avec WebGL)
cd /mnt/DATA/WORK/LAM_Audio2Expression
$HOME/miniconda3/bin/conda run -n lam_a2e python app_lam_audio2exp.py
```