Update chat voice part

models/stt.py

@@ -6,6 +6,6 @@ class STTResponse(BaseModel):
     class Config:
         json_schema_extra = {
             "example": {
-                "text": "Bonjour, comment allez-vous aujourd'hui ?"
+                "text": "Hello, how are you today?"
             }
         }

models/tts.py

@@ -1,5 +1,4 @@
 from pydantic import BaseModel, Field
-from typing import Optional
 
 class TTSRequest(BaseModel):
     text: str = Field(..., min_length=1, max_length=5000)
@@ -9,7 +8,7 @@ class TTSRequest(BaseModel):
     class Config:
         json_schema_extra = {
             "example": {
-                "text": "Bonjour, ceci est un test de synthèse vocale.",
+                "text": "Hello, this is a test of text-to-speech.",
                 "voice": "Aaliyah-PlayAI",
                 "format": "wav"
             }

models/voice_chat.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel
+from typing import Optional
+
+class TextChatRequest(BaseModel):
+    text: str
+    conversation_id: Optional[str] = None
+
+class VoiceChatResponse(BaseModel):
+    text_response: str
+    audio_url: Optional[str] = None
+    conversation_id: str
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "text_response": "Hello! How can I help you today?",
+                "audio_url": "/voice-chat/audio/123e4567",
+                "conversation_id": "123e4567"
+            }
+        }

routes/stt_routes.py

@@ -1,42 +1,42 @@
 from fastapi import APIRouter, UploadFile, File, HTTPException
-from fastapi.responses import JSONResponse
 from services.stt_service import speech_to_text
 from models.stt import STTResponse
-import os
-import uuid
 import tempfile
-from pathlib import Path
+import os
 
 router = APIRouter(prefix="/stt", tags=["Speech To Text"])
 
 @router.post("/", response_model=STTResponse)
 async def convert_speech_to_text(file: UploadFile = File(...)):
     """
-    Convert uploaded audio file to text using Groq's Whisper API
+    Convert uploaded audio file to text (English only)
     """
-    # Vérifier le type de fichier
+    # Check file type
     if not file.content_type or not file.content_type.startswith('audio/'):
         raise HTTPException(status_code=400, detail="File must be an audio file")
     
-    # Créer un fichier temporaire unique
+    # Create temporary file
     with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
         temp_path = temp_file.name
-        
-        # Écrire le contenu téléchargé
         content = await file.read()
+        
+        if len(content) == 0:
+            os.unlink(temp_path)
+            raise HTTPException(status_code=400, detail="Audio file is empty")
+        
         temp_file.write(content)
     
     try:
-        # Convertir audio en texte
+        # Convert audio to text
         text = speech_to_text(temp_path)
         
-        # Nettoyer le fichier temporaire
+        # Clean up
         os.unlink(temp_path)
         
         return STTResponse(text=text)
         
     except Exception as e:
-        # Nettoyer en cas d'erreur
+        # Clean up on error
         if os.path.exists(temp_path):
             os.unlink(temp_path)
         raise HTTPException(status_code=500, detail=str(e))

routes/tts_routes.py

@@ -2,32 +2,31 @@ from fastapi import APIRouter, HTTPException
 from fastapi.responses import FileResponse
 from models.tts import TTSRequest
 from services.tts_service import text_to_speech
-import os
 from pathlib import Path
 
 router = APIRouter(prefix="/tts", tags=["Text To Speech"])
 
 @router.post("/")
-async def generate_speech(request: TTSRequest):
+async def generate_tts(request: TTSRequest):
     """
-    Convert text to speech and return audio file
+    Convert text to speech (English only)
     """
     try:
-        # Générer l'audio
+        # Generate audio
         audio_path = text_to_speech(
             text=request.text,
             voice=request.voice,
             fmt=request.format
         )
         
-        # Vérifier que le fichier existe
+        # Verify file exists
         if not Path(audio_path).exists():
             raise HTTPException(status_code=500, detail="Audio file generation failed")
         
-        # Déterminer le type MIME
+        # Determine MIME type
         media_type = "audio/wav" if request.format == "wav" else "audio/mpeg"
         
-        # Retourner le fichier audio
+        # Return audio file
         return FileResponse(
             path=audio_path,
             filename=f"speech.{request.format}",

routes/voice_chat_routes.py

@@ -1,5 +1,5 @@
 from fastapi import APIRouter, UploadFile, File, HTTPException, Query
-from fastapi.responses import FileResponse, StreamingResponse
+from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 from typing import Optional
 import tempfile
@@ -10,21 +10,12 @@ import io
 
 from services.stt_service import speech_to_text
 from services.tts_service import text_to_speech
-# Assurez-vous que ce service existe et fonctionne correctement
 from services.chat_service import generate_chat_response
+from models.voice_chat import TextChatRequest, VoiceChatResponse
 
 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
-
-# Stockage temporaire pour l'audio généré
+# Temporary audio cache
 audio_cache = {}
 
 @router.post("/voice", response_model=VoiceChatResponse)
@@ -33,71 +24,75 @@ async def voice_chat_endpoint(
     conversation_id: Optional[str] = Query(None)
 ):
     """
-    Point d'entrée unique pour le chat vocal:
-    1. STT: Audio → Texte
-    2. Chatbot: Texte → Réponse
-    3. TTS: Réponse → Audio
+    Complete voice chat endpoint (English only):
+    1. STT: Audio → Text
+    2. Chatbot: Text → Response
+    3. TTS: Response → Audio
     """
-    # 1. Vérifier le fichier audio
+    # 1. Check audio file
     if not file.content_type or not file.content_type.startswith('audio/'):
         raise HTTPException(
             status_code=400, 
-            detail=f"Le fichier doit être un fichier audio. Type reçu: {file.content_type}"
+            detail=f"File must be an audio file. Received: {file.content_type}"
         )
     
-    # 2. Créer un ID de conversation si non fourni
+    # 2. Create conversation ID if not provided
     if not conversation_id:
         conversation_id = str(uuid.uuid4())
     
-    # 3. Sauvegarder temporairement l'audio
+    # 3. Save audio temporarily
     with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
         temp_path = temp_file.name
         content = await file.read()
         
-        # Vérifier que le fichier n'est pas vide
         if len(content) == 0:
             os.unlink(temp_path)
-            raise HTTPException(status_code=400, detail="Le fichier audio est vide")
+            raise HTTPException(status_code=400, detail="Audio file is empty")
         
         temp_file.write(content)
     
     try:
-        # 4. STT: Audio → Texte
+        # 4. STT: Audio → Text (English)
         user_text = speech_to_text(temp_path)
         
         if not user_text or user_text.strip() == "":
             raise HTTPException(
                 status_code=400, 
-                detail="Aucune parole détectée dans l'audio. Essayez de parler plus clairement."
+                detail="No speech detected in audio."
             )
         
-        # 5. Générer la réponse du chatbot
-        # Assurez-vous que generate_chat_response fonctionne correctement
+        print(f"🎤 STT Result: {user_text}")
+        
+        # 5. Generate chatbot response (English)
         chatbot_response = generate_chat_response(
             user_input=user_text,
             conversation_id=conversation_id
         )
         
-        # 6. TTS: Réponse texte → Audio
+        print(f"🤖 Chatbot Response: {chatbot_response}")
+        
+        # 6. TTS: Response text → Audio (English voice)
         audio_path = text_to_speech(
             text=chatbot_response,
-            voice="Aaliyah-PlayAI",
+            voice="Aaliyah-PlayAI",  # English voice
             fmt="wav"
         )
         
-        # 7. Lire le fichier audio
+        # 7. Read and store audio
         with open(audio_path, "rb") as audio_file:
             audio_data = audio_file.read()
         
-        # Stocker l'audio dans le cache
-        audio_cache[conversation_id] = audio_data
+        audio_cache[conversation_id] = {
+            "audio": audio_data,
+            "text": chatbot_response
+        }
         
-        # Nettoyer les fichiers temporaires
+        # 8. Clean up temporary files
         os.unlink(temp_path)
         if Path(audio_path).exists():
             os.unlink(audio_path)
         
-        # 8. Retourner réponse avec URL pour récupérer l'audio
+        # 9. Return response
         return VoiceChatResponse(
             text_response=chatbot_response,
             audio_url=f"/voice-chat/audio/{conversation_id}",
@@ -105,64 +100,69 @@ async def voice_chat_endpoint(
         )
         
     except HTTPException:
-        # Relancer les HTTPException
         raise
     except Exception as e:
-        # Nettoyer en cas d'erreur
+        # Clean up on error
         if os.path.exists(temp_path):
             os.unlink(temp_path)
         
-        # Log l'erreur complète pour le débogage
         import traceback
         error_details = traceback.format_exc()
-        print(f"Erreur dans voice_chat_endpoint: {error_details}")
+        print(f"❌ Error in voice_chat_endpoint: {error_details}")
         
         raise HTTPException(
             status_code=500, 
-            detail=f"Erreur lors du traitement vocal: {str(e)}"
+            detail=f"Error during voice processing: {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
+    Text chat with audio response (English only)
+    For users who prefer to type but hear the response
     """
     try:
-        # 1. Créer un ID de conversation si non fourni
+        # 1. Create conversation ID if not provided
         if not request.conversation_id:
             conversation_id = str(uuid.uuid4())
         else:
             conversation_id = request.conversation_id
         
-        # 2. Vérifier que le texte n'est pas vide
+        # 2. Validate text
         if not request.text or request.text.strip() == "":
-            raise HTTPException(status_code=400, detail="Le texte ne peut pas être vide")
+            raise HTTPException(status_code=400, detail="Text cannot be empty")
+        
+        print(f"📝 Text received: {request.text}")
         
-        # 3. Générer la réponse du chatbot
+        # 3. Generate chatbot response
         chatbot_response = generate_chat_response(
             user_input=request.text,
             conversation_id=conversation_id
         )
         
-        # 4. TTS: Réponse texte → Audio
+        print(f"🤖 Chatbot Response: {chatbot_response}")
+        
+        # 4. TTS with English voice
         audio_path = text_to_speech(
             text=chatbot_response,
             voice="Aaliyah-PlayAI",
             fmt="wav"
         )
         
-        # 5. Lire et stocker l'audio
+        # 5. Read and store audio
         with open(audio_path, "rb") as audio_file:
             audio_data = audio_file.read()
         
-        audio_cache[conversation_id] = audio_data
+        audio_cache[conversation_id] = {
+            "audio": audio_data,
+            "text": chatbot_response
+        }
         
-        # 6. Nettoyer le fichier temporaire
+        # 6. Clean up
         if Path(audio_path).exists():
             os.unlink(audio_path)
         
-        # 7. Retourner réponse
+        # 7. Return response
         return VoiceChatResponse(
             text_response=chatbot_response,
             audio_url=f"/voice-chat/audio/{conversation_id}",
@@ -174,66 +174,47 @@ async def text_chat_endpoint(request: TextChatRequest):
     except Exception as e:
         import traceback
         error_details = traceback.format_exc()
-        print(f"Erreur dans text_chat_endpoint: {error_details}")
+        print(f"❌ Error in text_chat_endpoint: {error_details}")
         
         raise HTTPException(
             status_code=500, 
-            detail=f"Erreur lors du chat: {str(e)}"
+            detail=f"Error during 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
+    Stream audio of the last response
     """
     if conversation_id not in audio_cache:
         raise HTTPException(
             status_code=404, 
-            detail=f"Aucun audio trouvé pour la conversation {conversation_id}"
+            detail=f"No audio found for conversation {conversation_id}"
         )
     
-    audio_data = audio_cache[conversation_id]
+    audio_data = audio_cache[conversation_id]["audio"]
     
-    # Retourner l'audio en streaming
     return StreamingResponse(
         io.BytesIO(audio_data),
         media_type="audio/wav",
         headers={
-            "Content-Disposition": f"attachment; filename=response_{conversation_id}.wav"
+            "Content-Disposition": f"attachment; filename=response_{conversation_id[:8]}.wav"
         }
     )
 
-@router.get("/conversation/{conversation_id}")
-async def get_conversation_history(conversation_id: str):
+@router.get("/test")
+async def test_endpoint():
     """
-    Récupérer l'historique d'une conversation
+    Test endpoint to verify API is working
     """
-    try:
-        from services.chat_service import get_conversation_history
-        history = get_conversation_history(conversation_id)
-        
-        return {
-            "conversation_id": conversation_id,
-            "history": history,
-            "message_count": len(history)
+    return {
+        "status": "ok",
+        "message": "Voice Chat API is working (English only)",
+        "endpoints": {
+            "POST /voice-chat/voice": "Voice input → Voice response",
+            "POST /voice-chat/text": "Text input → Voice response",
+            "GET /voice-chat/audio/{id}": "Get audio response",
+            "POST /stt/": "Speech to text",
+            "POST /tts/": "Text to speech"
         }
-    except Exception as e:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Erreur lors de la récupération de l'historique: {str(e)}"
-        )
-
-# Endpoint pour nettoyer le cache audio (optionnel)
-@router.delete("/audio/{conversation_id}")
-async def clear_audio_cache(conversation_id: str):
-    """
-    Supprimer l'audio d'une conversation du cache
-    """
-    if conversation_id in audio_cache:
-        del audio_cache[conversation_id]
-        return {"message": f"Audio de la conversation {conversation_id} supprimé"}
-    else:
-        raise HTTPException(
-            status_code=404,
-            detail=f"Aucun audio trouvé pour la conversation {conversation_id}"
-        )
+    }

services/chat_service.py

@@ -6,7 +6,7 @@ import json
 
 from config import GROQ_API_KEY, GROQ_CHAT_MODEL
 
-# Stockage en mémoire des conversations
+# In-memory conversation storage
 conversation_store: Dict[str, List[Dict]] = {}
 
 def generate_chat_response(
@@ -15,82 +15,80 @@ def generate_chat_response(
     system_prompt: Optional[str] = None
 ) -> str:
     """
-    Génère une réponse de chatbot pour une entrée utilisateur
+    Generate chatbot response for user input (English only)
     """
     try:
-        # 1. Vérifier que l'input n'est pas vide
+        # 1. Validate input
         if not user_input or not isinstance(user_input, str):
-            raise ValueError("L'entrée utilisateur doit être une chaîne de caractères non vide")
+            raise ValueError("User input must be a non-empty string")
         
         user_input = user_input.strip()
         if len(user_input) == 0:
-            return "Je n'ai pas entendu ce que vous avez dit. Pouvez-vous répéter ?"
+            return "I didn't hear what you said. Can you repeat?"
         
-        # 2. Gérer la conversation
+        # 2. Handle conversation
         if not conversation_id:
             conversation_id = str(uuid.uuid4())
         
-        # Initialiser la conversation si elle n'existe pas
+        # Initialize conversation if it doesn't exist
         if conversation_id not in conversation_store:
             conversation_store[conversation_id] = []
         
-        # 3. Ajouter le message utilisateur à l'historique
+        # 3. Add user message to history
         conversation_store[conversation_id].append({
             "role": "user",
             "content": user_input,
             "timestamp": datetime.now().isoformat()
         })
         
-        # 4. Préparer le prompt système
+        # 4. Prepare system prompt (English only)
         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.
-            Sois courtois et serviable."""
+            system_prompt = """You are a friendly and helpful English voice assistant. 
+            Respond in English only. Keep responses concise (2-3 sentences max), 
+            natural for speech, and helpful. Be polite and engaging."""
         
-        # 5. Préparer les messages pour l'API Groq
+        # 5. Prepare messages for Groq API
         messages = [{"role": "system", "content": system_prompt}]
         
-        # Ajouter l'historique (limité aux derniers messages)
-        history = conversation_store[conversation_id][-6:]  # Derniers 6 messages
+        # Add conversation history (last 6 messages)
+        history = conversation_store[conversation_id][-6:]
         for msg in history:
             messages.append({"role": msg["role"], "content": msg["content"]})
         
-        # 6. Appeler l'API Groq Chat
+        # 6. Call Groq Chat API
         if not GROQ_API_KEY:
-            # Fallback si pas de clé API
-            response_text = f"Bonjour ! Vous avez dit : '{user_input}'. Je suis configuré pour répondre, mais l'API Groq n'est pas configurée."
+            # Fallback if no API key
+            response_text = f"Hello! You said: '{user_input}'. I'm a voice assistant configured to respond in English."
         else:
             try:
                 response_text = call_groq_chat_api(messages)
             except Exception as api_error:
-                # Fallback en cas d'erreur API
-                print(f"Erreur API Groq: {api_error}")
-                response_text = f"D'accord, j'ai compris : {user_input}. Je suis un chatbot et je vous réponds."
+                print(f"Groq API error: {api_error}")
+                response_text = f"I understand you said: {user_input}. How can I help you today?"
         
-        # 7. Ajouter la réponse à l'historique
+        # 7. Add response to history
         conversation_store[conversation_id].append({
             "role": "assistant",
             "content": response_text,
             "timestamp": datetime.now().isoformat()
         })
         
-        # Limiter la taille de l'historique
+        # Limit history size
         if len(conversation_store[conversation_id]) > 20:
             conversation_store[conversation_id] = conversation_store[conversation_id][-10:]
         
         return response_text
         
     except Exception as e:
-        print(f"Erreur dans generate_chat_response: {e}")
-        return f"Désolé, une erreur est survenue : {str(e)}"
+        print(f"Error in generate_chat_response: {e}")
+        return "Sorry, an error occurred. Can you please repeat?"
 
 def call_groq_chat_api(messages: List[Dict]) -> str:
     """
-    Appelle l'API Groq Chat
+    Call Groq Chat API
     """
     if not GROQ_API_KEY:
-        raise RuntimeError("GROQ_API_KEY non configurée")
+        raise RuntimeError("GROQ_API_KEY is not configured")
     
     url = "https://api.groq.com/openai/v1/chat/completions"
     
@@ -103,7 +101,7 @@ def call_groq_chat_api(messages: List[Dict]) -> str:
         "model": GROQ_CHAT_MODEL,
         "messages": messages,
         "temperature": 0.7,
-        "max_tokens": 300,  # Augmenté pour des réponses plus complètes
+        "max_tokens": 300,
         "top_p": 0.9,
         "stream": False
     }
@@ -115,24 +113,24 @@ def call_groq_chat_api(messages: List[Dict]) -> str:
         result = response.json()
         
         if "choices" not in result or len(result["choices"]) == 0:
-            raise ValueError("Réponse invalide de l'API Groq")
+            raise ValueError("Invalid response from Groq API")
         
         return result["choices"][0]["message"]["content"]
         
     except requests.exceptions.RequestException as e:
-        raise Exception(f"Erreur de connexion à l'API Groq: {str(e)}")
+        raise Exception(f"Groq API connection error: {str(e)}")
     except KeyError as e:
-        raise Exception(f"Format de réponse invalide: {str(e)}")
+        raise Exception(f"Invalid response format: {str(e)}")
 
 def get_conversation_history(conversation_id: str) -> List[Dict]:
     """
-    Récupère l'historique d'une conversation
+    Get conversation history
     """
     return conversation_store.get(conversation_id, [])
 
-def clear_conversation(conversation_id: str):
+def clear_conversation(conversation_id: str) -> bool:
     """
-    Efface une conversation
+    Clear a conversation
     """
     if conversation_id in conversation_store:
         del conversation_store[conversation_id]

services/stt_service.py

@@ -1,11 +1,9 @@
 import requests
 from config import GROQ_API_KEY, GROQ_STT_MODEL
-import tempfile
-import os
 
 def speech_to_text(audio_file: str) -> str:
     """
-    Convert audio file to text using Groq's Whisper API
+    Convert audio file to text using Groq's Whisper API (English only)
     """
     if not GROQ_API_KEY:
         raise RuntimeError("GROQ_API_KEY is not set in config")
@@ -16,19 +14,19 @@ def speech_to_text(audio_file: str) -> str:
         "Authorization": f"Bearer {GROQ_API_KEY}"
     }
     
-    # Lire le fichier audio
     with open(audio_file, "rb") as audio_data:
         files = {
-            "file": (os.path.basename(audio_file), audio_data, "audio/wav")
+            "file": (audio_file, audio_data, "audio/wav")
         }
         data = {
             "model": GROQ_STT_MODEL,
+            "language": "en",  # Force English
             "temperature": 0,
             "response_format": "json"
         }
         
         try:
-            response = requests.post(url, headers=headers, files=files, data=data)
+            response = requests.post(url, headers=headers, files=files, data=data, timeout=30)
             response.raise_for_status()
             
             result = response.json()

services/tts_service.py

@@ -4,10 +4,13 @@ import os
 from pathlib import Path
 from config import GROQ_API_KEY, GROQ_TTS_MODEL
 
-def text_to_speech(text: str, voice: str = "Aaliyah-PlayAI", fmt: str = "wav") -> str:
+def text_to_speech(
+    text: str, 
+    voice: str = "Aaliyah-PlayAI",
+    fmt: str = "wav"
+) -> str:
     """
-    Convert text to speech using Groq's TTS API
-    Returns the path to the generated audio file
+    Convert text to speech using Groq's TTS API (English only)
     """
     if not GROQ_API_KEY:
         raise RuntimeError("GROQ_API_KEY is not set in config")
@@ -30,19 +33,19 @@ def text_to_speech(text: str, voice: str = "Aaliyah-PlayAI", fmt: str = "wav") -
     }
     
     try:
-        # Créer un répertoire temporaire pour les fichiers audio
+        # Create temp directory for audio files
         temp_dir = Path("temp_audio")
         temp_dir.mkdir(exist_ok=True)
         
-        # Nom de fichier unique
+        # Unique filename
         output_filename = f"tts_{uuid.uuid4().hex[:8]}.{fmt}"
         output_path = temp_dir / output_filename
         
-        # Appel API Groq
+        # Call Groq API
         response = requests.post(url, headers=headers, json=payload, timeout=30)
         response.raise_for_status()
         
-        # Sauvegarder le fichier audio
+        # Save audio file
         with open(output_path, "wb") as f:
             f.write(response.content)