Commit 5

gradio_interface.py

@@ -1,323 +1,98 @@
+# gradio_interface.py
 """
-Interfaz Gradio para el Servidor MCP
-Proporciona una interfaz web para interactuar con las herramientas MCP
+Gradio front‑end for the MCP server defined in `mcp_server_core.py`.
+
+Launches a tiny admin UI **and** exposes a fully‑compliant MCP/SSE endpoint
+at `/gradio_api/mcp/sse` thanks to `launch(mcp_server=True)`.
+
+Usage
+-----
+    pip install gradio>=4.25 simpleeval  # ensure dependencies
+    python gradio_interface.py           # open UI + MCP endpoint
+
+Notes
+-----
+* Handlers are declared `async` so that long‑running tools do not block the
+  Gradio event loop (they internally rely on the async helpers in the core).
+* The UI itself is intentionally minimal; extend it with extra tabs or widgets
+  without touching `mcp_server_core.py`.
 """
 
-import gradio as gr
+from __future__ import annotations
+
 import json
-from typing import Dict, List, Any
-from mcp_server_core import get_mcp_server, MCPTool
+from typing import Any
+
+import gradio as gr
+
+from mcp_server_core import get_server
+
+# ---------------------------------------------------------------------------
+# Wrapper class that bridges Gradio events ↔ MCPServer methods
+# ---------------------------------------------------------------------------
 
 
 class GradioMCPInterface:
-    """Interfaz Gradio para el servidor MCP"""
-    
-    def __init__(self):
-        self.mcp_server = get_mcp_server()
-    
-    def format_tools_list(self, tools: List[Dict[str, Any]]) -> str:
-        """Formatea la lista de herramientas para mostrar"""
-        if not tools:
-            return "❌ No hay herramientas disponibles."
-        
-        formatted = "## 🛠️ Herramientas Disponibles\n\n"
-        formatted += f"**Total:** {len(tools)} herramientas\n\n"
-        
-        # Agrupar por categoría
-        categories = {}
-        for tool in tools:
-            cat = tool.get('category', 'general')
-            if cat not in categories:
-                categories[cat] = []
-            categories[cat].append(tool)
-        
-        for category, cat_tools in sorted(categories.items()):
-            formatted += f"### 📂 {category.title()}\n\n"
-            for tool in sorted(cat_tools, key=lambda x: x['name']):
-                status = "✅" if tool.get('enabled', True) else "❌"
-                version = tool.get('version', 'N/A')
-                created = tool.get('created_at', 'N/A')[:10] if tool.get('created_at') else 'N/A'
-                
-                formatted += f"**{status} {tool['name']}** (v{version})\n"
-                formatted += f"   📝 {tool['description']}\n"
-                formatted += f"   📅 Creada: {created}\n\n"
-        
-        return formatted
-    
-    def format_tool_detail(self, tool_data: Dict[str, Any]) -> str:
-        """Formatea los detalles de una herramienta específica"""
-        if 'error' in tool_data:
-            return f"❌ **Error:** {tool_data['error']}"
-        
-        formatted = f"## 🔧 {tool_data['name']}\n\n"
-        formatted += f"**📝 Descripción:** {tool_data['description']}\n\n"
-        formatted += f"**📂 Categoría:** {tool_data.get('category', 'N/A')}\n\n"
-        formatted += f"**🏷️ Versión:** {tool_data.get('version', 'N/A')}\n\n"
-        
-        status = '✅ Habilitada' if tool_data.get('enabled', True) else '❌ Deshabilitada'
-        formatted += f"**⚡ Estado:** {status}\n\n"
-        
-        created = tool_data.get('created_at', 'N/A')
-        if created != 'N/A':
-            formatted += f"**📅 Creada:** {created[:19].replace('T', ' ')}\n\n"
-        
-        # Mostrar esquema de entrada
-        if 'input_schema' in tool_data:
-            formatted += "### 📥 Esquema de Entrada\n\n"
-            
-            # Mostrar propiedades de forma más legible
-            schema = tool_data['input_schema']
-            if 'properties' in schema:
-                formatted += "**Parámetros:**\n\n"
-                for prop_name, prop_info in schema['properties'].items():
-                    required = prop_name in schema.get('required', [])
-                    req_text = "*(requerido)*" if required else "*(opcional)*"
-                    prop_type = prop_info.get('type', 'unknown')
-                    
-                    formatted += f"- **{prop_name}** {req_text}: `{prop_type}`\n"
-                    
-                    if 'description' in prop_info:
-                        formatted += f"  - {prop_info['description']}\n"
-                    
-                    if 'examples' in prop_info:
-                        examples = ', '.join([f"`{ex}`" for ex in prop_info['examples'][:3]])
-                        formatted += f"  - Ejemplos: {examples}\n"
-                    
-                    if 'enum' in prop_info:
-                        values = ', '.join([f"`{val}`" for val in prop_info['enum']])
-                        formatted += f"  - Valores válidos: {values}\n"
-                    
-                    formatted += "\n"
-            
-            formatted += "\n**Esquema JSON completo:**\n\n"
-            formatted += f"```json\n{json.dumps(schema, indent=2, ensure_ascii=False)}\n```\n\n"
-        
-        return formatted
-    
-    def format_execution_result(self, result: Dict[str, Any]) -> str:
-        """Formatea el resultado de ejecución de una herramienta"""
-        if 'error' in result:
-            return f"❌ **Error:** {result['error']}"
-        
-        formatted = "## ✅ Resultado de Ejecución\n\n"
-        
-        # Formatear según el tipo de resultado
-        for key, value in result.items():
-            if key == 'error':
-                continue
-            
-            formatted += f"**{key.replace('_', ' ').title()}:** "
-            
-            if isinstance(value, (dict, list)):
-                formatted += f"\n```json\n{json.dumps(value, indent=2, ensure_ascii=False)}\n```\n\n"
-            elif isinstance(value, str) and len(value) > 50:
-                formatted += f"\n```\n{value}\n```\n\n"
-            else:
-                formatted += f"`{value}`\n\n"
-        
-        return formatted
-    
-    def list_all_tools(self):
-        """Lista todas las herramientas disponibles"""
-        tools = self.mcp_server.list_tools()
-        return self.format_tools_list(tools)
-    
-    def get_tool_details(self, tool_name: str):
-        """Obtiene detalles de una herramienta específica"""
-        if not tool_name.strip():
-            return "⚠️ Por favor, ingresa el nombre de una herramienta."
-        
-        tool_data = self.mcp_server.get_tool(tool_name.strip())
-        return self.format_tool_detail(tool_data)
-    
-    def list_tools_by_category(self, category: str):
-        """Lista herramientas por categoría"""
-        if not category.strip():
-            return "⚠️ Por favor, selecciona una categoría."
-        
-        tools = self.mcp_server.get_tools_by_category(category.strip())
-        return self.format_tools_list(tools)
-    
-    def show_server_info(self):
-        """Muestra información del servidor"""
-        info = self.mcp_server.get_server_info()
-        formatted = "## 🖥️ Información del Servidor MCP\n\n"
-        
-        formatted += f"**📛 Nombre:** {info['name']}\n\n"
-        formatted += f"**🏷️ Versión:** {info['version']}\n\n"
-        formatted += f"**📋 Versión del Protocolo:** {info['protocol_version']}\n\n"
-        formatted += f"**📅 Creado:** {info.get('created_at', 'N/A')[:19].replace('T', ' ')}\n\n"
-        
-        # Estadísticas
-        if 'stats' in info:
-            stats = info['stats']
-            formatted += "### 📊 Estadísticas\n\n"
-            formatted += f"- **Total de herramientas:** {stats['total_tools']}\n"
-            formatted += f"- **Herramientas habilitadas:** {stats['enabled_tools']}\n"
-            formatted += f"- **Categorías:** {stats['categories_count']}\n"
-            formatted += f"- **Lista de categorías:** {', '.join(stats['categories'])}\n\n"
-        
-        # Capacidades
-        formatted += "### ⚙️ Capacidades del Servidor\n\n"
-        formatted += f"```json\n{json.dumps(info['capabilities'], indent=2, ensure_ascii=False)}\n```\n\n"
-        
-        return formatted
-    
-    def execute_tool(self, tool_name: str, params_json: str):
-        """Ejecuta una herramienta con parámetros JSON"""
+    def __init__(self) -> None:
+        self.server = get_server()
+
+    # ----------------- Utility helpers -----------------
+
+    @staticmethod
+    def _md(obj: Any, lang: str = "json") -> str:
+        """Return a fenced code block for pretty Markdown rendering."""
+        return f"```{lang}\n{json.dumps(obj, indent=2, ensure_ascii=False)}\n```"
+
+    # ----------------- Event handlers (async) -----------------
+
+    async def run_tool(self, tool_name: str, params_json: str) -> str:
         if not tool_name.strip():
-            return "⚠️ Por favor, especifica el nombre de la herramienta."
-        
+            return "⚠️ Debes indicar una herramienta."
         try:
-            # Parsear parámetros JSON
-            if params_json.strip():
-                params = json.loads(params_json)
-            else:
-                params = {}
-            
-            # Ejecutar herramienta
-            result = self.mcp_server.execute_tool(tool_name.strip(), **params)
-            return self.format_execution_result(result)
-            
-        except json.JSONDecodeError as e:
-            return f"❌ **Error en JSON:** {str(e)}\n\nVerifica que el formato JSON sea válido."
-        except Exception as e:
-            return f"❌ **Error:** {str(e)}"
-    
-    def toggle_tool_status(self, tool_name: str):
-        """Cambia el estado de una herramienta"""
-        if not tool_name.strip():
-            return "⚠️ Por favor, especifica el nombre de la herramienta."
-        
-        result = self.mcp_server.toggle_tool(tool_name.strip())
-        
-        if 'error' in result:
-            return f"❌ **Error:** {result['error']}"
-        else:
-            status_emoji = "✅" if result['enabled'] else "❌"
-            return f"{status_emoji} **Herramienta '{result['tool']}'** ahora está **{result['status']}**"
-    
-    def get_available_tools_list(self):
-        """Obtiene lista de nombres de herramientas para dropdowns"""
-        tools = self.mcp_server.list_tools()
-        return [tool['name'] for tool in tools]
-    
-    def get_categories_list(self):
-        """Obtiene lista de categorías para dropdowns"""
-        return self.mcp_server.get_categories()
+            params = json.loads(params_json) if params_json.strip() else {}
+        except json.JSONDecodeError as exc:
+            return f"❌ JSON mal formado: {exc}"
+
+        result = await self.server.execute_tool_async(tool_name.strip(), **params)
+        if "error" in result:
+            return f"❌ {result['error']}"
+        return self._md(result)
+
+    def list_tools(self) -> str:
+        return self._md(self.server.list_tools())
+
 
+# ---------------------------------------------------------------------------
+# Build Gradio Blocks UI
+# ---------------------------------------------------------------------------
+
+def build_ui() -> gr.Blocks:  # noqa: D401 – not a public library function
+    iface = GradioMCPInterface()
+
+    theme = gr.themes.Soft()
+    with gr.Blocks(title="🛠️ MCP Admin", theme=theme) as demo:
+        gr.Markdown("# 🛠️ MCP Server (async + safe eval)")
+
+        with gr.Tab("Ejecutar herramienta"):
+            name_box = gr.Textbox(label="Nombre de la herramienta", placeholder="calculator")
+            params_box = gr.Textbox(label="Parámetros JSON", lines=3)
+            run_btn = gr.Button("Ejecutar", variant="primary")
+            out_md = gr.Markdown()
+            run_btn.click(iface.run_tool, inputs=[name_box, params_box], outputs=out_md)
+
+        with gr.Tab("Lista de herramientas"):
+            refresh_btn = gr.Button("Refrescar lista")
+            out_list = gr.Markdown()
+            refresh_btn.click(iface.list_tools, outputs=out_list)
 
-def create_gradio_interface():
-    """Crea y configura la interfaz Gradio"""
-    
-    # Crear instancia de la interfaz
-    interface = GradioMCPInterface()
-    
-    # Configurar tema personalizado
-    theme = gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="cyan",
-        neutral_hue="slate",
-    )
-    
-    # Crear la interfaz principal
-    with gr.Blocks(
-        title="🛠️ Servidor MCP - Gestor de Herramientas",
-        theme=theme,
-        css="""
-        .gradio-container {
-            max-width: 1200px !important;
-        }
-        .tool-card {
-            border: 1px solid #e5e7eb;
-            border-radius: 8px;
-            padding: 16px;
-            margin: 8px 0;
-        }
-        """
-    ) as demo:
-        
-        # Header
-        gr.Markdown("""
-        # 🛠️ Servidor MCP - Gestor de Herramientas
-        
-        **Model Context Protocol (MCP) Server** - Interfaz web para gestionar y ejecutar herramientas del protocolo MCP.
-        
-        ---
-        """)
-        
-        with gr.Tabs():
-            # Pestaña: Listar todas las herramientas
-            with gr.Tab("📋 Herramientas", id="tools_list"):
-                gr.Markdown("### Lista completa de herramientas disponibles")
-                
-                with gr.Row():
-                    list_btn = gr.Button("🔄 Actualizar Lista", variant="primary", scale=1)
-                    gr.Markdown("")  # Spacer
-                
-                tools_output = gr.Markdown(value="Cargando herramientas...")
-                list_btn.click(interface.list_all_tools, outputs=tools_output)
-            
-            # Pestaña: Detalles de la herramienta
-            with gr.Tab("🔧 Detalles de la Herramienta"):
-                gr.Markdown("### Obtén detalles de una herramienta específica")
-                
-                with gr.Row():
-                    tool_name_input = gr.Textbox(label="Nombre de la Herramienta", scale=3)
-                    get_details_btn = gr.Button("🔍 Obtener Detalles", variant="primary", scale=1)
-                
-                tool_details_output = gr.Markdown(value="")
-                get_details_btn.click(interface.get_tool_details, inputs=tool_name_input, outputs=tool_details_output)
-            
-            # Pestaña: Ejecutar Herramienta
-            with gr.Tab("💻 Ejecutar Herramienta"):
-                gr.Markdown("### Ejecuta una herramienta con parámetros")
-                
-                with gr.Row():
-                    tool_name_input = gr.Textbox(label="Nombre de la Herramienta", scale=3)
-                    params_input = gr.Textbox(label="Parámetros JSON", lines=3, scale=3)
-                    execute_btn = gr.Button("💻 Ejecutar", variant="primary", scale=1)
-                
-                execution_output = gr.Markdown(value="")
-                execute_btn.click(interface.execute_tool, inputs=[tool_name_input, params_input], outputs=execution_output)
-            
-            # Pestaña: Información del Servidor
-            with gr.Tab("🖥️ Información del Servidor"):
-                gr.Markdown("### Información general del servidor MCP")
-                
-                with gr.Row():
-                    server_info_btn = gr.Button("🔄 Actualizar Información", variant="primary", scale=1)
-                    gr.Markdown("")  # Spacer
-                
-                server_info_output = gr.Markdown(value="")
-                server_info_btn.click(interface.show_server_info, outputs=server_info_output)
-            
-            # Pestaña: Herramientas por Categoría
-            with gr.Tab("📂 Herramientas por Categoría"):
-                gr.Markdown("### Lista de herramientas por categoría")
-                
-                with gr.Row():
-                    category_input = gr.Dropdown(label="Categoría", choices=interface.get_categories_list(), scale=3)
-                    list_by_category_btn = gr.Button("🔄 Actualizar Lista", variant="primary", scale=1)
-                
-                tools_by_category_output = gr.Markdown(value="")
-                list_by_category_btn.click(interface.list_tools_by_category, inputs=category_input, outputs=tools_by_category_output)
-            
-            # Pestaña: Cambiar Estado de la Herramienta
-            with gr.Tab("🔌 Cambiar Estado de la Herramienta"):
-                gr.Markdown("### Cambia el estado de una herramienta")
-                
-                with gr.Row():
-                    tool_name_input = gr.Textbox(label="Nombre de la Herramienta", scale=3)
-                    toggle_status_btn = gr.Button("🔄 Cambiar Estado", variant="primary", scale=1)
-                
-                toggle_status_output = gr.Markdown(value="")
-                toggle_status_btn.click(interface.toggle_tool_status, inputs=tool_name_input, outputs=toggle_status_output)
-    
     return demo
 
 
-if __name__ == "__main__":
-    ui = create_gradio_interface()
-    ui.launch()
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
 
+if __name__ == "__main__":
+    ui = build_ui()
+    # 👇 This flag automatically adds the `/gradio_api/mcp/sse` endpoint.
+    ui.launch(server_name="0.0.0.0", mcp_server=True)

mcp_server_core.py

@@ -1,428 +1,238 @@
+# mcp_server_core.py
 """
-Servidor MCP (Model Context Protocol) - Módulo Core
-Gestiona herramientas y capacidades del protocolo MCP
+Core logic for an MCP server, separated from any user‑interface concerns.
+
+Features implemented (reflecting your requested improvements):
+1. **Safe evaluation** in the `calculator` tool via `simpleeval.simple_eval` plus a light
+   regex whitelist for allowed characters (digits, operators, spaces and parentheses).
+2. **Asynchronous execution** helper (`execute_tool_async`) that delegates the real work
+   to a background thread with `asyncio.to_thread`, so long‑running tools never block
+   an async‑capable web server.
+3. A clean **MCPServer** class that registers tools, provides `list_tools`, and performs
+   guarded look‑ups before execution.
+
+Import this module from your Gradio (or FastAPI) front‑end and call
+`get_server()` to obtain the singleton instance.
+
+Dependencies
+------------
+    pip install simpleeval>=0.9.15
 """
 
-import json
-from typing import Dict, List, Any, Optional
-from dataclasses import dataclass, asdict
-from datetime import datetime
-import uuid
+from __future__ import annotations
+
+import asyncio
 import re
-import math
+import uuid
+from dataclasses import asdict, dataclass
+from datetime import datetime
+from typing import Any, Dict, List
+
+from simpleeval import simple_eval
+
+# ---------------------------------------------------------------------------
+# Data model
+# ---------------------------------------------------------------------------
 
 
 @dataclass
 class MCPTool:
-    """Representa una herramienta MCP"""
+    """Represents a single MCP tool (function) and its metadata."""
+
     name: str
     description: str
     input_schema: Dict[str, Any]
     category: str = "general"
     version: str = "1.0.0"
     enabled: bool = True
-    created_at: Optional[str] = None
-    
-    def __post_init__(self):
+    created_at: str | None = None
+
+    def __post_init__(self) -> None:  # noqa: D401 – short description already in docstring
         if self.created_at is None:
-            self.created_at = datetime.now().isoformat()
+            self.created_at = datetime.utcnow().isoformat()
+
+
+# ---------------------------------------------------------------------------
+# Executors (business logic)
+# ---------------------------------------------------------------------------
 
 
 class MCPToolExecutor:
-    """Ejecutor de herramientas MCP - Implementa la lógica de cada herramienta"""
-    
+    """Concrete implementations for each built‑in tool."""
+
     @staticmethod
     def execute_calculator(expression: str) -> Dict[str, Any]:
-        """Ejecuta operaciones matemáticas básicas"""
+        """Safely evaluate basic arithmetic expressions without `eval()`.
+
+        Only digits, operators (+‑*/), periods, parentheses and whitespace are allowed.
+        """
+
+        if not re.fullmatch(r"[0-9+\-*/().\s]+", expression):
+            return {
+                "error": (
+                    "La expresión contiene caracteres no permitidos. "+
+                    "Solo se aceptan dígitos, operadores (+‑*/), puntos y paréntesis."
+                )
+            }
         try:
-            # Sanitizar la expresión para seguridad
-            allowed_chars = set('0123456789+-*/.() ')
-            if not all(c in allowed_chars for c in expression):
-                return {"error": "Expresión contiene caracteres no permitidos"}
-            
-            result = eval(expression)
+            result = simple_eval(expression)
             return {
-                "result": result,
                 "expression": expression,
-                "type": type(result).__name__
+                "result": result,
+                "type": type(result).__name__,
             }
-        except Exception as e:
-            return {"error": f"Error en cálculo: {str(e)}"}
-    
+        except Exception as exc:  # pylint: disable=broad-except – controlled boundary
+            return {"error": f"Error evaluando la expresión: {exc}"}
+
     @staticmethod
     def execute_datetime(format_str: str = "%Y-%m-%d %H:%M:%S", timezone: str = "UTC") -> Dict[str, Any]:
-        """Obtiene información de fecha y hora"""
-        try:
-            now = datetime.now()
-            return {
-                "timestamp": now.timestamp(),
-                "formatted": now.strftime(format_str),
-                "iso_format": now.isoformat(),
-                "timezone": timezone,
-                "weekday": now.strftime("%A"),
-                "year": now.year,
-                "month": now.month,
-                "day": now.day,
-                "hour": now.hour,
-                "minute": now.minute,
-                "second": now.second
-            }
-        except Exception as e:
-            return {"error": f"Error obteniendo fecha: {str(e)}"}
-    
+        now = datetime.utcnow()
+        return {
+            "timestamp": now.timestamp(),
+            "formatted": now.strftime(format_str),
+            "iso_format": now.isoformat(),
+            "timezone": timezone,
+        }
+
     @staticmethod
     def execute_email_validator(email: str) -> Dict[str, Any]:
-        """Valida formato de email"""
-        email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
-        is_valid = bool(re.match(email_pattern, email))
-        
+        pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
+        is_valid = bool(re.match(pattern, email))
         return {
             "email": email,
             "is_valid": is_valid,
-            "has_at": "@" in email,
-            "has_dot": "." in email,
-            "length": len(email),
-            "domain": email.split("@")[-1] if "@" in email else None
+            "domain": email.split("@")[-1] if "@" in email else None,
         }
-    
+
     @staticmethod
     def execute_text_generator(text_type: str, length: int = 100) -> Dict[str, Any]:
-        """Genera diferentes tipos de texto"""
-        try:
-            if text_type == "lorem":
-                lorem_words = [
-                    "lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit",
-                    "sed", "do", "eiusmod", "tempor", "incididunt", "ut", "labore", "et", "dolore",
-                    "magna", "aliqua", "enim", "ad", "minim", "veniam", "quis", "nostrud"
-                ]
-                words_needed = min(length // 6, len(lorem_words) * 4)  # Aproximación
-                text = " ".join((lorem_words * ((words_needed // len(lorem_words)) + 1))[:words_needed])
-                return {"text": text[:length], "type": "lorem", "length": len(text[:length])}
-            
-            elif text_type == "uuid":
-                generated_uuid = str(uuid.uuid4())
-                return {"text": generated_uuid, "type": "uuid", "length": len(generated_uuid)}
-            
-            elif text_type == "random":
-                import random
-                import string
-                chars = string.ascii_letters + string.digits + " "
-                text = "".join(random.choice(chars) for _ in range(length))
-                return {"text": text, "type": "random", "length": len(text)}
-            
-            else:
-                return {"error": f"Tipo de texto '{text_type}' no soportado"}
-                
-        except Exception as e:
-            return {"error": f"Error generando texto: {str(e)}"}
-    
-    @staticmethod
-    def execute_unit_converter(value: float, from_unit: str, to_unit: str) -> Dict[str, Any]:
-        """Convierte entre unidades"""
-        try:
-            # Conversiones de temperatura
-            temp_conversions = {
-                ("celsius", "fahrenheit"): lambda x: x * 9/5 + 32,
-                ("fahrenheit", "celsius"): lambda x: (x - 32) * 5/9,
-                ("celsius", "kelvin"): lambda x: x + 273.15,
-                ("kelvin", "celsius"): lambda x: x - 273.15,
-                ("fahrenheit", "kelvin"): lambda x: (x - 32) * 5/9 + 273.15,
-                ("kelvin", "fahrenheit"): lambda x: (x - 273.15) * 9/5 + 32,
-            }
-            
-            # Conversiones de distancia (a metros como base)
-            distance_to_meters = {
-                "meters": 1, "kilometers": 1000, "centimeters": 0.01,
-                "millimeters": 0.001, "inches": 0.0254, "feet": 0.3048,
-                "yards": 0.9144, "miles": 1609.34
-            }
-            
-            # Conversiones de peso (a kilogramos como base)
-            weight_to_kg = {
-                "kilograms": 1, "grams": 0.001, "pounds": 0.453592,
-                "ounces": 0.0283495, "tons": 1000
-            }
-            
-            from_unit = from_unit.lower()
-            to_unit = to_unit.lower()
-            
-            # Temperatura
-            if (from_unit, to_unit) in temp_conversions:
-                result = temp_conversions[(from_unit, to_unit)](value)
-                return {
-                    "original_value": value,
-                    "converted_value": round(result, 6),
-                    "from_unit": from_unit,
-                    "to_unit": to_unit,
-                    "conversion_type": "temperature"
-                }
-            
-            # Distancia
-            elif from_unit in distance_to_meters and to_unit in distance_to_meters:
-                meters = value * distance_to_meters[from_unit]
-                result = meters / distance_to_meters[to_unit]
-                return {
-                    "original_value": value,
-                    "converted_value": round(result, 6),
-                    "from_unit": from_unit,
-                    "to_unit": to_unit,
-                    "conversion_type": "distance"
-                }
-            
-            # Peso
-            elif from_unit in weight_to_kg and to_unit in weight_to_kg:
-                kg = value * weight_to_kg[from_unit]
-                result = kg / weight_to_kg[to_unit]
-                return {
-                    "original_value": value,
-                    "converted_value": round(result, 6),
-                    "from_unit": from_unit,
-                    "to_unit": to_unit,
-                    "conversion_type": "weight"
-                }
-            
-            else:
-                available_units = list(set(list(distance_to_meters.keys()) + 
-                                         list(weight_to_kg.keys()) + 
-                                         ["celsius", "fahrenheit", "kelvin"]))
-                return {
-                    "error": f"Conversión no soportada: {from_unit} -> {to_unit}",
-                    "available_units": available_units
-                }
-                
-        except Exception as e:
-            return {"error": f"Error en conversión: {str(e)}"}
+        if text_type == "uuid":
+            generated_uuid = str(uuid.uuid4())
+            return {"text": generated_uuid, "type": "uuid", "length": len(generated_uuid)}
+        if text_type == "random":
+            import random, string  # local import keeps optional deps light
+
+            chars = string.ascii_letters + string.digits + " "
+            txt = "".join(random.choice(chars) for _ in range(length))
+            return {"text": txt, "type": "random", "length": len(txt)}
+        if text_type == "lorem":
+            lorem = (
+                "lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor "
+                "incididunt ut labore et dolore magna aliqua"
+            )
+            repeated = " ".join([lorem] * ((length // len(lorem.split())) + 1))
+            return {"text": repeated[:length], "type": "lorem", "length": length}
+        return {"error": f"Tipo de texto '{text_type}' no soportado"}
+
+
+# ---------------------------------------------------------------------------
+# MCP Server façade
+# ---------------------------------------------------------------------------
 
 
 class MCPServer:
-    """Servidor MCP que gestiona herramientas y su ejecución"""
-    
-    def __init__(self):
-        self.tools = self._initialize_tools()
+    """Tool registry, routing and async helpers."""
+
+    def __init__(self) -> None:
+        self.tools: Dict[str, MCPTool] = self._initialize_tools()
         self.executor = MCPToolExecutor()
         self.server_info = {
-            "name": "Gradio MCP Server",
-            "version": "1.0.0",
+            "name": "Gradio MCP Server Core",
+            "version": "1.1.0",
             "protocol_version": "2024-11-05",
-            "capabilities": {
-                "tools": {"listChanged": True},
-                "resources": {},
-                "prompts": {}
-            },
-            "created_at": datetime.now().isoformat()
+            "created_at": datetime.utcnow().isoformat(),
         }
-    
+
+    # -------------------- Public API --------------------
+
+    def list_tools(self) -> List[Dict[str, Any]]:
+        """Return enabled tools as serialisable dicts."""
+        return [asdict(tool) for tool in self.tools.values() if tool.enabled]
+
+    def execute_tool(self, tool_name: str, **kwargs: Any) -> Dict[str, Any]:
+        """Synchronous execution (will call a *pure* function).
+
+        Raises no exceptions; always returns a JSON‑serialisable dict.
+        """
+        if tool_name not in self.tools:
+            return {"error": f"Herramienta '{tool_name}' no encontrada"}
+        if not self.tools[tool_name].enabled:
+            return {"error": f"Herramienta '{tool_name}' deshabilitada"}
+
+        mapping = {
+            "calculator": self.executor.execute_calculator,
+            "datetime": self.executor.execute_datetime,
+            "email_validator": self.executor.execute_email_validator,
+            "text_generator": self.executor.execute_text_generator,
+        }
+        if tool_name not in mapping:
+            return {"error": f"Ejecutor para '{tool_name}' no implementado"}
+        return mapping[tool_name](**kwargs)
+
+    async def execute_tool_async(self, tool_name: str, **kwargs: Any) -> Dict[str, Any]:
+        """Non‑blocking wrapper that runs the sync code in a thread."""
+        return await asyncio.to_thread(self.execute_tool, tool_name, **kwargs)
+
+    # ------------------- Internals -------------------
+
     def _initialize_tools(self) -> Dict[str, MCPTool]:
-        """Inicializa las herramientas disponibles"""
-        tools = {}
-        
-        # Herramienta de cálculo
+        """Register the built‑in tools. Add more here or load dynamically."""
+        tools: Dict[str, MCPTool] = {}
         tools["calculator"] = MCPTool(
             name="calculator",
-            description="Realiza operaciones matemáticas básicas (+, -, *, /, parentesis)",
+            description="Realiza operaciones matemáticas básicas (+, -, *, /).",
             input_schema={
                 "type": "object",
-                "properties": {
-                    "expression": {
-                        "type": "string",
-                        "description": "Expresión matemática a evaluar (ej: '2 + 3 * 4')",
-                        "examples": ["2 + 3", "10 * (5 - 2)", "100 / 4"]
-                    }
-                },
-                "required": ["expression"]
+                "properties": {"expression": {"type": "string", "description": "Expresión"}},
+                "required": ["expression"],
             },
-            category="matemáticas"
+            category="matemáticas",
         )
-        
-        # Herramienta de fecha/hora
         tools["datetime"] = MCPTool(
             name="datetime",
-            description="Obtiene información completa de fecha y hora actual del sistema",
+            description="Devuelve la fecha y hora UTC actuales en el formato indicado.",
             input_schema={
                 "type": "object",
                 "properties": {
-                    "format": {
-                        "type": "string",
-                        "description": "Formato de fecha personalizado (opcional)",
-                        "default": "%Y-%m-%d %H:%M:%S",
-                        "examples": ["%Y-%m-%d", "%H:%M:%S", "%A, %B %d, %Y"]
-                    },
-                    "timezone": {
-                        "type": "string",
-                        "description": "Zona horaria (solo informativo, no afecta el cálculo)",
-                        "default": "UTC"
-                    }
+                    "format_str": {"type": "string"},
+                    "timezone": {"type": "string"},
                 },
-                "required": []
             },
-            category="utilidades"
         )
-        
-        # Herramienta de validación de email
         tools["email_validator"] = MCPTool(
             name="email_validator",
-            description="Valida formato de email y proporciona análisis detallado",
+            description="Valida sintaxis de correo electrónico estándar (RFC 5322).",
             input_schema={
                 "type": "object",
-                "properties": {
-                    "email": {
-                        "type": "string",
-                        "description": "Dirección de email a validar",
-                        "examples": ["usuario@ejemplo.com", "test@domain.org"]
-                    }
-                },
-                "required": ["email"]
+                "properties": {"email": {"type": "string"}},
+                "required": ["email"],
             },
-            category="validación"
+            category="validación",
         )
-        
-        # Herramienta de generación de texto
         tools["text_generator"] = MCPTool(
             name="text_generator",
-            description="Genera diferentes tipos de texto: Lorem Ipsum, UUIDs, o texto aleatorio",
+            description="Genera UUID, texto aleatorio o lorem ipsum.",
             input_schema={
                 "type": "object",
                 "properties": {
-                    "type": {
-                        "type": "string",
-                        "enum": ["lorem", "random", "uuid"],
-                        "description": "Tipo de texto a generar"
-                    },
-                    "length": {
-                        "type": "integer",
-                        "description": "Longitud aproximada del texto (no aplica para UUID)",
-                        "minimum": 1,
-                        "maximum": 1000,
-                        "default": 100
-                    }
+                    "text_type": {"type": "string"},
+                    "length": {"type": "integer"},
                 },
-                "required": ["type"]
+                "required": ["text_type"],
             },
-            category="generación"
         )
-        
-        # Herramienta de conversión de unidades
-        tools["unit_converter"] = MCPTool(
-            name="unit_converter",
-            description="Convierte entre unidades de temperatura, distancia y peso",
-            input_schema={
-                "type": "object",
-                "properties": {
-                    "value": {
-                        "type": "number",
-                        "description": "Valor numérico a convertir"
-                    },
-                    "from_unit": {
-                        "type": "string",
-                        "description": "Unidad de origen",
-                        "examples": ["celsius", "kilometers", "pounds", "meters", "fahrenheit"]
-                    },
-                    "to_unit": {
-                        "type": "string",
-                        "description": "Unidad de destino",
-                        "examples": ["fahrenheit", "miles", "kilograms", "feet", "kelvin"]
-                    }
-                },
-                "required": ["value", "from_unit", "to_unit"]
-            },
-            category="conversión"
-        )
-        
         return tools
-    
-    def list_tools(self) -> List[Dict[str, Any]]:
-        """Lista todas las herramientas disponibles"""
-        return [asdict(tool) for tool in self.tools.values() if tool.enabled]
-    
-    def get_tool(self, name: str) -> Dict[str, Any]:
-        """Obtiene información de una herramienta específica"""
-        if name in self.tools:
-            return asdict(self.tools[name])
-        return {"error": f"Herramienta '{name}' no encontrada"}
-    
-    def get_tools_by_category(self, category: str) -> List[Dict[str, Any]]:
-        """Obtiene herramientas por categoría"""
-        return [asdict(tool) for tool in self.tools.values() 
-                if tool.category.lower() == category.lower() and tool.enabled]
-    
-    def get_categories(self) -> List[str]:
-        """Obtiene todas las categorías disponibles"""
-        return list(set(tool.category for tool in self.tools.values()))
-    
-    def get_server_info(self) -> Dict[str, Any]:
-        """Obtiene información del servidor"""
-        info = self.server_info.copy()
-        info["stats"] = {
-            "total_tools": len(self.tools),
-            "enabled_tools": len([t for t in self.tools.values() if t.enabled]),
-            "categories_count": len(self.get_categories()),
-            "categories": self.get_categories()
-        }
-        return info
-    
-    def execute_tool(self, tool_name: str, **kwargs) -> Dict[str, Any]:
-        """Ejecuta una herramienta con los parámetros dados"""
-        if tool_name not in self.tools:
-            return {"error": f"Herramienta '{tool_name}' no encontrada"}
-        
-        if not self.tools[tool_name].enabled:
-            return {"error": f"Herramienta '{tool_name}' está deshabilitada"}
-        
-        try:
-            # Mapeo de herramientas a métodos del ejecutor
-            method_map = {
-                "calculator": self.executor.execute_calculator,
-                "datetime": self.executor.execute_datetime,
-                "email_validator": self.executor.execute_email_validator,
-                "text_generator": self.executor.execute_text_generator,
-                "unit_converter": self.executor.execute_unit_converter
-            }
-            
-            if tool_name in method_map:
-                return method_map[tool_name](**kwargs)
-            else:
-                return {"error": f"Ejecutor para '{tool_name}' no implementado"}
-                
-        except Exception as e:
-            return {"error": f"Error ejecutando herramienta: {str(e)}"}
-    
-    def toggle_tool(self, tool_name: str) -> Dict[str, Any]:
-        """Habilita/deshabilita una herramienta"""
-        if tool_name not in self.tools:
-            return {"error": f"Herramienta '{tool_name}' no encontrada"}
-        
-        self.tools[tool_name].enabled = not self.tools[tool_name].enabled
-        status = "habilitada" if self.tools[tool_name].enabled else "deshabilitada"
-        
-        return {
-            "tool": tool_name,
-            "status": status,
-            "enabled": self.tools[tool_name].enabled
-        }
-    
-    def add_tool(self, tool: MCPTool) -> Dict[str, Any]:
-        """Agrega una nueva herramienta al servidor"""
-        if tool.name in self.tools:
-            return {"error": f"Herramienta '{tool.name}' ya existe"}
-        
-        self.tools[tool.name] = tool
-        return {"message": f"Herramienta '{tool.name}' agregada exitosamente"}
-    
-    def remove_tool(self, tool_name: str) -> Dict[str, Any]:
-        """Elimina una herramienta del servidor"""
-        if tool_name not in self.tools:
-            return {"error": f"Herramienta '{tool_name}' no encontrada"}
-        
-        del self.tools[tool_name]
-        return {"message": f"Herramienta '{tool_name}' eliminada exitosamente"}
 
 
-# Instancia global del servidor (singleton)
-_mcp_server_instance = None
+# ---------------------------------------------------------------------------
+# Singleton helper for easy import in the UI layer
+# ---------------------------------------------------------------------------
+
+_server_instance: MCPServer | None = None
 
-def get_mcp_server() -> MCPServer:
-    """Obtiene la instancia singleton del servidor MCP"""
-    global _mcp_server_instance
-    if _mcp_server_instance is None:
-        _mcp_server_instance = MCPServer()
-    return _mcp_server_instance
+def get_server() -> MCPServer:
+    """Return a singleton MCPServer so the same registry is shared across the app."""
+    global _server_instance  # pylint: disable=global-statement
+    if _server_instance is None:
+        _server_instance = MCPServer()
+    return _server_instance