@innvisor/conny-ai 9.7.0

package/conny_weekly_report.py

@@ -0,0 +1,85 @@
+"""conny_weekly_report.py — Weekly brain report to admin."""
+from __future__ import annotations
+import json, logging, sqlite3
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, Optional
+
+log = logging.getLogger("conny.weekly_report")
+
+
+async def generate_weekly_report(instance_id: str, db_path: str = "conny.db") -> str:
+    """Generate a human-readable weekly report."""
+    try:
+        conn = sqlite3.connect(db_path)
+        conn.row_factory = sqlite3.Row
+        c = conn.cursor()
+
+        week_ago = (datetime.now() - timedelta(days=7)).isoformat()
+
+        # Count conversations
+        c.execute("SELECT COUNT(DISTINCT chat_id) as patients FROM conversations WHERE role='user' AND created_at > ?", (week_ago,))
+        row = c.fetchone()
+        total_patients = row["patients"] if row else 0
+
+        # Count messages
+        c.execute("SELECT COUNT(*) as msgs FROM conversations WHERE created_at > ?", (week_ago,))
+        row = c.fetchone()
+        total_msgs = row["msgs"] if row else 0
+
+        # Count gaps
+        gaps_dir = Path("knowledge_gaps")
+        gaps_count = 0
+        gap_questions = []
+        if gaps_dir.exists():
+            for f in gaps_dir.glob("*.jsonl"):
+                for line in open(f):
+                    try:
+                        g = json.loads(line)
+                        gaps_count += 1
+                        gap_questions.append(g.get("user_msg", "")[:80])
+                    except:
+                        pass
+
+        # Count teachings learned
+        teachings_file = Path(f"teachings/{instance_id}.jsonl")
+        teachings_this_week = 0
+        if teachings_file.exists():
+            for line in open(teachings_file):
+                try:
+                    t = json.loads(line)
+                    if t.get("ts", "") > week_ago:
+                        teachings_this_week += 1
+                except:
+                    pass
+
+        conn.close()
+
+        # Build report
+        report = (
+            f"hola! te cuento cómo me fue esta semana:\n\n"
+            f"hablé con {total_patients} pacientes ({total_msgs} mensajes)\n"
+            f"aprendí {teachings_this_week} cosas nuevas\n"
+        )
+
+        if gaps_count > 0:
+            report += f"\nhubo {gaps_count} preguntas que no supe responder:\n"
+            for q in gap_questions[:5]:
+                report += f"  • {q}\n"
+            report += "\nsi me enseñas con /aprender las respondo sola la próxima vez"
+        else:
+            report += "\nrespondí todo sin problemas esta semana 💪"
+
+        return report
+
+    except Exception as e:
+        log.error(f"[weekly_report] error: {e}")
+        return "no pude generar el reporte esta semana, perdona"
+
+
+async def send_weekly_report(instance_id: str, admin_jid: str, send_fn, db_path: str = "conny.db"):
+    """Generate and send weekly report to admin."""
+    report = await generate_weekly_report(instance_id, db_path)
+    if send_fn and report:
+        await send_fn(admin_jid, report)
+        log.info(f"[weekly_report] sent to {admin_jid}")

package/conny_worm.py

@@ -0,0 +1,88 @@
+"""conny_worm.py — Animated ASCII worm for terminal."""
+from __future__ import annotations
+
+import math
+import sys
+import time
+
+
+SEGMENTS = ["◉", "█", "▓", "▒", "░", "·"]
+PURPLE = "\033[38;5;141m"
+DIM = "\033[2m"
+R = "\033[0m"
+
+
+def boot_sequence(duration: float = 2.0):
+    """
+    Animated worm crawls in, CONNY appears letter by letter.
+    Only runs on real TTY. Graceful skip otherwise.
+    """
+    if not sys.stdout.isatty():
+        return
+
+    frames = int(duration / 0.04)
+    width = 60
+
+    try:
+        sys.stdout.write("\033[?25l")  # hide cursor
+        for f in range(frames):
+            t = f / frames
+            sys.stdout.write("\033[H\033[J")  # clear
+
+            # Worm position (sinusoidal crawl from right to left)
+            worm_x = int((1.0 - t) * width * 0.7) + 2
+            worm_y = int(2 + math.sin(t * math.pi * 3) * 1.2)
+
+            # Canvas
+            canvas = [[" "] * width for _ in range(7)]
+
+            # Draw worm body
+            for i, seg in enumerate(SEGMENTS[:5]):
+                sx = worm_x + i * 2
+                sy = min(6, max(0, worm_y + int(math.sin((t * 6) - i * 0.5) * 0.8)))
+                if 0 <= sx < width and 0 <= sy < 7:
+                    canvas[sy][sx] = seg
+
+            # CONNY text types in progressively
+            word = "CONNY"
+            chars_shown = int(t * 2.5 * len(word))
+            for i, ch in enumerate(word[:min(chars_shown, len(word))]):
+                cx = 6 + i * 4
+                if cx < width:
+                    canvas[5][cx] = ch
+
+            # Render
+            sys.stdout.write("\n")
+            for row in canvas:
+                sys.stdout.write(f"  {PURPLE}{''.join(row)}{R}\n")
+            sys.stdout.flush()
+            time.sleep(0.04)
+
+    except (KeyboardInterrupt, BrokenPipeError):
+        pass
+    finally:
+        sys.stdout.write("\033[?25h")  # show cursor
+        sys.stdout.write("\033[H\033[J")  # clear for real content
+
+
+def crawl_spinner(text: str, duration: float = 1.5):
+    """Single-line crawling worm spinner for loading states."""
+    if not sys.stdout.isatty():
+        sys.stdout.write(f"  {text}\n")
+        return
+
+    frames = int(duration / 0.06)
+    try:
+        sys.stdout.write("\033[?25l")
+        for f in range(frames):
+            t = f / frames
+            x = int(abs(math.sin(t * math.pi * 2)) * 12)
+            worm = "".join(SEGMENTS[:4])
+            sys.stdout.write(f"\033[2K\r  {' ' * x}{PURPLE}{worm}{R} {DIM}{text}{R}")
+            sys.stdout.flush()
+            time.sleep(0.06)
+        sys.stdout.write(f"\033[2K\r")
+    except (KeyboardInterrupt, BrokenPipeError):
+        pass
+    finally:
+        sys.stdout.write("\033[?25h")

package/core/__init__.py

@@ -0,0 +1,25 @@
+"""
+conny/core/ — Clean public API for Conny v9.0.
+
+Exports the main engine components without requiring direct conny.py imports.
+This module bridges the legacy monolith (conny.py) with the new modular architecture.
+"""
+from conny_memory_engine import memory_engine, ConnyMemoryEngine
+from conny_uncertainty import uncertainty_detector, UncertaintyDetector
+from conny_voice import voice, ConnyVoice
+from conny_nova_proxy import NovaLLMProxy
+from src.interfaces.web.admin_api import router as admin_router
+from conny_cron import init_scheduler, shutdown_scheduler
+
+__all__ = [
+    "memory_engine",
+    "ConnyMemoryEngine",
+    "uncertainty_detector",
+    "UncertaintyDetector",
+    "voice",
+    "ConnyVoice",
+    "NovaLLMProxy",
+    "admin_router",
+    "init_scheduler",
+    "shutdown_scheduler",
+]

package/ecosystem.config.js

@@ -0,0 +1,24 @@
+module.exports = {
+  apps: [
+    {
+      name: "conny",
+      script: "/home/ubuntu/conny/run.sh",
+      cwd: "/home/ubuntu/conny",
+      restart_delay: 3000,
+      max_restarts: 10,
+      out_file: "/home/ubuntu/conny/logs/conny.log",
+      error_file: "/home/ubuntu/conny/logs/conny-error.log",
+      watch: false,
+    },
+    {
+      name: "conny-clinica-de-las-americas",
+      script: "/home/ubuntu/conny-instances/clinica-de-las-americas/run.sh",
+      cwd: "/home/ubuntu/conny-instances/clinica-de-las-americas",
+      restart_delay: 3000,
+      max_restarts: 10,
+      out_file: "/home/ubuntu/conny-instances/clinica-de-las-americas/logs/conny.log",
+      error_file: "/home/ubuntu/conny-instances/clinica-de-las-americas/logs/error.log",
+      watch: false,
+    }
+  ]
+}

package/fix_init.py

@@ -0,0 +1,27 @@
+file_path = "conny.py"
+with open(file_path, "r", encoding="utf-8") as f:
+    content = f.read()
+
+old_init = """async def init_conny():
+    \"\"\"Inicializa Conny Ultra.\"\"\"
+    global conny
+    conny = ConnyUltra()
+    await conny.initialize()"""
+
+new_init = """async def init_conny():
+    \"\"\"Inicializa Conny Ultra.\"\"\"
+    global conny
+    conny = ConnyUltra()
+    await conny.initialize()
+    
+    import src.core.globals as g
+    global db, llm_engine, auth_engine, mcp_manager
+    db = g.db
+    llm_engine = g.llm_engine
+    auth_engine = getattr(g, "auth_engine", None)
+    mcp_manager = getattr(g, "mcp_manager", None)
+"""
+
+content = content.replace(old_init, new_init)
+with open(file_path, "w", encoding="utf-8") as f:
+    f.write(content)

package/install.sh

@@ -0,0 +1,78 @@
+#!/bin/bash
+# Conny AI - The AI Receptionist Engine
+# Ultimate GitHub Installer Script
+set -e
+
+C_PRIMARY="\033[38;5;135m"
+C_SUCCESS="\033[38;5;46m"
+C_MUTED="\033[38;5;240m"
+BOLD="\033[1m"
+RESET="\033[0m"
+
+echo -e "\n  ${C_PRIMARY}${BOLD}✦ Conny AI - Ultimate Installer${RESET}"
+echo -e "  ${C_MUTED}─────────────────────────────────────────${RESET}"
+
+# Handle sudo gracefully (Termux / Root environments)
+SUDO=""
+if command -v sudo &> /dev/null; then
+    SUDO="sudo"
+fi
+
+# 1. Install chafa if possible
+if ! command -v chafa &> /dev/null; then
+    echo -e "\n  ${BOLD}1. Instalando motor True-Color (chafa)...${RESET}"
+    if command -v pkg &> /dev/null; then
+        pkg install -y chafa || true
+    elif command -v apt-get &> /dev/null; then
+        $SUDO apt-get update -yqq && $SUDO apt-get install -yqq chafa || true
+    elif command -v brew &> /dev/null; then
+        brew install chafa || true
+    else
+        echo -e "  ${C_MUTED}No se pudo instalar chafa automáticamente. Se usará el logo clásico.${RESET}"
+    fi
+else
+    echo -e "\n  ${BOLD}1. Motor True-Color detectado (chafa).${RESET}"
+fi
+
+# 2. Verify Python sanely (3.9+), without hardcoding minor versions
+PYTHON_BIN=""
+for candidate in python3 python; do
+    if command -v "$candidate" >/dev/null 2>&1; then
+        if "$candidate" - <<'PY' >/dev/null 2>&1
+import sys
+raise SystemExit(0 if sys.version_info >= (3, 9) else 1)
+PY
+        then
+            PYTHON_BIN="$candidate"
+            break
+        fi
+    fi
+done
+
+if [ -n "$PYTHON_BIN" ]; then
+    PY_VERSION="$($PYTHON_BIN -c 'import sys; print(".".join(map(str, sys.version_info[:3])))')"
+    echo -e "\n  ${BOLD}2. Python detectado:${RESET} ${C_SUCCESS}${PYTHON_BIN} (${PY_VERSION})${RESET}"
+else
+    echo -e "\n  ${BOLD}2. Python 3.9+ no detectado localmente.${RESET}"
+    echo -e "  ${C_MUTED}Conny intentará crear su runtime cuando se ejecute por primera vez.${RESET}"
+fi
+
+# 3. Install NPM Package
+if ! command -v npm &> /dev/null; then
+    echo -e "\n  \033[31mError: Node.js y npm son requeridos. Instálalos primero.\033[0m"
+    exit 1
+fi
+
+echo -e "\n  ${BOLD}3. Limpiando versiones anteriores...${RESET}"
+npm uninstall -g conny-ai @blackboss/conny || true
+
+echo -e "\n  ${BOLD}4. Instalando Conny CLI y Motor AI...${RESET}"
+npm install -g "${CONNY_INSTALL_PACKAGE:-conny-ai@latest}"
+
+echo -e "\n  ${BOLD}5. Verificando bootstrap del CLI...${RESET}"
+if command -v conny >/dev/null 2>&1; then
+    conny --version || true
+fi
+
+echo -e "\n  ${C_SUCCESS}${BOLD}✔ ¡Conny instalado con éxito!${RESET}"
+echo -e "  Ejecuta ${C_PRIMARY}conny init${RESET} en tu terminal para empezar la magia.\n"

package/knowledge_base.py

@@ -0,0 +1,330 @@
+"""
+knowledge_base.py — Base de conocimiento de la clinica para Conny
+
+Sistema que permite al admin cargar un documento maestro con toda la info
+de la clinica (servicios, precios, contraindicaciones, protocolos, FAQs, etc.)
+y que Conny consulte siempre antes de responder.
+
+Flujo:
+  1. Admin termina setup y Conny le pide el documento maestro
+  2. Admin envia texto libre (puede ser muy largo)
+  3. Se chunquea y se guarda en DB
+  4. Cuando un paciente pregunta algo, se recuperan los chunks relevantes
+  5. El contexto del KB se inyecta en el system prompt con maxima prioridad
+
+Schema DB adicional:
+  - knowledge_base: texto completo del documento
+  - kb_chunks: chunks indexados por palabras clave
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import sqlite3
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+
+log = logging.getLogger("conny.kb")
+
+# Tamano de chunks (en caracteres)
+CHUNK_SIZE   = 400
+CHUNK_OVERLAP = 80
+
+# Cuantos chunks incluir en el contexto del LLM
+MAX_CHUNKS_IN_CONTEXT = 4
+
+# Minima relevancia para incluir un chunk (0-1)
+MIN_RELEVANCE = 0.15
+
+
+# ─── Chunking ────────────────────────────────────────────────────────────────
+
+def _split_into_chunks(text: str) -> List[str]:
+    """
+    Divide el texto en chunks con overlap.
+    Intenta partir en parrafos/oraciones completas.
+    """
+    # Limpiar texto
+    text = re.sub(r'\r\n', '\n', text)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+    text = text.strip()
+
+    # Primero intentar partir por parrafos
+    paragraphs = [p.strip() for p in re.split(r'\n\n+', text) if p.strip()]
+
+    chunks = []
+    current = ""
+
+    for para in paragraphs:
+        if len(current) + len(para) < CHUNK_SIZE:
+            current = (current + "\n\n" + para).strip()
+        else:
+            if current:
+                chunks.append(current)
+            # Si el parrafo es muy largo, partirlo por oraciones
+            if len(para) > CHUNK_SIZE:
+                sentences = re.split(r'(?<=[.!?])\s+', para)
+                buf = ""
+                for s in sentences:
+                    if len(buf) + len(s) < CHUNK_SIZE:
+                        buf = (buf + " " + s).strip()
+                    else:
+                        if buf:
+                            chunks.append(buf)
+                        buf = s
+                if buf:
+                    current = buf
+                else:
+                    current = ""
+            else:
+                current = para
+
+    if current:
+        chunks.append(current)
+
+    return [c for c in chunks if len(c) > 30]
+
+
+def _extract_keywords(text: str) -> List[str]:
+    """
+    Extrae palabras clave de un texto para indexacion.
+    Ignora stopwords comunes en espanol.
+    """
+    STOPWORDS = {
+        "el", "la", "los", "las", "un", "una", "unos", "unas",
+        "de", "del", "al", "a", "en", "con", "por", "para", "que",
+        "como", "cuando", "donde", "cual", "quien", "este", "esta",
+        "ese", "esa", "mi", "tu", "su", "y", "o", "pero", "si", "no",
+        "mas", "muy", "ya", "es", "son", "era", "fue", "ser", "estar",
+        "hay", "han", "hemos", "tienen", "tiene", "hace", "hacer",
+        "puede", "pueden", "se", "lo", "le", "les", "me", "te", "nos",
+        "sobre", "entre", "hasta", "desde", "durante", "antes", "despues",
+        "tambien", "ademas", "aunque", "porque", "sino", "sino", "ni",
+        "todo", "toda", "todos", "todas", "cada", "otro", "otra",
+    }
+    words = re.findall(r'\b[a-záéíóúüñA-ZÁÉÍÓÚÜÑ]{3,}\b', text.lower())
+    keywords = [w for w in words if w not in STOPWORDS]
+    # Frecuencia
+    freq: Dict[str, int] = {}
+    for w in keywords:
+        freq[w] = freq.get(w, 0) + 1
+    # Top palabras por frecuencia
+    return sorted(freq, key=freq.get, reverse=True)[:20]
+
+
+def _score_chunk(chunk_keywords: List[str], query_keywords: List[str]) -> float:
+    """
+    Calcula relevancia de un chunk para una query.
+    Score de 0 a 1.
+    """
+    if not query_keywords or not chunk_keywords:
+        return 0.0
+    chunk_set = set(chunk_keywords)
+    matches = sum(1 for kw in query_keywords if kw in chunk_set)
+    # Bonus por matches exactos de frases
+    return min(matches / max(len(query_keywords), 1), 1.0)
+
+
+# ─── KnowledgeBase Manager ────────────────────────────────────────────────────
+
+class KnowledgeBase:
+    """
+    Gestor de la base de conocimiento de la clinica.
+    Se inicializa con la conexion DB de conny.
+    """
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self._ensure_tables()
+
+    def _conn(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _ensure_tables(self):
+        """Crea las tablas KB si no existen (migracion segura)."""
+        with self._conn() as c:
+            c.executescript("""
+            -- Documento maestro de la clinica
+            CREATE TABLE IF NOT EXISTS knowledge_base (
+                id INTEGER PRIMARY KEY,
+                raw_text TEXT DEFAULT '',
+                chunk_count INTEGER DEFAULT 0,
+                word_count INTEGER DEFAULT 0,
+                created_at TEXT DEFAULT (datetime('now')),
+                updated_at TEXT DEFAULT (datetime('now'))
+            );
+            INSERT OR IGNORE INTO knowledge_base (id) VALUES (1);
+
+            -- Chunks indexados para recuperacion rapida
+            CREATE TABLE IF NOT EXISTS kb_chunks (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                content TEXT NOT NULL,
+                keywords TEXT DEFAULT '[]',
+                section_hint TEXT DEFAULT '',
+                created_at TEXT DEFAULT (datetime('now'))
+            );
+            CREATE INDEX IF NOT EXISTS idx_kb_chunks_id ON kb_chunks(id);
+            """)
+        log.info("[kb] tablas listas")
+
+    # ─── Ingestion ────────────────────────────────────────────────────────────
+
+    def save_learned_fact(self, question: str, answer: str, source: str = "admin") -> Dict:
+        """Guarda un hecho aprendido directamente de la interacción con el admin."""
+        fact_text = f"\n\n--- DATO APRENDIDO ({source}) ---\nPREGUNTA: {question}\nRESPUESTA: {answer}"
+        return self.append(fact_text)
+
+    def ingest(self, raw_text: str) -> Dict:
+        """
+        Procesa y guarda el documento maestro de la clinica.
+        Reemplaza cualquier KB anterior.
+        Retorna stats del ingestion.
+        """
+        if not raw_text or not raw_text.strip():
+            return {"ok": False, "error": "texto vacio"}
+
+        raw_text = raw_text.strip()
+        chunks = _split_into_chunks(raw_text)
+        word_count = len(raw_text.split())
+
+        with self._conn() as c:
+            # Limpiar chunks anteriores
+            c.execute("DELETE FROM kb_chunks")
+
+            # Guardar documento maestro
+            c.execute("""
+                UPDATE knowledge_base
+                SET raw_text=?, chunk_count=?, word_count=?, updated_at=datetime('now')
+                WHERE id=1
+            """, (raw_text, len(chunks), word_count))
+
+            # Insertar chunks con keywords
+            for i, chunk in enumerate(chunks):
+                keywords = _extract_keywords(chunk)
+                # Detectar hint de seccion (primera linea si parece titulo)
+                first_line = chunk.split('\n')[0].strip()
+                section_hint = first_line if len(first_line) < 60 and not first_line.endswith('.') else ""
+
+                c.execute("""
+                    INSERT INTO kb_chunks (content, keywords, section_hint)
+                    VALUES (?, ?, ?)
+                """, (chunk, json.dumps(keywords, ensure_ascii=False), section_hint))
+
+        log.info(f"[kb] ingested {len(chunks)} chunks, {word_count} palabras")
+        return {
+            "ok": True,
+            "chunks": len(chunks),
+            "words": word_count,
+            "chars": len(raw_text),
+        }
+
+    def append(self, additional_text: str) -> Dict:
+        """Agrega texto al KB existente sin borrar lo anterior."""
+        existing = self.get_raw()
+        combined = (existing + "\n\n" + additional_text).strip() if existing else additional_text
+        return self.ingest(combined)
+
+    # ─── Recuperacion ─────────────────────────────────────────────────────────
+
+    def retrieve(self, query: str, max_chunks: int = MAX_CHUNKS_IN_CONTEXT) -> str:
+        """
+        Recupera los chunks mas relevantes para una query.
+        Retorna contexto listo para inyectar al LLM.
+        """
+        if not self.has_content():
+            return ""
+
+        query_keywords = _extract_keywords(query)
+        if not query_keywords:
+            # Sin keywords claras: retornar primeros chunks (intro de la clinica)
+            return self._get_first_chunks(max_chunks)
+
+        with self._conn() as c:
+            rows = c.execute("SELECT id, content, keywords FROM kb_chunks").fetchall()
+
+        # Calcular relevancia de cada chunk
+        scored: List[Tuple[float, str]] = []
+        for row in rows:
+            try:
+                chunk_kws = json.loads(row["keywords"] or "[]")
+            except Exception:
+                chunk_kws = []
+            score = _score_chunk(chunk_kws, query_keywords)
+            if score >= MIN_RELEVANCE:
+                scored.append((score, row["content"]))
+
+        if not scored:
+            # Ninguno relevante: dar los primeros (contexto general)
+            return self._get_first_chunks(max_chunks)
+
+        # Ordenar por relevancia descendente
+        scored.sort(key=lambda x: x[0], reverse=True)
+        selected = [content for _, content in scored[:max_chunks]]
+
+        return "\n\n---\n\n".join(selected)
+
+    def _get_first_chunks(self, n: int) -> str:
+        """Retorna los primeros n chunks (contexto general de la clinica)."""
+        with self._conn() as c:
+            rows = c.execute(
+                "SELECT content FROM kb_chunks ORDER BY id LIMIT ?", (n,)
+            ).fetchall()
+        return "\n\n---\n\n".join(r["content"] for r in rows)
+
+    def get_raw(self) -> str:
+        """Retorna el documento completo."""
+        with self._conn() as c:
+            row = c.execute("SELECT raw_text FROM knowledge_base WHERE id=1").fetchone()
+        return row["raw_text"] if row else ""
+
+    def get_stats(self) -> Dict:
+        with self._conn() as c:
+            row = c.execute(
+                "SELECT chunk_count, word_count, updated_at FROM knowledge_base WHERE id=1"
+            ).fetchone()
+        if row:
+            return {
+                "chunks": row["chunk_count"],
+                "words":  row["word_count"],
+                "updated_at": row["updated_at"],
+            }
+        return {"chunks": 0, "words": 0, "updated_at": None}
+
+    def has_content(self) -> bool:
+        with self._conn() as c:
+            row = c.execute(
+                "SELECT chunk_count FROM knowledge_base WHERE id=1"
+            ).fetchone()
+        return bool(row and row["chunk_count"] > 0)
+
+    def clear(self):
+        """Borra el KB completo."""
+        with self._conn() as c:
+            c.execute("DELETE FROM kb_chunks")
+            c.execute("""
+                UPDATE knowledge_base
+                SET raw_text='', chunk_count=0, word_count=0, updated_at=datetime('now')
+                WHERE id=1
+            """)
+        log.info("[kb] KB limpiado")
+
+
+# ─── Formateo para el LLM ─────────────────────────────────────────────────────
+
+def format_kb_context(kb_text: str) -> str:
+    """
+    Envuelve el contexto del KB en un bloque claro para el LLM.
+    """
+    if not kb_text:
+        return ""
+    return (
+        "=== BASE DE CONOCIMIENTO DE LA CLINICA ===\n"
+        "(Esta es informacion oficial de la clinica. Usala con maxima prioridad "
+        "antes de buscar en internet o inventar datos.)\n\n"
+        f"{kb_text}\n"
+        "=== FIN BASE DE CONOCIMIENTO ==="
+    )