Update expose

main.py

@@ -204,11 +204,17 @@ except ImportError as e:
 except Exception as e:
     logger.warning(f"⚠ Échec chargement routes API principales: {e}")
 
-# 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")
+# 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é")

models/__init__.py

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

routes/mcp_routes.py

@@ -1,13 +1,232 @@
-"""Routes pour exposer MCP via FastAPI (fallback minimal)"""
+"""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
 
-from fastapi import APIRouter
 from services.mcp_service import mcp_server
+from models.mcp_models import ToolListResponse, ToolInfo, ToolCallRequest, ToolCallResponse
+
+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"
+            }
+        }
+
 
-router = APIRouter(prefix="/mcp", tags=["MCP"])
+# ===== Routes MCP =====
 
-@router.get("/health")
+@router.get("/health", summary="Health Check MCP")
 async def mcp_health():
-    """Health check pour MCP (fallback)"""
-    return {"status": "MCP ready", "tools": [t.name for t in mcp_server.tools]}
+    """Health check pour le serveur MCP"""
+    try:
+        tools = mcp_server.list_tools()
+        tool_names = [tool.name for tool in tools] if tools else []
+        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:
+        tools = mcp_server.list_tools()
+        tool_list = []
+        for tool in tools:
+            tool_info = ToolInfo(
+                name=tool.name,
+                description=tool.description or "",
+                input_schema=tool.inputSchema if hasattr(tool, 'inputSchema') else {}
+            )
+            tool_list.append(tool_info)
+        
+        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 = mcp_server.call_tool(request.tool_name, request.arguments)
+        # Convertir en dict si nécessaire
+        if not isinstance(result, dict):
+            result = {"result": result}
+        return ToolCallResponse(
+            success=True,
+            result=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", summary="Détecter la stance d'un argument")
+async def mcp_detect_stance(request: DetectStanceRequest) -> Dict[str, Any]:
+    """Détecte si un argument est PRO ou CON pour un topic donné"""
+    try:
+        result = mcp_server.call_tool("detect_stance", {
+            "topic": request.topic,
+            "argument": request.argument
+        })
+        # S'assurer que le résultat est un dict
+        if isinstance(result, dict):
+            return result
+        return {"result": result}
+    except Exception as e:
+        logger.error(f"Error in detect_stance: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/tools/match-keypoint", summary="Matcher un argument avec un keypoint")
+async def mcp_match_keypoint(request: MatchKeypointRequest) -> Dict[str, Any]:
+    """Détermine si un argument correspond à un keypoint"""
+    try:
+        result = mcp_server.call_tool("match_keypoint_argument", {
+            "argument": request.argument,
+            "key_point": request.key_point
+        })
+        if isinstance(result, dict):
+            return result
+        return {"result": result}
+    except Exception as e:
+        logger.error(f"Error in match_keypoint_argument: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/tools/transcribe-audio", summary="Transcrire un audio en texte")
+async def mcp_transcribe_audio(request: TranscribeAudioRequest) -> Dict[str, str]:
+    """Convertit un fichier audio en texte"""
+    try:
+        result = mcp_server.call_tool("transcribe_audio", {
+            "audio_path": request.audio_path
+        })
+        # Le résultat est déjà une string
+        if isinstance(result, str):
+            return {"text": result}
+        return {"text": str(result)}
+    except Exception as e:
+        logger.error(f"Error in transcribe_audio: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/tools/generate-speech", summary="Générer de la parole à partir de texte")
+async def mcp_generate_speech(request: GenerateSpeechRequest) -> Dict[str, str]:
+    """Convertit du texte en fichier audio"""
+    try:
+        result = mcp_server.call_tool("generate_speech", {
+            "text": request.text,
+            "voice": request.voice,
+            "format": request.format
+        })
+        # Le résultat est déjà une string (chemin du fichier)
+        if isinstance(result, str):
+            return {"audio_path": result}
+        return {"audio_path": str(result)}
+    except Exception as e:
+        logger.error(f"Error in generate_speech: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/tools/generate-argument", summary="Générer un argument de débat")
+async def mcp_generate_argument(request: GenerateArgumentRequest) -> Dict[str, str]:
+    """Génère un argument de débat à partir d'un input utilisateur"""
+    try:
+        result = mcp_server.call_tool("generate_argument", {
+            "user_input": request.user_input,
+            "conversation_id": request.conversation_id
+        })
+        # Le résultat est déjà une string
+        if isinstance(result, str):
+            return {"argument": result}
+        return {"argument": str(result)}
+    except Exception as e:
+        logger.error(f"Error in generate_argument: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
-# Note : Pas de mount ici – tout est géré par init_mcp_server(app.mount)
+@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 = mcp_server.call_tool("health_check", {})
+        if isinstance(result, dict):
+            return result
+        return {"result": result}
+    except Exception as e:
+        logger.error(f"Error in health_check tool: {e}")
+        raise HTTPException(status_code=500, detail=str(e))