update mcp part

main.py

@@ -61,17 +61,15 @@ 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é: import depuis kpa_model_manager.py (cohérent partout)
+    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
-mcp_router = None
 try:
     from services.mcp_service import init_mcp_server
-    from routes.mcp_routes import router as mcp_router
     MCP_ENABLED = True
     logger.info("✓ Modules MCP détectés")
 except ImportError as e:
@@ -187,37 +185,37 @@ except ImportError as e:
 except Exception as e:
     logger.warning(f"⚠ Échec chargement route Voice Chat: {e}")
 
-# Main API Routes (KPA, Stance, etc.) - Assumant un api_router qui inclut kpa et stance
-api_router = None
+# Main API Routes (KPA, Stance, etc.)
 try:
-    from routes import api_router  # Ou from routes.api_router import router as api_router si c'est un fichier dédié
+    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 : Inclure directement les sub-routers si api_router n'existe pas
+    # Fallback
     try:
-        from routes.label import router as kpa_router  # Corrigé: assumant routes.kpa_routes.py
+        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  # Corrigé: assumant routes.stance_routes.py
+        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é - vérifiez vos fichiers routes/")
+        logger.warning("⚠ Fallback pour KPA/Stance échoué")
 except Exception as e:
     logger.warning(f"⚠ Échec chargement routes API principales: {e}")
 
-# MCP Routes
-if MCP_ENABLED and mcp_router:
-    app.include_router(mcp_router, prefix="/api/v1", tags=["MCP"])  # Corrigé: prefix="/api/v1" pour matcher le mount (évite double /mcp/mcp)
-    logger.info("✓ Routes MCP chargées")
+# MCP Routes - CORRIGÉ : Supprimé include_router (conflit double prefix) - mount gère tout
+# if MCP_ENABLED and mcp_router:  # Commenté pour éviter /mcp/mcp/...
+#     app.include_router(mcp_router, prefix="/api/v1", tags=["MCP"])
+#     logger.info("✓ Routes MCP chargées")
+if MCP_ENABLED:
+    logger.info("✓ MCP monté via lifespan (endpoints auto-gérés)")
 else:
-    logger.warning("⚠ Routes MCP non chargées (MCP désactivé ou router manquant)")
+    logger.warning("⚠ MCP désactivé")
 
 # --- Basic routes ---
 @app.get("/health", tags=["Health"])
 async def health():
-    """Health check endpoint"""
     health_status = {
         "status": "healthy",
         "service": "NLP Debater + Groq Voice",
@@ -238,8 +236,7 @@ async def health():
 
 @app.get("/", tags=["Root"])
 async def root():
-    """Root endpoint with redirect to Swagger UI"""
-    return RedirectResponse(url="/docs")  # Modifié: Redirige auto vers Swagger pour interface interactive
+    return RedirectResponse(url="/docs")
 
 # --- Error handlers ---
 @app.exception_handler(404)
@@ -251,14 +248,12 @@ async def not_found_handler(request, exc):
         "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",

routes/mcp_routes.py

@@ -1,15 +1,13 @@
-"""Routes pour exposer MCP via FastAPI"""
+"""Routes pour exposer MCP via FastAPI (fallback minimal)"""
 
 from fastapi import APIRouter
-from services.mcp_service import mcp_server  # Importe l'instance
+from services.mcp_service import mcp_server
 
 router = APIRouter(prefix="/mcp", tags=["MCP"])
 
-# Endpoint simple pour health MCP (fallback si mounting direct ne suffit pas)
 @router.get("/health")
 async def mcp_health():
-    """Health check pour MCP"""
+    """Health check pour MCP (fallback)"""
     return {"status": "MCP ready", "tools": [t.name for t in mcp_server.tools]}
 
-# Note : Le mounting principal des routes MCP (/tools, /call, /resources) se fait via app.mount dans init_mcp_server
-# Pas besoin de Starlette ici pour éviter les conflits de path/double mounting
+# Note : Pas de mount ici – tout est géré par init_mcp_server(app.mount)

services/mcp_service.py

@@ -4,40 +4,24 @@ from mcp.server.fastmcp import FastMCP
 from typing import Dict, Any
 import logging
 
-from fastapi import FastAPI  # Ajouté pour résoudre l'erreur Pylance "FastAPI is not defined"
+from fastapi import FastAPI
 
 from services.stance_model_manager import stance_model_manager
-from services.label_model_manager import kpa_model_manager  # Corrigé : import depuis kpa_model_manager.py (cohérent avec main.py)
+from services.label_model_manager import kpa_model_manager  # Corrigé : kpa_model_manager partout
 from services.stt_service import speech_to_text
 from services.tts_service import text_to_speech
 from services.chat_service import generate_chat_response
-# Note : Adapte les imports models si tes schémas sont dans un fichier unique (ex. models/schemas.py)
-# from models.stance import StanceRequest, StanceResponse  # Si séparé
-# from models.kpa import PredictionRequest, PredictionResponse  # Si séparé
-# Ou si un seul fichier models.py :
-# from models import StanceRequest, StanceResponse, PredictionRequest, PredictionResponse
 
 logger = logging.getLogger(__name__)
 
-# Créer l'instance FastMCP (nom du serveur, JSON pour responses structurées)
-mcp_server = FastMCP("NLP-Debater-MCP", json_response=True, stateless_http=False)  # Stateful pour sessions voice chat
+# Créer l'instance FastMCP
+mcp_server = FastMCP("NLP-Debater-MCP", json_response=True, stateless_http=False)  # Stateful pour sessions
 
-# Tool pour Stance Detection
+# Tools (inchangés, OK)
 @mcp_server.tool()
 def detect_stance(topic: str, argument: str) -> Dict[str, Any]:
-    """
-    Détecte la stance (PRO/CON) d'un argument par rapport à un topic.
-    
-    Args:
-        topic: Le sujet de débat (ex. "Assisted suicide should be a criminal offence")
-        argument: L'argument à classifier (ex. "People have the right to choose...")
-    
-    Returns:
-        Dict avec predicted_stance, confidence, probabilities.
-    """
     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"],
@@ -46,22 +30,10 @@ def detect_stance(topic: str, argument: str) -> Dict[str, Any]:
         "probability_pro": result["probability_pro"]
     }
 
-# Tool pour Key-Point Argument Matching (KPA)
 @mcp_server.tool()
 def match_keypoint_argument(argument: str, key_point: str) -> Dict[str, Any]:
-    """
-    Prédit si un argument matche un key-point (apparie/non_apparie).
-    
-    Args:
-        argument: Texte de l'argument
-        key_point: Le key-point de référence
-    
-    Returns:
-        Dict avec prediction (0/1), label, confidence, probabilities.
-    """
     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"],
@@ -70,77 +42,35 @@ def match_keypoint_argument(argument: str, key_point: str) -> Dict[str, Any]:
         "probabilities": result["probabilities"]
     }
 
-# Tool pour STT (Speech-to-Text) - Note : Pour audio, utilise un upload via resource ou adapte
 @mcp_server.tool()
 def transcribe_audio(audio_path: str) -> str:
-    """
-    Transcrit un fichier audio en texte (via Groq Whisper).
-    
-    Args:
-        audio_path: Chemin vers le fichier audio (ex. temp file)
-    
-    Returns:
-        Texte transcrit.
-    """
     return speech_to_text(audio_path)
 
-# Tool pour TTS (Text-to-Speech)
 @mcp_server.tool()
 def generate_speech(text: str, voice: str = "Aaliyah-PlayAI", format: str = "wav") -> str:
-    """
-    Génère un fichier audio à partir de texte (via Groq TTS).
-    
-    Args:
-        text: Texte à synthétiser
-        voice: Voix (défaut: Aaliyah-PlayAI)
-        format: wav ou mp3
-    
-    Returns:
-        Chemin vers le fichier audio généré.
-    """
     return text_to_speech(text, voice, format)
 
-# Tool pour Argument Generation (Chatbot)
 @mcp_server.tool()
 def generate_argument(user_input: str, conversation_id: str = None) -> str:
-    """
-    Génère une réponse argumentative via chatbot (via Groq Llama).
-    
-    Args:
-        user_input: Input utilisateur
-        conversation_id: ID de session (optionnel)
-    
-    Returns:
-        Réponse générée.
-    """
     return generate_chat_response(user_input, conversation_id)
 
-# Resource exemple : Prompt template pour débats (CORRIGÉ : Fonction sans paramètre pour matcher l'URI statique)
 @mcp_server.resource("debate://prompt")
 def get_debate_prompt() -> str:
-    """
-    Récupère un template de prompt générique pour générer des arguments sur un topic.
-    (Note: Pour des params dynamiques, utilise un tool comme detect_stance ou un URI avec {topic}).
-    """
     return "Tu es un expert en débat. Génère 3 arguments PRO pour le topic donné. Sois concis et persuasif."
 
-def init_mcp_server(app: FastAPI) -> None:  # Retiré les quotes : FastAPI est maintenant import��
+def init_mcp_server(app: FastAPI) -> None:
     """
     Initialise et monte le serveur MCP sur l'app FastAPI.
-    Ajoute les routes MCP à /api/v1/mcp (ex. : /tools, /call, /resources).
     """
-    # Monter l'app MCP sur FastAPI (via Starlette Mount, compatible FastAPI)
-    from starlette.routing import Mount
-    
-    # Créer l'app MCP streamable (CORRIGÉ : Sans l'argument streamable_http_path invalide)
-    mcp_app = mcp_server.streamable_http_app()  # Pas de paramètre supplémentaire - le mounting gère le path
+    # CORRIGÉ : Utilise mcp_server.app (ASGI app standard) au lieu de streamable_http_app()
+    mcp_app = mcp_server.app  # L'ASGI app pour mounting clean (gère /health, /tools, etc. nativement)
     
-    # Monter directement sur l'app FastAPI (app.mount pour sub-app)
-    app.mount("/api/v1/mcp", mcp_app)  # Monte à /api/v1/mcp - gère /tools, /call, etc.
+    # Monte à /api/v1/mcp - FastAPI gère le lifespan auto
+    app.mount("/api/v1/mcp", mcp_app)
     
-    logger.info("✓ Serveur MCP initialisé et monté sur /api/v1/mcp avec tools NLP/STT/TTS")
+    logger.info("✓ Serveur MCP monté sur /api/v1/mcp avec tools NLP/STT/TTS")
     
-    # Pour batch ou health, ajoute si besoin (ce tool est déjà décoré)
+    # Health tool optionnel (FastMCP a déjà /health)
     @mcp_server.tool()
     def health_check() -> Dict[str, Any]:
         return {"status": "healthy", "tools": list(mcp_server.tools.keys())}