update mcp part

main.py

@@ -56,16 +56,18 @@ def cleanup_on_exit():
             logger.warning("Échec du nettoyage final")
 
 # --- Import des singletons de services ---
+stance_model_manager = None
+kpa_model_manager = None
 try:
     from services.stance_model_manager import stance_model_manager
-    from services.label_model_manager import kpa_model_manager  # Corrigé: kpa_model_manager, pas label_model_manager
+    from services.label_model_manager import kpa_model_manager  # Corrigé : import depuis kpa_model_manager.py
     logger.info("✓ Gestionnaires de modèles importés")
 except ImportError as e:
     logger.warning(f"⚠ Impossible d'importer les gestionnaires de modèles: {e}")
-    stance_model_manager = None
-    kpa_model_manager = None
 
 # --- Vérification MCP ---
+MCP_ENABLED = False
+mcp_router = None
 try:
     from services.mcp_service import init_mcp_server
     from routes.mcp_routes import router as mcp_router
@@ -73,7 +75,6 @@ try:
     logger.info("✓ Modules MCP détectés")
 except ImportError as e:
     logger.warning(f"⚠ MCP non disponible: {e}")
-    MCP_ENABLED = False
 
 # --- Lifespan / startup API ---
 @asynccontextmanager
@@ -185,20 +186,32 @@ except ImportError as e:
 except Exception as e:
     logger.warning(f"⚠ Échec chargement route Voice Chat: {e}")
 
-# Main API Routes (KPA, Stance, etc.)
+# Main API Routes (KPA, Stance, etc.) - Assumant un api_router qui inclut kpa et stance
+api_router = None
 try:
-    from routes import api_router
-    app.include_router(api_router)
+    from routes import api_router  # Ou from routes.api_router import router as api_router si c'est un fichier dédié
+    app.include_router(api_router, prefix="/api/v1")
     logger.info("✓ Routes API principales chargées")
 except ImportError as e:
     logger.warning(f"⚠ Routes API principales non trouvées: {e}")
+    # Fallback : Inclure directement les sub-routers si api_router n'existe pas
+    try:
+        from routes.label import router as kpa_router
+        app.include_router(kpa_router, prefix="/api/v1/kpa", tags=["KPA"])
+        from routes.stance import router as stance_router  # Assumant le nom du fichier
+        app.include_router(stance_router, prefix="/api/v1/stance", tags=["Stance Detection"])
+        logger.info("✓ Routes KPA et Stance chargées en fallback")
+    except ImportError:
+        logger.warning("⚠ Fallback pour KPA/Stance échoué - vérifiez vos fichiers routes/")
 except Exception as e:
     logger.warning(f"⚠ Échec chargement routes API principales: {e}")
 
 # MCP Routes
-if MCP_ENABLED:
-    app.include_router(mcp_router, prefix="/api/v1", tags=["MCP"])
+if MCP_ENABLED and mcp_router:
+    app.include_router(mcp_router, prefix="/api/v1/mcp", tags=["MCP"])
     logger.info("✓ Routes MCP chargées")
+else:
+    logger.warning("⚠ Routes MCP non chargées (MCP désactivé ou router manquant)")
 
 # --- Basic routes ---
 @app.get("/health", tags=["Health"])

mcp/n8n_routes.py

@@ -0,0 +1,422 @@
+"""
+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")

routes/mcp_routes.py

@@ -1,104 +1,19 @@
-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
+"""Routes pour exposer MCP via FastAPI"""
+
+from fastapi import APIRouter
+from starlette.routing import Mount
+from services.mcp_service import mcp_server  # Importe l'instance
 
 router = APIRouter(prefix="/mcp", tags=["MCP"])
-logger = logging.getLogger(__name__)
 
+# Monter l'app FastMCP entière comme sub-app (gère /tools, /call, etc. automatiquement)
+from starlette.applications import Starlette
+mcp_starlette = Starlette(routes=[Mount("/", app=mcp_server.streamable_http_app())])
+
+# Inclure le Starlette comme route FastAPI (via sub-app mounting)
 @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
-        )
+    return {"status": "MCP ready", "tools": [t.name for t in mcp_server.tools]}
 
-@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"])
-    }
+# Le mounting principal se fait dans main.py via app.include_router
+# Mais pour compat, on peut exposer directement

services/mcp_service.py

@@ -1,24 +1,143 @@
-from mcp.server import MCPServer
-from fastapi import FastAPI
+"""Service pour initialiser le serveur MCP avec FastMCP"""
+
+from mcp.server.fastmcp import FastMCP
+from typing import Dict, Any
 import logging
 
+from fastapi import FastAPI  # Ajouté pour résoudre l'erreur Pylance "FastAPI is not defined"
+
+from services.stance_model_manager import stance_model_manager
+from services.label_model_manager import kpa_model_manager  # Corrigé : import depuis kpa_model_manager (cohérent avec main.py)
+from services.stt_service import speech_to_text
+from services.tts_service import text_to_speech
+from services.chat_service import generate_chat_response
+# Note : Adapte les imports models si tes schémas sont dans un fichier unique (ex. models/schemas.py)
+# from models.stance import StanceRequest, StanceResponse  # Si séparé
+# from models.kpa import PredictionRequest, PredictionResponse  # Si séparé
+# Ou si un seul fichier models.py :
+# from models import StanceRequest, StanceResponse, PredictionRequest, PredictionResponse
+
 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
+# Créer l'instance FastMCP (nom du serveur, JSON pour responses structurées)
+mcp_server = FastMCP("NLP-Debater-MCP", json_response=True, stateless_http=False)  # Stateful pour sessions voice chat
+
+# Tool pour Stance Detection
+@mcp_server.tool()
+def detect_stance(topic: str, argument: str) -> Dict[str, Any]:
+    """
+    Détecte la stance (PRO/CON) d'un argument par rapport à un topic.
+    
+    Args:
+        topic: Le sujet de débat (ex. "Assisted suicide should be a criminal offence")
+        argument: L'argument à classifier (ex. "People have the right to choose...")
+    
+    Returns:
+        Dict avec predicted_stance, confidence, probabilities.
+    """
+    if not stance_model_manager.model_loaded:
+        raise ValueError("Modèle stance non chargé")
+    
+    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"]
+    }
+
+# Tool pour Key-Point Argument Matching (KPA)
+@mcp_server.tool()
+def match_keypoint_argument(argument: str, key_point: str) -> Dict[str, Any]:
+    """
+    Prédit si un argument matche un key-point (apparie/non_apparie).
+    
+    Args:
+        argument: Texte de l'argument
+        key_point: Le key-point de référence
+    
+    Returns:
+        Dict avec prediction (0/1), label, confidence, probabilities.
+    """
+    if not kpa_model_manager.model_loaded:
+        raise ValueError("Modèle KPA non chargé")
+    
+    result = kpa_model_manager.predict(argument, key_point)
+    return {
+        "prediction": result["prediction"],
+        "label": result["label"],
+        "confidence": result["confidence"],
+        "probabilities": result["probabilities"]
+    }
+
+# Tool pour STT (Speech-to-Text) - Note : Pour audio, utilise un upload via resource ou adapte
+@mcp_server.tool()
+def transcribe_audio(audio_path: str) -> str:
+    """
+    Transcrit un fichier audio en texte (via Groq Whisper).
+    
+    Args:
+        audio_path: Chemin vers le fichier audio (ex. temp file)
+    
+    Returns:
+        Texte transcrit.
+    """
+    return speech_to_text(audio_path)
+
+# Tool pour TTS (Text-to-Speech)
+@mcp_server.tool()
+def generate_speech(text: str, voice: str = "Aaliyah-PlayAI", format: str = "wav") -> str:
+    """
+    Génère un fichier audio à partir de texte (via Groq TTS).
+    
+    Args:
+        text: Texte à synthétiser
+        voice: Voix (défaut: Aaliyah-PlayAI)
+        format: wav ou mp3
+    
+    Returns:
+        Chemin vers le fichier audio généré.
+    """
+    return text_to_speech(text, voice, format)
+
+# Tool pour Argument Generation (Chatbot)
+@mcp_server.tool()
+def generate_argument(user_input: str, conversation_id: str = None) -> str:
+    """
+    Génère une réponse argumentative via chatbot (via Groq Llama).
+    
+    Args:
+        user_input: Input utilisateur
+        conversation_id: ID de session (optionnel)
+    
+    Returns:
+        Réponse générée.
+    """
+    return generate_chat_response(user_input, conversation_id)
+
+# Resource exemple : Prompt template pour débats
+@mcp_server.resource("debate://prompt")
+def get_debate_prompt(topic: str) -> str:
+    """Récupère un template de prompt pour générer des arguments sur un topic."""
+    return f"Tu es un expert en débat. Génère 3 arguments PRO pour le topic: {topic}. Sois concis et persuasif."
+
+def init_mcp_server(app: FastAPI) -> None:  # Retiré les quotes : FastAPI est maintenant importé
+    """
+    Initialise et monte le serveur MCP sur l'app FastAPI.
+    Ajoute les routes MCP à /api/v1/mcp (ex. : /tools, /call, /resources).
+    """
+    # Monter l'app MCP sur FastAPI (via Starlette Mount, compatible FastAPI)
+    from starlette.routing import Mount
+    
+    # Créer l'app MCP streamable
+    mcp_app = mcp_server.streamable_http_app(streamable_http_path="/mcp")  # Chemin racine /mcp
+    
+    # Monter directement sur l'app FastAPI (app.mount pour sub-app)
+    app.mount("/api/v1/mcp", mcp_app)  # Monte à /api/v1/mcp - gère /tools, /call, etc.
+    
+    logger.info("✓ Serveur MCP initialisé et monté sur /api/v1/mcp avec tools NLP/STT/TTS")
+    
+    # Pour batch ou health, ajoute si besoin (ce tool est déjà décoré)
+    @mcp_server.tool()
+    def health_check() -> Dict[str, Any]:
+        return {"status": "healthy", "tools": list(mcp_server.tools.keys())}