Update main.py

main.py

@@ -37,9 +37,9 @@ def cleanup_temp_files():
     if temp_dir.exists():
         try:
             shutil.rmtree(temp_dir)
-            logger.info("✓ Cleaned up previous temp audio files")
+            logger.info("✓ Fichiers temporaires audio nettoyés")
         except Exception as e:
-            logger.warning(f"⚠ Could not clean temp directory: {e}")
+            logger.warning(f"⚠ Impossible de nettoyer le répertoire temporaire: {e}")
 
 # Appeler au démarrage
 cleanup_temp_files()
@@ -51,36 +51,47 @@ def cleanup_on_exit():
     if temp_dir.exists():
         try:
             shutil.rmtree(temp_dir)
+            logger.info("Nettoyage final des fichiers temporaires")
         except:
-            pass
+            logger.warning("Échec du nettoyage final")
 
 # --- Import des singletons de services ---
 try:
     from services.stance_model_manager import stance_model_manager
-    from services.label_model_manager import kpa_model_manager
-    logger.info("✓ Model managers imported")
+    from services.label_model_manager import kpa_model_manager  # Corrigé: kpa_model_manager, pas label_model_manager
+    logger.info("✓ Gestionnaires de modèles importés")
 except ImportError as e:
-    logger.warning(f"⚠ Could not import model managers: {e}")
+    logger.warning(f"⚠ Impossible d'importer les gestionnaires de modèles: {e}")
     stance_model_manager = None
     kpa_model_manager = None
 
+# --- Vérification MCP ---
+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:
+    logger.warning(f"⚠ MCP non disponible: {e}")
+    MCP_ENABLED = False
+
 # --- Lifespan / startup API ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     logger.info("="*60)
-    logger.info("🚀 API STARTUP - Loading models and checking APIs...")
+    logger.info("🚀 DÉMARRAGE API - Chargement des modèles et vérification des APIs...")
     logger.info("="*60)
     
     # Vérifier les clés API
     if not GROQ_API_KEY:
-        logger.warning("⚠ GROQ_API_KEY is not set. STT/TTS features may not work.")
+        logger.warning("⚠ GROQ_API_KEY non configurée. Fonctions STT/TTS désactivées.")
     else:
-        logger.info("✓ GROQ_API_KEY is configured")
+        logger.info("✓ GROQ_API_KEY configurée")
         
     if not HUGGINGFACE_API_KEY:
-        logger.warning("⚠ HUGGINGFACE_API_KEY is not set. Local models may not work.")
+        logger.warning("⚠ HUGGINGFACE_API_KEY non configurée. Modèles locaux désactivés.")
     else:
-        logger.info("✓ HUGGINGFACE_API_KEY is configured")
+        logger.info("✓ HUGGINGFACE_API_KEY configurée")
 
     # Précharger les modèles Hugging Face si configuré
     if PRELOAD_MODELS_ON_STARTUP:
@@ -89,28 +100,37 @@ async def lifespan(app: FastAPI):
         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("✓ Stance model loaded successfully")
+                logger.info("✓ Modèle de détection de stance chargé")
             except Exception as e:
-                logger.error(f"✗ Failed loading stance model: {e}")
+                logger.error(f"✗ Échec chargement modèle stance: {e}")
 
         # 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("✓ KPA model loaded successfully")
+                logger.info("✓ Modèle KPA chargé")
             except Exception as e:
-                logger.error(f"✗ Failed loading KPA model: {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("✓ Startup complete. API ready to receive requests.")
+    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("🛑 Shutting down API...")
+    logger.info("🛑 Arrêt de l'API...")
     # Nettoyage final
     cleanup_on_exit()
 
@@ -139,64 +159,47 @@ app.add_middleware(
 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("✓ STT route loaded (Groq Whisper)")
+    logger.info("✓ Route STT chargée (Groq Whisper)")
 except ImportError as e:
-    logger.warning(f"⚠ STT route not found: {e}")
+    logger.warning(f"⚠ Route STT non trouvée: {e}")
 except Exception as e:
-    logger.warning(f"⚠ Failed loading STT route: {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("✓ TTS route loaded (Groq PlayAI TTS)")
+    logger.info("✓ Route TTS chargée (Groq PlayAI TTS)")
 except ImportError as e:
-    logger.warning(f"⚠ TTS route not found: {e}")
+    logger.warning(f"⚠ Route TTS non trouvée: {e}")
 except Exception as e:
-    logger.warning(f"⚠ Failed loading TTS route: {e}")
+    logger.warning(f"⚠ Échec chargement route TTS: {e}")
 
-# Main API Routes
-try:
-    from routes import api_router
-    app.include_router(api_router)
-    logger.info("✓ Main API routes loaded")
-except ImportError as e:
-    logger.warning(f"⚠ Main API routes not found: {e}")
-except Exception as e:
-    logger.warning(f"⚠ Failed loading main API routes: {e}")
-
-# Dans main.py, après les autres routes
+# 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("✓ Voice Chat route loaded")
+    logger.info("✓ Route Voice Chat chargée")
 except ImportError as e:
-    logger.warning(f"⚠ Voice Chat route not found: {e}")
+    logger.warning(f"⚠ Route Voice Chat non trouvée: {e}")
 except Exception as e:
-    logger.warning(f"⚠ Failed loading Voice Chat route: {e}")
+    logger.warning(f"⚠ Échec chargement route Voice Chat: {e}")
 
-# Dans main.py, après les autres imports
+# Main API Routes (KPA, Stance, etc.)
 try:
-    from services.mcp_service import init_mcp_server
-    from routes.mcp_routes import router as mcp_router
-    MCP_ENABLED = True
+    from routes import api_router
+    app.include_router(api_router)
+    logger.info("✓ Routes API principales chargées")
 except ImportError as e:
-    logger.warning(f"⚠ MCP not available: {e}")
-    MCP_ENABLED = False
+    logger.warning(f"⚠ Routes API principales non trouvées: {e}")
+except Exception as e:
+    logger.warning(f"⚠ Échec chargement routes API principales: {e}")
 
-# Dans le lifespan manager, après le chargement des modèles
+# MCP Routes
 if MCP_ENABLED:
-    try:
-        init_mcp_server(app)
-        logger.info("✓ MCP Server initialized")
-    except Exception as e:
-        logger.error(f"✗ MCP initialization failed: {e}")
+    app.include_router(mcp_router, prefix="/api/v1", tags=["MCP"])
+    logger.info("✓ Routes MCP chargées")
 
-# Après les autres routes, ajoutez
-if MCP_ENABLED:
-    app.include_router(mcp_router)
-    logger.info("✓ MCP routes loaded")
-    
 # --- Basic routes ---
 @app.get("/health", tags=["Health"])
 async def health():
@@ -204,12 +207,17 @@ 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 stance_model_manager.model is not None) else "not loaded",
-            "kpa_model": "loaded" if (kpa_model_manager and kpa_model_manager.model is not None) else "not loaded"
+            "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
@@ -217,42 +225,64 @@ async def health():
 @app.get("/", tags=["Root"])
 async def root():
     """Root endpoint with API information"""
+    endpoints = {
+        "docs": "/docs",
+        "redoc": "/redoc",
+        "health": "/health",
+        "stt": "/api/v1/stt/",
+        "tts": "/api/v1/tts/",
+        "voice_chat": "/voice-chat/voice",
+    }
+    
+    if MCP_ENABLED:
+        endpoints["mcp"] = {
+            "health": "/api/v1/mcp/health",
+            "tools": "/api/v1/mcp/tools",
+            "resources": "/api/v1/mcp/resources",
+            "call_tool": "/api/v1/mcp/tools/call"
+        }
+    
     return {
-        "message": "NLP Debater API with Groq Voice Support",
+        "message": "NLP Debater API avec support vocal Groq et MCP",
         "version": API_VERSION,
-        "endpoints": {
-            "docs": "/docs",
-            "redoc": "/redoc",
-            "health": "/health",
-            "stt": "/api/v1/stt/",
-            "tts": "/api/v1/tts/"
-        },
+        "endpoints": endpoints,
         "models": {
-            "stt": GROQ_STT_MODEL,
-            "tts": GROQ_TTS_MODEL,
-            "chat": GROQ_CHAT_MODEL
+            "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",
+            "mcp": "enabled" if MCP_ENABLED else "disabled"
         }
     }
 
 # --- Error handlers ---
 @app.exception_handler(404)
 async def not_found_handler(request, exc):
+    endpoints = {
+        "GET /": "Informations API",
+        "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"The requested URL {request.url} was not found",
-        "available_endpoints": {
-            "GET /": "API information",
-            "GET /health": "Health check",
-            "POST /api/v1/stt/": "Speech to text",
-            "POST /api/v1/tts/": "Text to speech"
-        }
+        "message": f"URL {request.url} non trouvée",
+        "available_endpoints": endpoints
     }
 
 # --- Run server ---
 if __name__ == "__main__":
     logger.info("="*60)
-    logger.info(f"Starting server on {HOST}:{PORT}")
-    logger.info(f"Reload mode: {RELOAD}")
+    logger.info(f"Démarrage du serveur sur {HOST}:{PORT}")
+    logger.info(f"Mode reload: {RELOAD}")
     logger.info("="*60)
     
     uvicorn.run(