add mcp part

main.py

@@ -175,6 +175,28 @@ except ImportError as e:
 except Exception as e:
     logger.warning(f"⚠ Failed loading Voice Chat route: {e}")
 
+# Dans main.py, après les autres imports
+try:
+    from services.mcp_service import init_mcp_server
+    from routes.mcp_routes import router as mcp_router
+    MCP_ENABLED = True
+except ImportError as e:
+    logger.warning(f"⚠ MCP not available: {e}")
+    MCP_ENABLED = False
+
+# Dans le lifespan manager, après le chargement des modèles
+if MCP_ENABLED:
+    try:
+        init_mcp_server(app)
+        logger.info("✓ MCP Server initialized")
+    except Exception as e:
+        logger.error(f"✗ MCP initialization failed: {e}")
+
+# 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():

mcp/resources.py

@@ -0,0 +1,350 @@
+from typing import List, Dict, Any
+from mcp import Resource
+from datetime import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ModelResource(Resource):
+    """Resource representing a loaded model"""
+    def __init__(self, model_name: str, model_info: Dict[str, Any]):
+        self.model_name = model_name
+        self.model_info = model_info
+        super().__init__(
+            uri=f"model://{model_name}",
+            name=model_name,
+            description=f"{model_name} model information and status",
+            mime_type="application/json"
+        )
+    
+    async def get_content(self) -> str:
+        """Get model information as JSON"""
+        import json
+        return json.dumps({
+            **self.model_info,
+            "timestamp": datetime.now().isoformat(),
+            "uri": self.uri
+        })
+
+class StanceDetectionResource(ModelResource):
+    """Resource for stance detection model"""
+    def __init__(self):
+        from services.stance_model_manager import stance_model_manager
+        
+        model_info = {
+            "type": "stance_detection",
+            "description": "Detects PRO/CON stance for topic-argument pairs",
+            "capabilities": ["single_prediction", "batch_prediction"],
+            "input_format": {"topic": "string", "argument": "string"},
+            "output_format": {
+                "predicted_stance": "PRO/CON",
+                "confidence": "float",
+                "probabilities": {"PRO": "float", "CON": "float"}
+            }
+        }
+        
+        if stance_model_manager and stance_model_manager.model_loaded:
+            model_info.update({
+                "loaded": True,
+                "device": str(stance_model_manager.device),
+                "model_id": getattr(stance_model_manager, 'model_id', 'unknown')
+            })
+        else:
+            model_info["loaded"] = False
+            
+        super().__init__("stance_detection", model_info)
+
+class KPAResource(ModelResource):
+    """Resource for Keypoint-Argument matching model"""
+    def __init__(self):
+        from services.label_model_manager import kpa_model_manager
+        
+        model_info = {
+            "type": "keypoint_argument_matching",
+            "description": "Matches arguments with key points (apparie/non_apparie)",
+            "capabilities": ["single_prediction", "batch_prediction"],
+            "input_format": {"argument": "string", "key_point": "string"},
+            "output_format": {
+                "prediction": "0/1",
+                "label": "apparie/non_apparie",
+                "confidence": "float",
+                "probabilities": {"non_apparie": "float", "apparie": "float"}
+            }
+        }
+        
+        if kpa_model_manager and kpa_model_manager.model_loaded:
+            model_info.update({
+                "loaded": True,
+                "device": str(kpa_model_manager.device),
+                "model_id": getattr(kpa_model_manager, 'model_id', 'unknown'),
+                "max_length": getattr(kpa_model_manager, 'max_length', 256)
+            })
+        else:
+            model_info["loaded"] = False
+            
+        super().__init__("kpa_matching", model_info)
+
+class STTResource(Resource):
+    """Resource for Speech-to-Text capabilities"""
+    def __init__(self):
+        from config import GROQ_API_KEY, GROQ_STT_MODEL
+        
+        super().__init__(
+            uri="service://speech-to-text",
+            name="speech_to_text",
+            description="Speech-to-Text service using Groq Whisper API",
+            mime_type="application/json"
+        )
+        
+        self.config = {
+            "provider": "Groq",
+            "model": GROQ_STT_MODEL,
+            "enabled": bool(GROQ_API_KEY),
+            "language": "English only",
+            "max_audio_size": "10MB",
+            "supported_formats": ["wav", "mp3", "m4a", "mp4"]
+        }
+    
+    async def get_content(self) -> str:
+        """Get STT service information"""
+        import json
+        return json.dumps({
+            **self.config,
+            "timestamp": datetime.now().isoformat(),
+            "uri": self.uri
+        })
+
+class TTSResource(Resource):
+    """Resource for Text-to-Speech capabilities"""
+    def __init__(self):
+        from config import GROQ_API_KEY, GROQ_TTS_MODEL, GROQ_TTS_VOICE
+        
+        super().__init__(
+            uri="service://text-to-speech",
+            name="text_to_speech",
+            description="Text-to-Speech service using Groq PlayAI TTS",
+            mime_type="application/json"
+        )
+        
+        self.config = {
+            "provider": "Groq",
+            "model": GROQ_TTS_MODEL,
+            "voice": GROQ_TTS_VOICE,
+            "enabled": bool(GROQ_API_KEY),
+            "language": "English only",
+            "format": "wav/mp3",
+            "voices_available": ["Aaliyah-PlayAI", "Aria-PlayAI", "Dexter-PlayAI", "Fiona-PlayAI"]
+        }
+    
+    async def get_content(self) -> str:
+        """Get TTS service information"""
+        import json
+        return json.dumps({
+            **self.config,
+            "timestamp": datetime.now().isoformat(),
+            "uri": self.uri
+        })
+
+class ChatbotResource(Resource):
+    """Resource for Chatbot capabilities"""
+    def __init__(self):
+        from config import GROQ_API_KEY, GROQ_CHAT_MODEL
+        
+        super().__init__(
+            uri="service://chatbot",
+            name="chatbot",
+            description="Chatbot service using Groq LLM API",
+            mime_type="application/json"
+        )
+        
+        self.config = {
+            "provider": "Groq",
+            "model": GROQ_CHAT_MODEL,
+            "enabled": bool(GROQ_API_KEY),
+            "language": "English only",
+            "features": ["conversation", "context_awareness", "voice_chat"],
+            "max_context_length": 8192
+        }
+    
+    async def get_content(self) -> str:
+        """Get chatbot service information"""
+        import json
+        return json.dumps({
+            **self.config,
+            "timestamp": datetime.now().isoformat(),
+            "uri": self.uri
+        })
+
+class ArgumentGenerationResource(Resource):
+    """Resource for Argument Generation model (à compléter)"""
+    def __init__(self):
+        super().__init__(
+            uri="model://argument-generation",
+            name="argument_generation",
+            description="Persuasive argument generation model",
+            mime_type="application/json"
+        )
+        
+        self.config = {
+            "type": "argument_generation",
+            "status": "not_implemented",
+            "description": "TODO: Implement your argument generation model",
+            "planned_capabilities": [
+                "single_argument_generation",
+                "batch_generation",
+                "stance_controlled_generation",
+                "counter_argument_generation"
+            ]
+        }
+    
+    async def get_content(self) -> str:
+        """Get argument generation model information"""
+        import json
+        return json.dumps({
+            **self.config,
+            "timestamp": datetime.now().isoformat(),
+            "uri": self.uri,
+            "note": "This is a placeholder. Implement your model in services/argument_generation.py"
+        })
+
+class SystemHealthResource(Resource):
+    """Resource for system health and status"""
+    def __init__(self):
+        super().__init__(
+            uri="system://health",
+            name="system_health",
+            description="System health and service status",
+            mime_type="application/json"
+        )
+    
+    async def get_content(self) -> str:
+        """Get system health information"""
+        import json
+        from datetime import datetime
+        
+        # Collect model status
+        model_status = {}
+        try:
+            from services.stance_model_manager import stance_model_manager
+            model_status["stance_detection"] = {
+                "loaded": stance_model_manager.model_loaded if stance_model_manager else False
+            }
+        except:
+            model_status["stance_detection"] = {"loaded": False}
+        
+        try:
+            from services.label_model_manager import kpa_model_manager
+            model_status["kpa_matching"] = {
+                "loaded": kpa_model_manager.model_loaded if kpa_model_manager else False
+            }
+        except:
+            model_status["kpa_matching"] = {"loaded": False}
+        
+        # Service status
+        from config import GROQ_API_KEY
+        service_status = {
+            "stt": bool(GROQ_API_KEY),
+            "tts": bool(GROQ_API_KEY),
+            "chatbot": bool(GROQ_API_KEY),
+            "argument_generation": False  # À implémenter
+        }
+        
+        return json.dumps({
+            "timestamp": datetime.now().isoformat(),
+            "status": "operational",
+            "models": model_status,
+            "services": service_status,
+            "api_version": "1.0.0",
+            "mcp_version": "1.0.0"
+        })
+
+class APIDocumentationResource(Resource):
+    """Resource for API documentation"""
+    def __init__(self):
+        super().__init__(
+            uri="documentation://api",
+            name="api_documentation",
+            description="API endpoints documentation",
+            mime_type="application/json"
+        )
+        
+        self.documentation = {
+            "endpoints": {
+                "mcp": {
+                    "/mcp/health": "GET - Health check",
+                    "/mcp/resources": "GET - List all resources",
+                    "/mcp/tools": "GET - List all tools",
+                    "/mcp/tools/call": "POST - Call a tool"
+                },
+                "models": {
+                    "/api/v1/kpa/predict": "POST - KPA prediction",
+                    "/api/v1/stance/predict": "POST - Stance prediction",
+                    "/api/v1/stance/batch-predict": "POST - Batch stance prediction"
+                },
+                "voice": {
+                    "/api/v1/stt/": "POST - Speech to text",
+                    "/api/v1/tts/": "POST - Text to speech",
+                    "/voice-chat/voice": "POST - Voice chat",
+                    "/voice-chat/text": "POST - Text chat"
+                }
+            },
+            "authentication": "Currently none (add JWT or API key based auth)",
+            "rate_limits": "None configured",
+            "version": "2.0.0"
+        }
+    
+    async def get_content(self) -> str:
+        """Get API documentation"""
+        import json
+        return json.dumps({
+            **self.documentation,
+            "timestamp": datetime.now().isoformat(),
+            "uri": self.uri
+        })
+
+def get_resources() -> List[Resource]:
+    """Return all available MCP resources"""
+    resources = []
+    
+    try:
+        resources.append(StanceDetectionResource())
+    except Exception as e:
+        logger.warning(f"Failed to create StanceDetectionResource: {e}")
+    
+    try:
+        resources.append(KPAResource())
+    except Exception as e:
+        logger.warning(f"Failed to create KPAResource: {e}")
+    
+    try:
+        resources.append(STTResource())
+    except Exception as e:
+        logger.warning(f"Failed to create STTResource: {e}")
+    
+    try:
+        resources.append(TTSResource())
+    except Exception as e:
+        logger.warning(f"Failed to create TTSResource: {e}")
+    
+    try:
+        resources.append(ChatbotResource())
+    except Exception as e:
+        logger.warning(f"Failed to create ChatbotResource: {e}")
+    
+    try:
+        resources.append(ArgumentGenerationResource())
+    except Exception as e:
+        logger.warning(f"Failed to create ArgumentGenerationResource: {e}")
+    
+    try:
+        resources.append(SystemHealthResource())
+    except Exception as e:
+        logger.warning(f"Failed to create SystemHealthResource: {e}")
+    
+    try:
+        resources.append(APIDocumentationResource())
+    except Exception as e:
+        logger.warning(f"Failed to create APIDocumentationResource: {e}")
+    
+    logger.info(f"Created {len(resources)} MCP resources")
+    return resources

mcp/run_mcp.py

@@ -0,0 +1,4 @@
+from server import run_mcp
+
+if __name__ == "__main__":
+    run_mcp()

mcp/server.py

@@ -0,0 +1,68 @@
+from typing import Any, List, Optional
+import json
+from fastapi import FastAPI, HTTPException
+from mcp import Server, Resource, Tool
+from mcp.types import TextContent, ImageContent
+import logging
+from .resources import get_resources
+
+
+logger = logging.getLogger(__name__)
+
+class MCPServer:
+    def __init__(self, app: FastAPI):
+        self.app = app
+        self.server = Server()
+        self._setup_resources()
+        self._setup_tools()
+    
+    def _setup_resources(self):
+        """Définir les ressources exposées via MCP"""
+        
+        resources = get_resources()
+        for resource in resources:
+            self.server.add_resource(resource)
+    
+    def _setup_tools(self):
+        """Définir les outils exposés via MCP"""
+        from .tools import get_tools
+        
+        tools = get_tools()
+        for tool in tools:
+            self.server.add_tool(tool)
+    
+    async def list_resources(self) -> List[dict]:
+        """Lister toutes les ressources disponibles"""
+        return [
+            {
+                "uri": resource.uri,
+                "name": resource.name,
+                "description": resource.description,
+                "mime_type": resource.mime_type
+            }
+            for resource in self.server.resources.values()
+        ]
+    
+    async def list_tools(self) -> List[dict]:
+        """Lister tous les outils disponibles"""
+        return [
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": tool.input_schema
+            }
+            for tool in self.server.tools.values()
+        ]
+    
+    async def call_tool(self, tool_name: str, arguments: dict) -> Any:
+        """Appeler un outil MCP"""
+        if tool_name not in self.server.tools:
+            raise HTTPException(status_code=404, detail=f"Tool {tool_name} not found")
+        
+        try:
+            tool = self.server.tools[tool_name]
+            result = await tool.execute(arguments)
+            return result
+        except Exception as e:
+            logger.error(f"Tool execution error: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Tool execution failed: {str(e)}")

mcp/tools.py

@@ -0,0 +1,223 @@
+from typing import Dict, Any, List
+from mcp import Tool
+import logging
+from services import (
+    kpa_model_manager,
+    stance_model_manager,
+    chat_service
+)
+
+logger = logging.getLogger(__name__)
+
+async def predict_kpa_tool(arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """Tool for keypoint-argument matching prediction"""
+    try:
+        argument = arguments.get("argument", "")
+        key_point = arguments.get("key_point", "")
+        
+        if not argument or not key_point:
+            return {"error": "Both argument and key_point are required"}
+        
+        result = kpa_model_manager.predict(argument, key_point)
+        return {
+            "prediction": result["prediction"],
+            "label": result["label"],
+            "confidence": result["confidence"],
+            "probabilities": result["probabilities"]
+        }
+    except Exception as e:
+        logger.error(f"KPA tool error: {str(e)}")
+        return {"error": str(e)}
+
+async def predict_stance_tool(arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """Tool for stance detection prediction"""
+    try:
+        topic = arguments.get("topic", "")
+        argument = arguments.get("argument", "")
+        
+        if not topic or not argument:
+            return {"error": "Both topic and argument are required"}
+        
+        result = stance_model_manager.predict(topic, argument)
+        return {
+            "predicted_stance": result["predicted_stance"],
+            "confidence": result["confidence"],
+            "probability_con": result["probability_con"],
+            "probability_pro": result["probability_pro"]
+        }
+    except Exception as e:
+        logger.error(f"Stance tool error: {str(e)}")
+        return {"error": str(e)}
+
+async def batch_stance_tool(arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """Tool for batch stance detection"""
+    try:
+        items = arguments.get("items", [])
+        
+        if not items:
+            return {"error": "Items list is required"}
+        
+        results = []
+        for item in items:
+            result = stance_model_manager.predict(item["topic"], item["argument"])
+            results.append({
+                "topic": item["topic"],
+                "argument": item["argument"],
+                **result
+            })
+        
+        return {
+            "results": results,
+            "total_processed": len(results)
+        }
+    except Exception as e:
+        logger.error(f"Batch stance tool error: {str(e)}")
+        return {"error": str(e)}
+
+async def generate_argument_tool(arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """Tool for argument generation (à compléter avec votre modèle)"""
+    try:
+        prompt = arguments.get("prompt", "")
+        context = arguments.get("context", "")
+        
+        if not prompt:
+            return {"error": "Prompt is required"}
+        
+        # TODO: Intégrer votre modèle d'argument generation ici
+        # Pour l'instant, placeholder
+        from services.chat_service import generate_chat_response
+        
+        response = generate_chat_response(
+            user_input=f"Generate argument for: {prompt}. Context: {context}",
+            system_prompt="You are an argument generation assistant. Generate persuasive arguments based on the given prompt and context."
+        )
+        
+        return {
+            "generated_argument": response,
+            "prompt": prompt,
+            "context": context
+        }
+    except Exception as e:
+        logger.error(f"Argument generation tool error: {str(e)}")
+        return {"error": str(e)}
+
+async def voice_chat_tool(arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """Tool for voice chat interaction"""
+    try:
+        text = arguments.get("text", "")
+        conversation_id = arguments.get("conversation_id", "")
+        
+        if not text:
+            return {"error": "Text input is required"}
+        
+        # Utiliser le service de chat existant
+        from services.chat_service import generate_chat_response
+        
+        response = generate_chat_response(
+            user_input=text,
+            conversation_id=conversation_id if conversation_id else None
+        )
+        
+        # Optionnel: Ajouter TTS si nécessaire
+        tts_required = arguments.get("tts", False)
+        audio_url = None
+        
+        if tts_required:
+            from services.tts_service import text_to_speech
+            # TODO: Gérer le stockage et l'URL de l'audio
+            
+        return {
+            "response": response,
+            "conversation_id": conversation_id,
+            "has_audio": tts_required,
+            "audio_url": audio_url
+        }
+    except Exception as e:
+        logger.error(f"Voice chat tool error: {str(e)}")
+        return {"error": str(e)}
+
+def get_tools() -> List[Tool]:
+    """Retourne tous les outils disponibles"""
+    return [
+        Tool(
+            name="predict_kpa",
+            description="Predict keypoint-argument matching for a single pair",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "argument": {"type": "string", "description": "The argument text"},
+                    "key_point": {"type": "string", "description": "The key point to evaluate"}
+                },
+                "required": ["argument", "key_point"]
+            },
+            execute=predict_kpa_tool
+        ),
+        Tool(
+            name="predict_stance",
+            description="Predict stance for a topic-argument pair",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "topic": {"type": "string", "description": "The debate topic"},
+                    "argument": {"type": "string", "description": "The argument to classify"}
+                },
+                "required": ["topic", "argument"]
+            },
+            execute=predict_stance_tool
+        ),
+        Tool(
+            name="batch_predict_stance",
+            description="Predict stance for multiple topic-argument pairs",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "items": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "topic": {"type": "string"},
+                                "argument": {"type": "string"}
+                            },
+                            "required": ["topic", "argument"]
+                        },
+                        "description": "List of topic-argument pairs"
+                    }
+                },
+                "required": ["items"]
+            },
+            execute=batch_stance_tool
+        ),
+        Tool(
+            name="generate_argument",
+            description="Generate persuasive arguments based on prompt and context",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "prompt": {"type": "string", "description": "Main topic or question"},
+                    "context": {"type": "string", "description": "Additional context"},
+                    "stance": {
+                        "type": "string", 
+                        "enum": ["pro", "con", "neutral"],
+                        "description": "Desired stance"
+                    }
+                },
+                "required": ["prompt"]
+            },
+            execute=generate_argument_tool
+        ),
+        Tool(
+            name="voice_chat",
+            description="Chat with voice assistant capabilities",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Text input"},
+                    "conversation_id": {"type": "string", "description": "Conversation ID for context"},
+                    "tts": {"type": "boolean", "description": "Generate audio response"}
+                },
+                "required": ["text"]
+            },
+            execute=voice_chat_tool
+        )
+    ]

mcp/types.py

@@ -0,0 +1,353 @@
+"""
+Type definitions for MCP (Model Context Protocol)
+"""
+from typing import Dict, Any, List, Optional, Union, TypedDict
+from enum import Enum
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+# ==================== ENUMS ====================
+
+class ModelType(str, Enum):
+    """Types of models available"""
+    STANCE_DETECTION = "stance_detection"
+    KPA_MATCHING = "kpa_matching"
+    ARGUMENT_GENERATION = "argument_generation"
+    CHATBOT = "chatbot"
+
+class StanceType(str, Enum):
+    """Stance types"""
+    PRO = "PRO"
+    CON = "CON"
+    NEUTRAL = "NEUTRAL"
+
+class KpaLabel(str, Enum):
+    """KPA matching labels"""
+    APPARIE = "apparie"
+    NON_APPARIE = "non_apparie"
+
+class ServiceStatus(str, Enum):
+    """Service status"""
+    OPERATIONAL = "operational"
+    DEGRADED = "degraded"
+    MAINTENANCE = "maintenance"
+    OFFLINE = "offline"
+
+class ToolCategory(str, Enum):
+    """Tool categories"""
+    PREDICTION = "prediction"
+    GENERATION = "generation"
+    TRANSFORMATION = "transformation"
+    ANALYSIS = "analysis"
+    UTILITY = "utility"
+
+# ==================== CORE TYPES ====================
+
+class ResourceMetadata(TypedDict):
+    """Metadata for a resource"""
+    uri: str
+    name: str
+    description: Optional[str]
+    mime_type: str
+    created_at: datetime
+    updated_at: datetime
+    tags: List[str]
+
+class ToolMetadata(TypedDict):
+    """Metadata for a tool"""
+    name: str
+    description: str
+    version: str
+    category: ToolCategory
+    input_schema: Dict[str, Any]
+    output_schema: Dict[str, Any]
+    rate_limit: Optional[int]
+    requires_auth: bool
+
+class ModelMetadata(TypedDict):
+    """Metadata for a model"""
+    model_id: str
+    model_type: ModelType
+    provider: str
+    version: str
+    description: str
+    capabilities: List[str]
+    parameters: Dict[str, Any]
+    hardware_requirements: Dict[str, Any]
+
+# ==================== PREDICTION TYPES ====================
+
+class PredictionInput(BaseModel):
+    """Base class for prediction inputs"""
+    model_id: Optional[str] = Field(None, description="Specific model to use")
+
+class StancePredictionInput(PredictionInput):
+    """Input for stance prediction"""
+    topic: str = Field(..., min_length=5, max_length=500, description="Debate topic")
+    argument: str = Field(..., min_length=5, max_length=1000, description="Argument text")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "topic": "Climate change is the most pressing issue of our time",
+                "argument": "Renewable energy investments have created millions of jobs worldwide"
+            }
+        }
+
+class KPAPredictionInput(PredictionInput):
+    """Input for KPA prediction"""
+    argument: str = Field(..., description="Argument text")
+    key_point: str = Field(..., description="Key point to match")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "argument": "Renewable energy is cost-effective in the long term",
+                "key_point": "Economic benefits of green energy"
+            }
+        }
+
+class BatchPredictionInput(BaseModel):
+    """Input for batch predictions"""
+    items: List[Union[StancePredictionInput, KPAPredictionInput]]
+    batch_size: Optional[int] = Field(10, ge=1, le=100)
+    parallel: bool = Field(False, description="Process in parallel")
+
+# ==================== GENERATION TYPES ====================
+
+class ArgumentGenerationInput(BaseModel):
+    """Input for argument generation"""
+    prompt: str = Field(..., description="Main topic or question")
+    context: Optional[str] = Field(None, description="Additional context")
+    stance: Optional[StanceType] = Field(StanceType.NEUTRAL, description="Desired stance")
+    length: Optional[str] = Field("medium", description="Argument length: short/medium/long")
+    style: Optional[str] = Field("persuasive", description="Writing style")
+    num_arguments: Optional[int] = Field(1, ge=1, le=5, description="Number of arguments to generate")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "prompt": "Should artificial intelligence be regulated?",
+                "stance": "PRO",
+                "context": "Focus on ethical considerations",
+                "length": "medium"
+            }
+        }
+
+class CounterArgumentInput(BaseModel):
+    """Input for counter-argument generation"""
+    original_argument: str = Field(..., description="Original argument to counter")
+    target_stance: StanceType = Field(..., description="Stance for counter-argument")
+    context: Optional[str] = Field(None, description="Additional context")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "original_argument": "AI regulation stifles innovation",
+                "target_stance": "CON",
+                "context": "Focus on safety and ethics"
+            }
+        }
+
+# ==================== VOICE TYPES ====================
+
+class AudioFormat(str, Enum):
+    """Supported audio formats"""
+    WAV = "wav"
+    MP3 = "mp3"
+    M4A = "m4a"
+    OGG = "ogg"
+
+class VoiceProfile(str, Enum):
+    """Available voice profiles"""
+    ALIYAH = "Aaliyah-PlayAI"
+    ARIA = "Aria-PlayAI"
+    DEXTER = "Dexter-PlayAI"
+    FIONA = "Fiona-PlayAI"
+
+class STTInput(BaseModel):
+    """Input for speech-to-text"""
+    audio_format: AudioFormat = Field(AudioFormat.WAV, description="Audio format")
+    language: str = Field("en", description="Language code (en, fr, etc.)")
+    enable_timestamps: bool = Field(False, description="Include word timestamps")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "audio_format": "wav",
+                "language": "en",
+                "enable_timestamps": False
+            }
+        }
+
+class TTSInput(BaseModel):
+    """Input for text-to-speech"""
+    text: str = Field(..., description="Text to convert to speech")
+    voice: VoiceProfile = Field(VoiceProfile.ALIYAH, description="Voice to use")
+    format: AudioFormat = Field(AudioFormat.WAV, description="Output format")
+    speed: float = Field(1.0, ge=0.5, le=2.0, description="Speech speed")
+    pitch: float = Field(1.0, ge=0.5, le=2.0, description="Voice pitch")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "text": "Hello, this is a test of text-to-speech.",
+                "voice": "Aaliyah-PlayAI",
+                "format": "wav",
+                "speed": 1.0,
+                "pitch": 1.0
+            }
+        }
+
+# ==================== RESPONSE TYPES ====================
+
+class PredictionResult(BaseModel):
+    """Base prediction result"""
+    prediction: Union[int, str]
+    confidence: float = Field(..., ge=0.0, le=1.0)
+    processing_time: Optional[float] = Field(None, description="Processing time in seconds")
+
+class StancePredictionResult(PredictionResult):
+    """Stance prediction result"""
+    predicted_stance: StanceType
+    probability_pro: float = Field(..., ge=0.0, le=1.0)
+    probability_con: float = Field(..., ge=0.0, le=1.0)
+    topic: str
+    argument: str
+
+class KPAPredictionResult(PredictionResult):
+    """KPA prediction result"""
+    label: KpaLabel
+    probabilities: Dict[KpaLabel, float]
+    argument: str
+    key_point: str
+
+class GenerationResult(BaseModel):
+    """Base generation result"""
+    generated_text: str
+    prompt: str
+    context: Optional[str]
+    parameters: Dict[str, Any]
+    generation_time: Optional[float]
+
+class ArgumentGenerationResult(GenerationResult):
+    """Argument generation result"""
+    stance: StanceType
+    length: str
+    style: str
+    coherence_score: Optional[float] = Field(None, ge=0.0, le=1.0)
+
+class BatchResult(BaseModel):
+    """Batch processing result"""
+    results: List[Union[StancePredictionResult, KPAPredictionResult, ArgumentGenerationResult]]
+    total_processed: int
+    successful: int
+    failed: int
+    average_confidence: Optional[float]
+    total_time: float
+
+class ErrorResponse(BaseModel):
+    """Error response"""
+    error: str
+    code: Optional[str]
+    details: Optional[Dict[str, Any]]
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+class HealthResponse(BaseModel):
+    """Health check response"""
+    status: ServiceStatus
+    version: str
+    uptime: float
+    models: Dict[str, bool]
+    services: Dict[str, bool]
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+# ==================== TOOL EXECUTION TYPES ====================
+
+class ToolExecutionContext(BaseModel):
+    """Context for tool execution"""
+    tool_id: str
+    user_id: Optional[str]
+    session_id: Optional[str]
+    timestamp: datetime = Field(default_factory=datetime.now)
+    metadata: Optional[Dict[str, Any]]
+
+class ToolExecutionResult(BaseModel):
+    """Result of tool execution"""
+    success: bool
+    output: Optional[Dict[str, Any]]
+    error: Optional[str]
+    execution_time: float
+    context: ToolExecutionContext
+
+# ==================== CONVERSATION TYPES ====================
+
+class MessageRole(str, Enum):
+    """Roles in conversation"""
+    USER = "user"
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+
+class ConversationMessage(BaseModel):
+    """Single message in conversation"""
+    role: MessageRole
+    content: str
+    timestamp: datetime = Field(default_factory=datetime.now)
+    metadata: Optional[Dict[str, Any]]
+
+class ConversationState(BaseModel):
+    """Conversation state"""
+    conversation_id: str
+    messages: List[ConversationMessage]
+    created_at: datetime
+    updated_at: datetime = Field(default_factory=datetime.now)
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+# ==================== EXPORT ====================
+
+__all__ = [
+    # Enums
+    "ModelType",
+    "StanceType", 
+    "KpaLabel",
+    "ServiceStatus",
+    "ToolCategory",
+    "AudioFormat",
+    "VoiceProfile",
+    "MessageRole",
+    
+    # Input Types
+    "PredictionInput",
+    "StancePredictionInput", 
+    "KPAPredictionInput",
+    "BatchPredictionInput",
+    "ArgumentGenerationInput",
+    "CounterArgumentInput",
+    "STTInput",
+    "TTSInput",
+    
+    # Result Types
+    "PredictionResult",
+    "StancePredictionResult",
+    "KPAPredictionResult", 
+    "GenerationResult",
+    "ArgumentGenerationResult",
+    "BatchResult",
+    
+    # Response Types
+    "ErrorResponse",
+    "HealthResponse",
+    
+    # Tool Types
+    "ToolExecutionContext",
+    "ToolExecutionResult",
+    
+    # Conversation Types
+    "ConversationMessage",
+    "ConversationState",
+    
+    # TypedDicts (for compatibility)
+    "ResourceMetadata",
+    "ToolMetadata", 
+    "ModelMetadata"
+]

models/mcp_models.py

@@ -0,0 +1,37 @@
+from pydantic import BaseModel
+from typing import Any, Dict, List, Optional
+
+class ToolCallRequest(BaseModel):
+    """Request for calling an MCP tool"""
+    tool_name: str
+    arguments: Dict[str, Any] = {}
+
+class ToolCallResponse(BaseModel):
+    """Response from MCP tool call"""
+    success: bool
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    tool_name: str
+
+class ResourceInfo(BaseModel):
+    """Information about an MCP resource"""
+    uri: str
+    name: str
+    description: Optional[str] = None
+    mime_type: str
+
+class ToolInfo(BaseModel):
+    """Information about an MCP tool"""
+    name: str
+    description: str
+    input_schema: Dict[str, Any]
+
+class ResourceListResponse(BaseModel):
+    """Response for listing resources"""
+    resources: List[ResourceInfo]
+    count: int
+
+class ToolListResponse(BaseModel):
+    """Response for listing tools"""
+    tools: List[ToolInfo]
+    count: int

requirements.txt

@@ -1,20 +1,23 @@
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-python-multipart==0.0.6
-python-dotenv==1.0.0
-pydantic==2.5.0
+fastapi>=0.115.0
+uvicorn[standard]>=0.29.0
+python-multipart>=0.0.6
+python-dotenv>=1.0.0
+pydantic>=2.5.0
 
 # API Clients
-requests==2.31.0
-groq==0.9.0
+requests>=2.31.0
+groq>=0.9.0
 
 # Audio processing (optionnel si vous avez besoin de traitement local)
-soundfile==0.12.1
+soundfile>=0.12.1
 
 # Hugging Face
-transformers==4.35.0
-torch==2.0.1+cpu
---extra-index-url https://download.pytorch.org/whl/cpu
+transformers>=4.35.0
+torch>=2.0.1
 
 # Autres dépendances
-numpy==1.26.4
+numpy>=1.26.4
+
+mcp>=1.0.0
+# Note: fastapi-mcp peut ne pas exister officiellement, 
+# vous devrez probablement créer votre propre intégration

routes/mcp_routes.py

@@ -0,0 +1,104 @@
+from fastapi import APIRouter, HTTPException, Depends
+from typing import List, Dict, Any
+import logging
+from models.mcp_models import (
+    ToolCallRequest,
+    ToolCallResponse,
+    ResourceListResponse,
+    ToolListResponse
+)
+from services.mcp_service import get_mcp_server
+
+router = APIRouter(prefix="/mcp", tags=["MCP"])
+logger = logging.getLogger(__name__)
+
+@router.get("/health")
+async def mcp_health():
+    """Health check for MCP server"""
+    return {
+        "status": "healthy",
+        "service": "Model Context Protocol",
+        "version": "1.0.0"
+    }
+
+@router.get("/resources", response_model=ResourceListResponse)
+async def list_resources():
+    """List all MCP resources"""
+    try:
+        server = get_mcp_server()
+        resources = await server.list_resources()
+        return ResourceListResponse(
+            resources=resources,
+            count=len(resources)
+        )
+    except Exception as e:
+        logger.error(f"Error listing resources: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/tools", response_model=ToolListResponse)
+async def list_tools():
+    """List all MCP tools"""
+    try:
+        server = get_mcp_server()
+        tools = await server.list_tools()
+        return ToolListResponse(
+            tools=tools,
+            count=len(tools)
+        )
+    except Exception as e:
+        logger.error(f"Error listing tools: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/tools/call", response_model=ToolCallResponse)
+async def call_tool(request: ToolCallRequest):
+    """Call an MCP tool"""
+    try:
+        server = get_mcp_server()
+        result = await server.call_tool(
+            tool_name=request.tool_name,
+            arguments=request.arguments
+        )
+        
+        return ToolCallResponse(
+            success=True,
+            result=result,
+            tool_name=request.tool_name
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error calling tool {request.tool_name}: {str(e)}")
+        return ToolCallResponse(
+            success=False,
+            error=str(e),
+            tool_name=request.tool_name
+        )
+
+@router.post("/tools/batch")
+async def batch_call_tools(requests: List[ToolCallRequest]):
+    """Call multiple MCP tools"""
+    results = []
+    for request in requests:
+        try:
+            server = get_mcp_server()
+            result = await server.call_tool(
+                tool_name=request.tool_name,
+                arguments=request.arguments
+            )
+            results.append({
+                "tool_name": request.tool_name,
+                "success": True,
+                "result": result
+            })
+        except Exception as e:
+            results.append({
+                "tool_name": request.tool_name,
+                "success": False,
+                "error": str(e)
+            })
+    
+    return {
+        "results": results,
+        "total": len(results),
+        "successful": sum(1 for r in results if r["success"])
+    }

services/mcp_service.py

@@ -0,0 +1,24 @@
+from mcp.server import MCPServer
+from fastapi import FastAPI
+import logging
+
+logger = logging.getLogger(__name__)
+
+_mcp_server = None
+
+def init_mcp_server(app: FastAPI):
+    """Initialize MCP server"""
+    global _mcp_server
+    try:
+        _mcp_server = MCPServer(app)
+        logger.info("✓ MCP Server initialized successfully")
+        return _mcp_server
+    except Exception as e:
+        logger.error(f"✗ Failed to initialize MCP server: {str(e)}")
+        raise
+
+def get_mcp_server() -> MCPServer:
+    """Get MCP server instance"""
+    if _mcp_server is None:
+        raise RuntimeError("MCP server not initialized")
+    return _mcp_server