Add chat part

main.py

@@ -165,6 +165,16 @@ except ImportError as e:
 except Exception as e:
     logger.warning(f"⚠ Failed loading main API routes: {e}")
 
+# Dans main.py, après les autres routes
+try:
+    from routes.voice_chat_routes import router as voice_chat_router
+    app.include_router(voice_chat_router, tags=["Voice Chat"])
+    logger.info("✓ Voice Chat route loaded")
+except ImportError as e:
+    logger.warning(f"⚠ Voice Chat route not found: {e}")
+except Exception as e:
+    logger.warning(f"⚠ Failed loading Voice Chat route: {e}")
+
 # --- Basic routes ---
 @app.get("/health", tags=["Health"])
 async def health():

routes/voice_chat_routes.py

@@ -0,0 +1,145 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from typing import Optional
+import tempfile
+import os
+from pathlib import Path
+import io
+
+from services.stt_service import speech_to_text
+from services.tts_service import text_to_speech
+from services.chat_service import generate_chat_response  # Votre service de chatbot existant
+
+router = APIRouter(prefix="/voice-chat", tags=["Voice Chat"])
+
+class TextChatRequest(BaseModel):
+    text: str
+    conversation_id: Optional[str] = None
+
+class VoiceChatResponse(BaseModel):
+    text_response: str
+    audio_url: Optional[str] = None
+    conversation_id: str
+
+@router.post("/voice", response_model=VoiceChatResponse)
+async def voice_chat_endpoint(
+    file: UploadFile = File(...),
+    conversation_id: Optional[str] = None
+):
+    """
+    Point d'entrée unique pour le chat vocal:
+    1. STT: Audio → Texte
+    2. Chatbot: Texte → Réponse
+    3. TTS: Réponse → Audio
+    """
+    # 1. Vérifier le fichier audio
+    if not file.content_type.startswith('audio/'):
+        raise HTTPException(400, "Le fichier doit être un fichier audio")
+    
+    # Créer un ID de conversation si non fourni
+    if not conversation_id:
+        import uuid
+        conversation_id = str(uuid.uuid4())
+    
+    # 2. Sauvegarder temporairement l'audio
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
+        temp_path = temp_file.name
+        content = await file.read()
+        temp_file.write(content)
+    
+    try:
+        # 3. STT: Audio → Texte
+        user_text = speech_to_text(temp_path)
+        
+        if not user_text or user_text.strip() == "":
+            raise HTTPException(400, "Aucune parole détectée dans l'audio")
+        
+        # 4. Générer la réponse du chatbot (utilise votre logique existante)
+        chatbot_response = generate_chat_response(
+            user_input=user_text,
+            conversation_id=conversation_id
+        )
+        
+        # 5. TTS: Réponse texte → Audio
+        audio_path = text_to_speech(
+            text=chatbot_response,
+            voice="Aaliyah-PlayAI",  # ou une voix configurable
+            fmt="wav"
+        )
+        
+        # 6. Lire le fichier audio
+        with open(audio_path, "rb") as audio_file:
+            audio_data = audio_file.read()
+        
+        # Nettoyer les fichiers temporaires
+        os.unlink(temp_path)
+        if Path(audio_path).exists():
+            os.unlink(audio_path)
+        
+        # 7. Retourner réponse
+        return VoiceChatResponse(
+            text_response=chatbot_response,
+            audio_url=f"/voice-chat/audio/{conversation_id}",  # ou stream direct
+            conversation_id=conversation_id
+        )
+        
+    except Exception as e:
+        # Nettoyer en cas d'erreur
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
+        raise HTTPException(500, f"Erreur lors du traitement vocal: {str(e)}")
+
+@router.post("/text", response_model=VoiceChatResponse)
+async def text_chat_endpoint(request: TextChatRequest):
+    """
+    Alternative: Chat texte avec réponse audio
+    Pour les utilisateurs qui préfèrent taper mais écouter la réponse
+    """
+    # Créer un ID de conversation si non fourni
+    if not request.conversation_id:
+        import uuid
+        conversation_id = str(uuid.uuid4())
+    else:
+        conversation_id = request.conversation_id
+    
+    try:
+        # 1. Générer la réponse du chatbot
+        chatbot_response = generate_chat_response(
+            user_input=request.text,
+            conversation_id=conversation_id
+        )
+        
+        # 2. TTS: Réponse texte → Audio
+        audio_path = text_to_speech(
+            text=chatbot_response,
+            voice="Aaliyah-PlayAI",
+            fmt="wav"
+        )
+        
+        return VoiceChatResponse(
+            text_response=chatbot_response,
+            audio_url=f"/voice-chat/audio/{conversation_id}",
+            conversation_id=conversation_id
+        )
+        
+    except Exception as e:
+        raise HTTPException(500, f"Erreur lors du chat: {str(e)}")
+
+@router.get("/audio/{conversation_id}")
+async def get_audio_stream(conversation_id: str):
+    """
+    Stream l'audio de la dernière réponse
+    (Cache ou base de données dans une version réelle)
+    """
+    # Dans une vraie implémentation, vous stockeriez l'audio
+    # temporairement ou en cache
+    return {"message": "Endpoint pour récupérer l'audio"}
+
+@router.get("/conversation/{conversation_id}")
+async def get_conversation_history(conversation_id: str):
+    """
+    Récupérer l'historique d'une conversation
+    """
+    # Implémentez selon votre système de stockage
+    return {"conversation_id": conversation_id, "history": []}

services/chat_service.py

@@ -0,0 +1,102 @@
+import uuid
+from typing import Dict, List, Optional
+from datetime import datetime
+import json
+
+# Pour Groq Chat API (si vous utilisez Groq)
+import requests
+from config import GROQ_API_KEY, GROQ_CHAT_MODEL
+
+# Stockage en mémoire (remplacez par une base de données en production)
+conversation_store: Dict[str, List[Dict]] = {}
+
+def generate_chat_response(
+    user_input: str,
+    conversation_id: Optional[str] = None,
+    system_prompt: Optional[str] = None
+) -> str:
+    """
+    Génère une réponse de chatbot pour une entrée utilisateur
+    """
+    # 1. Gérer la conversation
+    if not conversation_id:
+        conversation_id = str(uuid.uuid4())
+        conversation_store[conversation_id] = []
+    
+    # 2. Ajouter le message utilisateur à l'historique
+    conversation_store[conversation_id].append({
+        "role": "user",
+        "content": user_input,
+        "timestamp": datetime.now().isoformat()
+    })
+    
+    # 3. Préparer le prompt système
+    if not system_prompt:
+        system_prompt = """Tu es un assistant vocal amical et utile. 
+        Tes réponses doivent être naturelles à l'oral, concises 
+        (max 2-3 phrases) et adaptées à une synthèse vocale."""
+    
+    # 4. Préparer les messages pour l'API Groq
+    messages = [{"role": "system", "content": system_prompt}]
+    
+    # Ajouter l'historique (limité aux derniers messages pour le contexte)
+    history = conversation_store[conversation_id][-5:]  # Derniers 5 échanges
+    for msg in history:
+        messages.append({"role": msg["role"], "content": msg["content"]})
+    
+    # 5. Appeler l'API Groq Chat
+    try:
+        response_text = call_groq_chat_api(messages)
+    except Exception as e:
+        # Fallback simple
+        response_text = f"Désolé, je ne peux pas répondre pour le moment. Erreur: {str(e)}"
+    
+    # 6. Ajouter la réponse à l'historique
+    conversation_store[conversation_id].append({
+        "role": "assistant",
+        "content": response_text,
+        "timestamp": datetime.now().isoformat()
+    })
+    
+    return response_text
+
+def call_groq_chat_api(messages: List[Dict]) -> str:
+    """
+    Appelle l'API Groq Chat
+    """
+    if not GROQ_API_KEY:
+        raise RuntimeError("GROQ_API_KEY non configurée")
+    
+    url = "https://api.groq.com/openai/v1/chat/completions"
+    
+    headers = {
+        "Authorization": f"Bearer {GROQ_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "model": GROQ_CHAT_MODEL,
+        "messages": messages,
+        "temperature": 0.7,
+        "max_tokens": 150,  # Limité pour les réponses vocales
+        "top_p": 0.9,
+    }
+    
+    response = requests.post(url, headers=headers, json=payload, timeout=30)
+    response.raise_for_status()
+    
+    result = response.json()
+    return result["choices"][0]["message"]["content"]
+
+def get_conversation_history(conversation_id: str) -> List[Dict]:
+    """
+    Récupère l'historique d'une conversation
+    """
+    return conversation_store.get(conversation_id, [])
+
+def clear_conversation(conversation_id: str):
+    """
+    Efface une conversation
+    """
+    if conversation_id in conversation_store:
+        del conversation_store[conversation_id]