@innvisor/conny-ai 9.7.0

package/conny_learning.py

@@ -0,0 +1,154 @@
+"""conny_learning.py — Real-time 3-layer learning engine."""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+log = logging.getLogger("conny.learning")
+
+POSITIVE_SIGNALS = [
+    "gracias", "perfecto", "listo", "genial", "excelente", "dale", "ok perfecto",
+    "thanks", "great", "perfect", "awesome",
+    "te agradezco", "muy amable", "me queda claro", "entendido",
+]
+NEGATIVE_SIGNALS = [
+    "no entiendo", "eso no es", "no me sirve", "otra vez", "repite",
+    "eso ya lo dije", "ya te dije", "no es eso", "equivocad",
+]
+
+
+class RealTimeLearningEngine:
+    """3-layer learning: per-turn, per-session, admin-corrected."""
+
+    def __init__(self, base_dir: str = "memory_store"):
+        self._base = Path(base_dir)
+        self._teachings_dir = Path("teachings")
+        self._teachings_dir.mkdir(exist_ok=True)
+
+    def _instance_dir(self, instance_id: str) -> Path:
+        d = self._base / instance_id / "learning"
+        d.mkdir(parents=True, exist_ok=True)
+        return d
+
+    async def learn_from_turn(self, instance_id: str, user_msg: str,
+                              bot_response: str, user_reply: str = ""):
+        idir = self._instance_dir(instance_id)
+        if user_reply and any(s in user_reply.lower() for s in POSITIVE_SIGNALS):
+            await self._reinforce_pattern(idir, bot_response, user_msg)
+        if user_reply and any(s in user_reply.lower() for s in NEGATIVE_SIGNALS):
+            await self._flag_failed_response(idir, bot_response, user_msg, user_reply)
+
+    async def _reinforce_pattern(self, idir: Path, response: str, trigger: str):
+        file = idir / "reinforced.jsonl"
+        entry = {"ts": datetime.now().isoformat(), "trigger": trigger[:200], "response": response[:300]}
+        with open(file, "a") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    async def _flag_failed_response(self, idir: Path, response: str,
+                                    user_msg: str, user_reply: str):
+        file = idir / "failures.jsonl"
+        entry = {
+            "ts": datetime.now().isoformat(),
+            "user_msg": user_msg[:200],
+            "bot_response": response[:300],
+            "user_complaint": user_reply[:200],
+        }
+        with open(file, "a") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+        log.info(f"[learning] flagged failed response for {idir.parent.name}")
+
+    async def learn_from_session(self, instance_id: str, messages: List[Dict],
+                                 outcome: str = "unknown"):
+        idir = self._instance_dir(instance_id)
+        file = idir / "sessions.jsonl"
+        entry = {
+            "ts": datetime.now().isoformat(),
+            "outcome": outcome,
+            "turns": len(messages),
+            "summary": self._summarize_session(messages),
+        }
+        with open(file, "a") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+        if outcome == "booked":
+            await self._save_successful_flow(idir, messages)
+        elif outcome == "abandoned":
+            await self._save_dropout_point(idir, messages)
+
+    async def _save_successful_flow(self, idir: Path, messages: List[Dict]):
+        file = idir / "successful_flows.jsonl"
+        flow = [{"role": m["role"], "content": m["content"][:150]} for m in messages[-8:]]
+        with open(file, "a") as f:
+            f.write(json.dumps({"ts": datetime.now().isoformat(), "flow": flow}, ensure_ascii=False) + "\n")
+
+    async def _save_dropout_point(self, idir: Path, messages: List[Dict]):
+        file = idir / "dropouts.jsonl"
+        last_bot = ""
+        for m in reversed(messages):
+            if m.get("role") == "assistant":
+                last_bot = m["content"][:200]
+                break
+        with open(file, "a") as f:
+            f.write(json.dumps({"ts": datetime.now().isoformat(), "last_bot_msg": last_bot}, ensure_ascii=False) + "\n")
+
+    def _summarize_session(self, messages: List[Dict]) -> str:
+        user_msgs = [m["content"] for m in messages if m.get("role") == "user"]
+        return " | ".join(msg[:50] for msg in user_msgs[:5]) if user_msgs else "empty"
+
+    async def learn_from_admin(self, instance_id: str, question: str, answer: str,
+                               admin_id: str = "") -> str:
+        teachings_file = self._teachings_dir / f"{instance_id}.jsonl"
+        entry = {
+            "ts": datetime.now().isoformat(),
+            "question": question,
+            "answer": answer,
+            "taught_by": admin_id,
+            "question_hash": hashlib.md5(question.lower().strip().encode()).hexdigest()[:12],
+        }
+        with open(teachings_file, "a") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+        try:
+            faq_file = self._base / instance_id / "semantic" / "faqs.json"
+            faq_file.parent.mkdir(parents=True, exist_ok=True)
+            faqs = json.loads(faq_file.read_text()) if faq_file.exists() else {}
+            faqs[entry["question_hash"]] = {
+                "question": question,
+                "answer": answer,
+                "frequency": faqs.get(entry["question_hash"], {}).get("frequency", 0) + 1,
+                "source": "admin_taught",
+                "last_asked": datetime.now().isoformat(),
+            }
+            faq_file.write_text(json.dumps(faqs, ensure_ascii=False, indent=2))
+        except Exception as e:
+            log.warning(f"[learning] FAQ update failed: {e}")
+
+        log.info(f"[learning] admin taught: '{question[:50]}' → '{answer[:50]}'")
+        return f"✅ Aprendido. Ya sé responder: '{question[:50]}...'"
+
+    async def get_teachings(self, instance_id: str, limit: int = 50) -> List[Dict]:
+        teachings_file = self._teachings_dir / f"{instance_id}.jsonl"
+        if not teachings_file.exists():
+            return []
+        teachings = []
+        for line in open(teachings_file):
+            try:
+                teachings.append(json.loads(line))
+            except Exception:
+                continue
+        return teachings[-limit:]
+
+    def build_teachings_prompt(self, teachings: List[Dict]) -> str:
+        if not teachings:
+            return ""
+        lines = ["INFORMACIÓN APRENDIDA (verificada por admin):"]
+        for t in teachings:
+            lines.append(f"- Pregunta: {t['question']}\n  Respuesta: {t['answer']}")
+        return "\n".join(lines)
+
+
+learning_engine = RealTimeLearningEngine()

package/conny_memory.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""
+conny_memory.py — Persistent memory system for Conny multi-tenant instances.
+Inspired by OpenClaw memory architecture, built for business use.
+
+File structure per instance:
+  instances/{instance_id}/
+    knowledge/
+      MEMORY.md       ← master memory (loaded on every conversation)
+      servicios.md    ← what the business offers
+      precios.md      ← pricing
+      faqs.md         ← frequently asked questions
+      objeciones.md   ← objections heard + resolutions
+      sector.md       ← industry context and tone rules
+    learned/
+      escalaciones/
+        {YYYY-MM-DD}/
+          {timestamp}.md   ← each escalation
+      patrones/
+        {YYYY-MM}.md       ← monthly patterns
+    persona/
+      tono.md              ← tone rules
+      personalidad.md      ← persona config
+    session_cache/
+      {chat_id}.json       ← last 20 messages per contact
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+log = logging.getLogger("conny.memory")
+
+
+class ConnyMemory:
+
+    def __init__(self, instance_id: str = "default"):
+        self.instance_id = instance_id
+        
+        # Check standard paths in order of preference
+        paths_to_try = [
+            Path(f"/home/ubuntu/conny-instances/{instance_id}"),
+            Path(f"/home/ubuntu/conny/instances/{instance_id}"),
+            Path(f"instances/{instance_id}"),
+        ]
+        
+        selected_base = paths_to_try[-1] # fallback
+        for p in paths_to_try:
+            if p.exists() and p.is_dir():
+                selected_base = p
+                break
+                
+        self.base = selected_base
+        self.memory_file = self.base / "knowledge" / "MEMORY.md"
+        self.knowledge_dir = self.base / "knowledge"
+        self.learned_dir = self.base / "learned"
+        self.persona_dir = self.base / "persona"
+        self.cache_dir = self.base / "session_cache"
+
+    def load_context(self) -> str:
+        """Load everything Conny needs at the start of every conversation."""
+        sections = []
+
+        if self.memory_file.exists():
+            sections.append(self.memory_file.read_text())
+
+        if self.knowledge_dir.exists():
+            for f in sorted(self.knowledge_dir.glob("*.md")):
+                if f.name == "MEMORY.md":
+                    continue
+                try:
+                    content = f.read_text().strip()
+                    if content:
+                        sections.append(f"## {f.stem.replace('_', ' ').title()}\n{content}")
+                except Exception as e:
+                    log.warning(f"[memory] read error {f}: {e}")
+
+        escalations = sorted(
+            (self.learned_dir / "escalaciones").rglob("*.md"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )[:10]
+        if escalations:
+            parts = []
+            for e in escalations:
+                try:
+                    parts.append(e.read_text().strip())
+                except Exception:
+                    pass
+            if parts:
+                sections.append("## Respuestas aprendidas\n" + "\n\n---\n\n".join(parts))
+
+        return "\n\n---\n\n".join(sections) if sections else ""
+
+    def save_escalation(
+        self,
+        client_msg: str,
+        admin_response: str,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Save an admin escalation so Conny learns it."""
+        now = datetime.now()
+        folder = self.learned_dir / "escalaciones" / now.strftime("%Y-%m-%d")
+        folder.mkdir(parents=True, exist_ok=True)
+        ts = now.strftime("%H%M%S")
+        content = (
+            f"# Escalación {ts}\n"
+            f"Pregunta del cliente: {client_msg}\n"
+            f"Respuesta del admin: {admin_response}\n"
+            f"Fecha: {now.isoformat()}\n"
+        )
+        if context:
+            content += f"\nContexto:\n{json.dumps(context, ensure_ascii=False, indent=2)}\n"
+        (folder / f"{ts}.md").write_text(content)
+        self._append_to_memory(
+            f"- Aprendido {now.strftime('%Y-%m-%d')}: "
+            f"'{client_msg[:60]}' → '{admin_response[:120]}'"
+        )
+        log.info(f"[memory] escalation saved: {client_msg[:40]}")
+
+    def update_knowledge(self, file: str, content: str) -> None:
+        """Admin updates a knowledge file."""
+        safe = file.replace("..", "").replace("/", "").strip()
+        target = self.knowledge_dir / f"{safe}.md"
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(content)
+        log.info(f"[memory] knowledge updated: {safe}")
+
+    def read_knowledge(self, file: str) -> str:
+        """Read a knowledge file."""
+        safe = file.replace("..", "").replace("/", "").strip()
+        target = self.knowledge_dir / f"{safe}.md"
+        if target.exists():
+            return target.read_text()
+        return ""
+
+    def get_session_cache(self, chat_id: str) -> List[Dict[str, str]]:
+        """Get last 20 messages for a chat."""
+        cache_file = self.cache_dir / f"{chat_id}.json"
+        if cache_file.exists():
+            try:
+                return json.loads(cache_file.read_text())
+            except Exception:
+                pass
+        return []
+
+    def save_session_cache(self, chat_id: str, messages: List[Dict[str, str]]) -> None:
+        """Save session cache, keeping last 20."""
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        cache_file = self.cache_dir / f"{chat_id}.json"
+        cache_file.write_text(json.dumps(messages[-20:], ensure_ascii=False))
+
+    def append_to_cache(self, chat_id: str, role: str, content: str) -> None:
+        """Append one message to session cache."""
+        cache = self.get_session_cache(chat_id)
+        cache.append({"role": role, "content": content})
+        self.save_session_cache(chat_id, cache)
+
+    def delete_session_cache(self, chat_id: str) -> None:
+        """Borra la caché de sesión y archivos de aprendizaje temporal para un chat_id en modo demo."""
+        try:
+            cache_file = self.cache_dir / f"{chat_id}.json"
+            if cache_file.exists():
+                cache_file.unlink()
+        except Exception as e:
+            log.warning(f"Error deleting session cache for {chat_id}: {e}")
+
+    def get_persona_tone(self) -> str:
+        """Load persona tone file."""
+        tone = self.persona_dir / "tono.md"
+        if tone.exists():
+            return tone.read_text()
+        return ""
+
+    def save_persona_tone(self, content: str) -> None:
+        """Save persona tone."""
+        self.persona_dir.mkdir(parents=True, exist_ok=True)
+        (self.persona_dir / "tono.md").write_text(content)
+
+    def save_pattern(self, pattern_type: str, content: str) -> None:
+        """Save monthly pattern."""
+        now = datetime.now()
+        folder = self.learned_dir / "patrones"
+        folder.mkdir(parents=True, exist_ok=True)
+        month_file = folder / f"{now.strftime('%Y-%m')}.md"
+        with open(month_file, "a") as f:
+            f.write(f"\n## {now.strftime('%Y-%m-%d')} [{pattern_type}]\n{content}")
+
+    def get_patterns(self, months: int = 2) -> str:
+        """Get recent patterns."""
+        folder = self.learned_dir / "patrones"
+        if not folder.exists():
+            return ""
+        parts = []
+        now = datetime.now()
+        for i in range(months):
+            dt = now.replace(day=1)
+            m = now.month - i
+            while m <= 0:
+                m += 12
+            dt = dt.replace(month=((m - 1) % 12) + 1)
+            if m > now.month:
+                dt = dt.replace(year=dt.year - 1)
+            f = folder / f"{dt.strftime('%Y-%m')}.md"
+            if f.exists():
+                parts.append(f.read_text())
+        return "\n\n".join(parts)
+
+    def _append_to_memory(self, line: str) -> None:
+        """Append line to MEMORY.md."""
+        self.knowledge_dir.mkdir(parents=True, exist_ok=True)
+        with open(self.memory_file, "a") as f:
+            f.write(f"\n{line}")
+
+    def init_instance(self) -> None:
+        """Create all directories for a new instance."""
+        for d in (
+            self.knowledge_dir,
+            self.learned_dir / "escalaciones",
+            self.learned_dir / "patrones",
+            self.persona_dir,
+            self.cache_dir,
+        ):
+            d.mkdir(parents=True, exist_ok=True)
+        if not self.memory_file.exists():
+            self.memory_file.write_text(
+                f"# MEMORY.md — {self.instance_id}\n"
+                f"# Inicializado: {datetime.now().isoformat()}\n\n"
+                "## Lo que sé de este negocio:\n(vacío)\n"
+            )
+
+
+_memory_cache: Dict[str, "ConnyMemory"] = {}
+
+
+def get_memory(instance_id: str = "default") -> "ConnyMemory":
+    if instance_id not in _memory_cache:
+        _memory_cache[instance_id] = ConnyMemory(instance_id)
+    return _memory_cache[instance_id]

package/conny_memory_engine.py

@@ -0,0 +1,292 @@
+"""
+conny_memory_engine.py — Self-learning episodic + semantic memory.
+Inspired by OpenClaw's memory pattern.
+Per-instance memory with TF-IDF recall, entity extraction, FAQ consolidation.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import re
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+log = logging.getLogger("conny.memory")
+
+
+class ConnyMemoryEngine:
+    """Per-instance memory with episodic recall + semantic extraction + procedural learning."""
+
+    def __init__(self, base_dir: str = "memory_store"):
+        self._base = Path(base_dir)
+        self._base.mkdir(exist_ok=True)
+        self._tfidf_cache: Dict[str, Any] = {}
+
+    def _instance_dir(self, instance_id: str) -> Path:
+        d = self._base / instance_id
+        for sub in ("episodic", "semantic", "procedural", "working"):
+            (d / sub).mkdir(parents=True, exist_ok=True)
+        return d
+
+    async def ingest_conversation(self, instance_id: str, chat_id: str, messages: List[Dict[str, str]]):
+        """After every conversation: store episodic + extract entities + update FAQ frequency."""
+        idir = self._instance_dir(instance_id)
+        today = datetime.now().strftime("%Y-%m-%d")
+
+        # 1. Store episodic
+        ep_file = idir / "episodic" / f"{today}.jsonl"
+        entry = {
+            "ts": datetime.now().isoformat(),
+            "chat_id": chat_id,
+            "messages": messages[-20:],
+        }
+        with open(ep_file, "a") as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+        # 2. Extract entities
+        entities = self._extract_entities(messages)
+        if entities:
+            ent_file = idir / "semantic" / "entities.json"
+            existing = json.loads(ent_file.read_text()) if ent_file.exists() else {}
+            for etype, values in entities.items():
+                if etype not in existing:
+                    existing[etype] = {}
+                for val in values:
+                    if val in existing[etype]:
+                        existing[etype][val]["count"] += 1
+                        existing[etype][val]["last_seen"] = datetime.now().isoformat()
+                    else:
+                        existing[etype][val] = {
+                            "count": 1,
+                            "last_seen": datetime.now().isoformat(),
+                            "chat_id": chat_id,
+                        }
+            ent_file.write_text(json.dumps(existing, ensure_ascii=False, indent=2))
+
+        # 3. Update FAQ frequency
+        user_questions = [
+            m["content"] for m in messages
+            if m.get("role") == "user" and "?" in m.get("content", "")
+        ]
+        if user_questions:
+            faq_file = idir / "semantic" / "faqs.json"
+            faqs = json.loads(faq_file.read_text()) if faq_file.exists() else {}
+            for q in user_questions:
+                qhash = hashlib.md5(q.lower().strip().encode()).hexdigest()[:12]
+                if qhash in faqs:
+                    faqs[qhash]["frequency"] += 1
+                    faqs[qhash]["last_asked"] = datetime.now().isoformat()
+                else:
+                    answer = ""
+                    for i, m in enumerate(messages):
+                        if m.get("content") == q and i + 1 < len(messages):
+                            answer = messages[i + 1].get("content", "")
+                            break
+                    faqs[qhash] = {
+                        "question": q,
+                        "answer": answer[:500],
+                        "frequency": 1,
+                        "first_asked": datetime.now().isoformat(),
+                        "last_asked": datetime.now().isoformat(),
+                    }
+            faq_file.write_text(json.dumps(faqs, ensure_ascii=False, indent=2))
+
+        # Invalidate TF-IDF cache
+        self._tfidf_cache.pop(instance_id, None)
+
+    async def recall_context(self, instance_id: str, user_message: str, top_k: int = 5) -> List[Dict]:
+        """Before every LLM call: retrieve relevant past exchanges using TF-IDF similarity."""
+        idir = self._instance_dir(instance_id)
+
+        # Load episodic entries from last 30 days
+        docs: List[Dict] = []
+        ep_dir = idir / "episodic"
+        cutoff = datetime.now() - timedelta(days=30)
+
+        for f in sorted(ep_dir.glob("*.jsonl"), reverse=True):
+            try:
+                file_date = datetime.strptime(f.stem, "%Y-%m-%d")
+                if file_date < cutoff:
+                    break
+            except ValueError:
+                continue
+            with open(f) as fh:
+                for line in fh:
+                    try:
+                        entry = json.loads(line)
+                        text = " ".join(
+                            m.get("content", "") for m in entry.get("messages", [])
+                        )
+                        if text.strip():
+                            docs.append({"text": text, "entry": entry})
+                    except json.JSONDecodeError:
+                        continue
+
+        if not docs or not user_message.strip():
+            return []
+
+        try:
+            from sklearn.feature_extraction.text import TfidfVectorizer
+            from sklearn.metrics.pairwise import cosine_similarity
+
+            corpus = [d["text"] for d in docs] + [user_message]
+            vectorizer = TfidfVectorizer(max_features=5000)
+            tfidf_matrix = vectorizer.fit_transform(corpus)
+
+            query_vec = tfidf_matrix[-1]
+            doc_vecs = tfidf_matrix[:-1]
+            similarities = cosine_similarity(query_vec, doc_vecs).flatten()
+
+            top_indices = similarities.argsort()[-top_k:][::-1]
+            results = []
+            for idx in top_indices:
+                if similarities[idx] > 0.05:
+                    results.append({
+                        "score": float(similarities[idx]),
+                        "messages": docs[idx]["entry"].get("messages", [])[-6:],
+                        "chat_id": docs[idx]["entry"].get("chat_id", ""),
+                        "ts": docs[idx]["entry"].get("ts", ""),
+                    })
+            return results
+        except ImportError:
+            log.warning("[memory] scikit-learn not available, skipping recall")
+            return []
+        except Exception as e:
+            log.warning(f"[memory] recall error: {e}")
+            return []
+
+    async def get_top_faqs(self, instance_id: str, limit: int = 20) -> List[Dict]:
+        """Get most frequently asked questions for system prompt injection."""
+        idir = self._instance_dir(instance_id)
+        faq_file = idir / "semantic" / "faqs.json"
+        if not faq_file.exists():
+            return []
+        faqs = json.loads(faq_file.read_text())
+        sorted_faqs = sorted(faqs.values(), key=lambda x: x.get("frequency", 0), reverse=True)
+        return sorted_faqs[:limit]
+
+    async def learn_from_success(self, instance_id: str, chat_id: str,
+                                 flow: List[Dict], outcome: str = "booking"):
+        """Store successful conversation patterns."""
+        idir = self._instance_dir(instance_id)
+        success_file = idir / "procedural" / "successful_flows.json"
+        existing = json.loads(success_file.read_text()) if success_file.exists() else []
+        existing.append({
+            "ts": datetime.now().isoformat(),
+            "chat_id": chat_id,
+            "outcome": outcome,
+            "flow_summary": [
+                {"role": m["role"], "content": m["content"][:200]}
+                for m in flow[-10:]
+            ],
+        })
+        existing = existing[-200:]
+        success_file.write_text(json.dumps(existing, ensure_ascii=False, indent=2))
+
+    async def learn_from_failure(self, instance_id: str, chat_id: str,
+                                 flow: List[Dict], reason: str = "escalated"):
+        """Store failed conversation patterns for avoidance."""
+        idir = self._instance_dir(instance_id)
+        fail_file = idir / "procedural" / "failed_flows.json"
+        existing = json.loads(fail_file.read_text()) if fail_file.exists() else []
+        existing.append({
+            "ts": datetime.now().isoformat(),
+            "chat_id": chat_id,
+            "reason": reason,
+            "flow_summary": [
+                {"role": m["role"], "content": m["content"][:200]}
+                for m in flow[-10:]
+            ],
+        })
+        existing = existing[-100:]
+        fail_file.write_text(json.dumps(existing, ensure_ascii=False, indent=2))
+
+    async def weekly_consolidation(self, instance_id: str):
+        """Merge episodic -> semantic, prune duplicates, update FAQ index. Run weekly."""
+        idir = self._instance_dir(instance_id)
+        log.info(f"[memory] starting weekly consolidation for {instance_id}")
+
+        # 1. Re-scan all episodic for FAQ extraction
+        ep_dir = idir / "episodic"
+        all_questions: List[Dict] = []
+        for f in ep_dir.glob("*.jsonl"):
+            with open(f) as fh:
+                for line in fh:
+                    try:
+                        entry = json.loads(line)
+                        msgs = entry.get("messages", [])
+                        for i, m in enumerate(msgs):
+                            if m.get("role") == "user" and "?" in m.get("content", ""):
+                                answer = ""
+                                if i + 1 < len(msgs) and msgs[i + 1].get("role") == "assistant":
+                                    answer = msgs[i + 1]["content"][:500]
+                                all_questions.append({"q": m["content"], "a": answer})
+                    except Exception:
+                        continue
+
+        # 2. Update FAQ index
+        faq_file = idir / "semantic" / "faqs.json"
+        faqs = json.loads(faq_file.read_text()) if faq_file.exists() else {}
+
+        for qa in all_questions:
+            qhash = hashlib.md5(qa["q"].lower().strip().encode()).hexdigest()[:12]
+            if qhash in faqs:
+                faqs[qhash]["frequency"] += 1
+                if qa["a"] and len(qa["a"]) > len(faqs[qhash].get("answer", "")):
+                    faqs[qhash]["answer"] = qa["a"]
+            else:
+                faqs[qhash] = {
+                    "question": qa["q"],
+                    "answer": qa["a"],
+                    "frequency": 1,
+                    "first_asked": datetime.now().isoformat(),
+                    "last_asked": datetime.now().isoformat(),
+                }
+
+        faq_file.write_text(json.dumps(faqs, ensure_ascii=False, indent=2))
+
+        # 3. Prune episodic older than 90 days
+        cutoff = datetime.now() - timedelta(days=90)
+        for f in ep_dir.glob("*.jsonl"):
+            try:
+                file_date = datetime.strptime(f.stem, "%Y-%m-%d")
+                if file_date < cutoff:
+                    f.unlink()
+                    log.info(f"[memory] pruned old episodic: {f.name}")
+            except Exception:
+                continue
+
+        log.info(f"[memory] consolidation complete for {instance_id}: {len(faqs)} FAQs")
+
+    def _extract_entities(self, messages: List[Dict]) -> Dict[str, List[str]]:
+        """Simple regex-based entity extraction."""
+        entities: Dict[str, List[str]] = {"phones": [], "emails": [], "names": []}
+        text = " ".join(
+            m.get("content", "") for m in messages if m.get("role") == "user"
+        )
+
+        # Colombian phone numbers
+        phones = re.findall(r"\b3[0-9]{9}\b", text)
+        entities["phones"] = list(set(phones))
+
+        # Emails
+        emails = re.findall(r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}", text)
+        entities["emails"] = list(set(emails))
+
+        # Names after "me llamo", "soy", "mi nombre es"
+        name_patterns = [
+            r"(?:me llamo|soy|mi nombre es)\s+([A-ZÁÉÍÓÚ][a-záéíóú]+(?:\s+[A-ZÁÉÍÓÚ][a-záéíóú]+)?)",
+        ]
+        for pat in name_patterns:
+            matches = re.findall(pat, text)
+            entities["names"].extend(matches)
+        entities["names"] = list(set(entities["names"]))
+
+        return {k: v for k, v in entities.items() if v}
+
+
+# Singleton
+memory_engine = ConnyMemoryEngine()