delete mcp part

mcp/n8n_routes.py

@@ -1,422 +0,0 @@
-"""
-Routes FastAPI pour intégration n8n avec MCP
-À ajouter dans votre app.py principal
-"""
-from fastapi import APIRouter, HTTPException, BackgroundTasks, UploadFile, File
-from pydantic import BaseModel
-from typing import Dict, Any, Optional, List
-import logging
-from datetime import datetime
-
-logger = logging.getLogger(__name__)
-
-# Router pour n8n
-n8n_router = APIRouter(prefix="/n8n", tags=["n8n"])
-
-# ==================== MODELS ====================
-
-class N8NToolRequest(BaseModel):
-    """Request model pour appels n8n"""
-    tool_name: str
-    arguments: Dict[str, Any]
-    context: Optional[Dict[str, Any]] = None
-    async_callback: Optional[str] = None  # URL pour callback asynchrone
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "tool_name": "predict_stance",
-                "arguments": {
-                    "topic": "climate change",
-                    "argument": "We need renewable energy"
-                },
-                "context": {
-                    "session_id": "session_123",
-                    "user_id": "user_456"
-                }
-            }
-        }
-
-class N8NBatchRequest(BaseModel):
-    """Request pour traitement batch"""
-    tool_name: str
-    items: List[Dict[str, Any]]
-    batch_size: int = 10
-    parallel: bool = False
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "tool_name": "predict_stance",
-                "items": [
-                    {"topic": "AI", "argument": "AI will help humanity"},
-                    {"topic": "AI", "argument": "AI is dangerous"}
-                ],
-                "batch_size": 10
-            }
-        }
-
-class N8NPipelineRequest(BaseModel):
-    """Request pour pipeline complexe"""
-    pipeline_name: str
-    input_data: Dict[str, Any]
-    steps: List[Dict[str, Any]]
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "pipeline_name": "debate_analysis",
-                "input_data": {
-                    "topic": "climate change",
-                    "text": "We must act now"
-                },
-                "steps": [
-                    {"tool": "predict_stance", "output_key": "stance"},
-                    {"tool": "predict_kpa", "use_previous": True}
-                ]
-            }
-        }
-
-class N8NResponse(BaseModel):
-    """Response standardisée pour n8n"""
-    success: bool
-    data: Optional[Dict[str, Any]] = None
-    error: Optional[str] = None
-    execution_time: float
-    timestamp: datetime = datetime.now()
-
-# ==================== ENDPOINTS ====================
-
-@n8n_router.post("/execute", response_model=N8NResponse)
-async def execute_tool(request: N8NToolRequest):
-    """
-    Endpoint principal pour exécuter un outil MCP depuis n8n
-    """
-    import time
-    start_time = time.time()
-    
-    try:
-        from mcp.server import MCPServer
-        from mcp import server  # Importer votre instance MCP
-        
-        # Exécuter l'outil
-        result = await server.call_tool(
-            tool_name=request.tool_name,
-            arguments=request.arguments
-        )
-        
-        # Ajouter le contexte si fourni
-        if request.context:
-            result["context"] = request.context
-        
-        execution_time = time.time() - start_time
-        
-        return N8NResponse(
-            success=True,
-            data=result,
-            execution_time=execution_time
-        )
-        
-    except Exception as e:
-        logger.error(f"Tool execution failed: {str(e)}")
-        execution_time = time.time() - start_time
-        
-        return N8NResponse(
-            success=False,
-            error=str(e),
-            execution_time=execution_time
-        )
-
-@n8n_router.post("/batch", response_model=N8NResponse)
-async def batch_execute(request: N8NBatchRequest):
-    """
-    Endpoint pour traitement batch depuis n8n
-    """
-    import time
-    import asyncio
-    start_time = time.time()
-    
-    try:
-        from mcp import server
-        
-        results = []
-        
-        # Traitement séquentiel ou parallèle
-        if request.parallel:
-            # Traitement parallèle
-            tasks = []
-            for item in request.items:
-                task = server.call_tool(
-                    tool_name=request.tool_name,
-                    arguments=item
-                )
-                tasks.append(task)
-            
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-        else:
-            # Traitement séquentiel par batch
-            for i in range(0, len(request.items), request.batch_size):
-                batch = request.items[i:i + request.batch_size]
-                
-                for item in batch:
-                    try:
-                        result = await server.call_tool(
-                            tool_name=request.tool_name,
-                            arguments=item
-                        )
-                        results.append(result)
-                    except Exception as e:
-                        results.append({"error": str(e), "item": item})
-        
-        execution_time = time.time() - start_time
-        
-        return N8NResponse(
-            success=True,
-            data={
-                "results": results,
-                "total": len(results),
-                "successful": sum(1 for r in results if not isinstance(r, Exception) and "error" not in r),
-                "failed": sum(1 for r in results if isinstance(r, Exception) or "error" in r)
-            },
-            execution_time=execution_time
-        )
-        
-    except Exception as e:
-        logger.error(f"Batch execution failed: {str(e)}")
-        execution_time = time.time() - start_time
-        
-        return N8NResponse(
-            success=False,
-            error=str(e),
-            execution_time=execution_time
-        )
-
-@n8n_router.post("/pipeline", response_model=N8NResponse)
-async def execute_pipeline(request: N8NPipelineRequest):
-    """
-    Endpoint pour exécuter un pipeline multi-étapes
-    """
-    import time
-    start_time = time.time()
-    
-    try:
-        from mcp import server
-        
-        pipeline_context = {"input": request.input_data}
-        results = {}
-        
-        for step in request.steps:
-            tool_name = step["tool"]
-            output_key = step.get("output_key", tool_name)
-            use_previous = step.get("use_previous", False)
-            
-            # Préparer les arguments
-            if use_previous:
-                # Utiliser le résultat de l'étape précédente
-                arguments = {**request.input_data, **results}
-            else:
-                arguments = step.get("arguments", request.input_data)
-            
-            # Exécuter l'étape
-            result = await server.call_tool(
-                tool_name=tool_name,
-                arguments=arguments
-            )
-            
-            results[output_key] = result
-            pipeline_context[output_key] = result
-        
-        execution_time = time.time() - start_time
-        
-        return N8NResponse(
-            success=True,
-            data={
-                "pipeline": request.pipeline_name,
-                "results": results,
-                "context": pipeline_context
-            },
-            execution_time=execution_time
-        )
-        
-    except Exception as e:
-        logger.error(f"Pipeline execution failed: {str(e)}")
-        execution_time = time.time() - start_time
-        
-        return N8NResponse(
-            success=False,
-            error=str(e),
-            execution_time=execution_time
-        )
-
-@n8n_router.post("/voice-pipeline")
-async def voice_debate_pipeline(
-    audio: UploadFile = File(...),
-    topic: str = None,
-    session_id: str = None
-):
-    """
-    Pipeline complet : Audio → STT → Stance → KPA → Argument Generation → TTS
-    Optimisé pour n8n
-    """
-    import time
-    import tempfile
-    import os
-    start_time = time.time()
-    
-    try:
-        from mcp import server
-        from services.stt_service import transcribe_audio
-        from services.tts_service import text_to_speech
-        
-        # 1. Sauvegarder l'audio temporairement
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
-            content = await audio.read()
-            tmp.write(content)
-            tmp_path = tmp.name
-        
-        try:
-            # 2. Speech-to-Text
-            transcription = await transcribe_audio(tmp_path)
-            user_text = transcription.get("text", "")
-            
-            # 3. Stance Detection
-            stance_result = await server.call_tool(
-                "predict_stance",
-                {"topic": topic, "argument": user_text}
-            )
-            
-            # 4. KPA Matching (optionnel)
-            # kpa_result = await mcp_server.call_tool(...)
-            
-            # 5. Generate Counter-Argument
-            opposite_stance = "CON" if stance_result["predicted_stance"] == "PRO" else "PRO"
-            counter_arg_result = await server.call_tool(
-                "generate_argument",
-                {
-                    "prompt": f"Generate a {opposite_stance} argument about {topic}",
-                    "context": f"User said: {user_text}",
-                    "stance": opposite_stance
-                }
-            )
-            
-            # 6. Text-to-Speech du contre-argument
-            tts_audio_path = await text_to_speech(
-                counter_arg_result["generated_argument"]
-            )
-            
-            execution_time = time.time() - start_time
-            
-            return N8NResponse(
-                success=True,
-                data={
-                    "transcription": user_text,
-                    "stance_analysis": stance_result,
-                    "counter_argument": counter_arg_result,
-                    "audio_response_path": tts_audio_path,
-                    "session_id": session_id
-                },
-                execution_time=execution_time
-            )
-            
-        finally:
-            # Nettoyer le fichier temporaire
-            if os.path.exists(tmp_path):
-                os.remove(tmp_path)
-        
-    except Exception as e:
-        logger.error(f"Voice pipeline failed: {str(e)}")
-        return N8NResponse(
-            success=False,
-            error=str(e),
-            execution_time=time.time() - start_time
-        )
-
-@n8n_router.get("/tools")
-async def list_tools():
-    """
-    Liste tous les outils disponibles (format n8n-friendly)
-    """
-    try:
-        from mcp import server
-        tools = await server.list_tools()
-        
-        return {
-            "success": True,
-            "tools": tools,
-            "total": len(tools)
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@n8n_router.get("/resources")
-async def list_resources():
-    """
-    Liste toutes les ressources disponibles (format n8n-friendly)
-    """
-    try:
-        from mcp import server
-        resources = await server.list_resources()
-        
-        return {
-            "success": True,
-            "resources": resources,
-            "total": len(resources)
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-@n8n_router.get("/health")
-async def health_check():
-    """
-    Health check pour n8n monitoring
-    """
-    from services.stance_model_manager import stance_model_manager
-    from services.label_model_manager import kpa_model_manager
-    
-    return {
-        "status": "healthy",
-        "timestamp": datetime.now().isoformat(),
-        "models": {
-            "stance": stance_model_manager.model_loaded if stance_model_manager else False,
-            "kpa": kpa_model_manager.model_loaded if kpa_model_manager else False
-        },
-        "services": {
-            "stt": True,  # Vérifier si GROQ_API_KEY existe
-            "tts": True,
-            "chat": True
-        }
-    }
-
-# ==================== WEBHOOKS ====================
-
-@n8n_router.post("/webhook/debate-result")
-async def webhook_debate_result(data: Dict[str, Any], background_tasks: BackgroundTasks):
-    """
-    Webhook pour recevoir les résultats de débat depuis n8n
-    Peut être utilisé pour stocker, notifier, etc.
-    """
-    logger.info(f"Received debate result webhook: {data}")
-    
-    # Traiter en arrière-plan
-    background_tasks.add_task(process_debate_result, data)
-    
-    return {"status": "received", "message": "Processing in background"}
-
-async def process_debate_result(data: Dict[str, Any]):
-    """
-    Traiter les résultats de débat en arrière-plan
-    """
-    # TODO: Implémenter votre logique
-    # - Sauvegarder dans DB
-    # - Envoyer des notifications
-    # - Mettre à jour des métriques
-    logger.info(f"Processing debate result: {data}")
-
-# ==================== EXPORT ====================
-
-def register_n8n_routes(app):
-    """
-    Enregistrer les routes n8n dans l'application FastAPI
-    """
-    app.include_router(n8n_router)
-    logger.info("n8n routes registered successfully")

mcp/resources.py

@@ -1,350 +0,0 @@
-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

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

mcp/server.py

@@ -1,68 +0,0 @@
-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

@@ -1,223 +0,0 @@
-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

@@ -1,353 +0,0 @@
-"""
-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"
-]