@innvisor/conny-ai 9.7.0

package/src/domain/swarm/queen.py

@@ -0,0 +1,96 @@
+import asyncio
+import logging
+from typing import Dict, Any, List, Optional
+from src.core.globals import llm_engine
+
+log = logging.getLogger("conny.swarm")
+
+class Agent:
+    def __init__(self, name: str, role: str, instruction: str):
+        self.name = name
+        self.role = role
+        self.instruction = instruction
+
+    async def execute(self, task: str, context: Dict[str, Any]) -> str:
+        prompt = f"Role: {self.role}\nInstruction: {self.instruction}\nContext: {context}\nTask: {task}"
+        log.info(f"[{self.name}] Executing task...")
+        # Llama al motor LLM real usando complete
+        messages = [{"role": "user", "content": prompt}]
+        response, _ = await llm_engine.complete(messages, model_tier="fast")
+        log.info(f"[{self.name}] Raw response: {response}")
+        return response
+
+class QueenCoordinator:
+    """
+    Coordina el enjambre jerárquico (Swarm V3).
+    Evita el 'drift' (desvío de instrucciones) dividiendo el trabajo.
+    """
+    def __init__(self):
+        self.research_agent = Agent(
+            name="ResearchAgent",
+            role="Analista de Conocimiento",
+            instruction="Busca en la base de datos de FAQs o en el contexto del paciente para extraer hechos exactos."
+        )
+        self.response_agent = Agent(
+            name="ResponseAgent",
+            role="Generador de Respuestas",
+            instruction="Sintetiza la respuesta final basándose únicamente en los hechos encontrados, adoptando el tono de la clínica. Evita cualquier frase preprogramada o robótica."
+        )
+        self.reviewer_agent = Agent(
+            name="ReviewerAgent",
+            role="Auditor de Calidad",
+            instruction="Verifica la respuesta generada. Quita cualquier fragmento que suene a robot o call center. Devuelve ÚNICAMENTE un array de strings en formato JSON con los mensajes finales que recibirá el cliente (ejemplo: [\"¡Hola! Claro que sí.\", \"¿Te viene bien por la tarde?\"]). No devuelvas bloques de auditoría, objetos con llaves o explicaciones extra."
+        )
+
+    def _clean_json_text(self, text: str) -> str:
+        """Limpia bloques de código markdown si los hay."""
+        text = text.strip()
+        if text.startswith("```"):
+            # Quitar primera línea de bloque de código
+            lines = text.splitlines()
+            if lines[0].startswith("```"):
+                lines = lines[1:]
+            if lines and lines[-1].strip() == "```":
+                lines = lines[:-1]
+            text = "\n".join(lines).strip()
+        return text
+
+    async def process(self, user_message: str, clinic_context: Dict[str, Any]) -> List[str]:
+        log.info("[swarm] Queen ha recibido un mensaje, coordinando enjambre...")
+        
+        # 1. Investigación
+        facts = await self.research_agent.execute(f"Extrae datos relevantes para responder a: '{user_message}'", clinic_context)
+        
+        # 2. Generación
+        draft_context = {"user_message": user_message, "facts": facts, "clinic": clinic_context}
+        draft_response = await self.response_agent.execute("Escribe la respuesta final en JSON", draft_context)
+        
+        # 3. Revisión
+        final_response = await self.reviewer_agent.execute("Verifica esta respuesta y devuelve el JSON final de mensajes", {"draft": draft_response})
+        
+        cleaned = self._clean_json_text(final_response)
+        
+        try:
+            import json
+            parsed = json.loads(cleaned)
+            if isinstance(parsed, list):
+                # Extraer strings de los elementos (en caso de que sean objetos o arrays anidados)
+                result = []
+                for item in parsed:
+                    if isinstance(item, str):
+                        result.append(item)
+                    elif isinstance(item, dict):
+                        # En caso de que el LLM insista en devolver objetos con llave 'response'
+                        val = item.get("response") or item.get("text") or str(item)
+                        result.append(val)
+                return result
+            elif isinstance(parsed, dict):
+                val = parsed.get("response") or parsed.get("text")
+                if val:
+                    return [val]
+            return [cleaned]
+        except Exception as e:
+            log.warning(f"[swarm] Error al parsear JSON del ReviewerAgent ({e}). Usando fallback de texto crudo.")
+            return [cleaned]
+
+swarm_queen = QueenCoordinator()

package/src/infrastructure/llm_providers/engine.py

@@ -0,0 +1,487 @@
+import json
+import time
+import httpx
+import hashlib
+import re
+import logging
+from typing import List, Dict, Tuple, Any
+from conny_config import Config
+
+log = logging.getLogger("conny.llm")
+
+try:
+    from conny import model_manager
+except ImportError:
+    model_manager = None
+
+
+class LLMProvider:
+    """Interfaz base para proveedores LLM."""
+    name: str = "base"
+
+    async def complete(self, messages: List[Dict], model: str,
+                       temperature: float = 0.7, max_tokens: int = 1000,
+                       **kwargs) -> Tuple[str, Dict]:
+        raise NotImplementedError
+
+    async def embed(self, text: str) -> List[float]:
+        raise NotImplementedError
+
+
+def _parse_http_json_response(response: httpx.Response, provider_name: str) -> Dict[str, Any]:
+    body = response.text or ""
+    stripped = body.strip()
+    content_type = (response.headers.get("content-type") or "").strip() or "unknown"
+    if not stripped:
+        raise ValueError(f"{provider_name} devolvió body vacío [{content_type}]")
+    try:
+        parsed = response.json()
+    except Exception as exc:
+        snippet = re.sub(r"\s+", " ", stripped)[:220]
+        raise ValueError(
+            f"{provider_name} devolvió body no-JSON [{content_type}]: {snippet}"
+        ) from exc
+    if not isinstance(parsed, dict):
+        raise ValueError(f"{provider_name} devolvió JSON no-objeto [{content_type}]")
+    return parsed
+
+
+class GroqProvider(LLMProvider):
+    """Groq — el mas rapido (~500ms). Llama-3.3-70b."""
+    name = "groq"
+    BASE  = "https://api.groq.com/openai/v1"
+    MDLS  = {"reasoning": "llama-3.3-70b-versatile",
+              "fast":      "llama-3.3-70b-versatile",
+              "lite":      "llama-3.1-8b-instant"}
+
+    def __init__(self, key: str): self.key = key
+
+    async def complete(self, messages, model="fast", temperature=0.7, max_tokens=1000, **kw):
+        start = time.time()
+        if isinstance(model, str) and model in self.MDLS:
+            m = self.MDLS[model]
+        elif isinstance(model, str) and model.startswith("groq/"):
+            m = model.split("/", 1)[1]
+        elif isinstance(model, str) and model not in ("fast", "reasoning", "lite"):
+            m = model
+        else:
+            m = self.MDLS["fast"]
+        async with httpx.AsyncClient(timeout=15.0) as c:
+            r = await c.post(f"{self.BASE}/chat/completions",
+                headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"},
+                json={"model": m, "messages": messages, "temperature": temperature, "max_tokens": max_tokens})
+            r.raise_for_status()
+        payload = _parse_http_json_response(r, self.name)
+        text = payload["choices"][0]["message"]["content"].strip()
+        return text, {"model": m, "latency_ms": int((time.time()-start)*1000), "provider": "groq"}
+
+    async def embed(self, text):
+        raise NotImplementedError
+
+
+class GeminiProvider(LLMProvider):
+    """Google Gemini directo. Soporta rotacion de claves."""
+    name = "gemini"
+    BASE  = "https://generativelanguage.googleapis.com/v1beta"
+    MDLS  = {"reasoning": "gemini-2.5-pro",        # Pro para razonamiento complejo
+              "fast":      "gemini-2.5-flash",      # Flash para velocidad
+              "lite":      "gemini-2.5-flash-lite"}
+
+    def __init__(self, key: str, label: str = "gemini"):
+        self.key   = key
+        self.name  = label
+
+    async def complete(self, messages, model="fast", temperature=0.7, max_tokens=1000, **kw):
+        start = time.time()
+        if isinstance(model, str) and model in self.MDLS:
+            gm = self.MDLS[model]
+        elif isinstance(model, str) and model.startswith("google/"):
+            gm = model.split("/", 1)[1]
+        elif isinstance(model, str) and model.startswith("gemini-"):
+            gm = model
+        else:
+            gm = self.MDLS["fast"]
+        system_parts, contents = [], []
+        for m in messages:
+            if m["role"] == "system":
+                system_parts.append({"text": m["content"]})
+            elif m["role"] == "user":
+                contents.append({"role": "user",  "parts": [{"text": m["content"]}]})
+            elif m["role"] == "assistant":
+                contents.append({"role": "model", "parts": [{"text": m["content"]}]})
+        gen_config = {"temperature": temperature, "maxOutputTokens": max_tokens}
+        if "gemini-2.5-flash" in gm:
+            gen_config["thinkingConfig"] = {"thinkingBudget": 0}
+        elif "gemini-2.5-pro" in gm:
+            # Pro utiliza razonamiento obligatorio que cuenta hacia maxOutputTokens; subimos el límite
+            gen_config["maxOutputTokens"] = max(max_tokens, 4000)
+            
+        payload = {"contents": contents, "generationConfig": gen_config}
+        if system_parts:
+            payload["systemInstruction"] = {"parts": system_parts}
+        url = f"{self.BASE}/models/{gm}:generateContent?key={self.key}"
+        async with httpx.AsyncClient(timeout=20.0) as c:
+            r = await c.post(url, json=payload)
+            r.raise_for_status()
+        payload = _parse_http_json_response(r, self.name)
+        text = payload["candidates"][0]["content"]["parts"][0]["text"].strip()
+        return text, {"model": gm, "latency_ms": int((time.time()-start)*1000), "provider": self.name}
+
+    async def embed(self, text):
+        url = f"{self.BASE}/models/text-embedding-004:embedContent?key={self.key}"
+        async with httpx.AsyncClient(timeout=30.0) as c:
+            r = await c.post(url, json={"content": {"parts": [{"text": text}]}})
+            r.raise_for_status()
+        return r.json()["embedding"]["values"]
+
+
+class OpenRouterProvider(LLMProvider):
+    """OpenRouter — acceso a todos los modelos."""
+    name = "openrouter"
+    BASE  = "https://openrouter.ai/api/v1"
+    MDLS  = {"reasoning": "anthropic/claude-sonnet-4",
+              "fast":      "google/gemini-2.5-flash",
+              "lite":      "google/gemini-2.5-flash-lite"}
+
+    def __init__(self, key: str): self.key = key
+
+    async def complete(self, messages, model="fast", temperature=0.7, max_tokens=1000, **kw):
+        start = time.time()
+        m = self.MDLS.get(model, model if isinstance(model, str) else self.MDLS["fast"])
+        async with httpx.AsyncClient(timeout=25.0) as c:
+            r = await c.post(f"{self.BASE}/chat/completions",
+                headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json",
+                         "HTTP-Referer": "https://conny.ai", "X-Title": "Conny Ultra"},
+                json={"model": m, "messages": messages, "temperature": temperature, "max_tokens": max_tokens})
+            r.raise_for_status()
+        payload = _parse_http_json_response(r, self.name)
+        text = payload["choices"][0]["message"]["content"].strip()
+        return text, {"model": m, "latency_ms": int((time.time()-start)*1000), "provider": "openrouter"}
+
+    async def embed(self, text):
+        async with httpx.AsyncClient(timeout=30.0) as c:
+            r = await c.post(f"{self.BASE}/embeddings",
+                headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"},
+                json={"model": "openai/text-embedding-3-small", "input": text})
+            r.raise_for_status()
+        return r.json()["data"][0]["embedding"]
+
+
+class OpenAIProvider(LLMProvider):
+    """OpenAI — ultimo recurso."""
+    name = "openai"
+    BASE  = "https://api.openai.com/v1"
+    MDLS  = {"reasoning": "gpt-4o", "fast": "gpt-4o-mini", "lite": "gpt-4o-mini"}
+
+    def __init__(self, key: str): self.key = key
+
+    async def complete(self, messages, model="fast", temperature=0.7, max_tokens=1000, **kw):
+        start = time.time()
+        if isinstance(model, str) and model in self.MDLS:
+            m = self.MDLS[model]
+        elif isinstance(model, str) and model.startswith("openai/"):
+            m = model.split("/", 1)[1]
+        elif isinstance(model, str) and model.startswith("gpt-"):
+            m = model
+        else:
+            m = self.MDLS["fast"]
+        async with httpx.AsyncClient(timeout=25.0) as c:
+            r = await c.post(f"{self.BASE}/chat/completions",
+                headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"},
+                json={"model": m, "messages": messages, "temperature": temperature, "max_tokens": max_tokens})
+            r.raise_for_status()
+        payload = _parse_http_json_response(r, self.name)
+        text = payload["choices"][0]["message"]["content"].strip()
+        return text, {"model": m, "latency_ms": int((time.time()-start)*1000), "provider": "openai"}
+
+    async def embed(self, text):
+        async with httpx.AsyncClient(timeout=30.0) as c:
+            r = await c.post(f"{self.BASE}/embeddings",
+                headers={"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"},
+                json={"model": "text-embedding-3-small", "input": text})
+            r.raise_for_status()
+        return r.json()["data"][0]["embedding"]
+
+
+class LLMEngine:
+    """
+    Motor LLM con cascada de 6 proveedores.
+    Groq -> Gemini(key1) -> Gemini(key2) -> Gemini(key3) -> OpenRouter -> OpenAI
+
+    V8.1 — Fixes de fallos silenciosos:
+    - Blacklist temporal (60s) en vez de permanente
+    - Detección de respuesta vacía o inválida
+    - Timeout de provider < timeout de caller (nunca zombie)
+    - _push_to_engine solo en OpenRouter (único multi-modelo real)
+    - Métricas de fallo por provider en DB para diagnóstico
+    """
+
+    # Providers que soportan modelos externos (OpenRouter puede usar cualquier modelo)
+    _MULTI_MODEL_PROVIDERS = {"openrouter"}
+
+    def __init__(self):
+        self.providers: List[LLMProvider] = []
+        self._failures:     Dict[str, int]   = {}   # conteo de fallos
+        self._blocked_until: Dict[str, float] = {}  # timestamp hasta cuando está bloqueado
+        self._last_success: Dict[str, float] = {}
+        self._blacklist_ttl  = 60.0   # segundos de bloqueo tras 3 fallos consecutivos
+        self._cache: Dict[str, Tuple[str, float]] = {}
+        self._cache_ttl = 300
+
+        if Config.GROQ_API_KEY:
+            self.providers.append(GroqProvider(Config.GROQ_API_KEY))
+            log.info("[llm] Groq OK")
+        _all_gemini_keys = Config.GEMINI_API_KEYS or [
+            Config.GEMINI_API_KEY,   Config.GEMINI_API_KEY_2,
+            Config.GEMINI_API_KEY_3, Config.GEMINI_API_KEY_4,
+            Config.GEMINI_API_KEY_5, Config.GEMINI_API_KEY_6,
+        ]
+        for i, key in enumerate(_all_gemini_keys):
+            if key:
+                self.providers.append(GeminiProvider(key, f"gemini_k{i+1}"))
+                log.info(f"[llm] Gemini key{i+1} OK")
+        if Config.OPENROUTER_API_KEY:
+            self.providers.append(OpenRouterProvider(Config.OPENROUTER_API_KEY))
+            log.info("[llm] OpenRouter OK")
+        if Config.OPENAI_API_KEY:
+            self.providers.append(OpenAIProvider(Config.OPENAI_API_KEY))
+            log.info("[llm] OpenAI OK")
+
+        n = len(self.providers)
+        if n == 0:
+            log.critical("[llm] SIN PROVEEDORES — el bot no podra generar respuestas inteligentes")
+        else:
+            log.info(f"[llm] cascada lista: {n} proveedores")
+
+    def _hash(self, messages, **kw):
+        return hashlib.md5((json.dumps(messages, sort_keys=True) + json.dumps(kw, sort_keys=True)).encode()).hexdigest()
+
+    def _get_requested_model(self, model_tier: str) -> str:
+        try:
+            if model_manager:
+                effective = model_manager.get_effective_models()
+                chosen = effective.get(model_tier)
+                if chosen:
+                    return chosen
+        except Exception:
+            pass
+        return Config.LLM_MODELS.get(model_tier, model_tier)
+
+    def _ordered_providers(self, requested_model: str) -> List[LLMProvider]:
+        providers = list(self.providers)
+
+        def _priority(provider: LLMProvider) -> int:
+            name = provider.name
+            if requested_model.startswith("google/") or requested_model.startswith("gemini-"):
+                if name.startswith("gemini"):
+                    return 0
+                if name == "openrouter":
+                    return 1
+                return 2
+            if requested_model.startswith("anthropic/") or requested_model.startswith("meta-llama/") or requested_model.startswith("mistralai/"):
+                if name == "openrouter":
+                    return 0
+                return 2
+            if requested_model.startswith("openai/") or requested_model.startswith("gpt-"):
+                if name == "openai":
+                    return 0
+                if name == "openrouter":
+                    return 1
+                return 2
+            if requested_model.startswith("groq/") or requested_model.startswith("llama-"):
+                if name == "groq":
+                    return 0
+                if name == "openrouter":
+                    return 1
+                return 2
+            return 0
+
+        return sorted(
+            providers,
+            key=lambda provider: (
+                _priority(provider),
+                self._failures.get(provider.name, 0),
+                -self._last_success.get(provider.name, 0.0),
+                provider.name,
+            ),
+        )
+
+    def _resolve_provider_model(self, provider: LLMProvider,
+                                requested_model: str,
+                                model_tier: str) -> str:
+        name = provider.name
+        if name.startswith("gemini") and (
+            requested_model.startswith("google/") or requested_model.startswith("gemini-")
+        ):
+            return requested_model
+        if name == "openai" and (
+            requested_model.startswith("openai/") or requested_model.startswith("gpt-")
+        ):
+            return requested_model
+        if name == "groq" and (
+            requested_model.startswith("groq/") or requested_model.startswith("llama-")
+        ):
+            return requested_model
+        if name == "openrouter":
+            return requested_model
+        return model_tier
+
+    def _is_blocked(self, provider_name: str) -> bool:
+        """Blacklist temporal: bloqueado solo por _blacklist_ttl segundos."""
+        until = self._blocked_until.get(provider_name, 0)
+        if until and time.time() < until:
+            return True
+        # Tiempo expirado — resetear fallos para darle otra oportunidad
+        if until and time.time() >= until:
+            self._failures[provider_name] = 0
+            self._blocked_until[provider_name] = 0
+            log.info(f"[llm] {provider_name} desbloqueado (blacklist expirado)")
+        return False
+
+    def _register_failure(self, provider_name: str, error: Exception):
+        """Registra un fallo y bloquea si acumula 3 consecutivos."""
+        self._failures[provider_name] = self._failures.get(provider_name, 0) + 1
+        count = self._failures[provider_name]
+        log.warning(f"[llm] {provider_name} fallo #{count}: {str(error)[:100]}")
+        status_code = getattr(getattr(error, "response", None), "status_code", None)
+        block_after = 3
+        block_ttl = self._blacklist_ttl
+        if status_code in (401, 402, 403):
+            block_after = 1
+            block_ttl = max(block_ttl, 1800.0)
+        elif status_code in (429, 500, 502, 503, 504):
+            block_after = 2
+            block_ttl = max(block_ttl, 180.0)
+        if count >= block_after:
+            self._blocked_until[provider_name] = time.time() + block_ttl
+            log.error(f"[llm] {provider_name} BLOQUEADO por {block_ttl}s tras {count} fallos")
+        # Guardar métrica en DB para que el admin pueda ver con /v8
+        try:
+            if db:
+                db.record_metric("llm_failure", provider_name, count,
+                                 {"error": str(error)[:80], "blocked": count >= block_after, "status_code": status_code})
+        except Exception:
+            pass
+
+    def _is_valid_response(self, text: str) -> bool:
+        """Detecta respuestas vacías o inválidas que no deben llegar al usuario."""
+        if not text or not text.strip():
+            return False
+        stripped = text.strip()
+        # Respuesta puramente de error del API
+        if stripped.startswith("Error") and len(stripped) < 30:
+            return False
+        # JSON de error de OpenRouter / Gemini que se filtró
+        if stripped.startswith('{"error"') or stripped.startswith('{"status"'):
+            return False
+        return True
+
+    async def complete(self, messages: List[Dict],
+                       model_tier: str = "fast",
+                       temperature: float = 0.7,
+                       max_tokens: int = 1000,
+                       use_cache: bool = True,
+                       **kwargs) -> Tuple[str, Dict]:
+        requested_model = self._get_requested_model(model_tier)
+        if use_cache and db:
+            ck = self._hash(messages, t=temperature, m=max_tokens,
+                            tier=model_tier, requested_model=requested_model)
+            cached = db.get_cached_response(ck)
+            if cached and self._is_valid_response(cached):
+                return cached, {"cached": True}
+
+        last_error = None
+        attempted  = []
+        for provider in self._ordered_providers(requested_model):
+            if self._is_blocked(provider.name):
+                log.debug(f"[llm] {provider.name} saltado (blacklist activo)")
+                continue
+            attempted.append(provider.name)
+            try:
+                provider_model = self._resolve_provider_model(provider, requested_model, model_tier)
+                # Timeout del provider siempre menor que el del caller
+                # para evitar zombies. El caller (admin_brain) usa 12s,
+                # los providers internos usan hasta 25s — reducimos aquí.
+                response, metadata = await asyncio.wait_for(
+                    provider.complete(
+                        messages, model=provider_model,
+                        temperature=temperature, max_tokens=max_tokens, **kwargs),
+                    timeout=10.0   # siempre < 12s del caller
+                )
+
+                # Verificar que la respuesta sea válida — no vacía ni error
+                if not self._is_valid_response(response):
+                    err = ValueError(f"respuesta inválida/vacía: '{response[:40]}'")
+                    self._register_failure(provider.name, err)
+                    last_error = err
+                    log.warning(f"[llm] {provider.name} devolvió respuesta inválida — siguiente")
+                    continue
+
+                # Éxito — resetear fallos
+                self._failures[provider.name] = 0
+                self._last_success[provider.name] = time.time()
+                if use_cache and db:
+                    db.cache_response(ck, response)
+                if db:
+                    db.record_metric("llm", "completion",
+                                     metadata.get("latency_ms", 0),
+                                     {"provider": metadata.get("provider"), "tier": model_tier,
+                                      "requested_model": requested_model})
+                log.info(
+                    f"[llm] {provider.name} OK ({metadata.get('latency_ms',0)}ms) | "
+                    f"tier={model_tier} requested={requested_model}"
+                )
+                return response, metadata
+
+            except asyncio.TimeoutError as e:
+                te = TimeoutError(f"timeout 10s")
+                self._register_failure(provider.name, te)
+                last_error = te
+            except Exception as e:
+                self._register_failure(provider.name, e)
+                last_error = e
+
+        providers_tried = ", ".join(attempted) if attempted else "ninguno"
+        raise RuntimeError(f"Todos los LLM fallaron [{providers_tried}]: {last_error}")
+
+    def get_health(self) -> Dict:
+        """Estado de salud de cada provider. Usado por /v8 y diagnóstico."""
+        now = time.time()
+        result = {}
+        for p in self.providers:
+            blocked_until = self._blocked_until.get(p.name, 0)
+            result[p.name] = {
+                "failures": self._failures.get(p.name, 0),
+                "blocked":  now < blocked_until,
+                "unblocks_in": max(0, int(blocked_until - now)) if now < blocked_until else 0,
+            }
+        return result
+
+    async def embed(self, text: str) -> List[float]:
+        for p in self.providers:
+            try:
+                return await p.embed(text)
+            except Exception:
+                continue
+        return self._simple_embedding(text)
+
+    def _simple_embedding(self, text: str, dim: int = 384) -> List[float]:
+        words = text.lower().split()
+        vec = [0.0] * dim
+        for i, w in enumerate(words[:dim]):
+            vec[i % dim] += hash(w) % 100 / 100.0
+        norm = math.sqrt(sum(x*x for x in vec))
+        return [x/norm for x in vec] if norm > 0 else vec
+
+
+# Instancia global
+llm_engine: LLMEngine = None
+
+def init_llm():
+    global llm_engine
+    llm_engine = LLMEngine()
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# ANALIZADOR DE MENSAJES AVANZADO
+# ═══════════════════════════════════════════════════════════════════════════════
+

package/src/interfaces/mcp_server.py

@@ -0,0 +1,73 @@
+import json
+import sys
+import logging
+from typing import Dict, Any
+from src.interfaces.nova_bridge import nova_bridge
+
+log = logging.getLogger("conny.mcp")
+
+class MCPServer:
+    """
+    Servidor Model Context Protocol (MCP) sobre stdio.
+    Expone las herramientas del Enjambre (Swarm) y AgentDB a la máquina anfitriona.
+    """
+    def __init__(self):
+        self.tools = {
+            "agent_spawn": self.tool_agent_spawn,
+            "memory_store": self.tool_memory_store,
+            "task_orchestrate": self.tool_task_orchestrate
+        }
+        # Registrar reglas de seguridad con Nova Governance
+        nova_bridge.connect(cannot_do_rules=["rm -rf /", "leak patient data"])
+
+    def handle_request(self, req: Dict[str, Any]) -> Dict[str, Any]:
+        method = req.get("method")
+        params = req.get("params", {})
+        
+        if method == "tools/list":
+            return {"tools": list(self.tools.keys())}
+            
+        if method == "tools/call":
+            tool_name = params.get("name")
+            tool_args = params.get("arguments", {})
+            
+            if tool_name in self.tools:
+                # Validar la acción con Nova Governance antes de ejecutarla
+                if not nova_bridge.validate_action(tool_name, tool_args):
+                    return {"error": f"Acción bloqueada por Nova Governance: {tool_name}"}
+                
+                result = self.tools[tool_name](tool_args)
+                return {"result": result}
+            else:
+                return {"error": "Tool not found"}
+
+        return {"error": "Unknown method"}
+
+    def tool_agent_spawn(self, args: Dict) -> str:
+        role = args.get("role", "coder")
+        return f"Agent {role} spawned successfully."
+
+    def tool_memory_store(self, args: Dict) -> str:
+        # Aquí se conectaría a src.conny.brain.memory.AgentDB
+        key = args.get("key")
+        return f"Memory {key} stored in AgentDB."
+
+    def tool_task_orchestrate(self, args: Dict) -> str:
+        task = args.get("task")
+        return f"Task '{task}' routed to Swarm Queen."
+
+    def start_stdio(self):
+        """Escucha JSON-RPC en stdin."""
+        for line in sys.stdin:
+            if not line.strip():
+                continue
+            try:
+                req = json.loads(line)
+                res = self.handle_request(req)
+                print(json.dumps(res), flush=True)
+            except Exception as e:
+                print(json.dumps({"error": str(e)}), flush=True)
+
+if __name__ == "__main__":
+    server = MCPServer()
+    server.start_stdio()