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

models/__init__.py

@@ -48,7 +48,6 @@ from .mcp_models import (
     MatchKeypointResponse,
     TranscribeAudioResponse,
     GenerateSpeechResponse,
-    GenerateArgumentResponse,
 )
 
 __all__ = [
@@ -84,5 +83,4 @@ __all__ = [
     "MatchKeypointResponse",
     "TranscribeAudioResponse",
     "GenerateSpeechResponse",
-    "GenerateArgumentResponse",
 ]

models/mcp_models.py

@@ -3,15 +3,43 @@ from typing import Any, Dict, List, Optional
 
 class ToolCallRequest(BaseModel):
     """Request for calling an MCP tool"""
-    tool_name: str
-    arguments: Dict[str, Any] = {}
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "tool_name": "detect_stance",
+                "arguments": {
+                    "topic": "Climate change is real",
+                    "argument": "Rising global temperatures prove it"
+                }
+            }
+        }
+    )
+    
+    tool_name: str = Field(..., description="Name of the MCP tool to call (e.g., 'detect_stance', 'match_keypoint_argument', 'transcribe_audio', 'generate_speech', 'generate_argument')")
+    arguments: Dict[str, Any] = Field(default_factory=dict, description="Arguments for the tool (varies by tool)")
 
 class ToolCallResponse(BaseModel):
     """Response from MCP tool call"""
-    success: bool
-    result: Optional[Dict[str, Any]] = None
-    error: Optional[str] = None
-    tool_name: str
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "success": True,
+                "result": {
+                    "predicted_stance": "PRO",
+                    "confidence": 0.9598,
+                    "probability_con": 0.0402,
+                    "probability_pro": 0.9598
+                },
+                "error": None,
+                "tool_name": "detect_stance"
+            }
+        }
+    )
+    
+    success: bool = Field(..., description="Whether the tool call was successful")
+    result: Optional[Dict[str, Any]] = Field(None, description="Result from the tool call")
+    error: Optional[str] = Field(None, description="Error message if the call failed")
+    tool_name: str = Field(..., description="Name of the tool that was called")
 
 # Response models for individual MCP tools
 class DetectStanceResponse(BaseModel):
@@ -77,18 +105,6 @@ class GenerateSpeechResponse(BaseModel):
     
     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

routes/mcp_routes.py

@@ -1,12 +1,19 @@
 """Routes pour exposer MCP via FastAPI pour Swagger UI"""
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, UploadFile, File
+from fastapi.responses import FileResponse
 from typing import Dict, Any, Optional
 from pydantic import BaseModel, Field
 import logging
 import json
+import tempfile
+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, 
@@ -15,9 +22,10 @@ from models.mcp_models import (
     DetectStanceResponse,
     MatchKeypointResponse,
     TranscribeAudioResponse,
-    GenerateSpeechResponse,
-    GenerateArgumentResponse
+    GenerateSpeechResponse
 )
+from models.generate import GenerateRequest, GenerateResponse
+from datetime import datetime
 
 router = APIRouter(prefix="/api/v1/mcp", tags=["MCP"])
 logger = logging.getLogger(__name__)
@@ -51,16 +59,6 @@ class MatchKeypointRequest(BaseModel):
             }
         }
 
-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"""
@@ -77,18 +75,6 @@ class GenerateSpeechRequest(BaseModel):
             }
         }
 
-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 =====
@@ -171,14 +157,14 @@ async def list_mcp_tools():
             ),
             ToolInfo(
                 name="generate_argument",
-                description="Génère un argument de débat à partir d'un input utilisateur",
+                description="Génère un argument de débat pour un topic et une position donnés",
                 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)"}
+                        "topic": {"type": "string", "description": "Le sujet du débat"},
+                        "position": {"type": "string", "description": "La position à prendre (positive ou negative)"}
                     },
-                    "required": ["user_input"]
+                    "required": ["topic", "position"]
                 }
             ),
             ToolInfo(
@@ -199,7 +185,66 @@ async def list_mcp_tools():
 
 @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"""
+    """
+    Appelle un outil MCP par son nom avec des arguments
+    
+    **Exemples d'utilisation:**
+    
+    1. **detect_stance** - Détecter la stance d'un argument:
+    ```json
+    {
+      "tool_name": "detect_stance",
+      "arguments": {
+        "topic": "Climate change is real",
+        "argument": "Rising global temperatures prove it"
+      }
+    }
+    ```
+    
+    2. **match_keypoint_argument** - Matcher un argument avec un keypoint:
+    ```json
+    {
+      "tool_name": "match_keypoint_argument",
+      "arguments": {
+        "argument": "Renewable energy reduces emissions",
+        "key_point": "Environmental benefits"
+      }
+    }
+    ```
+    
+    3. **generate_argument** - Générer un argument:
+    ```json
+    {
+      "tool_name": "generate_argument",
+      "arguments": {
+        "topic": "Assisted suicide should be legal",
+        "position": "positive"
+      }
+    }
+    ```
+    
+    4. **transcribe_audio** - Transcrire un audio:
+    ```json
+    {
+      "tool_name": "transcribe_audio",
+      "arguments": {
+        "audio_path": "/path/to/audio.wav"
+      }
+    }
+    ```
+    
+    5. **generate_speech** - Générer de la parole:
+    ```json
+    {
+      "tool_name": "generate_speech",
+      "arguments": {
+        "text": "Hello, this is a test",
+        "voice": "Aaliyah-PlayAI",
+        "format": "wav"
+      }
+    }
+    ```
+    """
     try:
         result = await mcp_server.call_tool(request.tool_name, request.arguments)
         # Gérer différents types de retours MCP
@@ -248,43 +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
-        })
-        
-        # 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
+        # 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:
-            raise HTTPException(status_code=500, detail="Empty response 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})")
@@ -292,49 +313,30 @@ async def mcp_detect_stance(request: DetectStanceRequest):
         
     except HTTPException:
         raise
+    except KeyError as e:
+        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
-        })
+        # 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")
         
-        # 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")
+        # 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})")
@@ -342,16 +344,35 @@ async def mcp_match_keypoint(request: MatchKeypointRequest):
         
     except HTTPException:
         raise
+    except KeyError as e:
+        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")
-async def mcp_transcribe_audio(request: TranscribeAudioRequest):
-    """Convertit un fichier audio en texte"""
+async def mcp_transcribe_audio(file: UploadFile = File(...)):
+    """Convertit un fichier audio en texte (upload de fichier)"""
+    # Vérifier le type de fichier
+    if not file.content_type or not file.content_type.startswith('audio/'):
+        raise HTTPException(status_code=400, detail="File must be an audio file")
+    
+    # Créer un fichier temporaire
+    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:
+        # Appeler le service MCP avec le chemin temporaire
         result = await mcp_server.call_tool("transcribe_audio", {
-            "audio_path": request.audio_path
+            "audio_path": temp_path
         })
         
         # Extraire le texte du résultat MCP
@@ -388,10 +409,14 @@ async def mcp_transcribe_audio(request: TranscribeAudioRequest):
     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}")
+    finally:
+        # Nettoyer le fichier temporaire
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
 
-@router.post("/tools/generate-speech", response_model=GenerateSpeechResponse, summary="Générer de la parole à partir de texte")
+@router.post("/tools/generate-speech", summary="Générer de la parole à partir de texte")
 async def mcp_generate_speech(request: GenerateSpeechRequest):
-    """Convertit du texte en fichier audio"""
+    """Convertit du texte en fichier audio (téléchargeable)"""
     try:
         result = await mcp_server.call_tool("generate_speech", {
             "text": request.text,
@@ -418,12 +443,35 @@ async def mcp_generate_speech(request: GenerateSpeechRequest):
         else:
             audio_path = str(result)
         
+        # Nettoyer le chemin si c'est une représentation string d'objet
+        if audio_path and isinstance(audio_path, str):
+            # Si c'est une représentation d'objet TextContent, extraire le chemin
+            if "text='" in audio_path and ".wav" in audio_path:
+                import re
+                match = re.search(r"text='([^']+)'", audio_path)
+                if match:
+                    audio_path = match.group(1)
+        
         if not audio_path:
             raise HTTPException(status_code=500, detail="Empty audio path from MCP tool")
         
-        response = GenerateSpeechResponse(audio_path=audio_path)
+        # Vérifier que le fichier existe
+        if not Path(audio_path).exists():
+            raise HTTPException(status_code=500, detail=f"Audio file not found: {audio_path}")
+        
+        # Déterminer le type MIME
+        media_type = "audio/wav" if request.format == "wav" else "audio/mpeg"
+        
+        # Retourner le fichier pour téléchargement
         logger.info(f"Speech generated: {audio_path}")
-        return response
+        return FileResponse(
+            path=audio_path,
+            filename=f"speech.{request.format}",
+            media_type=media_type,
+            headers={
+                "Content-Disposition": f"attachment; filename=speech.{request.format}"
+            }
+        )
         
     except HTTPException:
         raise
@@ -431,45 +479,35 @@ async def mcp_generate_speech(request: GenerateSpeechRequest):
         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"""
+@router.post("/tools/generate-argument", response_model=GenerateResponse, summary="Générer un argument de débat")
+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", {
-            "user_input": request.user_input,
-            "conversation_id": request.conversation_id
-        })
+        # 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 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)
+        # Appeler directement le modèle (plus fiable que via MCP)
+        argument_text = generate_model_manager.generate(
+            topic=request.topic,
+            position=request.position
+        )
         
-        if not generated_argument:
-            raise HTTPException(status_code=500, detail="Empty argument from MCP tool")
+        # Construire la réponse structurée
+        response = GenerateResponse(
+            topic=request.topic,
+            position=request.position,
+            argument=argument_text,
+            timestamp=datetime.now().isoformat()
+        )
         
-        response = GenerateArgumentResponse(argument=generated_argument)
-        logger.info(f"Argument generated: {len(generated_argument)} characters")
+        logger.info(f"Argument generated for topic '{request.topic}' with position '{request.position}': {len(response.argument)} characters")
         return response
         
     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)")

services/mcp_service.py

@@ -10,7 +10,7 @@ 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
+from services.generate_model_manager import generate_model_manager
 
 logger = logging.getLogger(__name__)
 
@@ -51,8 +51,16 @@ def generate_speech(text: str, voice: str = "Aaliyah-PlayAI", format: str = "wav
     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)
+def generate_argument(topic: str, position: str) -> Dict[str, Any]:
+    """Generate an argument for a given topic and position"""
+    if not generate_model_manager.model_loaded:
+        raise ValueError("Modèle de génération non chargé")
+    argument = generate_model_manager.generate(topic=topic, position=position)
+    return {
+        "topic": topic,
+        "position": position,
+        "argument": argument
+    }
 
 @mcp_server.resource("debate://prompt")
 def get_debate_prompt() -> str: