@innvisor/conny-ai 9.7.0

package/src/conny/integrations/__init__.py

@@ -0,0 +1,19 @@
+"""Integrations subsystem: external services, calendar, search, knowledge."""
+
+from conny.integrations.knowledge import (
+    KnowledgeBase,
+    format_kb_context,
+    CHUNK_SIZE,
+    CHUNK_OVERLAP,
+    MAX_CHUNKS_IN_CONTEXT,
+    MIN_RELEVANCE,
+)
+
+__all__ = [
+    "KnowledgeBase",
+    "format_kb_context",
+    "CHUNK_SIZE",
+    "CHUNK_OVERLAP",
+    "MAX_CHUNKS_IN_CONTEXT",
+    "MIN_RELEVANCE",
+]

package/src/conny/integrations/calendar.py

@@ -0,0 +1,169 @@
+"""conny_calendar.py — Google Calendar: check availability + book appointments."""
+from __future__ import annotations
+import json, logging, os
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, List, Optional
+import httpx
+
+log = logging.getLogger("conny.calendar")
+
+VAULT_DIR = Path("integrations/vault")
+
+
+class ConnyCalendar:
+    """Google Calendar integration for booking appointments."""
+
+    def __init__(self, instance_id: str = "default"):
+        self.instance_id = instance_id
+        self._tokens_file = VAULT_DIR / instance_id / "google_tokens.json"
+        self._creds_file = VAULT_DIR / instance_id / "google_credentials.json"
+
+    @property
+    def is_connected(self) -> bool:
+        return self._tokens_file.exists()
+
+    async def _get_access_token(self) -> Optional[str]:
+        """Get valid access token (refresh if needed)."""
+        if not self._tokens_file.exists():
+            return None
+        tokens = json.loads(self._tokens_file.read_text())
+        refresh_token = tokens.get("refresh_token")
+        if not refresh_token:
+            return tokens.get("access_token")
+
+        # Load client creds
+        if not self._creds_file.exists():
+            return tokens.get("access_token")
+        creds_data = json.loads(self._creds_file.read_text())
+        inner = creds_data.get("installed") or creds_data.get("web") or creds_data
+        client_id = inner.get("client_id", "")
+        client_secret = inner.get("client_secret", "")
+
+        if not client_id:
+            return tokens.get("access_token")
+
+        # Refresh
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                r = await client.post("https://oauth2.googleapis.com/token", data={
+                    "client_id": client_id,
+                    "client_secret": client_secret,
+                    "refresh_token": refresh_token,
+                    "grant_type": "refresh_token",
+                })
+                if r.status_code == 200:
+                    new = r.json()
+                    tokens["access_token"] = new["access_token"]
+                    self._tokens_file.write_text(json.dumps(tokens, indent=2))
+                    return new["access_token"]
+        except Exception as e:
+            log.warning(f"[calendar] refresh failed: {e}")
+
+        return tokens.get("access_token")
+
+    async def get_availability(self, date: str = None, days_ahead: int = 3) -> List[Dict]:
+        """Get available slots for the next N days."""
+        token = await self._get_access_token()
+        if not token:
+            return []
+
+        if not date:
+            start = datetime.now()
+        else:
+            try:
+                start = datetime.strptime(date, "%Y-%m-%d")
+            except:
+                start = datetime.now()
+
+        end = start + timedelta(days=days_ahead)
+        time_min = start.isoformat() + "Z"
+        time_max = end.isoformat() + "Z"
+
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                r = await client.get(
+                    "https://www.googleapis.com/calendar/v3/calendars/primary/events",
+                    headers={"Authorization": f"Bearer {token}"},
+                    params={"timeMin": time_min, "timeMax": time_max,
+                            "singleEvents": "true", "orderBy": "startTime"},
+                )
+                if r.status_code == 200:
+                    events = r.json().get("items", [])
+                    return [{"summary": e.get("summary", "Ocupado"),
+                             "start": e.get("start", {}).get("dateTime", ""),
+                             "end": e.get("end", {}).get("dateTime", "")}
+                            for e in events]
+                else:
+                    log.warning(f"[calendar] events fetch failed: {r.status_code}")
+                    return []
+        except Exception as e:
+            log.error(f"[calendar] error: {e}")
+            return []
+
+    async def create_appointment(self, patient_name: str, phone: str,
+                                  service: str, date_time: str,
+                                  duration_minutes: int = 30) -> Optional[str]:
+        """Create a calendar event for an appointment."""
+        token = await self._get_access_token()
+        if not token:
+            return None
+
+        try:
+            start_dt = datetime.fromisoformat(date_time)
+        except:
+            return None
+
+        end_dt = start_dt + timedelta(minutes=duration_minutes)
+
+        event = {
+            "summary": f"Cita: {patient_name} — {service}",
+            "description": f"Paciente: {patient_name}\nTeléfono: {phone}\nServicio: {service}\nAgendado por: Conny AI",
+            "start": {"dateTime": start_dt.isoformat(), "timeZone": "America/Bogota"},
+            "end": {"dateTime": end_dt.isoformat(), "timeZone": "America/Bogota"},
+            "reminders": {
+                "useDefault": False,
+                "overrides": [
+                    {"method": "popup", "minutes": 60},
+                    {"method": "popup", "minutes": 1440},
+                ],
+            },
+        }
+
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                r = await client.post(
+                    "https://www.googleapis.com/calendar/v3/calendars/primary/events",
+                    headers={"Authorization": f"Bearer {token}", "Content-Type": "application/json"},
+                    json=event,
+                )
+                if r.status_code in (200, 201):
+                    created = r.json()
+                    log.info(f"[calendar] appointment created: {created.get('id')}")
+                    return created.get("id")
+                else:
+                    log.error(f"[calendar] create failed: {r.status_code} {r.text[:200]}")
+                    return None
+        except Exception as e:
+            log.error(f"[calendar] create error: {e}")
+            return None
+
+    async def get_availability_summary(self, days_ahead: int = 3) -> str:
+        """Get human-readable availability summary for Conny to use."""
+        events = await self.get_availability(days_ahead=days_ahead)
+        if not events:
+            return "sin citas programadas los próximos días — disponibilidad abierta"
+
+        busy_times = []
+        for e in events[:10]:
+            start = e.get("start", "")
+            if start:
+                try:
+                    dt = datetime.fromisoformat(start.replace("Z", ""))
+                    busy_times.append(f"{dt.strftime('%A %d')} a las {dt.strftime('%I:%M%p')}: {e['summary']}")
+                except:
+                    pass
+
+        if busy_times:
+            return "Citas existentes:\n" + "\n".join(busy_times)
+        return "calendario disponible"

package/src/conny/integrations/knowledge.py

@@ -0,0 +1,312 @@
+"""Knowledge base: clinic document ingestion, chunking, and retrieval."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import sqlite3
+from typing import Dict, List, 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 interaccion 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 ==="
+    )

package/src/conny/integrations/search.py

@@ -0,0 +1,66 @@
+"""conny_web_search.py — Web search via Brave Search API."""
+from __future__ import annotations
+
+import logging
+import os
+from typing import List, Dict, Optional
+
+import httpx
+
+log = logging.getLogger("conny.web_search")
+
+BRAVE_API_KEY = os.getenv("BRAVE_API_KEY", "")
+BRAVE_URL = "https://api.search.brave.com/res/v1/web/search"
+
+
+async def search_web(query: str, num_results: int = 5) -> List[Dict[str, str]]:
+    """Search the web using Brave Search API. Returns list of {title, snippet, url}."""
+    if not BRAVE_API_KEY:
+        log.debug("[web_search] no BRAVE_API_KEY configured")
+        return []
+
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            r = await client.get(
+                BRAVE_URL,
+                params={"q": query, "count": num_results},
+                headers={"X-Subscription-Token": BRAVE_API_KEY, "Accept": "application/json"},
+            )
+            if r.status_code != 200:
+                log.warning(f"[web_search] Brave returned {r.status_code}")
+                return []
+            data = r.json()
+            results = []
+            for item in data.get("web", {}).get("results", [])[:num_results]:
+                results.append({
+                    "title": item.get("title", ""),
+                    "snippet": item.get("description", ""),
+                    "url": item.get("url", ""),
+                })
+            return results
+    except Exception as e:
+        log.error(f"[web_search] error: {e}")
+        return []
+
+
+async def search_business(business_name: str, city: str = "Medellín") -> str:
+    """Search for a business and return a summary string for LLM context."""
+    query = f"{business_name} {city} servicios precios horario"
+    results = await search_web(query, num_results=5)
+    if not results:
+        return ""
+    lines = []
+    for r in results:
+        lines.append(f"- {r['title']}: {r['snippet'][:150]}")
+    return "\n".join(lines)
+
+
+async def search_topic(topic: str) -> str:
+    """General topic search, returns formatted results."""
+    results = await search_web(topic, num_results=3)
+    if not results:
+        return ""
+    lines = []
+    for r in results:
+        lines.append(f"- {r['title']}: {r['snippet'][:200]}")
+    return "\n".join(lines)