Merge branch 'main' of https://huggingface.co/spaces/NLP-Debater-Project/FastAPI-Backend-Models

config.py

@@ -3,38 +3,83 @@
 import os
 from pathlib import Path
 from dotenv import load_dotenv
+import logging
 
-# Load environment variables from .env file
+logger = logging.getLogger(__name__)
+
+# Load .env variables
 load_dotenv()
 
-# Get project root directory
+# ============ DIRECTORIES ============
 API_DIR = Path(__file__).parent
 PROJECT_ROOT = API_DIR.parent
 
-# Hugging Face configuration
+# ============ HUGGING FACE MODELS ============
 HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY", "")
-
 HUGGINGFACE_STANCE_MODEL_ID = os.getenv("HUGGINGFACE_STANCE_MODEL_ID")
 HUGGINGFACE_LABEL_MODEL_ID = os.getenv("HUGGINGFACE_LABEL_MODEL_ID")
 HUGGINGFACE_GENERATE_MODEL_ID = os.getenv("HUGGINGFACE_GENERATE_MODEL_ID", "YOUR_ORG/kpa-t5-improved")
 
+<<<<<<< HEAD
 # Use Hugging Face model ID instead of local path
 STANCE_MODEL_ID = HUGGINGFACE_STANCE_MODEL_ID
 LABEL_MODEL_ID = HUGGINGFACE_LABEL_MODEL_ID
 GENERATE_MODEL_ID = HUGGINGFACE_GENERATE_MODEL_ID
+=======
+# ============ GROQ MODELS ============
+GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
+>>>>>>> 45e145b23965e35eefb7990d09b535073040e40a
+
+# **Speech-to-Text**
+GROQ_STT_MODEL = "whisper-large-v3-turbo"
+
+# **Text-to-Speech**
+GROQ_TTS_MODEL = "playai-tts"
+GROQ_TTS_VOICE = "Aaliyah-PlayAI"
+GROQ_TTS_FORMAT = "wav"
 
-# API configuration
-API_TITLE = "NLP Project API"
-API_DESCRIPTION = "API for various NLP models including stance detection and more"
-API_VERSION = "1.0.0"
+# **Chat Model**
+GROQ_CHAT_MODEL = "llama3-70b-8192"
 
-# Server configuration
-HOST = os.getenv("HOST", "0.0.0.0")  # Use 0.0.0.0 for Docker/Spaces
-PORT = int(os.getenv("PORT", "7860"))  # Default 7860 for Hugging Face Spaces
-RELOAD = os.getenv("RELOAD", "False").lower() == "true"  # Set to False in production
+# ============ API META ============
+API_TITLE = "NLP Debater - Voice Chatbot"
+API_DESCRIPTION = "NLP stance detection, KPA, and Groq STT/TTS chatbot"
+API_VERSION = "2.0.0"
 
-# CORS configuration
-CORS_ORIGINS = ["*"]  # In production, specify exact origins
+# ============ SERVER ============
+HOST = os.getenv("HOST", "0.0.0.0")
+PORT = int(os.getenv("PORT", 7860))
+RELOAD = os.getenv("RELOAD", "false").lower() == "true"
+
+# ============ CORS ============
+CORS_ORIGINS = ["*"]
 CORS_CREDENTIALS = True
 CORS_METHODS = ["*"]
 CORS_HEADERS = ["*"]
+
+# ============ AUDIO SETTINGS ============
+MAX_AUDIO_SIZE = 10 * 1024 * 1024  # 10MB
+AUDIO_SAMPLE_RATE = 16000
+AUDIO_DURATION_LIMIT = 120  # seconds
+ALLOWED_AUDIO_TYPES = {
+    "audio/wav", "audio/x-wav",
+    "audio/mpeg", "audio/mp3",
+    "audio/mp4", "audio/m4a"
+}
+
+# ============ MODEL PRELOADING ============
+PRELOAD_MODELS_ON_STARTUP = True
+LOAD_STANCE_MODEL = True
+LOAD_KPA_MODEL = True
+LOAD_STT_MODEL = False        # Groq STT = no preload
+LOAD_CHATBOT_MODEL = False    # Groq Chat = no preload
+LOAD_TTS_MODEL = False        # Groq TTS = no preload
+
+logger.info("="*60)
+logger.info("✓ Configuration loaded successfully")
+logger.info(f"  HF Stance Model : {HUGGINGFACE_STANCE_MODEL_ID}")
+logger.info(f"  HF Label Model  : {HUGGINGFACE_LABEL_MODEL_ID}")
+logger.info(f"  GROQ STT Model  : {GROQ_STT_MODEL}")
+logger.info(f"  GROQ TTS Model  : {GROQ_TTS_MODEL}")
+logger.info(f"  GROQ Chat Model : {GROQ_CHAT_MODEL}")
+logger.info("="*60)

main.py

@@ -1,19 +1,16 @@
-"""Main FastAPI application entry point"""
-
 import sys
 from pathlib import Path
-
-# Add the app directory to Python path to ensure imports work
-app_dir = Path(__file__).parent
-if str(app_dir) not in sys.path:
-    sys.path.insert(0, str(app_dir))
-
+import logging
 from contextlib import asynccontextmanager
+import atexit
+import shutil
+
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import RedirectResponse
 import uvicorn
-import logging
 
+<<<<<<< HEAD
 from config import (
     API_TITLE,
     API_DESCRIPTION,
@@ -37,15 +34,81 @@ from routes import api_router
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
+=======
+# --- Logging ---
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+>>>>>>> 45e145b23965e35eefb7990d09b535073040e40a
 logger = logging.getLogger(__name__)
 
+# --- Ajouter app dir au PATH ---
+app_dir = Path(__file__).parent
+sys.path.insert(0, str(app_dir))
+
+# --- Config ---
+from config import (
+    API_TITLE, API_DESCRIPTION, API_VERSION,
+    HUGGINGFACE_API_KEY, HUGGINGFACE_STANCE_MODEL_ID, HUGGINGFACE_LABEL_MODEL_ID,
+    HOST, PORT, RELOAD,
+    CORS_ORIGINS, CORS_METHODS, CORS_HEADERS, CORS_CREDENTIALS,
+    PRELOAD_MODELS_ON_STARTUP, LOAD_STANCE_MODEL, LOAD_KPA_MODEL,
+    GROQ_API_KEY, GROQ_STT_MODEL, GROQ_TTS_MODEL, GROQ_CHAT_MODEL
+)
+
+# --- Fonction de nettoyage ---
+def cleanup_temp_files():
+    """Nettoyer les fichiers temporaires audio au démarrage"""
+    temp_dir = Path("temp_audio")
+    if temp_dir.exists():
+        try:
+            shutil.rmtree(temp_dir)
+            logger.info("✓ Fichiers temporaires audio nettoyés")
+        except Exception as e:
+            logger.warning(f"⚠ Impossible de nettoyer le répertoire temporaire: {e}")
+
+# Appeler au démarrage
+cleanup_temp_files()
 
+# Configurer le nettoyage à la fermeture
+@atexit.register
+def cleanup_on_exit():
+    temp_dir = Path("temp_audio")
+    if temp_dir.exists():
+        try:
+            shutil.rmtree(temp_dir)
+            logger.info("Nettoyage final des fichiers temporaires")
+        except:
+            logger.warning("Échec du nettoyage final")
+
+# --- Import des singletons de services ---
+stance_model_manager = None
+kpa_model_manager = None
+try:
+    from services.stance_model_manager import stance_model_manager
+    from services.label_model_manager import kpa_model_manager  # Corrigé : kpa_model_manager partout
+    logger.info("✓ Gestionnaires de modèles importés")
+except ImportError as e:
+    logger.warning(f"⚠ Impossible d'importer les gestionnaires de modèles: {e}")
+
+# --- Vérification MCP ---
+MCP_ENABLED = False
+try:
+    from services.mcp_service import init_mcp_server
+    MCP_ENABLED = True
+    logger.info("✓ Modules MCP détectés")
+except ImportError as e:
+    logger.warning(f"⚠ MCP non disponible: {e}")
+
+# --- Lifespan / startup API ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    """Load models on startup and cleanup on shutdown"""
-    # Startup: Load all models
-    logger.info("Loading models on startup...")
+    logger.info("="*60)
+    logger.info("🚀 DÉMARRAGE API - Chargement des modèles et vérification des APIs...")
+    logger.info("="*60)
     
+<<<<<<< HEAD
     # Load stance detection model
     try:
         logger.info(f"Loading stance model from Hugging Face: {HUGGINGFACE_STANCE_MODEL_ID}")
@@ -77,18 +140,72 @@ async def lifespan(app: FastAPI):
     
     # Shutdown: Cleanup (if needed)
     # Currently no cleanup needed, but you can add it here if necessary
+=======
+    # Vérifier les clés API
+    if not GROQ_API_KEY:
+        logger.warning("⚠ GROQ_API_KEY non configurée. Fonctions STT/TTS désactivées.")
+    else:
+        logger.info("✓ GROQ_API_KEY configurée")
+        
+    if not HUGGINGFACE_API_KEY:
+        logger.warning("⚠ HUGGINGFACE_API_KEY non configurée. Modèles locaux désactivés.")
+    else:
+        logger.info("✓ HUGGINGFACE_API_KEY configurée")
+>>>>>>> 45e145b23965e35eefb7990d09b535073040e40a
+
+    # Précharger les modèles Hugging Face si configuré
+    if PRELOAD_MODELS_ON_STARTUP:
+        
+        # Charger stance model
+        if LOAD_STANCE_MODEL and stance_model_manager and HUGGINGFACE_STANCE_MODEL_ID:
+            try:
+                stance_model_manager.load_model(HUGGINGFACE_STANCE_MODEL_ID, HUGGINGFACE_API_KEY)
+                logger.info("✓ Modèle de détection de stance chargé")
+            except Exception as e:
+                logger.error(f"✗ Échec chargement modèle stance: {e}")
 
-# Create FastAPI application
+        # Charger KPA model
+        if LOAD_KPA_MODEL and kpa_model_manager and HUGGINGFACE_LABEL_MODEL_ID:
+            try:
+                kpa_model_manager.load_model(HUGGINGFACE_LABEL_MODEL_ID, HUGGINGFACE_API_KEY)
+                logger.info("✓ Modèle KPA chargé")
+            except Exception as e:
+                logger.error(f"✗ Échec chargement modèle KPA: {e}")
+
+    # Initialiser MCP si disponible
+    if MCP_ENABLED:
+        try:
+            init_mcp_server(app)
+            logger.info("✓ Serveur MCP initialisé")
+        except Exception as e:
+            logger.error(f"✗ Échec initialisation MCP: {e}")
+
+    logger.info("="*60)
+    logger.info("✓ Démarrage terminé. API prête à recevoir des requêtes.")
+    logger.info(f"  STT Model: {GROQ_STT_MODEL}")
+    logger.info(f"  TTS Model: {GROQ_TTS_MODEL}")
+    logger.info(f"  Chat Model: {GROQ_CHAT_MODEL}")
+    logger.info(f"  MCP: {'Activé' if MCP_ENABLED else 'Désactivé'}")
+    logger.info("="*60)
+    
+    yield
+    
+    logger.info("🛑 Arrêt de l'API...")
+    # Nettoyage final
+    cleanup_on_exit()
+
+# --- FastAPI app ---
 app = FastAPI(
     title=API_TITLE,
     description=API_DESCRIPTION,
     version=API_VERSION,
+    lifespan=lifespan,
     docs_url="/docs",
     redoc_url="/redoc",
-    lifespan=lifespan,
+    openapi_url="/openapi.json"
 )
 
-# Add CORS middleware
+# --- CORS ---
 app.add_middleware(
     CORSMiddleware,
     allow_origins=CORS_ORIGINS,
@@ -97,20 +214,129 @@ app.add_middleware(
     allow_headers=CORS_HEADERS,
 )
 
-# Include API routes
-app.include_router(api_router)
+# --- Routes ---
+# STT Routes
+try:
+    from routes.stt_routes import router as stt_router
+    app.include_router(stt_router, prefix="/api/v1/stt", tags=["Speech To Text"])
+    logger.info("✓ Route STT chargée (Groq Whisper)")
+except ImportError as e:
+    logger.warning(f"⚠ Route STT non trouvée: {e}")
+except Exception as e:
+    logger.warning(f"⚠ Échec chargement route STT: {e}")
+
+# TTS Routes
+try:
+    from routes.tts_routes import router as tts_router
+    app.include_router(tts_router, prefix="/api/v1/tts", tags=["Text To Speech"])
+    logger.info("✓ Route TTS chargée (Groq PlayAI TTS)")
+except ImportError as e:
+    logger.warning(f"⚠ Route TTS non trouvée: {e}")
+except Exception as e:
+    logger.warning(f"⚠ Échec chargement route TTS: {e}")
+
+# Voice Chat Routes
+try:
+    from routes.voice_chat_routes import router as voice_chat_router
+    app.include_router(voice_chat_router, tags=["Voice Chat"])
+    logger.info("✓ Route Voice Chat chargée")
+except ImportError as e:
+    logger.warning(f"⚠ Route Voice Chat non trouvée: {e}")
+except Exception as e:
+    logger.warning(f"⚠ Échec chargement route Voice Chat: {e}")
+
+# Main API Routes (KPA, Stance, etc.)
+try:
+    from routes import api_router
+    app.include_router(api_router, prefix="/api/v1")
+    logger.info("✓ Routes API principales chargées")
+except ImportError as e:
+    logger.warning(f"⚠ Routes API principales non trouvées: {e}")
+    # Fallback
+    try:
+        from routes.label import router as kpa_router
+        app.include_router(kpa_router, prefix="/api/v1/kpa", tags=["KPA"])
+        from routes.stance import router as stance_router
+        app.include_router(stance_router, prefix="/api/v1/stance", tags=["Stance Detection"])
+        logger.info("✓ Routes KPA et Stance chargées en fallback")
+    except ImportError:
+        logger.warning("⚠ Fallback pour KPA/Stance échoué")
+except Exception as e:
+    logger.warning(f"⚠ Échec chargement routes API principales: {e}")
+
+# MCP Routes - Routes FastAPI pour Swagger UI + mount pour compatibilité MCP
+if MCP_ENABLED:
+    try:
+        from routes.mcp_routes import router as mcp_router
+        app.include_router(mcp_router)  # Pas de prefix car déjà dans le router
+        logger.info("✓ Routes MCP FastAPI chargées (visibles dans Swagger)")
+    except ImportError as e:
+        logger.warning(f"⚠ Routes MCP FastAPI non trouvées: {e}")
+    except Exception as e:
+        logger.warning(f"⚠ Échec chargement routes MCP FastAPI: {e}")
+    
+    logger.info("✓ MCP monté via lifespan (endpoints auto-gérés)")
+else:
+    logger.warning("⚠ MCP désactivé")
+
+# --- Basic routes ---
+@app.get("/health", tags=["Health"])
+async def health():
+    health_status = {
+        "status": "healthy",
+        "service": "NLP Debater + Groq Voice",
+        "version": API_VERSION,
+        "features": {
+            "stt": GROQ_STT_MODEL if GROQ_API_KEY else "disabled",
+            "tts": GROQ_TTS_MODEL if GROQ_API_KEY else "disabled",
+            "chat": GROQ_CHAT_MODEL if GROQ_API_KEY else "disabled",
+            "stance_model": "loaded" if (stance_model_manager and hasattr(stance_model_manager, 'model_loaded') and stance_model_manager.model_loaded) else "not loaded",
+            "kpa_model": "loaded" if (kpa_model_manager and hasattr(kpa_model_manager, 'model_loaded') and kpa_model_manager.model_loaded) else "not loaded",
+            "mcp": "enabled" if MCP_ENABLED else "disabled"
+        },
+        "endpoints": {
+            "mcp": "/api/v1/mcp" if MCP_ENABLED else "disabled"
+        }
+    }
+    return health_status
+
+@app.get("/", tags=["Root"])
+async def root():
+    return RedirectResponse(url="/docs")
 
+# --- Error handlers ---
+@app.exception_handler(404)
+async def not_found_handler(request, exc):
+    endpoints = {
+        "GET /": "Redirige vers /docs (Swagger UI)",
+        "GET /health": "Health check",
+        "POST /api/v1/stt/": "Speech to text",
+        "POST /api/v1/tts/": "Text to speech",
+        "POST /voice-chat/voice": "Voice chat"
+    }
+    if MCP_ENABLED:
+        endpoints.update({
+            "GET /api/v1/mcp/health": "Health check MCP",
+            "GET /api/v1/mcp/tools": "Liste outils MCP",
+            "POST /api/v1/mcp/tools/call": "Appel d'outil MCP"
+        })
+    return {
+        "error": "Not Found",
+        "message": f"URL {request.url} non trouvée",
+        "available_endpoints": endpoints
+    }
 
+# --- Run server ---
 if __name__ == "__main__":
-    # Run the API server
-    # Access at: http://localhost:8000
-    # API docs at: http://localhost:8000/docs
+    logger.info("="*60)
+    logger.info(f"Démarrage du serveur sur {HOST}:{PORT}")
+    logger.info(f"Mode reload: {RELOAD}")
+    logger.info("="*60)
     
-    # Run the API server
     uvicorn.run(
         "main:app",
         host=HOST,
         port=PORT,
         reload=RELOAD,
         log_level="info"
-    )
+    )

models/__init__.py

@@ -22,6 +22,21 @@ from .health import (
     HealthResponse,
 )
 
+# Import MCP-related schemas
+from .mcp_models import (
+    ToolCallRequest,
+    ToolCallResponse,
+    ToolInfo,
+    ToolListResponse,
+    ResourceInfo,
+    ResourceListResponse,
+    DetectStanceResponse,
+    MatchKeypointResponse,
+    TranscribeAudioResponse,
+    GenerateSpeechResponse,
+    GenerateArgumentResponse,
+)
+
 __all__ = [
     # Stance schemas
     "StanceRequest",
@@ -36,4 +51,16 @@ __all__ = [
     "KPAHealthResponse",
     # Health schemas
     "HealthResponse",
+    # MCP schemas
+    "ToolCallRequest",
+    "ToolCallResponse",
+    "ToolInfo",
+    "ToolListResponse",
+    "ResourceInfo",
+    "ResourceListResponse",
+    "DetectStanceResponse",
+    "MatchKeypointResponse",
+    "TranscribeAudioResponse",
+    "GenerateSpeechResponse",
+    "GenerateArgumentResponse",
 ]

models/mcp_models.py

@@ -0,0 +1,113 @@
+from pydantic import BaseModel, Field, ConfigDict
+from typing import Any, Dict, List, Optional
+
+class ToolCallRequest(BaseModel):
+    """Request for calling an MCP tool"""
+    tool_name: str
+    arguments: Dict[str, Any] = {}
+
+class ToolCallResponse(BaseModel):
+    """Response from MCP tool call"""
+    success: bool
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    tool_name: str
+
+# Response models for individual MCP tools
+class DetectStanceResponse(BaseModel):
+    """Response model for stance detection"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "predicted_stance": "PRO",
+                "confidence": 0.9598,
+                "probability_con": 0.0402,
+                "probability_pro": 0.9598
+            }
+        }
+    )
+    
+    predicted_stance: str = Field(..., description="PRO or CON")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score")
+    probability_con: float = Field(..., ge=0.0, le=1.0)
+    probability_pro: float = Field(..., ge=0.0, le=1.0)
+
+class MatchKeypointResponse(BaseModel):
+    """Response model for keypoint matching"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "prediction": 1,
+                "label": "apparie",
+                "confidence": 0.8157,
+                "probabilities": {
+                    "non_apparie": 0.1843,
+                    "apparie": 0.8157
+                }
+            }
+        }
+    )
+    
+    prediction: int = Field(..., description="1 = apparie, 0 = non_apparie")
+    label: str = Field(..., description="apparie or non_apparie")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score")
+    probabilities: Dict[str, float] = Field(..., description="Dictionary of class probabilities")
+
+class TranscribeAudioResponse(BaseModel):
+    """Response model for audio transcription"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "text": "Hello, this is the transcribed text from the audio file."
+            }
+        }
+    )
+    
+    text: str = Field(..., description="Transcribed text from audio")
+
+class GenerateSpeechResponse(BaseModel):
+    """Response model for speech generation"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "audio_path": "temp_audio/tts_e9b78164.wav"
+            }
+        }
+    )
+    
+    audio_path: str = Field(..., description="Path to generated audio file")
+
+class GenerateArgumentResponse(BaseModel):
+    """Response model for argument generation"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "argument": "Climate change is a pressing issue that requires immediate action..."
+            }
+        }
+    )
+    
+    argument: str = Field(..., description="Generated debate argument")
+
+class ResourceInfo(BaseModel):
+    """Information about an MCP resource"""
+    uri: str
+    name: str
+    description: Optional[str] = None
+    mime_type: str
+
+class ToolInfo(BaseModel):
+    """Information about an MCP tool"""
+    name: str
+    description: str
+    input_schema: Dict[str, Any]
+
+class ResourceListResponse(BaseModel):
+    """Response for listing resources"""
+    resources: List[ResourceInfo]
+    count: int
+
+class ToolListResponse(BaseModel):
+    """Response for listing tools"""
+    tools: List[ToolInfo]
+    count: int

models/stt.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+
+class STTResponse(BaseModel):
+    text: str
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "text": "Hello, how are you today?"
+            }
+        }

models/tts.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel, Field
+
+class TTSRequest(BaseModel):
+    text: str = Field(..., min_length=1, max_length=5000)
+    voice: str = Field(default="Aaliyah-PlayAI")
+    format: str = Field(default="wav", pattern="^(wav|mp3)$")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "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"
+            }
+        }

requirements.txt

@@ -1,10 +1,23 @@
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-pydantic==2.5.0
-python-dotenv==1.0.0
-torch>=2.0.0
+fastapi>=0.115.0
+uvicorn[standard]>=0.29.0
+python-multipart>=0.0.6
+python-dotenv>=1.0.0
+pydantic>=2.5.0
+
+# API Clients
+requests>=2.31.0
+groq>=0.9.0
+
+# Audio processing (optionnel si vous avez besoin de traitement local)
+soundfile>=0.12.1
+
+# Hugging Face
 transformers>=4.35.0
-accelerate>=0.24.0
-protobuf>=3.20.0
-huggingface_hub>=0.19.0
+torch>=2.0.1
+
+# Autres dépendances
+numpy>=1.26.4
 
+mcp>=1.0.0
+# Note: fastapi-mcp peut ne pas exister officiellement, 
+# vous devrez probablement créer votre propre intégration

routes/__init__.py

@@ -1,8 +1,13 @@
 """API route handlers"""
 
 from fastapi import APIRouter
+<<<<<<< HEAD
 from . import root, health, stance, label, generate
 
+=======
+from . import root, health, stance, label
+from routes.tts_routes import router as audio_router 
+>>>>>>> 45e145b23965e35eefb7990d09b535073040e40a
 # Create main router
 api_router = APIRouter()
 
@@ -11,7 +16,12 @@ api_router.include_router(root.router)
 api_router.include_router(health.router)
 api_router.include_router(stance.router, prefix="/stance")
 api_router.include_router(label.router, prefix="/label")
+<<<<<<< HEAD
 api_router.include_router(generate.router, prefix="/generate")
+=======
+api_router.include_router(audio_router)  
+>>>>>>> 45e145b23965e35eefb7990d09b535073040e40a
 
 __all__ = ["api_router"]
 
+

routes/mcp_routes.py

@@ -0,0 +1,502 @@
+"""Routes pour exposer MCP via FastAPI pour Swagger UI"""
+
+from fastapi import APIRouter, HTTPException
+from typing import Dict, Any, Optional
+from pydantic import BaseModel, Field
+import logging
+import json
+
+from services.mcp_service import mcp_server
+from models.mcp_models import (
+    ToolListResponse, 
+    ToolInfo, 
+    ToolCallRequest, 
+    ToolCallResponse,
+    DetectStanceResponse,
+    MatchKeypointResponse,
+    TranscribeAudioResponse,
+    GenerateSpeechResponse,
+    GenerateArgumentResponse
+)
+
+router = APIRouter(prefix="/api/v1/mcp", tags=["MCP"])
+logger = logging.getLogger(__name__)
+
+
+# ===== Models pour chaque outil MCP =====
+
+class DetectStanceRequest(BaseModel):
+    """Request pour détecter la stance d'un argument"""
+    topic: str = Field(..., description="Le sujet du débat")
+    argument: str = Field(..., description="L'argument à analyser")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "topic": "Climate change is real",
+                "argument": "Rising global temperatures prove it"
+            }
+        }
+
+class MatchKeypointRequest(BaseModel):
+    """Request pour matcher un argument avec un keypoint"""
+    argument: str = Field(..., description="L'argument à évaluer")
+    key_point: str = Field(..., description="Le keypoint de référence")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "argument": "Renewable energy reduces emissions",
+                "key_point": "Environmental benefits"
+            }
+        }
+
+class TranscribeAudioRequest(BaseModel):
+    """Request pour transcrire un audio"""
+    audio_path: str = Field(..., description="Chemin vers le fichier audio")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "audio_path": "/path/to/audio.wav"
+            }
+        }
+
+class GenerateSpeechRequest(BaseModel):
+    """Request pour générer de la parole"""
+    text: str = Field(..., description="Texte à convertir en parole")
+    voice: str = Field(default="Aaliyah-PlayAI", description="Voix à utiliser")
+    format: str = Field(default="wav", description="Format audio (wav, mp3, etc.)")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "text": "Hello, this is a test",
+                "voice": "Aaliyah-PlayAI",
+                "format": "wav"
+            }
+        }
+
+class GenerateArgumentRequest(BaseModel):
+    """Request pour générer un argument"""
+    user_input: str = Field(..., description="Input utilisateur pour générer l'argument")
+    conversation_id: Optional[str] = Field(default=None, description="ID de conversation (optionnel)")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "user_input": "Generate an argument about climate change",
+                "conversation_id": "conv_123"
+            }
+        }
+
+
+# ===== Routes MCP =====
+
+@router.get("/health", summary="Health Check MCP")
+async def mcp_health():
+    """Health check pour le serveur MCP"""
+    try:
+        # Liste hardcodée des outils disponibles (plus fiable)
+        tool_names = [
+            "detect_stance",
+            "match_keypoint_argument",
+            "transcribe_audio",
+            "generate_speech",
+            "generate_argument",
+            "health_check"
+        ]
+        return {
+            "status": "healthy",
+            "tools": tool_names,
+            "tool_count": len(tool_names)
+        }
+    except Exception as e:
+        logger.error(f"MCP health check error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/tools", response_model=ToolListResponse, summary="Liste des outils MCP")
+async def list_mcp_tools():
+    """Liste tous les outils MCP disponibles"""
+    try:
+        # Définir manuellement les outils avec leurs schémas
+        tool_list = [
+            ToolInfo(
+                name="detect_stance",
+                description="Détecte si un argument est PRO ou CON pour un topic donné",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "topic": {"type": "string", "description": "Le sujet du débat"},
+                        "argument": {"type": "string", "description": "L'argument à analyser"}
+                    },
+                    "required": ["topic", "argument"]
+                }
+            ),
+            ToolInfo(
+                name="match_keypoint_argument",
+                description="Détermine si un argument correspond à un keypoint",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "argument": {"type": "string", "description": "L'argument à évaluer"},
+                        "key_point": {"type": "string", "description": "Le keypoint de référence"}
+                    },
+                    "required": ["argument", "key_point"]
+                }
+            ),
+            ToolInfo(
+                name="transcribe_audio",
+                description="Convertit un fichier audio en texte",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "audio_path": {"type": "string", "description": "Chemin vers le fichier audio"}
+                    },
+                    "required": ["audio_path"]
+                }
+            ),
+            ToolInfo(
+                name="generate_speech",
+                description="Convertit du texte en fichier audio",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "text": {"type": "string", "description": "Texte à convertir en parole"},
+                        "voice": {"type": "string", "description": "Voix à utiliser", "default": "Aaliyah-PlayAI"},
+                        "format": {"type": "string", "description": "Format audio", "default": "wav"}
+                    },
+                    "required": ["text"]
+                }
+            ),
+            ToolInfo(
+                name="generate_argument",
+                description="Génère un argument de débat à partir d'un input utilisateur",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "user_input": {"type": "string", "description": "Input utilisateur pour générer l'argument"},
+                        "conversation_id": {"type": "string", "description": "ID de conversation (optionnel)"}
+                    },
+                    "required": ["user_input"]
+                }
+            ),
+            ToolInfo(
+                name="health_check",
+                description="Health check pour le serveur MCP",
+                input_schema={
+                    "type": "object",
+                    "properties": {},
+                    "required": []
+                }
+            )
+        ]
+        
+        return ToolListResponse(tools=tool_list, count=len(tool_list))
+    except Exception as e:
+        logger.error(f"Error listing MCP tools: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/tools/call", response_model=ToolCallResponse, summary="Appeler un outil MCP")
+async def call_mcp_tool(request: ToolCallRequest):
+    """Appelle un outil MCP par son nom avec des arguments"""
+    try:
+        result = await mcp_server.call_tool(request.tool_name, request.arguments)
+        # Gérer différents types de retours MCP
+        if isinstance(result, dict):
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text') and content_block.text:
+                    try:
+                        final_result = json.loads(content_block.text)
+                    except json.JSONDecodeError:
+                        final_result = {"text": content_block.text}
+                else:
+                    final_result = result
+            else:
+                final_result = result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            # Si c'est une liste de ContentBlock, extraire le contenu
+            if hasattr(result[0], 'text') and result[0].text:
+                try:
+                    final_result = json.loads(result[0].text)
+                except json.JSONDecodeError:
+                    final_result = {"text": result[0].text}
+            else:
+                final_result = {"result": result[0] if result else {}}
+        else:
+            final_result = {"result": result}
+        
+        return ToolCallResponse(
+            success=True,
+            result=final_result,
+            tool_name=request.tool_name
+        )
+    except Exception as e:
+        logger.error(f"Error calling MCP tool {request.tool_name}: {e}")
+        return ToolCallResponse(
+            success=False,
+            error=str(e),
+            tool_name=request.tool_name
+        )
+
+
+# ===== Routes individuelles pour chaque outil (pour Swagger) =====
+
+@router.post("/tools/detect-stance", response_model=DetectStanceResponse, summary="Détecter la stance d'un argument")
+async def mcp_detect_stance(request: DetectStanceRequest):
+    """Détecte si un argument est PRO ou CON pour un topic donné"""
+    try:
+        # Appeler directement via call_tool (async)
+        result = await mcp_server.call_tool("detect_stance", {
+            "topic": request.topic,
+            "argument": request.argument
+        })
+        
+        # Extraire les données du résultat MCP
+        parsed_result = None
+        if isinstance(result, dict):
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text') and content_block.text:
+                    try:
+                        parsed_result = json.loads(content_block.text)
+                    except json.JSONDecodeError:
+                        raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+            else:
+                parsed_result = result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text') and result[0].text:
+                try:
+                    parsed_result = json.loads(result[0].text)
+                except json.JSONDecodeError:
+                    raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+        else:
+            parsed_result = result
+        
+        if not parsed_result:
+            raise HTTPException(status_code=500, detail="Empty response from MCP tool")
+        
+        # Construire la réponse structurée
+        response = DetectStanceResponse(
+            predicted_stance=parsed_result["predicted_stance"],
+            confidence=parsed_result["confidence"],
+            probability_con=parsed_result["probability_con"],
+            probability_pro=parsed_result["probability_pro"]
+        )
+        
+        logger.info(f"Stance prediction: {response.predicted_stance} (conf={response.confidence:.4f})")
+        return response
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in detect_stance: {e}")
+        raise HTTPException(status_code=500, detail=f"Error executing tool detect_stance: {e}")
+
+@router.post("/tools/match-keypoint", response_model=MatchKeypointResponse, summary="Matcher un argument avec un keypoint")
+async def mcp_match_keypoint(request: MatchKeypointRequest):
+    """Détermine si un argument correspond à un keypoint"""
+    try:
+        result = await mcp_server.call_tool("match_keypoint_argument", {
+            "argument": request.argument,
+            "key_point": request.key_point
+        })
+        
+        # Extraire les données du résultat MCP
+        parsed_result = None
+        if isinstance(result, dict):
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text') and content_block.text:
+                    try:
+                        parsed_result = json.loads(content_block.text)
+                    except json.JSONDecodeError:
+                        raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+            else:
+                parsed_result = result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text') and result[0].text:
+                try:
+                    parsed_result = json.loads(result[0].text)
+                except json.JSONDecodeError:
+                    raise HTTPException(status_code=500, detail="Invalid JSON response from MCP tool")
+        else:
+            parsed_result = result
+        
+        if not parsed_result:
+            raise HTTPException(status_code=500, detail="Empty response from MCP tool")
+        
+        # Construire la réponse structurée
+        response = MatchKeypointResponse(
+            prediction=parsed_result["prediction"],
+            label=parsed_result["label"],
+            confidence=parsed_result["confidence"],
+            probabilities=parsed_result["probabilities"]
+        )
+        
+        logger.info(f"Keypoint matching: {response.label} (conf={response.confidence:.4f})")
+        return response
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in match_keypoint_argument: {e}")
+        raise HTTPException(status_code=500, detail=f"Error executing tool match_keypoint_argument: {e}")
+
+@router.post("/tools/transcribe-audio", response_model=TranscribeAudioResponse, summary="Transcrire un audio en texte")
+async def mcp_transcribe_audio(request: TranscribeAudioRequest):
+    """Convertit un fichier audio en texte"""
+    try:
+        result = await mcp_server.call_tool("transcribe_audio", {
+            "audio_path": request.audio_path
+        })
+        
+        # Extraire le texte du résultat MCP
+        transcribed_text = None
+        if isinstance(result, dict):
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text'):
+                    transcribed_text = content_block.text
+            elif "text" in result:
+                transcribed_text = result["text"]
+        elif isinstance(result, str):
+            transcribed_text = result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text'):
+                transcribed_text = result[0].text
+            else:
+                transcribed_text = str(result[0])
+        else:
+            transcribed_text = str(result)
+        
+        if not transcribed_text:
+            raise HTTPException(status_code=500, detail="Empty transcription result from MCP tool")
+        
+        response = TranscribeAudioResponse(text=transcribed_text)
+        logger.info(f"Audio transcribed: {len(transcribed_text)} characters")
+        return response
+        
+    except FileNotFoundError as e:
+        logger.error(f"File not found in transcribe_audio: {e}")
+        raise HTTPException(status_code=500, detail=f"Error executing tool transcribe_audio: {e}")
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in transcribe_audio: {e}")
+        raise HTTPException(status_code=500, detail=f"Error executing tool transcribe_audio: {e}")
+
+@router.post("/tools/generate-speech", response_model=GenerateSpeechResponse, summary="Générer de la parole à partir de texte")
+async def mcp_generate_speech(request: GenerateSpeechRequest):
+    """Convertit du texte en fichier audio"""
+    try:
+        result = await mcp_server.call_tool("generate_speech", {
+            "text": request.text,
+            "voice": request.voice,
+            "format": request.format
+        })
+        
+        # Extraire le chemin audio du résultat MCP
+        audio_path = None
+        if isinstance(result, dict):
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text'):
+                    audio_path = content_block.text
+            elif "audio_path" in result:
+                audio_path = result["audio_path"]
+        elif isinstance(result, str):
+            audio_path = result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text'):
+                audio_path = result[0].text
+            else:
+                audio_path = str(result[0])
+        else:
+            audio_path = str(result)
+        
+        if not audio_path:
+            raise HTTPException(status_code=500, detail="Empty audio path from MCP tool")
+        
+        response = GenerateSpeechResponse(audio_path=audio_path)
+        logger.info(f"Speech generated: {audio_path}")
+        return response
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in generate_speech: {e}")
+        raise HTTPException(status_code=500, detail=f"Error executing tool generate_speech: {e}")
+
+@router.post("/tools/generate-argument", response_model=GenerateArgumentResponse, summary="Générer un argument de débat")
+async def mcp_generate_argument(request: GenerateArgumentRequest):
+    """Génère un argument de débat à partir d'un input utilisateur"""
+    try:
+        result = await mcp_server.call_tool("generate_argument", {
+            "user_input": request.user_input,
+            "conversation_id": request.conversation_id
+        })
+        
+        # Extraire l'argument du résultat MCP
+        generated_argument = None
+        if isinstance(result, dict):
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text'):
+                    generated_argument = content_block.text
+            elif "argument" in result:
+                generated_argument = result["argument"]
+        elif isinstance(result, str):
+            generated_argument = result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text'):
+                generated_argument = result[0].text
+            else:
+                generated_argument = str(result[0])
+        else:
+            generated_argument = str(result)
+        
+        if not generated_argument:
+            raise HTTPException(status_code=500, detail="Empty argument from MCP tool")
+        
+        response = GenerateArgumentResponse(argument=generated_argument)
+        logger.info(f"Argument generated: {len(generated_argument)} characters")
+        return response
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error in generate_argument: {e}")
+        raise HTTPException(status_code=500, detail=f"Error executing tool generate_argument: {e}")
+
+@router.get("/tools/health-check", summary="Health check MCP (outil)")
+async def mcp_tool_health_check() -> Dict[str, Any]:
+    """Health check via l'outil MCP"""
+    try:
+        result = await mcp_server.call_tool("health_check", {})
+        # Gérer différents types de retours MCP
+        import json
+        if isinstance(result, dict):
+            # Si le résultat contient une clé "result" avec une liste de ContentBlock
+            if "result" in result and isinstance(result["result"], list) and len(result["result"]) > 0:
+                content_block = result["result"][0]
+                if hasattr(content_block, 'text') and content_block.text:
+                    try:
+                        return json.loads(content_block.text)
+                    except json.JSONDecodeError:
+                        return {"text": content_block.text}
+            return result
+        elif isinstance(result, (list, tuple)) and len(result) > 0:
+            if hasattr(result[0], 'text') and result[0].text:
+                try:
+                    return json.loads(result[0].text)
+                except json.JSONDecodeError:
+                    return {"text": result[0].text}
+            return {"result": result[0] if result else {}}
+        return {"result": result}
+    except Exception as e:
+        logger.error(f"Error in health_check tool: {e}")
+        raise HTTPException(status_code=500, detail=f"Error executing tool health_check: {e}")

routes/stt_routes.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException
+from services.stt_service import speech_to_text
+from models.stt import STTResponse
+import tempfile
+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 (English only)
+    """
+    # 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")
+    
+    # Create temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
+        temp_path = temp_file.name
+        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:
+        # Convert audio to text
+        text = speech_to_text(temp_path)
+        
+        # Clean up
+        os.unlink(temp_path)
+        
+        return STTResponse(text=text)
+        
+    except Exception as e:
+        # 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

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse
+from models.tts import TTSRequest
+from services.tts_service import text_to_speech
+from pathlib import Path
+
+router = APIRouter(prefix="/tts", tags=["Text To Speech"])
+
+@router.post("/")
+async def generate_tts(request: TTSRequest):
+    """
+    Convert text to speech (English only)
+    """
+    try:
+        # Generate audio
+        audio_path = text_to_speech(
+            text=request.text,
+            voice=request.voice,
+            fmt=request.format
+        )
+        
+        # Verify file exists
+        if not Path(audio_path).exists():
+            raise HTTPException(status_code=500, detail="Audio file generation failed")
+        
+        # Determine MIME type
+        media_type = "audio/wav" if request.format == "wav" else "audio/mpeg"
+        
+        # Return audio file
+        return FileResponse(
+            path=audio_path,
+            filename=f"speech.{request.format}",
+            media_type=media_type,
+            headers={
+                "Content-Disposition": f"attachment; filename=speech.{request.format}"
+            }
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

routes/voice_chat_routes.py

@@ -0,0 +1,220 @@
+from fastapi import APIRouter, UploadFile, File, HTTPException, Query
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from typing import Optional
+import tempfile
+import os
+from pathlib import Path
+import uuid
+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
+from models.voice_chat import TextChatRequest, VoiceChatResponse
+
+router = APIRouter(prefix="/voice-chat", tags=["Voice Chat"])
+
+# Temporary audio cache
+audio_cache = {}
+
+@router.post("/voice", response_model=VoiceChatResponse)
+async def voice_chat_endpoint(
+    file: UploadFile = File(...),
+    conversation_id: Optional[str] = Query(None)
+):
+    """
+    Complete voice chat endpoint (English only):
+    1. STT: Audio → Text
+    2. Chatbot: Text → Response
+    3. TTS: Response → Audio
+    """
+    # 1. Check audio file
+    if not file.content_type or not file.content_type.startswith('audio/'):
+        raise HTTPException(
+            status_code=400, 
+            detail=f"File must be an audio file. Received: {file.content_type}"
+        )
+    
+    # 2. Create conversation ID if not provided
+    if not conversation_id:
+        conversation_id = str(uuid.uuid4())
+    
+    # 3. Save audio temporarily
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as temp_file:
+        temp_path = temp_file.name
+        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:
+        # 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="No speech detected in audio."
+            )
+        
+        print(f"🎤 STT Result: {user_text}")
+        
+        # 5. Generate chatbot response (English)
+        chatbot_response = generate_chat_response(
+            user_input=user_text,
+            conversation_id=conversation_id
+        )
+        
+        print(f"🤖 Chatbot Response: {chatbot_response}")
+        
+        # 6. TTS: Response text → Audio (English voice)
+        audio_path = text_to_speech(
+            text=chatbot_response,
+            voice="Aaliyah-PlayAI",  # English voice
+            fmt="wav"
+        )
+        
+        # 7. Read and store audio
+        with open(audio_path, "rb") as audio_file:
+            audio_data = audio_file.read()
+        
+        audio_cache[conversation_id] = {
+            "audio": audio_data,
+            "text": chatbot_response
+        }
+        
+        # 8. Clean up temporary files
+        os.unlink(temp_path)
+        if Path(audio_path).exists():
+            os.unlink(audio_path)
+        
+        # 9. Return response
+        return VoiceChatResponse(
+            text_response=chatbot_response,
+            audio_url=f"/voice-chat/audio/{conversation_id}",
+            conversation_id=conversation_id
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        # Clean up on error
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
+        
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"❌ Error in voice_chat_endpoint: {error_details}")
+        
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Error during voice processing: {str(e)}"
+        )
+
+@router.post("/text", response_model=VoiceChatResponse)
+async def text_chat_endpoint(request: TextChatRequest):
+    """
+    Text chat with audio response (English only)
+    For users who prefer to type but hear the response
+    """
+    try:
+        # 1. Create conversation ID if not provided
+        if not request.conversation_id:
+            conversation_id = str(uuid.uuid4())
+        else:
+            conversation_id = request.conversation_id
+        
+        # 2. Validate text
+        if not request.text or request.text.strip() == "":
+            raise HTTPException(status_code=400, detail="Text cannot be empty")
+        
+        print(f"📝 Text received: {request.text}")
+        
+        # 3. Generate chatbot response
+        chatbot_response = generate_chat_response(
+            user_input=request.text,
+            conversation_id=conversation_id
+        )
+        
+        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. Read and store audio
+        with open(audio_path, "rb") as audio_file:
+            audio_data = audio_file.read()
+        
+        audio_cache[conversation_id] = {
+            "audio": audio_data,
+            "text": chatbot_response
+        }
+        
+        # 6. Clean up
+        if Path(audio_path).exists():
+            os.unlink(audio_path)
+        
+        # 7. Return response
+        return VoiceChatResponse(
+            text_response=chatbot_response,
+            audio_url=f"/voice-chat/audio/{conversation_id}",
+            conversation_id=conversation_id
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"❌ Error in text_chat_endpoint: {error_details}")
+        
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Error during chat: {str(e)}"
+        )
+
+@router.get("/audio/{conversation_id}")
+async def get_audio_stream(conversation_id: str):
+    """
+    Stream audio of the last response
+    """
+    if conversation_id not in audio_cache:
+        raise HTTPException(
+            status_code=404, 
+            detail=f"No audio found for conversation {conversation_id}"
+        )
+    
+    audio_data = audio_cache[conversation_id]["audio"]
+    
+    return StreamingResponse(
+        io.BytesIO(audio_data),
+        media_type="audio/wav",
+        headers={
+            "Content-Disposition": f"attachment; filename=response_{conversation_id[:8]}.wav"
+        }
+    )
+
+@router.get("/test")
+async def test_endpoint():
+    """
+    Test endpoint to verify API is working
+    """
+    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"
+        }
+    }

services/__init__.py

@@ -4,11 +4,22 @@ from .stance_model_manager import StanceModelManager, stance_model_manager
 from .label_model_manager import KpaModelManager, kpa_model_manager
 from .generate_model_manager import GenerateModelManager, generate_model_manager
 
+# NEW imports
+from .stt_service import speech_to_text
+from .tts_service import text_to_speech
+
 __all__ = [
     "StanceModelManager",
     "stance_model_manager",
     "KpaModelManager",
     "kpa_model_manager",
+<<<<<<< HEAD
     "GenerateModelManager",
     "generate_model_manager",
+=======
+
+    # NEW exports
+    "speech_to_text",
+    "text_to_speech",
+>>>>>>> 45e145b23965e35eefb7990d09b535073040e40a
 ]

services/chat_service.py

@@ -0,0 +1,138 @@
+import uuid
+from typing import Dict, List, Optional
+from datetime import datetime
+import requests
+import json
+
+from config import GROQ_API_KEY, GROQ_CHAT_MODEL
+
+# In-memory conversation storage
+conversation_store: Dict[str, List[Dict]] = {}
+
+def generate_chat_response(
+    user_input: str,
+    conversation_id: Optional[str] = None,
+    system_prompt: Optional[str] = None
+) -> str:
+    """
+    Generate chatbot response for user input (English only)
+    """
+    try:
+        # 1. Validate input
+        if not user_input or not isinstance(user_input, str):
+            raise ValueError("User input must be a non-empty string")
+        
+        user_input = user_input.strip()
+        if len(user_input) == 0:
+            return "I didn't hear what you said. Can you repeat?"
+        
+        # 2. Handle conversation
+        if not conversation_id:
+            conversation_id = str(uuid.uuid4())
+        
+        # Initialize conversation if it doesn't exist
+        if conversation_id not in conversation_store:
+            conversation_store[conversation_id] = []
+        
+        # 3. Add user message to history
+        conversation_store[conversation_id].append({
+            "role": "user",
+            "content": user_input,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # 4. Prepare system prompt (English only)
+        if not system_prompt:
+            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. Prepare messages for Groq API
+        messages = [{"role": "system", "content": system_prompt}]
+        
+        # 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. Call Groq Chat API
+        if not GROQ_API_KEY:
+            # 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:
+                print(f"Groq API error: {api_error}")
+                response_text = f"I understand you said: {user_input}. How can I help you today?"
+        
+        # 7. Add response to history
+        conversation_store[conversation_id].append({
+            "role": "assistant",
+            "content": response_text,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # 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"Error in generate_chat_response: {e}")
+        return "Sorry, an error occurred. Can you please repeat?"
+
+def call_groq_chat_api(messages: List[Dict]) -> str:
+    """
+    Call Groq Chat API
+    """
+    if not GROQ_API_KEY:
+        raise RuntimeError("GROQ_API_KEY is not configured")
+    
+    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": 300,
+        "top_p": 0.9,
+        "stream": False
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=payload, timeout=30)
+        response.raise_for_status()
+        
+        result = response.json()
+        
+        if "choices" not in result or len(result["choices"]) == 0:
+            raise ValueError("Invalid response from Groq API")
+        
+        return result["choices"][0]["message"]["content"]
+        
+    except requests.exceptions.RequestException as e:
+        raise Exception(f"Groq API connection error: {str(e)}")
+    except KeyError as e:
+        raise Exception(f"Invalid response format: {str(e)}")
+
+def get_conversation_history(conversation_id: str) -> List[Dict]:
+    """
+    Get conversation history
+    """
+    return conversation_store.get(conversation_id, [])
+
+def clear_conversation(conversation_id: str) -> bool:
+    """
+    Clear a conversation
+    """
+    if conversation_id in conversation_store:
+        del conversation_store[conversation_id]
+        return True
+    return False

services/mcp_service.py

@@ -0,0 +1,89 @@
+"""Service pour initialiser le serveur MCP avec FastMCP"""
+
+from mcp.server.fastmcp import FastMCP
+from typing import Dict, Any
+import logging
+
+from fastapi import FastAPI
+
+from services.stance_model_manager import stance_model_manager
+from services.label_model_manager import kpa_model_manager  
+from services.stt_service import speech_to_text
+from services.tts_service import text_to_speech
+from services.chat_service import generate_chat_response
+
+logger = logging.getLogger(__name__)
+
+# Créer l'instance FastMCP
+mcp_server = FastMCP("NLP-Debater-MCP", json_response=True, stateless_http=False)  # Stateful pour sessions
+
+# Tools (inchangés, OK)
+@mcp_server.tool()
+def detect_stance(topic: str, argument: str) -> Dict[str, Any]:
+    if not stance_model_manager.model_loaded:
+        raise ValueError("Modèle stance non chargé")
+    result = stance_model_manager.predict(topic, argument)
+    return {
+        "predicted_stance": result["predicted_stance"],
+        "confidence": result["confidence"],
+        "probability_con": result["probability_con"],
+        "probability_pro": result["probability_pro"]
+    }
+
+@mcp_server.tool()
+def match_keypoint_argument(argument: str, key_point: str) -> Dict[str, Any]:
+    if not kpa_model_manager.model_loaded:
+        raise ValueError("Modèle KPA non chargé")
+    result = kpa_model_manager.predict(argument, key_point)
+    return {
+        "prediction": result["prediction"],
+        "label": result["label"],
+        "confidence": result["confidence"],
+        "probabilities": result["probabilities"]
+    }
+
+@mcp_server.tool()
+def transcribe_audio(audio_path: str) -> str:
+    return speech_to_text(audio_path)
+
+@mcp_server.tool()
+def generate_speech(text: str, voice: str = "Aaliyah-PlayAI", format: str = "wav") -> str:
+    return text_to_speech(text, voice, format)
+
+@mcp_server.tool()
+def generate_argument(user_input: str, conversation_id: str = None) -> str:
+    return generate_chat_response(user_input, conversation_id)
+
+@mcp_server.resource("debate://prompt")
+def get_debate_prompt() -> str:
+    return "Tu es un expert en débat. Génère 3 arguments PRO pour le topic donné. Sois concis et persuasif."
+
+# Health tool (enregistré avant l'initialisation)
+@mcp_server.tool()
+def health_check() -> Dict[str, Any]:
+    """Health check pour le serveur MCP"""
+    try:
+        # Liste hardcodée pour éviter les problèmes avec list_tools()
+        tool_names = [
+            "detect_stance",
+            "match_keypoint_argument",
+            "transcribe_audio",
+            "generate_speech",
+            "generate_argument",
+            "health_check"
+        ]
+    except Exception:
+        tool_names = []
+    return {"status": "healthy", "tools": tool_names}
+
+def init_mcp_server(app: FastAPI) -> None:
+    """
+    Initialise et monte le serveur MCP sur l'app FastAPI.
+    """
+    # CORRIGÉ : Utilise streamable_http_app() qui retourne l'ASGI app
+    mcp_app = mcp_server.streamable_http_app()  # L'ASGI app pour mounting (gère /health, /tools, etc. nativement)
+    
+    # Monte à /api/v1/mcp - FastAPI gère le lifespan auto
+    app.mount("/api/v1/mcp", mcp_app)
+    
+    logger.info("✓ Serveur MCP monté sur /api/v1/mcp avec tools NLP/STT/TTS")

services/stt_service.py

@@ -0,0 +1,38 @@
+import requests
+from config import GROQ_API_KEY, GROQ_STT_MODEL
+
+def speech_to_text(audio_file: str) -> str:
+    """
+    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")
+
+    url = "https://api.groq.com/openai/v1/audio/transcriptions"
+    
+    headers = {
+        "Authorization": f"Bearer {GROQ_API_KEY}"
+    }
+    
+    with open(audio_file, "rb") as audio_data:
+        files = {
+            "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, timeout=30)
+            response.raise_for_status()
+            
+            result = response.json()
+            return result.get("text", "")
+            
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Groq STT API error: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Unexpected error in speech_to_text: {str(e)}")

services/tts_service.py

@@ -0,0 +1,57 @@
+import requests
+import uuid
+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:
+    """
+    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")
+    
+    if not text or not text.strip():
+        raise ValueError("Text cannot be empty")
+    
+    url = "https://api.groq.com/openai/v1/audio/speech"
+    
+    headers = {
+        "Authorization": f"Bearer {GROQ_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "model": GROQ_TTS_MODEL,
+        "input": text.strip(),
+        "voice": voice,
+        "response_format": fmt
+    }
+    
+    try:
+        # Create temp directory for audio files
+        temp_dir = Path("temp_audio")
+        temp_dir.mkdir(exist_ok=True)
+        
+        # Unique filename
+        output_filename = f"tts_{uuid.uuid4().hex[:8]}.{fmt}"
+        output_path = temp_dir / output_filename
+        
+        # Call Groq API
+        response = requests.post(url, headers=headers, json=payload, timeout=30)
+        response.raise_for_status()
+        
+        # Save audio file
+        with open(output_path, "wb") as f:
+            f.write(response.content)
+        
+        return str(output_path)
+        
+    except requests.exceptions.RequestException as e:
+        raise Exception(f"Groq TTS API error: {str(e)}")
+    except Exception as e:
+        raise Exception(f"Unexpected error in text_to_speech: {str(e)}")