Initial commit - HOLOKIA-AVATAR v2.2

.gitattributes

@@ -0,0 +1,111 @@
+# ===========================================
+# Configuration Git LFS pour HOLOKIA-AVATAR
+# ===========================================
+# Modèles 3D
+*.glb filter=lfs diff=lfs merge=lfs -text
+*.fbx filter=lfs diff=lfs merge=lfs -text
+*.obj filter=lfs diff=lfs merge=lfs -text
+*.dae filter=lfs diff=lfs merge=lfs -text
+*.3ds filter=lfs diff=lfs merge=lfs -text
+*.blend filter=lfs diff=lfs merge=lfs -text
+*.max filter=lfs diff=lfs merge=lfs -text
+*.ma filter=lfs diff=lfs merge=lfs -text
+*.mb filter=lfs diff=lfs merge=lfs -text
+*.c4d filter=lfs diff=lfs merge=lfs -text
+*.x3d filter=lfs diff=lfs merge=lfs -text
+*.ply filter=lfs diff=lfs merge=lfs -text
+*.stl filter=lfs diff=lfs merge=lfs -text
+*.wrl filter=lfs diff=lfs merge=lfs -text
+*.3dm filter=lfs diff=lfs merge=lfs -text
+*.3dmf filter=lfs diff=lfs merge=lfs -text
+*.ac filter=lfs diff=lfs merge=lfs -text
+*.ac3d filter=lfs diff=lfs merge=lfs -text
+*.acc filter=lfs diff=lfs merge=lfs -text
+*.ase filter=lfs diff=lfs merge=lfs -text
+*.ask filter=lfs diff=lfs merge=lfs -text
+*.b3d filter=lfs diff=lfs merge=lfs -text
+*.bvh filter=lfs diff=lfs merge=lfs -text
+*.cob filter=lfs diff=lfs merge=lfs -text
+*.csm filter=lfs diff=lfs merge=lfs -text
+*.dxf filter=lfs diff=lfs merge=lfs -text
+*.enff filter=lfs diff=lfs merge=lfs -text
+*.hmp filter=lfs diff=lfs merge=lfs -text
+*.irrmesh filter=lfs diff=lfs merge=lfs -text
+*.irr filter=lfs diff=lfs merge=lfs -text
+*.lwo filter=lfs diff=lfs merge=lfs -text
+*.lws filter=lfs diff=lfs merge=lfs -text
+*.lxo filter=lfs diff=lfs merge=lfs -text
+*.md2 filter=lfs diff=lfs merge=lfs -text
+*.md3 filter=lfs diff=lfs merge=lfs -text
+*.md5anim filter=lfs diff=lfs merge=lfs -text
+*.md5camera filter=lfs diff=lfs merge=lfs -text
+*.md5mesh filter=lfs diff=lfs merge=lfs -text
+*.mdc filter=lfs diff=lfs merge=lfs -text
+*.mdl filter=lfs diff=lfs merge=lfs -text
+*.mesh filter=lfs diff=lfs merge=lfs -text
+*.mesh.xml filter=lfs diff=lfs merge=lfs -text
+*.mot filter=lfs diff=lfs merge=lfs -text
+*.ms3d filter=lfs diff=lfs merge=lfs -text
+*.ndo filter=lfs diff=lfs merge=lfs -text
+*.nff filter=lfs diff=lfs merge=lfs -text
+*.off filter=lfs diff=lfs merge=lfs -text
+*.ogex filter=lfs diff=lfs merge=lfs -text
+*.pmx filter=lfs diff=lfs merge=lfs -text
+*.prj filter=lfs diff=lfs merge=lfs -text
+*.q3o filter=lfs diff=lfs merge=lfs -text
+*.q3s filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+*.scn filter=lfs diff=lfs merge=lfs -text
+*.smd filter=lfs diff=lfs merge=lfs -text
+*.ter filter=lfs diff=lfs merge=lfs -text
+*.uc filter=lfs diff=lfs merge=lfs -text
+*.vta filter=lfs diff=lfs merge=lfs -text
+*.x filter=lfs diff=lfs merge=lfs -text
+*.xgl filter=lfs diff=lfs merge=lfs -text
+*.xml filter=lfs diff=lfs merge=lfs -text
+*.zae filter=lfs diff=lfs merge=lfs -text
+*.zgl filter=lfs diff=lfs merge=lfs -text
+# Textures et images volumineuses
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.tga filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+*.tif filter=lfs diff=lfs merge=lfs -text
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.exr filter=lfs diff=lfs merge=lfs -text
+*.hdr filter=lfs diff=lfs merge=lfs -text
+# Audio volumineux
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.aac filter=lfs diff=lfs merge=lfs -text
+# Vidéos
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.avi filter=lfs diff=lfs merge=lfs -text
+*.mov filter=lfs diff=lfs merge=lfs -text
+*.mkv filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+# Archives
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text
+*.tar.bz2 filter=lfs diff=lfs merge=lfs -text
+# Fichiers binaires
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.dat filter=lfs diff=lfs merge=lfs -text
+*.db filter=lfs diff=lfs merge=lfs -text
+*.sqlite filter=lfs diff=lfs merge=lfs -text
+*.sqlite3 filter=lfs diff=lfs merge=lfs -text
+# Fichiers de cache et temporaires
+*.cache filter=lfs diff=lfs merge=lfs -text
+*.tmp filter=lfs diff=lfs merge=lfs -text
+*.temp filter=lfs diff=lfs merge=lfs -text
+# Fichiers de logs volumineux
+*.log filter=lfs diff=lfs merge=lfs -text
+# Fichiers de sauvegarde
+*.bak filter=lfs diff=lfs merge=lfs -text
+*.backup filter=lfs diff=lfs merge=lfs -text
+*.ico filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,175 @@
+# ===========================================
+# .gitignore pour HOLOKIA-AVATAR
+# ===========================================
+
+# Fichiers Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Environnements virtuels
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Variables d'environnement (IMPORTANT pour HF)
+.env
+.env.*
+!.env.example
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Logs
+*.log
+logs/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Node.js
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# Builds
+dist/
+build/
+.cache/
+
+# Fichiers temporaires
+tmp/
+temp/
+*.tmp
+*.temp
+
+# Fichiers système
+.DS_Store
+Thumbs.db
+
+# Cache TTS
+Back-end/tts_cache/
+tts_cache/
+
+# Fichiers de configuration locale
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Fichiers de test
+coverage/
+.nyc_output/
+.pytest_cache/
+
+# Docker
+.dockerignore
+
+# Fichiers de déploiement (optionnels)
+deploy_to_hf.sh
+test_deployment.py
+README_HF_DEPLOYMENT.md
+
+# Fichiers de développement
+build-frontend.sh
+docker-compose*.yml
+docker/
+
+# Fichiers Git LFS (seront gérés par LFS)
+*.glb
+*.fbx
+*.obj
+*.dae
+*.3ds
+*.blend
+*.max
+*.ma
+*.mb
+*.c4d
+*.fbx
+*.x3d
+*.ply
+*.stl
+*.wrl
+*.x3d
+*.3dm
+*.3dmf
+*.ac
+*.ac3d
+*.acc
+*.ase
+*.ask
+*.b3d
+*.bvh
+*.cob
+*.csm
+*.dae
+*.dxf
+*.enff
+*.hmp
+*.irrmesh
+*.irr
+*.lwo
+*.lws
+*.lxo
+*.md2
+*.md3
+*.md5anim
+*.md5camera
+*.md5mesh
+*.mdc
+*.mdl
+*.mesh
+*.mesh.xml
+*.mot
+*.ms3d
+*.ndo
+*.nff
+*.off
+*.ogex
+*.ply
+*.pmx
+*.prj
+*.q3o
+*.q3s
+*.raw
+*.scn
+*.smd
+*.stl
+*.ter
+*.uc
+*.vta
+*.x
+*.x3d
+*.xgl
+*.xml
+*.zae
+*.zgl

Back-end/README.md

@@ -0,0 +1,118 @@
+# HOLOKIA-AVATAR Backend
+
+Ce dossier contient le backend du projet: il gère la génération de texte IA (LLM), la synthèse vocale (TTS), la reconnaissance vocale (STT), et le streaming audio en temps réel avec Websocket.
+
+---
+
+## Structure du dossier
+
+```
+Back-end/
+├── .env                      # Variables d'environnement (API keys, config)
+├── requirements.txt          # Dépendances Python
+├── start_service.py          # Script de lancement des services                 # Script de démarrage principal
+|__ tts_cache                 # Le cache
+├── app/
+│   ├── __init__.py
+│   └── main.py               # API principale FastAPI
+├── env/                      # Environnement virtuel Python (venv)
+├── services/
+│   ├── live_stream_service.py
+│   ├── llm_service.py
+│   ├── stt_service.py
+│   ├── tts_service.py
+```
+
+---
+
+## Prérequis
+
+- Python 3.10 ou supérieur
+- Installer les dépendances :
+  ```sh
+  pip install -r requirements.txt
+  ```
+- Configurer le fichier `.env` avec vos clés API et paramètres nécessaires (voir exemple ci-dessous).
+
+---
+
+## Configuration
+
+Exemple de fichier `.env` :
+```
+GROQ_API_KEY=your_groq_api_key
+
+```
+
+Adaptez les clés et chemins selon votre environnement.
+
+---
+
+## Lancement du backend
+
+### Démarrage global
+
+```sh
+python start_services.py
+```
+Ce script lance tous les services backend (API principale, TTS, STT, streaming...).
+
+### Démarrage manuel de l’API FastAPI
+
+```sh
+uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
+```
+
+---
+
+## Fonctionnalités principales
+
+- **Reconnaissance vocale (STT)**  
+  Endpoint : `POST /stt/transcribe`  
+  Envoie un fichier audio, reçoit le texte transcrit.
+
+- **Synthèse vocale (TTS)**  
+  Endpoint : `POST /tts/generate-tts`  
+  Envoie du texte, reçoit le chemin du fichier audio généré.
+
+- **Génération de texte IA (LLM)**  
+  Endpoint : `POST /llm/generate`  
+  Envoie un prompt, reçoit la réponse générée.
+
+- **Streaming audio en temps réel**  
+  Endpoint : `/live_stream/{user_id}`  
+  Permet la communication audio temps réel avec le backend.
+
+- **Health check**  
+  Endpoint : `GET /health`  
+  Vérifie l’état du backend.
+
+---
+
+## Dossiers de cache et de test
+
+- `tts_cache/` : fichiers audio générés par le TTS
+
+---
+
+## Bonnes pratiques
+
+- Utilisez l’environnement virtuel fourni (`env/`) pour isoler les dépendances.
+- Protégez votre fichier `.env` et ne le partagez pas publiquement.
+- Consultez et adaptez `lipsync_config.yaml` selon vos besoins de synchronisation labiale.
+- En production, restreignez les origines CORS dans `main.py`.
+
+---
+
+## Contribution
+
+Pour toute modification :
+- Documentez votre code
+- Ajoutez des tests si nécessaire
+- Respectez la structure existante
+
+---
+
+## Support
+
+Pour toute question ou problème, Veillez contacter Holokia particuliérement Mr Sinaly ou Mr Omar.

Back-end/app/main.py

@@ -0,0 +1,69 @@
+# app/main.py
+from fastapi import FastAPI, UploadFile, File, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from services import stt_service, tts_service, llm_service, live_stream_service # type: ignore
+import uvicorn
+
+app = FastAPI(
+    title="Holokia Avatar Backend",
+    description="Backend pour avatar 3D interactif avec STT, TTS, LLM et LiveKit streaming",
+    version="1.0.0"
+)
+
+# ✅ Activer CORS pour éviter les blocages côté front
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # ⚠️ En prod, mettre le domaine du front
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 🩺 Health check
+@app.get("/health")
+async def health():
+    return {"status": "ok", "message": "Backend operational"}
+
+# 🎤 STT - Audio → Texte
+@app.post("/stt/transcribe")
+async def transcribe_audio(file: UploadFile = File(...)):
+    try:
+        result = await stt_service.transcribe_audio(file)
+        return {"text": result}
+    except Exception as e:
+        return {"error": str(e)}
+
+# 🗣 TTS - Texte → Audio
+@app.post("/tts/generate")
+async def generate_tts(text: str):
+    try:
+        audio_path = await tts_service.text_to_speech(text)
+        return {"audio_file": audio_path}
+    except Exception as e:
+        return {"error": str(e)}
+
+# 🤖 LLM - Prompt → Texte
+@app.post("/llm/generate")
+async def generate_llm(prompt: str):
+    try:
+        response = await llm_service.generate_response(prompt)
+        return {"response": response}
+    except Exception as e:
+        return {"error": str(e)}
+
+# 📡 Live streaming WebSocket
+@app.websocket("/live-stream")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    try:
+        await live_stream_service.handle_connection(websocket)
+    except WebSocketDisconnect:
+        print("🔌 Client déconnecté du live stream")
+    except Exception as e:
+        print(f"❌ Erreur WebSocket : {e}")
+    finally:
+        await websocket.close()
+
+# 🚀 Point d'entrée
+if __name__ == "__main__":
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True)

Back-end/requirements.txt

@@ -0,0 +1,12 @@
+fastapi>=0.115
+uvicorn[standard]>=0.30
+aiohttp>=3.9
+python-multipart>=0.0.9
+gTTS>=2.5
+pydub>=0.25
+faster-whisper>=1.0
+ctranslate2>=4.6.0
+langdetect>=1.0.9
+httpx>=0.27
+langchain-groq  # si tu utilises Groq
+langgraph

Back-end/services/live_stream_service.py

@@ -0,0 +1,445 @@
+import os
+import sys
+import logging
+import json
+import asyncio
+import aiohttp  # type: ignore
+import tempfile
+import wave
+import audioop
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.websockets import WebSocketState
+from fastapi.middleware.cors import CORSMiddleware
+from typing import Dict, List, Optional, TypedDict
+import uvicorn
+from langgraph.graph import StateGraph, END, START
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+# Configuration du logger
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", stream=sys.stdout)
+logger = logging.getLogger("live_stream_service")
+
+# URLs des micro-services
+STT_SERVICE_URL = "http://localhost:5001/transcribe"
+LLM_SERVICE_URL = "http://localhost:5002/generate"
+TTS_SERVICE_URL = "http://localhost:5000/generate-tts"
+
+# Paramètres audio
+SAMPLE_RATE = 16000
+CHANNELS = 1
+SAMPLE_WIDTH = 2
+SILENCE_THRESHOLD = 1000
+SILENCE_DURATION = 1.0
+MIN_AUDIO_DURATION = 1.0
+MAX_CONNECTIONS_PER_ROOM = 100  # Limite de connexions par salle
+
+app = FastAPI()
+
+# CORS
+origins = ["http://localhost:5173", "http://127.0.0.1:5173"]
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Gestion des salles et participants
+rooms: Dict[str, List[WebSocket]] = {}
+participants_lang: Dict[str, str] = {}
+user_histories: Dict[str, List[Dict[str, str]]] = {}  # Historique persistant par user_id
+
+# État du graphe LangGraph
+class ChatState(TypedDict):
+    audio_bytes: bytes
+    transcript: str
+    lang: Optional[str]
+    llm_response: str
+    audio_response: bytes
+    user_id: str
+    room_id: str
+    history: List[Dict[str, str]]  # Historique: [{"role": "user|assistant", "content": "..."}]
+
+async def safe_delete_file(file_path: str, max_attempts: int = 3, delay: float = 0.1) -> None:
+    """Supprime un fichier avec retry en cas de PermissionError."""
+    for attempt in range(max_attempts):
+        try:
+            if os.path.exists(file_path):
+                os.unlink(file_path)
+                logger.debug(f"Fichier supprimé: {file_path}")
+            return
+        except PermissionError as e:
+            logger.warning(f"Tentative {attempt + 1}/{max_attempts} de suppression de {file_path} échouée: {e}")
+            if attempt < max_attempts - 1:
+                await asyncio.sleep(delay)
+        except Exception as e:
+            logger.error(f"Erreur lors de la suppression de {file_path}: {e}")
+            return
+    logger.error(f"Échec de la suppression de {file_path} après {max_attempts} tentatives")
+
+# Nœuds du graphe avec retry
+@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=10))
+async def transcribe_node(state: ChatState) -> ChatState:
+    """Appelle le service STT pour transcrire l'audio avec retry."""
+    audio_bytes = state.get("audio_bytes", b"")
+    user_id = state.get("user_id", "unknown")
+    print(f"[STT] Début transcription pour {user_id}, audio size: {len(audio_bytes)} bytes")
+    
+    if not audio_bytes:
+        print("[STT] Audio vide, skip")
+        return {"transcript": "", "lang": state.get("lang", "fr")}
+
+    duration = len(audio_bytes) / (SAMPLE_RATE * SAMPLE_WIDTH * CHANNELS)
+    if duration < MIN_AUDIO_DURATION:
+        logger.debug(f"[STT] Audio trop court ({duration:.2f}s), skip")
+        return {"transcript": "", "lang": state.get("lang", "fr")}
+
+    try:
+        rms_global = audioop.rms(audio_bytes, SAMPLE_WIDTH)
+        logger.debug(f"[STT] RMS global: {rms_global}")
+        if rms_global < SILENCE_THRESHOLD:
+            logger.debug(f"[STT] Audio silencieux (RMS={rms_global}), skip")
+            return {"transcript": "", "lang": state.get("lang", "fr")}
+    except Exception as e:
+        logger.warning(f"[STT] Erreur RMS global: {e}")
+        return {"transcript": "", "lang": state.get("lang", "fr")}
+
+    tmp_path = None
+    file_handle = None
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmpfile:
+            with wave.open(tmpfile.name, "wb") as wf:
+                wf.setnchannels(CHANNELS)
+                wf.setsampwidth(SAMPLE_WIDTH)
+                wf.setframerate(SAMPLE_RATE)
+                wf.writeframes(audio_bytes)
+            tmp_path = tmpfile.name
+
+        form = aiohttp.FormData()
+        file_handle = open(tmp_path, "rb")
+        form.add_field("file", file_handle, filename="audio.wav", content_type="audio/wav")
+        if state.get("lang"):
+            form.add_field("language", state["lang"])
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(STT_SERVICE_URL, data=form) as resp:
+                if resp.status != 200:
+                    text = await resp.text()
+                    raise RuntimeError(f"STT service error {resp.status}: {text}")
+                result = await resp.json()
+                transcript = result.get("transcript", "")
+                lang = result.get("lang", state.get("lang", "fr"))
+                if transcript.strip():
+                    history = state.get("history", [])
+                    history.append({"role": "user", "content": transcript})
+                    return {"transcript": transcript, "lang": lang, "history": history}
+                return {"transcript": "", "lang": lang}
+    except Exception as e:
+        logger.error(f"[STT] Erreur: {e}", exc_info=True)
+        raise  # Laisser tenacity gérer le retry
+    finally:
+        if file_handle:
+            file_handle.close()
+        if tmp_path:
+            await safe_delete_file(tmp_path)
+
+@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=10))
+async def llm_node(state: ChatState) -> ChatState:
+    """Appelle le service LLM avec le transcript et l’historique."""
+    transcript = state.get("transcript", "")
+    user_id = state.get("user_id", "")
+    if not transcript.strip():
+        logger.debug("[LLM] Transcript vide, skip")
+        return {"llm_response": ""}
+
+    # Construire le prompt avec l’historique
+    history = state.get("history", [])
+    logger.debug(f"[LLM] Historique envoyé: {history}")
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                LLM_SERVICE_URL,
+                json={
+                    "text": transcript,
+                    "user_id": user_id,
+                    "history": history[-3:]
+                }
+            ) as resp:
+                if resp.status != 200:
+                    text = await resp.text()
+                    raise RuntimeError(f"LLM service error {resp.status}: {text}")
+                result = await resp.json()
+                response = result.get("response", "")
+                new_history = result.get("history", history)
+                if response.strip():
+                    logger.info(f"[LLM] Réponse: {response}")
+                    return {"llm_response": response, "history": new_history}
+                return {"llm_response": ""}
+    except Exception as e:
+        logger.error(f"[LLM] Erreur: {e}", exc_info=True)
+        raise  # Laisser tenacity gérer le retry
+
+@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=10))
+async def tts_node(state: ChatState) -> ChatState:
+    """Appelle le service TTS pour générer l’audio."""
+    llm_response = state.get("llm_response", "")
+    if not llm_response.strip():
+        logger.debug("[TTS] Pas de réponse LLM, skip")
+        return {"audio_response": b""}
+
+    logger.debug(f"[TTS] Appel avec texte: {llm_response}, lang: {state['lang']}")
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(TTS_SERVICE_URL, json={"text": llm_response, "lang": state["lang"]}) as resp:
+                if resp.status != 200:
+                    text_resp = await resp.text()
+                    raise RuntimeError(f"TTS service error {resp.status}: {text_resp}")
+                result = await resp.json()
+                audio_url = result.get("url")
+                if not audio_url:
+                    raise RuntimeError("TTS no URL")
+                
+                # Construire l'URL complète si c'est une URL relative
+                if audio_url.startswith("/"):
+                    audio_url = f"http://localhost:5000{audio_url}"
+                
+                async with session.get(audio_url) as audio_resp:
+                    if audio_resp.status != 200:
+                        raise RuntimeError(f"TTS file fetch error {audio_resp.status}")
+                    audio_data = await audio_resp.read()
+                    logger.info(f"[TTS] Audio généré, taille: {len(audio_data)} bytes")
+                    return {"audio_response": audio_data}
+    except Exception as e:
+        logger.error(f"[TTS] Erreur: {e}", exc_info=True)
+        raise  # Laisser tenacity gérer le retry
+
+# Construiction du graphe LangGraph
+workflow = StateGraph(ChatState)
+workflow.add_node("transcribe", transcribe_node)
+workflow.add_node("llm", llm_node)
+workflow.add_node("tts", tts_node)
+workflow.add_edge(START, "transcribe")
+workflow.add_edge("transcribe", "llm")
+workflow.add_edge("llm", "tts")
+workflow.add_edge("tts", END)
+graph = workflow.compile()
+
+async def broadcast(room_id: str, message, sender: WebSocket = None):
+    """Diffuse message à la salle, sauf au sender."""
+    for ws in rooms.get(room_id, []):
+        if ws != sender and ws.application_state == WebSocketState.CONNECTED:
+            try:
+                if isinstance(message, bytes):
+                    await ws.send_bytes(message)
+                else:
+                    await ws.send_text(message)
+            except Exception:
+                rooms[room_id].remove(ws) if ws in rooms.get(room_id, []) else None
+
+def is_silence(audio_chunk: bytes) -> bool:
+    """Vérifie si chunk est silence via RMS."""
+    if not audio_chunk or len(audio_chunk) < SAMPLE_WIDTH * 2:
+        return True
+    if len(audio_chunk) % SAMPLE_WIDTH != 0:
+        audio_chunk = audio_chunk[:-(len(audio_chunk) % SAMPLE_WIDTH)]
+    try:
+        rms = audioop.rms(audio_chunk, SAMPLE_WIDTH)
+        logger.debug(f"[is_silence] RMS={rms}")
+        return rms < SILENCE_THRESHOLD
+    except Exception as e:
+        logger.warning(f"[is_silence] Erreur RMS: {e}")
+        return True
+
+@app.websocket("/live_stream/{user_id}")
+async def websocket_endpoint(ws: WebSocket, user_id: str, lang: Optional[str] = None, room_id: str = "default"):
+    """Gère connexion WebSocket pour stream audio avec LangGraph."""
+    await ws.accept()
+    print(f"[Live] Connecté: {user_id} (lang={lang or 'auto'}, room={room_id})")
+    logger.info(f"[Live] Connecté: {user_id} (lang={lang or 'auto'}, room={room_id})")
+
+    if room_id not in rooms:
+        rooms[room_id] = []
+    if len(rooms[room_id]) >= MAX_CONNECTIONS_PER_ROOM:
+        logger.warning(f"[Live] Limite de connexions atteinte pour la salle {room_id}")
+        await ws.close(code=1000, reason="Salle pleine")
+        return
+    rooms[room_id].append(ws)
+    participants_lang[user_id] = lang or "auto"
+
+    # Initialise l'historique pour cet utilisateur s'il n'existe pas
+    if user_id not in user_histories:
+        user_histories[user_id] = []
+    history = user_histories[user_id]
+
+    buffer = bytearray()
+    silent_counter = 0.0
+
+    try:
+        while True:
+            try:
+                message = await asyncio.wait_for(ws.receive(), timeout=60)
+                print(f"[Live] Message reçu de {user_id}: {type(message)}")
+            except asyncio.TimeoutError:
+                print(f"[Live] Timeout WS pour {user_id}")
+                logger.warning(f"[Live] Timeout WS pour {user_id}")
+                break
+            except WebSocketDisconnect as e:
+                print(f"[Live] Disconnect ({e.code}) pour {user_id}")
+                logger.info(f"[Live] Disconnect ({e.code}) pour {user_id}")
+                break
+            except RuntimeError as e:
+                print(f"[Live] Receive error: {e}")
+                logger.info(f"[Live] Receive error: {e}")
+                break
+            except Exception as e:
+                print(f"[Live] ws.receive error: {e}")
+                logger.warning(f"[Live] ws.receive error: {e}")
+                break
+
+            if "bytes" in message:
+                chunk = message["bytes"]
+                if not chunk:
+                    continue
+
+                if len(chunk) % SAMPLE_WIDTH != 0:
+                    chunk = chunk[:-(len(chunk) % SAMPLE_WIDTH)]
+                    logger.debug(f"[Live] Chunk aligné ({len(chunk)} bytes)")
+
+                buffer.extend(chunk)
+                frames = len(chunk) / SAMPLE_WIDTH
+                time_delta = frames / SAMPLE_RATE
+
+                if is_silence(chunk):
+                    silent_counter += time_delta
+                else:
+                    silent_counter = 0.0
+
+                if silent_counter >= SILENCE_DURATION and buffer:
+                    audio_snapshot = bytes(buffer)
+                    buffer.clear()
+                    silent_counter = 0.0
+
+                    # Exécute le graphe LangGraph
+                    state = {
+                        "audio_bytes": audio_snapshot,
+                        "user_id": user_id,
+                        "room_id": room_id,
+                        "lang": lang or "fr",
+                        "history": history,
+                        "transcript": "",
+                        "llm_response": "",
+                        "audio_response": b""
+                    }
+                    try:
+                        print(f"[Live] Exécution du graphe pour {user_id}, audio size: {len(audio_snapshot)} bytes")
+                        result = await graph.ainvoke(state)
+                        print(f"[Live] Graphe exécuté avec succès pour {user_id}")
+                    except Exception as e:
+                        print(f"[Live] ERREUR lors de l'exécution du graphe pour {user_id}: {e}")
+                        print(f"[Live] Audio size: {len(audio_snapshot)} bytes, lang: {lang}")
+                        import traceback
+                        print(f"[Live] Traceback: {traceback.format_exc()}")
+                        if ws.application_state == WebSocketState.CONNECTED:
+                            await ws.send_text(json.dumps({"type": "error", "message": f"Erreur de traitement audio: {str(e)}"}))
+                        continue  # Continue au lieu de break pour permettre d'autres tentatives
+
+                    # Mettre à jour l'historique global
+                    history = result.get("history", history)
+                    user_histories[user_id] = history
+
+                    # Envoie les résultats au user et à la salle
+                    if result["transcript"].strip():
+                        effective_lang = result["lang"] or lang or "fr"
+                        logger.info(f"[STT] {user_id}: {result['transcript']} (lang={effective_lang})")
+                        await broadcast(room_id, f"{user_id}({effective_lang}): {result['transcript']}", sender=ws)
+                    if result["llm_response"].strip():
+                        logger.debug(f"[Handle Response] Envoi réponse texte: {result['llm_response']}")
+                        await ws.send_text(f"Système: {result['llm_response']}")
+                    if result["audio_response"]:
+                        logger.debug(f"[Handle Response] Envoi audio, taille: {len(result['audio_response'])} bytes")
+                        await ws.send_bytes(result["audio_response"])
+                        await broadcast(room_id, result["audio_response"], sender=ws)
+
+            elif "text" in message:
+                try:
+                    data = json.loads(message["text"])
+                    ttype = data.get("type")
+                    print(f"[Live] Message texte reçu de {user_id}: {ttype}")
+                    if ttype == "start":
+                        print(f"[Live] Début stream: {user_id}")
+                        logger.info(f"[Live] Début stream: {user_id}")
+                    elif ttype == "ping":
+                        print(f"[Live] Ping reçu de {user_id}")
+                        logger.debug(f"[Live] Ping de {user_id}")
+                        if ws.application_state == WebSocketState.CONNECTED:
+                            await ws.send_text(json.dumps({"type": "pong"}))
+                    elif ttype == "stop":
+                        logger.info(f"[Live] Arrêt stream: {user_id}")
+                        if buffer:
+                            state = {
+                                "audio_bytes": bytes(buffer),
+                                "user_id": user_id,
+                                "room_id": room_id,
+                                "lang": lang or "fr",
+                                "history": history,
+                                "transcript": "",
+                                "llm_response": "",
+                                "audio_response": b""
+                            }
+                            try:
+                                result = await graph.ainvoke(state)
+                            except Exception as e:
+                                logger.error(f"[Live] Erreur lors de l'exécution du graphe (stop): {e}", exc_info=True)
+                                if ws.application_state == WebSocketState.CONNECTED:
+                                    await ws.send_text(json.dumps({"type": "error", "message": "Désolé, une erreur s'est produite, veuillez réessayer."}))
+                                break
+                            history = result.get("history", history)
+                            user_histories[user_id] = history
+                            if result["transcript"].strip():
+                                effective_lang = result["lang"] or lang or "fr"
+                                logger.info(f"[STT] (final) {user_id}: {result['transcript']} (lang={effective_lang})")
+                                await broadcast(room_id, f"{user_id}({effective_lang}): {result['transcript']}", sender=ws)
+                            if result["llm_response"].strip():
+                                await ws.send_text(f"Système: {result['llm_response']}")
+                            if result["audio_response"]:
+                                await ws.send_bytes(result["audio_response"])
+                                await broadcast(room_id, result["audio_response"], sender=ws)
+                        if ws.application_state == WebSocketState.CONNECTED:
+                            await ws.send_text(json.dumps({"type": "stopped"}))
+                            await ws.close()
+                        return
+                    else:
+                        logger.warning(f"[Live] Type inconnu: {ttype}")
+                        if ws.application_state == WebSocketState.CONNECTED:
+                            await ws.send_text(json.dumps({"type": "error", "message": "Désolé, une erreur s'est produite, veuillez réessayer."}))
+                except json.JSONDecodeError:
+                    logger.error(f"[Live] JSON invalide: {message['text']}")
+                    if ws.application_state == WebSocketState.CONNECTED:
+                        await ws.send_text(json.dumps({"type": "error", "message": "Désolé, une erreur s'est produite, veuillez réessayer."}))
+                    break
+    except Exception as e:
+        logger.error(f"[Live] Erreur générale: {e}", exc_info=True)
+        if ws.application_state == WebSocketState.CONNECTED:
+            try:
+                await ws.send_text(json.dumps({"type": "error", "message": "Désolé, une erreur s'est produite, veuillez réessayer."}))
+            except Exception as send_error:
+                logger.error(f"[Live] Erreur lors de l'envoi du message d'erreur: {send_error}")
+    finally:
+        rooms[room_id].remove(ws) if ws in rooms.get(room_id, []) else None
+        participants_lang.pop(user_id, None)
+        buffer.clear()
+        logger.info(f"[Live] Cleanup: {user_id}")
+        if ws.application_state == WebSocketState.CONNECTED:
+            try:
+                await ws.close()
+            except Exception as close_error:
+                logger.error(f"[Live] Erreur lors de la fermeture de la connexion: {close_error}")
+
+@app.get("/health")
+async def health_check():
+    """Vérifie l’état du service."""
+    return {"status": "ok", "service": "live_stream"}
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=5003, ws_ping_interval=20, ws_ping_timeout=120)

Back-end/services/llm_service.py

@@ -0,0 +1,168 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import logging
+import uvicorn
+from langdetect import detect, DetectorFactory, LangDetectException
+from langchain_groq import ChatGroq
+from dotenv import load_dotenv
+import os
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Dict
+import re
+
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger("LLM_Service")
+
+app = FastAPI()
+
+origins = ["http://localhost:5173", "http://127.0.0.1:5173"]
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+api_key = os.getenv("GROQ_API_KEY")
+if not api_key:
+    logger.error("GROQ_API_KEY manquante dans l'environnement")
+    raise RuntimeError("GROQ_API_KEY non configurée")
+
+MODEL_NAME = "meta-llama/llama-4-scout-17b-16e-instruct"
+logger.info(f"Chargement du modèle LLM Groq : {MODEL_NAME}")
+llm = ChatGroq(model=MODEL_NAME, temperature=0)
+
+DetectorFactory.seed = 0
+
+EN_WORDS = {"hi", "hello", "hey", "ok", "thanks", "bye", "yes", "no"}
+AR_WORDS = {"salam", "salaam", "marhaban", "مرحبا", "سلام", "شكرا", "أهلا"}
+FR_WORDS = {"bonjour", "salut", "merci", "oui", "non", "s'il vous plaît", "svp"}
+
+user_histories: Dict[str, List[Dict[str, str]]] = {}
+
+def normalize_text(text: str) -> str:
+    text = re.sub(r'[^\w\s]', '', text.lower().strip())
+    text = re.sub(r'\s+', ' ', text)
+    return text
+
+def detect_language(user_text: str, user_id: str, default_lang: str = "fr") -> str:
+    if not user_text:
+        return default_lang
+
+    text_normalized = normalize_text(user_text)
+
+    if text_normalized in EN_WORDS:
+        return "en"
+    if text_normalized in AR_WORDS:
+        return "ar"
+    if text_normalized in FR_WORDS:
+        return "fr"
+
+    history = user_histories.get(user_id, [])
+    if history and len(user_text) < 10:
+        last_msgs = [msg["content"] for msg in history[-2:] if msg["role"] == "user"]
+        for msg in last_msgs:
+            try:
+                lang = detect(msg)
+                if lang in {"fr", "en", "ar"}:
+                    return lang
+            except LangDetectException:
+                pass
+
+    try:
+        lang = detect(user_text)
+    except LangDetectException:
+        return default_lang
+
+    if lang not in {"fr", "en", "ar"}:
+        return default_lang
+
+    return lang
+
+class LLMRequest(BaseModel):
+    text: str
+    user_id: str
+    history: List[Dict[str, str]] = []
+
+@app.post("/generate")
+async def generate_response(request: LLMRequest):
+    user_text = request.text.strip()
+    user_id = request.user_id
+    if not user_text:
+        raise HTTPException(status_code=400, detail="Le texte ne peut pas être vide")
+    if not user_id:
+        raise HTTPException(status_code=400, detail="L'identifiant utilisateur est requis")
+
+    lang = detect_language(user_text, user_id, default_lang="fr")
+    logger.info(f"Requête LLM reçue ({len(user_text)} caractères), langue: {lang}, user_id: {user_id}")
+
+    if lang == "fr":
+        system_prompt = (
+            "Tu es HOLOKIA, un avatar IA conversationnel. "
+            "Réponds uniquement aux questions posées avec précision, clarté et simplicité. "
+            "Sois toujours poli et chaleureux dans ta manière de parler. "
+            "Si la question n’est pas claire, demande gentiment une précision. "
+            "Ne donne pas d’informations inutiles et reste concentré sur le sujet."
+        )
+    elif lang == "ar":
+        system_prompt = (
+            "أنت HOLOKIA، شخصية ذكاء اصطناعي محادثة. "
+            "أجب فقط على الأسئلة المطروحة بدقة ووضوح وبأسلوب بسيط. "
+            "كن دائمًا مهذبًا ودودًا في طريقة كلامك. "
+            "إذا لم يكن السؤال واضحًا، اطلب بلطف توضيحًا. "
+            "لا تضف معلومات غير ضرورية وابقَ مركزًا على الموضوع."
+        )
+    else:
+        system_prompt = (
+            "You are HOLOKIA, a conversational AI avatar. "
+            "Answer only the questions asked, with accuracy, clarity, and simplicity. "
+            "Always remain polite and friendly in your tone. "
+            "If the question is unclear, kindly ask for clarification. "
+            "Do not add unnecessary information and stay focused on the topic."
+        )
+
+    history = request.history if request.history else user_histories.get(user_id, [])
+    history.append({"role": "user", "content": user_text})
+
+    messages = [("system", system_prompt)] + [
+        (msg["role"], msg["content"]) for msg in history[-3:]
+    ]
+
+    total_length = sum(len(msg[1]) for msg in messages)
+    if total_length > 4000:
+        logger.warning(f"Prompt trop long ({total_length} caractères), truncation")
+        messages = [("system", system_prompt)] + messages[-2:]
+
+    logger.debug(f"Prompt envoyé au LLM: {messages}")
+
+    try:
+        response = llm.invoke(messages)
+        response_text = response.content.strip()
+        history.append({"role": "assistant", "content": response_text})
+        user_histories[user_id] = history[-5:]
+        logger.info("Réponse LLM générée avec succès")
+        return {
+            "response": response_text,
+            "lang": lang,
+            "history": user_histories[user_id]
+        }
+    except Exception as e:
+        logger.error(f"Erreur LLM: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Échec de génération de réponse")
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok", "service": "llm"}
+
+@app.options("/generate")
+async def options_generate():
+    return {"message": "OK"}
+
+def run_service():
+    uvicorn.run(app, host="0.0.0.0", port=5002)
+
+if __name__ == "__main__":
+    run_service()

Back-end/services/stt_service.py

@@ -0,0 +1,180 @@
+import tempfile
+from fastapi import FastAPI, UploadFile, File, HTTPException
+import logging
+import os
+import uvicorn
+from faster_whisper import WhisperModel
+from tempfile import NamedTemporaryFile
+from fastapi.middleware.cors import CORSMiddleware
+from pydub import AudioSegment
+from langdetect import detect, DetectorFactory, LangDetectException
+import glob
+
+# Configuration du logger
+logging.basicConfig(level=logging.DEBUG, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger("STT_Service")
+
+# Initialisation FastAPI
+app = FastAPI()
+
+# CORS pour frontend local
+origins = ["http://localhost:5173", "http://127.0.0.1:5173"]
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Paramètres
+MODEL_SIZE = "small"  # Léger et rapide
+MIN_AUDIO_SIZE = 1024  # Bytes (~0.03s à 16kHz)
+MIN_AUDIO_DURATION = 0.75  # Sec min pour traitement
+SAMPLE_RATE = 16000  # Hz, 16-bit mono
+MAX_TEMP_FILES = 1000  # Limite de fichiers temporaires
+
+# Initialisation du modèle Whisper
+logger.info(f"Chargement du modèle Faster-Whisper ({MODEL_SIZE})")
+try:
+    model = WhisperModel(MODEL_SIZE, device="cpu", compute_type="int8")
+    logger.info("Modèle Whisper chargé avec succès")
+except Exception as e:
+    logger.error(f"Erreur lors du chargement du modèle Whisper: {e}")
+    model = None
+
+# Rendre langdetect plus stable
+DetectorFactory.seed = 0
+
+# Correction langues fréquentes
+EN_WORDS = {"hi", "hello", "hey", "ok", "thanks", "bye", "yes", "no"}
+AR_WORDS = {"salam", "salaam", "marhaban", "مرحبا", "سلام", "شكرا", "أهلا"}
+
+def validate_language(transcript: str, whisper_lang: str, probability: float) -> str:
+    """Valide ou corrige la langue détectée par Whisper avec langdetect."""
+    if not transcript.strip():
+        return whisper_lang or "fr"
+
+    try:
+        detected_lang = detect(transcript)
+    except LangDetectException:
+        return whisper_lang or "fr"
+
+    # Normalisation et correction
+    text_lower = transcript.lower().strip()
+    if text_lower in EN_WORDS:
+        return "en"
+    if text_lower in AR_WORDS:
+        return "ar"
+
+    # Si probabilité faible (<0.9) et langdetect donne une langue différente, préférer langdetect
+    if probability < 0.9 and detected_lang in {"fr", "en", "ar"}:
+        logger.debug(f"Langue corrigée par langdetect: {whisper_lang} -> {detected_lang}")
+        return detected_lang
+
+    # Sinon, on garde la langue de Whisper
+    return whisper_lang or "fr"
+
+def clean_temp_files():
+    """Supprime les fichiers temporaires excédentaires."""
+    temp_files = glob.glob(f"{tempfile.gettempdir()}/*.wav")
+    if len(temp_files) > MAX_TEMP_FILES:
+        temp_files.sort(key=os.path.getmtime)
+        for file in temp_files[:-MAX_TEMP_FILES]:
+            try:
+                os.unlink(file)
+                logger.info(f"Fichier temporaire supprimé: {file}")
+            except Exception as e:
+                logger.warning(f"Erreur lors de la suppression de {file}: {e}")
+
+@app.post("/transcribe")
+async def transcribe_audio(file: UploadFile = File(...), language: str = None):
+    """
+    Transcrit un fichier audio en texte avec Faster-Whisper.
+    - file: Audio (WAV, MP3, M4A, WebM, etc.)
+    - language: Langue cible (optionnel: en, ar, fr, etc.), sinon autodétection
+    """
+    logger.info(f"Fichier reçu: filename={file.filename}, content_type={file.content_type}")
+
+    # Vérifier si le modèle est chargé
+    if model is None:
+        logger.error("Modèle Whisper non chargé")
+        raise HTTPException(status_code=503, detail="Service STT non disponible")
+
+    temp_audio_path = None
+    try:
+        # Nettoie les fichiers temporaires si nécessaire
+        clean_temp_files()
+
+        # Sauvegarde temporaire
+        suffix = os.path.splitext(file.filename)[1].lower()
+        content = await file.read()
+        if len(content) < MIN_AUDIO_SIZE:
+            logger.debug(f"Audio trop petit ({len(content)} bytes), skip")
+            return {"transcript": "", "lang": language or "unknown", "status": "skipped"}
+
+        with NamedTemporaryFile(delete=False, suffix=suffix) as temp_audio:
+            temp_audio.write(content)
+            temp_audio_path = temp_audio.name
+
+        # Vérification durée
+        duration = os.path.getsize(temp_audio_path) / (SAMPLE_RATE * 2)  # 16kHz, 16-bit mono
+        logger.info(f"Processing audio, duration: {duration:.3f}s")
+        if duration < MIN_AUDIO_DURATION:
+            logger.debug(f"Audio trop court ({duration:.3f}s), skip")
+            return {"transcript": "", "lang": language or "unknown", "status": "skipped"}
+
+        # Conversion si non supporté
+        supported_formats = [".wav", ".mp3", ".m4a", ".webm"]
+        wav_path = temp_audio_path
+        if suffix != ".wav":
+            try:
+                audio = AudioSegment.from_file(temp_audio_path)
+                with NamedTemporaryFile(delete=False, suffix=".wav") as wav_fd:
+                    audio.export(wav_fd.name, format="wav")
+                    wav_path = wav_fd.name
+                logger.info(f"Converti en WAV: {wav_path}")
+            except Exception as e:
+                logger.error(f"Erreur conversion WAV: {e}")
+                raise HTTPException(status_code=400, detail="Erreur conversion audio")
+
+        # Transcription
+        segments, info = model.transcribe(wav_path, language=language if language else None)
+        transcript = " ".join([s.text.strip() for s in segments if s.text.strip()])
+
+        # Validation de la langue
+        detected_lang = language or validate_language(transcript, info.language, info.language_probability)
+        logger.info(f"Langue détectée: {info.language}, Probabilité: {info.language_probability:.2f}, Langue finale: {detected_lang}")
+        logger.info(f"Transcript: '{transcript}'")
+
+        return {
+            "transcript": transcript,
+            "lang": detected_lang,
+            "status": "success" if transcript else "empty"
+        }
+
+    except Exception as e:
+        logger.error(f"Échec transcription: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Erreur STT")
+
+    finally:
+        # Nettoyage fichiers temporaires
+        try:
+            if temp_audio_path and os.path.exists(temp_audio_path):
+                os.unlink(temp_audio_path)
+            if "wav_path" in locals() and wav_path != temp_audio_path and os.path.exists(wav_path):
+                os.unlink(wav_path)
+        except Exception as e:
+            logger.warning(f"Erreur nettoyage fichiers: {e}")
+
+@app.get("/health")
+async def health_check():
+    """Vérifie l’état du service."""
+    return {"status": "ok", "service": "stt"}
+
+def run_service():
+    """Lance le service STT."""
+    uvicorn.run(app, host="0.0.0.0", port=5001)
+
+if __name__ == "__main__":
+    run_service()

Back-end/services/tts_service.py

@@ -0,0 +1,119 @@
+# File: tts_service.py
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from gtts import gTTS
+import hashlib
+import os
+import sys
+import logging
+import uvicorn
+from pathlib import Path
+from fastapi.middleware.cors import CORSMiddleware
+
+# Configuration du logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+    stream=sys.stdout
+)
+logger = logging.getLogger("TTS_Service")
+
+app = FastAPI()
+
+# Chemins absolus
+BASE_DIR = Path(__file__).parent.parent.resolve()
+CACHE_DIR = BASE_DIR / "tts_cache"
+CACHE_DIR.mkdir(exist_ok=True)
+
+# Configuration CORS
+origins = ["*"]  # Autoriser toutes les origines pour les tests
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Langues supportées
+SUPPORTED_LANGUAGES = {"fr", "en", "ar", "es", "de", "it"}
+
+class TTSRequest(BaseModel):
+    text: str
+    lang: str
+
+@app.post("/generate-tts")
+async def generate_tts(request: TTSRequest):
+    text = request.text.strip()
+    lang = request.lang.strip().lower()
+    
+    # Validation des entrées
+    if not text:
+        raise HTTPException(status_code=400, detail="Le texte ne peut pas être vide")
+    if lang not in SUPPORTED_LANGUAGES:
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Langue non supportée. Choisissez parmi: {', '.join(SUPPORTED_LANGUAGES)}"
+        )
+
+    logger.info(f"Génération TTS: {len(text)} caractères en {lang}")
+
+    # Génération du hash
+    normalized_text = text.replace(" ", "_").lower()
+    text_hash = hashlib.md5(f"{normalized_text}_{lang}".encode('utf-8')).hexdigest()
+    filename = f"{text_hash}.mp3"
+    filepath = CACHE_DIR / filename
+
+    # Utilisation du cache si disponible
+    if filepath.exists():
+        logger.info(f"Fichier existant: {filepath}")
+        return {
+            "audioPath": str(filepath.relative_to(BASE_DIR)),
+            "url": f"/audio/{filepath.relative_to(BASE_DIR)}"
+        }
+
+    # Génération du fichier audio
+    try:
+        tts = gTTS(text=text, lang=lang)
+        tts.save(str(filepath))
+        logger.info(f"Fichier généré: {filepath}")
+        
+        return {
+            "audioPath": str(filepath.relative_to(BASE_DIR)),
+            "url": f"/audio/{filepath.relative_to(BASE_DIR)}"
+        }
+    except Exception as e:
+        logger.error(f"Erreur TTS: {str(e)}", exc_info=True)
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Échec de génération audio: {str(e)}"
+        )
+    
+@app.get("/audio/{file_path:path}")
+async def get_audio(file_path: str):
+    # Sécurité: empêcher les accès en dehors du cache
+    if ".." in file_path or file_path.startswith("/"):
+        raise HTTPException(status_code=403, detail="Accès non autorisé")
+    
+    full_path = BASE_DIR / file_path
+    
+    # Vérifier que le chemin est dans le cache
+    if not str(full_path).startswith(str(CACHE_DIR)):
+        raise HTTPException(status_code=403, detail="Accès non autorisé")
+    
+    if not full_path.exists():
+        raise HTTPException(status_code=404, detail="Fichier audio non trouvé")
+    
+    return FileResponse(full_path, media_type="audio/mpeg")
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok", "service": "tts"}
+
+def run_service():
+    uvicorn.run(app, host="0.0.0.0", port=5000)
+
+if __name__ == "__main__":
+    run_service()

Back-end/start_services.py

@@ -0,0 +1,121 @@
+import os
+import subprocess
+import sys
+import logging
+from logging.handlers import RotatingFileHandler
+from datetime import datetime
+import threading
+import time
+
+# ─────────────── UTF-8 Windows ───────────────
+if os.name == 'nt':
+    import ctypes
+    ctypes.windll.kernel32.SetConsoleCP(65001)
+    ctypes.windll.kernel32.SetConsoleOutputCP(65001)
+
+# ─────────────── Répertoires de logs ───────────────
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+LOG_DIR = os.path.join(BASE_DIR, "logs")
+os.makedirs(LOG_DIR, exist_ok=True)
+
+# ─────────────── Logger central ───────────────
+central_logger = logging.getLogger("Holokia")
+central_logger.setLevel(logging.INFO)
+
+console_handler = logging.StreamHandler(sys.stdout)
+console_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+
+central_file_handler = RotatingFileHandler(
+    os.path.join(LOG_DIR, "holokia.log"),
+    maxBytes=5*1024*1024,
+    backupCount=5,
+    encoding="utf-8"
+)
+central_file_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+
+central_logger.addHandler(console_handler)
+central_logger.addHandler(central_file_handler)
+
+central_logger.info("🚀 Démarrage de tous les services Holokia Avatar")
+central_logger.info(f"📅 Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+
+# ─────────────── Services ───────────────
+SERVICES = {
+    "TTS": {"script": "services/tts_service.py", "port": 5000, "prefix": "[TTS]"},
+    "STT": {"script": "services/stt_service.py", "port": 5001, "prefix": "[STT]"},
+    "LLM": {"script": "services/llm_service.py", "port": 5002, "prefix": "[LLM]"},
+    "LiveStream": {"script": "services/live_stream_service.py", "port": 5003, "prefix": "[Live]"},
+    # "Backend": {"script": os.path.join(BASE_DIR, "app/main.py"), "port": int(os.getenv("PORT", 8000)), "prefix": "[Backend]"}
+}
+
+processes = {}
+
+# ─────────────── Fonction pour créer un logger par service ───────────────
+def create_service_logger(name):
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    
+    file_handler = RotatingFileHandler(
+        os.path.join(LOG_DIR, f"{name}.log"),
+        maxBytes=5*1024*1024,
+        backupCount=3,
+        encoding="utf-8"
+    )
+    file_handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+    
+    # Eviter d'ajouter plusieurs handlers si déjà créé
+    if not logger.handlers:
+        logger.addHandler(console_handler)
+        logger.addHandler(file_handler)
+    
+    return logger
+
+# ─────────────── Démarrer un service ───────────────
+def start_service(name, info):
+    prefix = info["prefix"]
+    port = info["port"]
+    script = info["script"]
+    
+    service_logger = create_service_logger(name)
+    
+    # Ajuster PYTHONPATH
+    #env = os.environ.copy()
+    #env["PYTHONPATH"] = f"{BASE_DIR};{os.path.dirname(script)};{env.get('PYTHONPATH','')}"
+    
+    service_logger.info(f"{prefix} 🚀 Démarrage du service sur le port {port} ...")
+    
+    proc = subprocess.Popen(
+        [sys.executable, script],
+        stdout=sys.stdout,
+        stderr=sys.stderr,
+        bufsize=1,
+        universal_newlines=True,
+        #env=env
+    )
+    
+    # Les logs des services apparaîtront directement dans stdout
+    
+    return proc
+
+# ─────────────── Lancement de tous les services ───────────────
+for name, info in SERVICES.items():
+    proc = start_service(name, info)
+    processes[name] = proc
+
+central_logger.info("⚙️ Tous les services ont été lancés. Ctrl+C pour arrêter.")
+
+# ─────────────── Boucle de surveillance ───────────────
+try:
+    while True:
+        for name, proc in list(processes.items()):
+            ret = proc.poll()
+            if ret is not None:
+                central_logger.error(f"{SERVICES[name]['prefix']} ❌ Service arrêté ! Code: {ret}")
+                proc_new = start_service(name, SERVICES[name])
+                processes[name] = proc_new
+        time.sleep(2)
+except KeyboardInterrupt:
+    central_logger.info("⏹ Arrêt de tous les services...")
+    for name, proc in processes.items():
+        proc.terminate()
+    central_logger.info("✅ Tous les services ont été arrêtés.")

Dockerfile

@@ -0,0 +1,92 @@
+# ===========================================
+# Dockerfile pour Hugging Face Spaces
+# HOLOKIA-AVATAR - Avatar 3D Interactif
+# ===========================================
+
+# Stage 1: Build frontend
+FROM node:18-alpine AS frontend-build
+
+WORKDIR /app/frontend
+
+# Copy package files
+COPY frontend/package*.json ./
+COPY frontend/wawa-lipsync/package*.json ./wawa-lipsync/
+
+# Install dependencies (including dev dependencies for build)
+RUN npm ci
+
+# Copy source code
+COPY frontend/ .
+
+# Install wawa-lipsync dependencies and build
+WORKDIR /app/frontend/wawa-lipsync
+RUN npm install
+RUN npm run build
+
+# Build main application
+WORKDIR /app/frontend
+RUN npm run build
+
+# Stage 2: Python backend
+FROM python:3.11-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    curl \
+    ffmpeg \
+    nginx \
+    wget \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create non-root user
+RUN useradd --create-home --shell /bin/bash app
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY Back-end/requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy backend application code
+COPY Back-end/ .
+
+# Copy frontend built files from previous stage
+COPY --from=frontend-build /app/frontend/dist /usr/share/nginx/html
+
+# Copy nginx configuration
+COPY docker/nginx.conf /etc/nginx/nginx.conf
+
+# Copy app.py (entry point for HF)
+COPY app.py .
+
+# Copy diagnostic scripts
+COPY debug_websocket.py .
+COPY test_services_detailed.py .
+
+# Create necessary directories and set permissions
+RUN mkdir -p logs tts_cache /var/cache/nginx /var/log/nginx /var/run /var/lib/nginx && \
+    chown -R app:app /app && \
+    chown -R app:app /usr/share/nginx/html && \
+    chown -R app:app /var/cache/nginx /var/log/nginx /var/run /var/lib/nginx
+
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV PORT=7860
+
+# Expose port (Hugging Face standard)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Switch to non-root user
+USER app
+
+# Start application
+CMD ["python", "app.py"]

README.md

@@ -0,0 +1,45 @@
+---
+title: HOLOKIA-AVATAR
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+short_description: Avatar 3D intelligent avec IA conversationnelle
+---
+
+# 🤖 HOLOKIA-AVATAR - Avatar 3D Interactif
+
+Un avatar 3D intelligent avec capacités de conversation en temps réel, utilisant l'IA pour des interactions naturelles.
+
+## ✨ Fonctionnalités
+
+- 🎭 **Avatar 3D interactif** avec synchronisation labiale
+- 🗣️ **Reconnaissance vocale** (Speech-to-Text)
+- 🔊 **Synthèse vocale** (Text-to-Speech)
+- 🧠 **IA conversationnelle** (Groq LLM)
+- 📡 **Streaming temps réel** via WebSocket
+- 🌐 **Interface web moderne** avec React et Three.js
+
+## 🚀 Utilisation
+
+1. **Parlez** à l'avatar via le microphone
+2. **L'avatar écoute** et comprend votre message
+3. **L'IA génère** une réponse intelligente
+4. **L'avatar parle** avec synchronisation labiale
+5. **Interaction continue** en temps réel
+
+## 🔧 Configuration
+
+Ajoutez votre clé API Groq dans les **Secrets** du Space :
+- Nom : `GROQ_API_KEY`
+- Valeur : `gsk_...` (votre clé API)
+
+## 📄 Licence
+
+MIT License
+
+---
+
+**Développé avec ❤️ par l'équipe HOLOKIA**

app.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+HOLOKIA-AVATAR - Point d'entrée pour Hugging Face Spaces
+Avatar 3D interactif avec IA conversationnelle
+"""
+
+import os
+import sys
+import subprocess
+import time
+import logging
+from pathlib import Path
+
+# Configuration du logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("HOLOKIA-AVATAR")
+
+def check_requirements():
+    """Vérifie que toutes les dépendances sont installées."""
+    try:
+        import fastapi
+        import uvicorn
+        import gtts
+        import faster_whisper
+        import langchain_groq
+        logger.info("✅ Toutes les dépendances sont installées")
+        return True
+    except ImportError as e:
+        logger.error(f"❌ Dépendance manquante: {e}")
+        return False
+
+def check_environment():
+    """Vérifie les variables d'environnement requises."""
+    groq_key = os.getenv("GROQ_API_KEY")
+    if not groq_key:
+        logger.warning("⚠️ GROQ_API_KEY n'est pas définie")
+        logger.info("💡 Ajoutez votre clé API Groq dans les secrets du Space")
+        # Ne pas arrêter l'application, juste avertir
+        return True
+    
+    logger.info("✅ Variables d'environnement configurées")
+    return True
+
+def check_frontend():
+    """Vérifie que le frontend est disponible."""
+    nginx_html = Path("/usr/share/nginx/html")
+    
+    if nginx_html.exists() and any(nginx_html.iterdir()):
+        logger.info("✅ Frontend disponible (construit dans le Dockerfile)")
+        return True
+    else:
+        logger.error("❌ Frontend non disponible")
+        return False
+
+def test_services():
+    """Teste que tous les services backend sont accessibles."""
+    logger.info("🔍 Test des services backend...")
+    
+    import requests
+    
+    services = [
+        ("TTS", "http://localhost:5000/health"),
+        ("STT", "http://localhost:5001/health"),
+        ("LLM", "http://localhost:5002/health"),
+        ("Live Stream", "http://localhost:5003/health"),
+    ]
+    
+    all_ok = True
+    for name, url in services:
+        try:
+            response = requests.get(url, timeout=5)
+            if response.status_code == 200:
+                logger.info(f"✅ {name}: OK")
+            else:
+                logger.error(f"❌ {name}: Erreur (status {response.status_code})")
+                all_ok = False
+        except Exception as e:
+            logger.error(f"❌ {name}: Erreur de connexion - {e}")
+            all_ok = False
+    
+    return all_ok
+
+def start_services():
+    """Démarre tous les services backend."""
+    logger.info("🚀 Démarrage des services backend...")
+    
+    try:
+        # Vérifier que le script existe
+        start_script = Path("start_services.py")
+        if not start_script.exists():
+            logger.error(f"❌ Script de démarrage non trouvé: {start_script}")
+            return False
+        
+        # Démarrer les services en arrière-plan
+        logger.info("⏳ Démarrage des services en arrière-plan...")
+        process = subprocess.Popen([
+            sys.executable, str(start_script)
+        ], cwd=os.getcwd(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        
+        # Attendre un peu pour que les services démarrent
+        time.sleep(15)
+        
+        # Vérifier que le processus est toujours en vie
+        if process.poll() is not None:
+            logger.error("❌ Les services backend se sont arrêtés prématurément")
+            stdout, stderr = process.communicate()
+            logger.error(f"STDOUT: {stdout.decode()}")
+            logger.error(f"STDERR: {stderr.decode()}")
+            return False
+        
+        # Tester que les services sont accessibles
+        if not test_services():
+            logger.error("❌ Certains services ne sont pas accessibles")
+            return False
+        
+        # Test détaillé des services
+        logger.info("🔍 Test détaillé des services...")
+        try:
+            result = subprocess.run([sys.executable, "debug_websocket.py"], 
+                                  capture_output=True, text=True, timeout=30)
+            if result.stdout:
+                logger.info(f"Résultats des tests WebSocket:\n{result.stdout}")
+            if result.stderr:
+                logger.error(f"Erreurs des tests WebSocket:\n{result.stderr}")
+        except Exception as e:
+            logger.warning(f"Impossible d'exécuter les tests WebSocket: {e}")
+        
+        # Test détaillé des services
+        logger.info("🔍 Test détaillé des services...")
+        try:
+            result = subprocess.run([sys.executable, "test_services_detailed.py"], 
+                                  capture_output=True, text=True, timeout=120)
+            if result.stdout:
+                logger.info(f"Résultats des tests détaillés:\n{result.stdout}")
+            if result.stderr:
+                logger.error(f"Erreurs des tests détaillés:\n{result.stderr}")
+        except Exception as e:
+            logger.warning(f"Impossible d'exécuter les tests détaillés: {e}")
+        
+        logger.info("✅ Services backend démarrés et testés")
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ Erreur lors du démarrage des services: {e}")
+        return False
+
+def start_nginx():
+    """Démarre Nginx."""
+    logger.info("🌐 Démarrage de Nginx...")
+    
+    try:
+        # Vérifier la configuration Nginx
+        result = subprocess.run(["nginx", "-t"], capture_output=True, text=True)
+        if result.returncode != 0:
+            logger.error(f"❌ Configuration Nginx invalide: {result.stderr}")
+            return False
+        
+        logger.info("✅ Configuration Nginx valide")
+        
+        # Démarrer Nginx en mode daemon
+        subprocess.run(["nginx"], check=True)
+        logger.info("✅ Nginx démarré")
+        
+        return True
+        
+    except subprocess.CalledProcessError as e:
+        logger.error(f"❌ Erreur Nginx: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"❌ Erreur inattendue avec Nginx: {e}")
+        return False
+
+def main():
+    """Point d'entrée principal."""
+    logger.info("🤖 HOLOKIA-AVATAR - Démarrage sur Hugging Face Spaces (v2.2)")
+    logger.info(f"📁 Répertoire de travail: {os.getcwd()}")
+    logger.info(f"🐍 Version Python: {sys.version}")
+    
+    try:
+        # Vérifications préliminaires
+        if not check_requirements():
+            logger.error("❌ Vérification des dépendances échouée")
+            sys.exit(1)
+        
+        if not check_environment():
+            logger.warning("⚠️ Vérification de l'environnement échouée, mais on continue")
+        
+        if not check_frontend():
+            logger.error("❌ Vérification du frontend échouée")
+            sys.exit(1)
+        
+        # Démarrage des services
+        if not start_services():
+            logger.error("❌ Impossible de démarrer les services backend")
+            # Ne pas arrêter, essayer de continuer avec Nginx seulement
+        
+        # Démarrage de Nginx
+        if not start_nginx():
+            logger.error("❌ Impossible de démarrer Nginx")
+            sys.exit(1)
+        
+        logger.info("🎉 Application démarrée avec succès!")
+        logger.info("🌐 Serveur web accessible sur le port 7860")
+        
+        # Garder l'application en vie
+        try:
+            while True:
+                time.sleep(60)
+                logger.info("💓 Application en vie...")
+        except KeyboardInterrupt:
+            logger.info("🛑 Arrêt de l'application")
+            
+    except Exception as e:
+        logger.error(f"❌ Erreur critique: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

clean_and_restructure.ps1

@@ -0,0 +1,278 @@
+# ===========================================
+# Script PowerShell de nettoyage et restructuration pour Hugging Face
+# HOLOKIA-AVATAR - Avatar 3D Interactif
+# ===========================================
+
+param(
+    [switch]$Help
+)
+
+# Fonctions utilitaires
+function Write-Info {
+    param([string]$Message)
+    Write-Host "[INFO] $Message" -ForegroundColor Blue
+}
+
+function Write-Success {
+    param([string]$Message)
+    Write-Host "[SUCCESS] $Message" -ForegroundColor Green
+}
+
+function Write-Warning {
+    param([string]$Message)
+    Write-Host "[WARNING] $Message" -ForegroundColor Yellow
+}
+
+function Write-Error {
+    param([string]$Message)
+    Write-Host "[ERROR] $Message" -ForegroundColor Red
+}
+
+# Aide
+if ($Help) {
+    Write-Host "Usage: .\clean_and_restructure.ps1 [OPTIONS]"
+    Write-Host ""
+    Write-Host "Ce script nettoie l'historique Git et restructure le projet pour Hugging Face Spaces."
+    Write-Host ""
+    Write-Host "Options:"
+    Write-Host "  -Help    Afficher cette aide"
+    Write-Host ""
+    Write-Host "ATTENTION: Ce script va supprimer l'historique Git existant!"
+    Write-Host "Une sauvegarde sera créée dans ..\backup_holokia_avatar\"
+    Write-Host ""
+    exit 0
+}
+
+# Vérifications préliminaires
+function Test-Requirements {
+    Write-Info "Vérification des prérequis..."
+    
+    # Vérifier Git
+    if (-not (Get-Command git -ErrorAction SilentlyContinue)) {
+        Write-Error "Git n'est pas installé"
+        exit 1
+    }
+    
+    # Vérifier Git LFS
+    if (-not (Get-Command git-lfs -ErrorAction SilentlyContinue)) {
+        Write-Warning "Git LFS n'est pas installé"
+        Write-Info "Téléchargez et installez Git LFS depuis: https://git-lfs.github.io/"
+        Write-Info "Ou utilisez: winget install Git.Git-LFS"
+        exit 1
+    }
+    
+    Write-Success "Tous les prérequis sont satisfaits"
+}
+
+# Sauvegarde des fichiers importants
+function Backup-ImportantFiles {
+    Write-Info "Sauvegarde des fichiers importants..."
+    
+    # Créer un dossier de sauvegarde
+    $backupDir = "..\backup_holokia_avatar"
+    if (-not (Test-Path $backupDir)) {
+        New-Item -ItemType Directory -Path $backupDir -Force | Out-Null
+    }
+    
+    # Sauvegarder les fichiers de configuration
+    Copy-Item -Path "." -Destination $backupDir -Recurse -Force
+    
+    Write-Success "Sauvegarde terminée dans $backupDir"
+}
+
+# Nettoyage de l'historique Git
+function Clear-GitHistory {
+    Write-Info "Nettoyage de l'historique Git..."
+    
+    # Supprimer le dossier .git existant
+    if (Test-Path ".git") {
+        Write-Info "Suppression de l'historique Git existant..."
+        Remove-Item -Path ".git" -Recurse -Force
+    }
+    
+    # Initialiser un nouveau dépôt Git
+    Write-Info "Initialisation d'un nouveau dépôt Git..."
+    git init
+    
+    # Configurer Git LFS
+    Write-Info "Configuration de Git LFS..."
+    git lfs install
+    
+    # Ajouter les fichiers LFS
+    git lfs track "*.glb"
+    git lfs track "*.fbx"
+    git lfs track "*.obj"
+    git lfs track "*.png"
+    git lfs track "*.jpg"
+    git lfs track "*.jpeg"
+    git lfs track "*.wav"
+    git lfs track "*.mp3"
+    
+    Write-Success "Historique Git nettoyé et LFS configuré"
+}
+
+# Restructuration des fichiers
+function Restructure-Files {
+    Write-Info "Restructuration des fichiers pour Hugging Face..."
+    
+    # Supprimer les fichiers de développement
+    $filesToRemove = @(
+        "build-frontend.sh",
+        "deploy_to_hf.sh",
+        "test_deployment.py",
+        "README_HF_DEPLOYMENT.md",
+        "huggingface_hub_config.yaml"
+    )
+    
+    foreach ($file in $filesToRemove) {
+        if (Test-Path $file) {
+            Remove-Item -Path $file -Force
+            Write-Info "Supprimé: $file"
+        }
+    }
+    
+    # Supprimer les dossiers de développement
+    $dirsToRemove = @(
+        "docker",
+        "Back-end\tts_cache",
+        "Back-end\logs",
+        "frontend\node_modules",
+        "frontend\dist",
+        "__pycache__",
+        ".pytest_cache"
+    )
+    
+    foreach ($dir in $dirsToRemove) {
+        if (Test-Path $dir) {
+            Remove-Item -Path $dir -Recurse -Force
+            Write-Info "Supprimé: $dir"
+        }
+    }
+    
+    # Supprimer les fichiers docker-compose
+    Get-ChildItem -Path "." -Name "docker-compose*.yml" | ForEach-Object {
+        Remove-Item -Path $_ -Force
+        Write-Info "Supprimé: $_"
+    }
+    
+    # Supprimer les fichiers .env (sauf .env.example)
+    Get-ChildItem -Path "." -Name ".env*" -Recurse | Where-Object { $_.Name -ne ".env.example" } | ForEach-Object {
+        Remove-Item -Path $_.FullName -Force
+        Write-Info "Supprimé: $($_.FullName)"
+    }
+    
+    Write-Success "Restructuration terminée"
+}
+
+# Création des fichiers nécessaires pour HF
+function New-HuggingFaceFiles {
+    Write-Info "Création des fichiers nécessaires pour Hugging Face..."
+    
+    # Créer un README.md simple pour HF
+    $readmeContent = @"
+---
+title: HOLOKIA-AVATAR
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+short_description: Avatar 3D intelligent avec IA conversationnelle en temps réel
+---
+
+# 🤖 HOLOKIA-AVATAR - Avatar 3D Interactif
+
+Un avatar 3D intelligent avec capacités de conversation en temps réel, utilisant l'IA pour des interactions naturelles.
+
+## ✨ Fonctionnalités
+
+- 🎭 **Avatar 3D interactif** avec synchronisation labiale
+- 🗣️ **Reconnaissance vocale** (Speech-to-Text)
+- 🔊 **Synthèse vocale** (Text-to-Speech)
+- 🧠 **IA conversationnelle** (Groq LLM)
+- 📡 **Streaming temps réel** via WebSocket
+- 🌐 **Interface web moderne** avec React et Three.js
+
+## 🚀 Utilisation
+
+1. **Parlez** à l'avatar via le microphone
+2. **L'avatar écoute** et comprend votre message
+3. **L'IA génère** une réponse intelligente
+4. **L'avatar parle** avec synchronisation labiale
+5. **Interaction continue** en temps réel
+
+## 🔧 Configuration
+
+Ajoutez votre clé API Groq dans les **Secrets** du Space :
+- Nom : `GROQ_API_KEY`
+- Valeur : `gsk_...` (votre clé API)
+
+## 📄 Licence
+
+MIT License
+
+---
+
+**Développé avec ❤️ par l'équipe HOLOKIA**
+"@
+    
+    $readmeContent | Out-File -FilePath "README.md" -Encoding UTF8
+    
+    Write-Success "Fichiers HF créés"
+}
+
+# Configuration Git
+function Set-GitConfiguration {
+    Write-Info "Configuration Git..."
+    
+    # Ajouter tous les fichiers
+    git add .
+    
+    # Commit initial
+    git commit -m "Initial commit: HOLOKIA-AVATAR for Hugging Face Spaces"
+    
+    Write-Success "Configuration Git terminée"
+}
+
+# Fonction principale
+function Main {
+    Write-Host "🧹 HOLOKIA-AVATAR - Nettoyage et restructuration pour Hugging Face" -ForegroundColor Cyan
+    Write-Host "==================================================================" -ForegroundColor Cyan
+    Write-Host ""
+    
+    # Vérifications
+    Test-Requirements
+    
+    # Sauvegarde
+    Backup-ImportantFiles
+    
+    # Nettoyage
+    Clear-GitHistory
+    
+    # Restructuration
+    Restructure-Files
+    
+    # Création des fichiers HF
+    New-HuggingFaceFiles
+    
+    # Configuration Git
+    Set-GitConfiguration
+    
+    Write-Host ""
+    Write-Success "🎉 Nettoyage et restructuration terminés!"
+    Write-Host ""
+    Write-Info "Prochaines étapes:"
+    Write-Host "1. Ajoutez le remote Hugging Face:"
+    Write-Host "   git remote add origin https://huggingface.co/spaces/DataSage12/avatar-v2"
+    Write-Host ""
+    Write-Host "2. Poussez le code:"
+    Write-Host "   git push -u origin main"
+    Write-Host ""
+    Write-Host "3. Ajoutez votre clé API Groq dans les secrets du Space"
+    Write-Host ""
+    Write-Warning "Sauvegarde disponible dans: ..\backup_holokia_avatar\"
+}
+
+# Exécution
+Main

clean_and_restructure.sh

@@ -0,0 +1,259 @@
+#!/bin/bash
+
+# ===========================================
+# Script de nettoyage et restructuration pour Hugging Face
+# HOLOKIA-AVATAR - Avatar 3D Interactif
+# ===========================================
+
+set -e
+
+# Couleurs pour les logs
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Fonctions utilitaires
+log_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+log_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Vérifications préliminaires
+check_requirements() {
+    log_info "Vérification des prérequis..."
+    
+    # Vérifier Git
+    if ! command -v git &> /dev/null; then
+        log_error "Git n'est pas installé"
+        exit 1
+    fi
+    
+    # Vérifier Git LFS
+    if ! command -v git-lfs &> /dev/null; then
+        log_warning "Git LFS n'est pas installé"
+        log_info "Installation de Git LFS..."
+        if command -v apt-get &> /dev/null; then
+            sudo apt-get install git-lfs
+        elif command -v brew &> /dev/null; then
+            brew install git-lfs
+        else
+            log_error "Impossible d'installer Git LFS automatiquement"
+            log_info "Installez Git LFS manuellement: https://git-lfs.github.io/"
+            exit 1
+        fi
+    fi
+    
+    log_success "Tous les prérequis sont satisfaits"
+}
+
+# Sauvegarde des fichiers importants
+backup_important_files() {
+    log_info "Sauvegarde des fichiers importants..."
+    
+    # Créer un dossier de sauvegarde
+    mkdir -p ../backup_holokia_avatar
+    
+    # Sauvegarder les fichiers de configuration
+    cp -r . ../backup_holokia_avatar/ 2>/dev/null || true
+    
+    log_success "Sauvegarde terminée dans ../backup_holokia_avatar/"
+}
+
+# Nettoyage de l'historique Git
+clean_git_history() {
+    log_info "Nettoyage de l'historique Git..."
+    
+    # Supprimer le dossier .git existant
+    if [ -d ".git" ]; then
+        log_info "Suppression de l'historique Git existant..."
+        rm -rf .git
+    fi
+    
+    # Initialiser un nouveau dépôt Git
+    log_info "Initialisation d'un nouveau dépôt Git..."
+    git init
+    
+    # Configurer Git LFS
+    log_info "Configuration de Git LFS..."
+    git lfs install
+    
+    # Ajouter les fichiers LFS
+    git lfs track "*.glb"
+    git lfs track "*.fbx"
+    git lfs track "*.obj"
+    git lfs track "*.png"
+    git lfs track "*.jpg"
+    git lfs track "*.jpeg"
+    git lfs track "*.wav"
+    git lfs track "*.mp3"
+    
+    log_success "Historique Git nettoyé et LFS configuré"
+}
+
+# Restructuration des fichiers
+restructure_files() {
+    log_info "Restructuration des fichiers pour Hugging Face..."
+    
+    # Supprimer les fichiers de développement
+    rm -f build-frontend.sh
+    rm -f deploy_to_hf.sh
+    rm -f test_deployment.py
+    rm -f README_HF_DEPLOYMENT.md
+    rm -f huggingface_hub_config.yaml
+    rm -rf docker/
+    rm -f docker-compose*.yml
+    
+    # Supprimer les fichiers de cache et temporaires
+    rm -rf Back-end/tts_cache/
+    rm -rf Back-end/logs/
+    rm -rf frontend/node_modules/
+    rm -rf frontend/dist/
+    rm -rf __pycache__/
+    rm -rf .pytest_cache/
+    
+    # Supprimer les fichiers .env s'ils existent
+    find . -name ".env*" -not -name ".env.example" -delete 2>/dev/null || true
+    
+    log_success "Restructuration terminée"
+}
+
+# Création des fichiers nécessaires pour HF
+create_hf_files() {
+    log_info "Création des fichiers nécessaires pour Hugging Face..."
+    
+    # Créer un README.md simple pour HF
+    cat > README.md << 'EOF'
+---
+title: HOLOKIA-AVATAR
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+short_description: Avatar 3D intelligent avec IA conversationnelle en temps réel
+---
+
+# 🤖 HOLOKIA-AVATAR - Avatar 3D Interactif
+
+Un avatar 3D intelligent avec capacités de conversation en temps réel, utilisant l'IA pour des interactions naturelles.
+
+## ✨ Fonctionnalités
+
+- 🎭 **Avatar 3D interactif** avec synchronisation labiale
+- 🗣️ **Reconnaissance vocale** (Speech-to-Text)
+- 🔊 **Synthèse vocale** (Text-to-Speech)
+- 🧠 **IA conversationnelle** (Groq LLM)
+- 📡 **Streaming temps réel** via WebSocket
+- 🌐 **Interface web moderne** avec React et Three.js
+
+## 🚀 Utilisation
+
+1. **Parlez** à l'avatar via le microphone
+2. **L'avatar écoute** et comprend votre message
+3. **L'IA génère** une réponse intelligente
+4. **L'avatar parle** avec synchronisation labiale
+5. **Interaction continue** en temps réel
+
+## 🔧 Configuration
+
+Ajoutez votre clé API Groq dans les **Secrets** du Space :
+- Nom : `GROQ_API_KEY`
+- Valeur : `gsk_...` (votre clé API)
+
+## 📄 Licence
+
+MIT License
+
+---
+
+**Développé avec ❤️ par l'équipe HOLOKIA**
+EOF
+
+    log_success "Fichiers HF créés"
+}
+
+# Configuration Git
+setup_git() {
+    log_info "Configuration Git..."
+    
+    # Ajouter tous les fichiers
+    git add .
+    
+    # Commit initial
+    git commit -m "Initial commit: HOLOKIA-AVATAR for Hugging Face Spaces"
+    
+    log_success "Configuration Git terminée"
+}
+
+# Fonction principale
+main() {
+    echo "🧹 HOLOKIA-AVATAR - Nettoyage et restructuration pour Hugging Face"
+    echo "=================================================================="
+    echo ""
+    
+    # Vérifications
+    check_requirements
+    
+    # Sauvegarde
+    backup_important_files
+    
+    # Nettoyage
+    clean_git_history
+    
+    # Restructuration
+    restructure_files
+    
+    # Création des fichiers HF
+    create_hf_files
+    
+    # Configuration Git
+    setup_git
+    
+    echo ""
+    log_success "🎉 Nettoyage et restructuration terminés!"
+    echo ""
+    log_info "Prochaines étapes:"
+    echo "1. Ajoutez le remote Hugging Face:"
+    echo "   git remote add origin https://huggingface.co/spaces/DataSage12/avatar-v2"
+    echo ""
+    echo "2. Poussez le code:"
+    echo "   git push -u origin main"
+    echo ""
+    echo "3. Ajoutez votre clé API Groq dans les secrets du Space"
+    echo ""
+    log_warning "Sauvegarde disponible dans: ../backup_holokia_avatar/"
+}
+
+# Gestion des arguments
+case "${1:-}" in
+    --help|-h)
+        echo "Usage: $0 [OPTIONS]"
+        echo ""
+        echo "Ce script nettoie l'historique Git et restructure le projet pour Hugging Face Spaces."
+        echo ""
+        echo "Options:"
+        echo "  --help    Afficher cette aide"
+        echo ""
+        echo "ATTENTION: Ce script va supprimer l'historique Git existant!"
+        echo "Une sauvegarde sera créée dans ../backup_holokia_avatar/"
+        echo ""
+        exit 0
+        ;;
+    *)
+        main "$@"
+        ;;
+esac

debug_websocket.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""
+Script de diagnostic pour le problème WebSocket
+"""
+
+import asyncio
+import aiohttp
+import json
+import sys
+
+async def test_websocket_connection():
+    """Teste la connexion WebSocket"""
+    print("🔍 Test de connexion WebSocket...")
+    
+    try:
+        # Test de connexion WebSocket
+        async with aiohttp.ClientSession() as session:
+            async with session.ws_connect("ws://localhost:5003/live_stream/test_user?lang=fr&room_id=test") as ws:
+                print("✅ Connexion WebSocket établie")
+                
+                # Envoyer un message ping
+                ping_message = {"type": "ping"}
+                await ws.send_str(json.dumps(ping_message))
+                print("✅ Message ping envoyé")
+                
+                # Attendre une réponse
+                try:
+                    async with asyncio.timeout(5):
+                        msg = await ws.receive()
+                        print(f"✅ Réponse reçue: {msg}")
+                except asyncio.TimeoutError:
+                    print("⚠️ Aucune réponse reçue dans les 5 secondes")
+                
+                await ws.close()
+                print("✅ Connexion WebSocket fermée")
+                
+    except Exception as e:
+        print(f"❌ Erreur WebSocket: {e}")
+        import traceback
+        print(f"Traceback: {traceback.format_exc()}")
+
+async def main():
+    print("🚀 Démarrage du diagnostic WebSocket...")
+    await test_websocket_connection()
+    print("✅ Diagnostic terminé")
+
+if __name__ == "__main__":
+    asyncio.run(main())

deploy_to_hf_final.ps1

@@ -0,0 +1,252 @@
+# ===========================================
+# Script de déploiement final pour Hugging Face Spaces
+# HOLOKIA-AVATAR - Avatar 3D Interactif
+# ===========================================
+
+param(
+    [switch]$Help,
+    [string]$HuggingFaceToken = ""
+)
+
+# Configuration
+$HF_USERNAME = "DataSage12"
+$SPACE_NAME = "avatar-v2"
+$REPO_URL = "https://huggingface.co/spaces/$HF_USERNAME/$SPACE_NAME"
+
+# Fonctions utilitaires
+function Write-Info {
+    param([string]$Message)
+    Write-Host "[INFO] $Message" -ForegroundColor Blue
+}
+
+function Write-Success {
+    param([string]$Message)
+    Write-Host "[SUCCESS] $Message" -ForegroundColor Green
+}
+
+function Write-Warning {
+    param([string]$Message)
+    Write-Host "[WARNING] $Message" -ForegroundColor Yellow
+}
+
+function Write-Error {
+    param([string]$Message)
+    Write-Host "[ERROR] $Message" -ForegroundColor Red
+}
+
+# Aide
+if ($Help) {
+    Write-Host "Usage: .\deploy_to_hf_final.ps1 [OPTIONS]"
+    Write-Host ""
+    Write-Host "Options:"
+    Write-Host "  -Help                    Afficher cette aide"
+    Write-Host "  -HuggingFaceToken <token> Token d'accès Hugging Face (optionnel)"
+    Write-Host ""
+    Write-Host "Ce script déploie HOLOKIA-AVATAR sur Hugging Face Spaces."
+    Write-Host ""
+    Write-Host "Variables d'environnement requises:"
+    Write-Host "  GROQ_API_KEY             Clé API Groq"
+    Write-Host ""
+    exit 0
+}
+
+# Vérifications préliminaires
+function Test-Requirements {
+    Write-Info "Vérification des prérequis..."
+    
+    # Vérifier Git
+    if (-not (Get-Command git -ErrorAction SilentlyContinue)) {
+        Write-Error "Git n'est pas installé"
+        exit 1
+    }
+    
+    # Vérifier Git LFS
+    if (-not (Get-Command git-lfs -ErrorAction SilentlyContinue)) {
+        Write-Error "Git LFS n'est pas installé"
+        Write-Info "Installez Git LFS: winget install Git.Git-LFS"
+        exit 1
+    }
+    
+    # Vérifier la clé API Groq
+    $groqKey = $env:GROQ_API_KEY
+    if (-not $groqKey) {
+        Write-Error "GROQ_API_KEY n'est pas définie"
+        Write-Info "Définissez votre clé API avec: `$env:GROQ_API_KEY = 'your_key_here'"
+        exit 1
+    }
+    
+    Write-Success "Tous les prérequis sont satisfaits"
+    Write-Info "Clé API Groq: $($groqKey.Substring(0, 10))..."
+}
+
+# Vérifier la structure du projet
+function Test-ProjectStructure {
+    Write-Info "Vérification de la structure du projet..."
+    
+    $requiredFiles = @(
+        "Dockerfile",
+        "app.py",
+        "requirements.txt",
+        "Back-end\start_services.py",
+        "Back-end\services\tts_service.py",
+        "Back-end\services\stt_service.py",
+        "Back-end\services\llm_service.py",
+        "Back-end\services\live_stream_service.py",
+        "frontend\package.json",
+        "frontend\src\App.jsx"
+    )
+    
+    $missingFiles = @()
+    foreach ($file in $requiredFiles) {
+        if (-not (Test-Path $file)) {
+            $missingFiles += $file
+        }
+    }
+    
+    if ($missingFiles.Count -gt 0) {
+        Write-Error "Fichiers manquants:"
+        foreach ($file in $missingFiles) {
+            Write-Host "  - $file" -ForegroundColor Red
+        }
+        exit 1
+    }
+    
+    Write-Success "Structure du projet validée"
+}
+
+# Configuration Git
+function Set-GitConfiguration {
+    Write-Info "Configuration Git..."
+    
+    # Vérifier si le remote HF existe
+    $existingRemote = git remote get-url origin 2>$null
+    if ($existingRemote) {
+        Write-Info "Remote existant: $existingRemote"
+        if ($existingRemote -ne $REPO_URL) {
+            Write-Info "Mise à jour du remote..."
+            git remote set-url origin $REPO_URL
+        }
+    } else {
+        Write-Info "Ajout du remote Hugging Face..."
+        git remote add origin $REPO_URL
+    }
+    
+    # Configurer l'authentification si un token est fourni
+    if ($HuggingFaceToken) {
+        Write-Info "Configuration de l'authentification..."
+        $authUrl = $REPO_URL -replace "https://", "https://$HuggingFaceToken@"
+        git remote set-url origin $authUrl
+    }
+    
+    Write-Success "Configuration Git terminée"
+}
+
+# Test de l'image Docker
+function Test-DockerImage {
+    Write-Info "Test de l'image Docker localement..."
+    
+    # Vérifier Docker
+    if (-not (Get-Command docker -ErrorAction SilentlyContinue)) {
+        Write-Warning "Docker n'est pas installé, test ignoré"
+        return
+    }
+    
+    try {
+        # Construire l'image
+        Write-Info "Construction de l'image Docker..."
+        docker build -t holokia-avatar:test .
+        
+        # Tester l'image
+        Write-Info "Test de l'image..."
+        $containerId = docker run -d -p 7860:7860 -e GROQ_API_KEY=$env:GROQ_API_KEY holokia-avatar:test
+        
+        # Attendre le démarrage
+        Write-Info "Attente du démarrage du service..."
+        Start-Sleep -Seconds 60
+        
+        # Vérifier la santé
+        try {
+            $response = Invoke-WebRequest -Uri "http://localhost:7860/health" -TimeoutSec 10
+            if ($response.StatusCode -eq 200) {
+                Write-Success "Test local réussi"
+            } else {
+                Write-Warning "Test local: code de statut $($response.StatusCode)"
+            }
+        } catch {
+            Write-Warning "Test local: service non accessible"
+        }
+        
+        # Nettoyer
+        docker stop $containerId
+        docker rm $containerId
+        docker rmi holokia-avatar:test
+        
+    } catch {
+        Write-Warning "Erreur lors du test Docker: $($_.Exception.Message)"
+    }
+}
+
+# Déploiement
+function Deploy-ToHuggingFace {
+    Write-Info "Déploiement sur Hugging Face Spaces..."
+    
+    # Ajouter tous les fichiers
+    git add .
+    
+    # Commit
+    $commitMessage = "Deploy to Hugging Face Spaces - $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss')"
+    git commit -m $commitMessage
+    
+    # Push vers HF
+    Write-Info "Push vers Hugging Face..."
+    git push -u origin main
+    
+    Write-Success "Déploiement terminé!"
+}
+
+# Affichage des informations
+function Show-Info {
+    Write-Info "Informations de déploiement:"
+    Write-Host "  - Utilisateur HF: $HF_USERNAME"
+    Write-Host "  - Nom du Space: $SPACE_NAME"
+    Write-Host "  - URL du Space: $REPO_URL"
+    Write-Host "  - Clé API Groq: $($env:GROQ_API_KEY.Substring(0, 10))..."
+    Write-Host ""
+}
+
+# Fonction principale
+function Main {
+    Write-Host "🚀 HOLOKIA-AVATAR - Déploiement sur Hugging Face Spaces" -ForegroundColor Cyan
+    Write-Host "=====================================================" -ForegroundColor Cyan
+    Write-Host ""
+    
+    Show-Info
+    
+    # Vérifications
+    Test-Requirements
+    Test-ProjectStructure
+    
+    # Test Docker (optionnel)
+    Test-DockerImage
+    
+    # Configuration Git
+    Set-GitConfiguration
+    
+    # Déploiement
+    Deploy-ToHuggingFace
+    
+    Write-Host ""
+    Write-Success "🎉 Déploiement terminé avec succès!"
+    Write-Host ""
+    Write-Info "Votre Space sera disponible à:"
+    Write-Host "  $REPO_URL"
+    Write-Host ""
+    Write-Info "N'oubliez pas d'ajouter votre clé API Groq dans les secrets du Space:"
+    Write-Host "  - Nom: GROQ_API_KEY"
+    Write-Host "  - Valeur: $env:GROQ_API_KEY"
+    Write-Host ""
+    Write-Info "Le Space va automatiquement se construire et démarrer dans quelques minutes."
+}
+
+# Exécution
+Main

env.example

@@ -0,0 +1,37 @@
+# ===========================================
+# Variables d'environnement pour HOLOKIA-AVATAR
+# ===========================================
+
+# Clé API Groq (requise)
+GROQ_API_KEY=gsk_your_groq_api_key_here
+
+# Configuration Hugging Face (pour le déploiement)
+HF_USERNAME=your_huggingface_username
+SPACE_NAME=holokia-avatar
+
+# Configuration des services
+PYTHONPATH=/app
+PORT=7860
+
+# Configuration des logs
+LOG_LEVEL=INFO
+
+# Configuration TTS
+TTS_CACHE_DIR=/app/tts_cache
+TTS_LANGUAGES=fr,en,ar
+
+# Configuration STT
+STT_MODEL_SIZE=small
+STT_MIN_AUDIO_DURATION=0.75
+
+# Configuration LLM
+LLM_MODEL_NAME=meta-llama/llama-4-scout-17b-16e-instruct
+LLM_TEMPERATURE=0
+
+# Configuration WebSocket
+WS_PING_INTERVAL=20
+WS_PING_TIMEOUT=120
+
+# Configuration Nginx
+NGINX_WORKER_PROCESSES=auto
+NGINX_WORKER_CONNECTIONS=1024

frontend/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="fr">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>Holokia — Avatar vocal</title>
+  </head>
+  <body className="bg-gray-50 text-gray-900">
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "1.0.0",
+  "type": "commonjs",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@react-three/drei": "^10.6.1",
+    "@react-three/fiber": "^9.3.0",
+    "@react-three/postprocessing": "^3.0.4",
+    "@tailwindcss/vite": "^4.0.9",
+    "axios": "^1.11.0",
+    "franc-min": "^6.2.0",
+    "leva": "^0.10.0",
+    "postcss": "^8.5.6",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "react-icons": "^5.5.0",
+    "three": "^0.174.0",
+    "uuid": "^11.1.0",
+    "wawa-lipsync": "^0.0.1",
+    "wawa-vfx": "^1.0.16",
+    "zustand": "^5.0.4"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.10",
+    "@types/react-dom": "^19.0.4",
+    "@vitejs/plugin-react": "^4.3.4",
+    "autoprefixer": "^10.4.21",
+    "framer-motion": "^11.18.2",
+    "globals": "^15.15.0",
+    "postcss": "^8.4.38",
+    "postcss-import": "^16.0.1",
+    "postcss-nested": "^6.0.1",
+    "tailwindcss": "^3.4.1",
+    "vite": "^6.2.0"
+  }
+}

frontend/public/pcm-worklet.js

@@ -0,0 +1,108 @@
+class PCMProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+    const o = options?.processorOptions || {};
+    this.targetSampleRate = o.sampleRate || 16000;
+    this.inputSampleRate = o.inputSampleRate || sampleRate;
+    this.chunkSize = o.chunkSize || 1024;
+    this.silenceThreshold = o.silenceThreshold || 0.01;
+    this.silenceWindow = o.silenceWindow || 3;
+    this.buffer = [];
+    this.silenceCount = 0;
+
+    this.port.onmessage = (e) => {
+      const data = e.data || {};
+      if (data.type === "flush") {
+        this._flush();
+      } else if (data.type === "config") {
+        if (typeof data.targetSampleRate === "number") this.targetSampleRate = data.targetSampleRate;
+        if (typeof data.inputSampleRate === "number") this.inputSampleRate = data.inputSampleRate;
+        if (typeof data.chunkSize === "number" && data.chunkSize > 0) this.chunkSize = data.chunkSize;
+        if (typeof data.silenceThreshold === "number") this.silenceThreshold = data.silenceThreshold;
+        if (typeof data.silenceWindow === "number") this.silenceWindow = data.silenceWindow;
+      }
+    };
+  }
+
+  _isSilence(chunk) {
+    if (!chunk || chunk.length === 0) return true;
+    let sum = 0;
+    for (let i = 0; i < chunk.length; i++) {
+      sum += chunk[i] * chunk[i];
+    }
+    const rms = Math.sqrt(sum / chunk.length);
+    return rms < this.silenceThreshold;
+  }
+
+  _resampleFloat32(buffer, inSR, outSR) {
+    if (inSR === outSR) return buffer;
+    const ratio = inSR / outSR;
+    const newLength = Math.max(1, Math.round(buffer.length / ratio));
+    const out = new Float32Array(newLength);
+    for (let i = 0; i < newLength; i++) {
+      const idx = i * ratio;
+      const idxFloor = Math.floor(idx);
+      const idxCeil = Math.min(buffer.length - 1, idxFloor + 1);
+      const t = idx - idxFloor;
+      out[i] = (1 - t) * buffer[idxFloor] + t * buffer[idxCeil];
+    }
+    return out;
+  }
+
+  _floatTo16BitPCM(float32Array) {
+    const out = new Int16Array(float32Array.length);
+    for (let i = 0; i < float32Array.length; i++) {
+      const s = Math.max(-1, Math.min(1, float32Array[i]));
+      out[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+    }
+    return out;
+  }
+
+  _emitChunkIfReady() {
+    if (this.buffer.length >= this.chunkSize) {
+      const take = this.buffer.splice(0, this.chunkSize);
+      if (take.length === 0) return;
+      const f32 = new Float32Array(take);
+      const pcm16 = this._floatTo16BitPCM(f32);
+      this.port.postMessage({ buffer: pcm16.buffer }, [pcm16.buffer]);
+    }
+  }
+
+  _flush() {
+    if (this.buffer.length > 0) {
+      const f32 = new Float32Array(this.buffer);
+      this.buffer.length = 0;
+      const pcm16 = this._floatTo16BitPCM(f32);
+      this.port.postMessage({ buffer: pcm16.buffer }, [pcm16.buffer]);
+    }
+  }
+
+  process(inputs) {
+    const input = inputs[0];
+    if (!input || input.length === 0) return true;
+
+    const channel = input[0];
+    if (!channel) return true;
+
+    if (this._isSilence(channel)) {
+      this.silenceCount++;
+      if (this.silenceCount >= this.silenceWindow) {
+        return true;
+      }
+    } else {
+      this.silenceCount = 0;
+    }
+
+    const resampled = this._resampleFloat32(channel, this.inputSampleRate, this.targetSampleRate);
+
+    for (let i = 0; i < resampled.length; i++) {
+      this.buffer.push(resampled[i]);
+      if (this.buffer.length >= this.chunkSize) {
+        this._emitChunkIfReady();
+      }
+    }
+    return true;
+  }
+}
+
+registerProcessor("pcm-processor", PCMProcessor);