feat: Refactor stance detection, keypoint matching, and argument generation to utilize dedicated model managers for improved reliability and response handling

routes/mcp_routes.py

@@ -11,6 +11,9 @@ import os
 from pathlib import Path
 
 from services.mcp_service import mcp_server
+from services.stance_model_manager import stance_model_manager
+from services.label_model_manager import kpa_model_manager
+from services.generate_model_manager import generate_model_manager
 from models.mcp_models import (
     ToolListResponse, 
     ToolInfo, 
@@ -290,49 +293,19 @@ async def call_mcp_tool(request: ToolCallRequest):
 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
-        })
-        
-        # FastMCP avec json_response=True retourne directement le dict
-        parsed_result = None
-        if isinstance(result, dict):
-            # Vérifier si c'est un dict avec "result" contenant des ContentBlocks
-            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:
-                    # Si pas de text, utiliser le dict directement
-                    parsed_result = result
-            else:
-                # Dict direct retourné par le tool
-                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[0] if isinstance(result[0], dict) else result
-        else:
-            parsed_result = result
+        # Vérifier que le modèle est chargé
+        if not stance_model_manager.model_loaded:
+            raise HTTPException(status_code=503, detail="Stance model not loaded")
         
-        if not parsed_result or not isinstance(parsed_result, dict):
-            raise HTTPException(status_code=500, detail="Invalid response format from MCP tool")
+        # Appeler directement le modèle (plus fiable que via MCP)
+        result = stance_model_manager.predict(request.topic, request.argument)
         
-        # Construire la réponse structurée
+        # Construire la réponse structurée directement depuis le résultat du modèle
         response = DetectStanceResponse(
-            predicted_stance=parsed_result["predicted_stance"],
-            confidence=parsed_result["confidence"],
-            probability_con=parsed_result["probability_con"],
-            probability_pro=parsed_result["probability_pro"]
+            predicted_stance=result["predicted_stance"],
+            confidence=result["confidence"],
+            probability_con=result["probability_con"],
+            probability_pro=result["probability_pro"]
         )
         
         logger.info(f"Stance prediction: {response.predicted_stance} (conf={response.confidence:.4f})")
@@ -344,52 +317,26 @@ async def mcp_detect_stance(request: DetectStanceRequest):
         logger.error(f"Missing key in detect_stance response: {e}")
         raise HTTPException(status_code=500, detail=f"Invalid response format: missing {e}")
     except Exception as e:
-        logger.error(f"Error in detect_stance: {e}")
+        logger.error(f"Error in detect_stance: {e}", exc_info=True)
         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
-        })
-        
-        # FastMCP avec json_response=True retourne directement le dict
-        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
-            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[0] if isinstance(result[0], dict) else result
-        else:
-            parsed_result = result
+        # Vérifier que le modèle est chargé
+        if not kpa_model_manager.model_loaded:
+            raise HTTPException(status_code=503, detail="KPA model not loaded")
         
-        if not parsed_result or not isinstance(parsed_result, dict):
-            raise HTTPException(status_code=500, detail="Invalid response format from MCP tool")
+        # Appeler directement le modèle (plus fiable que via MCP)
+        result = kpa_model_manager.predict(request.argument, request.key_point)
         
-        # Construire la réponse structurée
+        # Construire la réponse structurée directement depuis le résultat du modèle
         response = MatchKeypointResponse(
-            prediction=parsed_result["prediction"],
-            label=parsed_result["label"],
-            confidence=parsed_result["confidence"],
-            probabilities=parsed_result["probabilities"]
+            prediction=result["prediction"],
+            label=result["label"],
+            confidence=result["confidence"],
+            probabilities=result["probabilities"]
         )
         
         logger.info(f"Keypoint matching: {response.label} (conf={response.confidence:.4f})")
@@ -401,7 +348,7 @@ async def mcp_match_keypoint(request: MatchKeypointRequest):
         logger.error(f"Missing key in match_keypoint response: {e}")
         raise HTTPException(status_code=500, detail=f"Invalid response format: missing {e}")
     except Exception as e:
-        logger.error(f"Error in match_keypoint_argument: {e}")
+        logger.error(f"Error in match_keypoint_argument: {e}", exc_info=True)
         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")
@@ -536,50 +483,20 @@ async def mcp_generate_speech(request: GenerateSpeechRequest):
 async def mcp_generate_argument(request: GenerateRequest):
     """Génère un argument de débat pour un topic et une position donnés"""
     try:
-        result = await mcp_server.call_tool("generate_argument", {
-            "topic": request.topic,
-            "position": request.position
-        })
-        
-        # FastMCP avec json_response=True retourne directement le dict
-        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:
-                        # Si ce n'est pas du JSON, c'est peut-être juste le texte
-                        parsed_result = {"argument": content_block.text}
-                else:
-                    parsed_result = result
-            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:
-                    parsed_result = {"argument": result[0].text}
-            else:
-                parsed_result = result[0] if isinstance(result[0], dict) else result
-        else:
-            parsed_result = result
-        
-        if not parsed_result or not isinstance(parsed_result, dict):
-            raise HTTPException(status_code=500, detail="Invalid response format from MCP tool")
+        # Vérifier que le modèle est chargé
+        if not generate_model_manager.model_loaded:
+            raise HTTPException(status_code=503, detail="Generation model not loaded")
         
-        # Extraire l'argument (peut être dans "argument" ou directement dans le dict)
-        argument_text = parsed_result.get("argument", "")
-        if not argument_text:
-            # Essayer de trouver le texte ailleurs dans la réponse
-            argument_text = str(parsed_result)
+        # Appeler directement le modèle (plus fiable que via MCP)
+        argument_text = generate_model_manager.generate(
+            topic=request.topic,
+            position=request.position
+        )
         
         # Construire la réponse structurée
         response = GenerateResponse(
-            topic=parsed_result.get("topic", request.topic),
-            position=parsed_result.get("position", request.position),
+            topic=request.topic,
+            position=request.position,
             argument=argument_text,
             timestamp=datetime.now().isoformat()
         )
@@ -590,7 +507,7 @@ async def mcp_generate_argument(request: GenerateRequest):
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error in generate_argument: {e}")
+        logger.error(f"Error in generate_argument: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Error executing tool generate_argument: {e}")
 
 @router.get("/tools/health-check", summary="Health check MCP (outil)")