cognia-ai 3.2.0__tar.gz

cognia_ai-3.2.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: cognia-ai
+Version: 3.2.0
+Summary: Local cognitive AI with episodic memory, distributed inference, and swarm learning
+Author: Acua124298042
+License: MIT
+Project-URL: Homepage, https://github.com/tomascomenta-blip/cognia_v2
+Project-URL: Repository, https://github.com/tomascomenta-blip/cognia_v2
+Keywords: ai,llm,distributed,memory,cognia
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: uvicorn[standard]>=0.29.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: flask>=2.3.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: pdfplumber>=0.10.0
+Requires-Dist: numpy
+Requires-Dist: sentence-transformers>=2.2.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: websockets>=12.0
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: slowapi>=0.1.9
+Requires-Dist: sse-starlette>=1.6
+Requires-Dist: rich>=13.0
+Requires-Dist: prompt_toolkit>=3.0
+
+# Cognia v3 — Arquitectura Cognitiva Simbolico-Neural
+
+> IA local, ligera, sin APIs externas. Corre en CPU. Objetivo: 2-5W de consumo.
+> Ahora con inferencia distribuida real (SRDN) y soporte Qwen2.5-Coder.
+
+**Stack:** Python 3.11+ · SQLite · Qwen2.5-Coder (INT4) · sentence-transformers · numpy · FastAPI · Electron
+
+---
+
+## Estado del proyecto (Mayo 2026)
+
+| Fase | Estado | Descripcion |
+|------|--------|-------------|
+| **Fase 1-6 — Estabilizacion y Core** | COMPLETADA | Base limpia, NarrativeThread, MeshNode, Seguridad, Escalado. |
+| **Fase 7 — Shattering (SRDN)** | COMPLETADA | LOGOS/TECHNE/RHETOR sub-models, MoE, NPQ, RST, MLA. |
+| **Fase 8 — Commercial Release** | COMPLETADA | Instaladores, UX, Cifrado por defecto, Documentacion completa. |
+| **Fase 9-12 — Hardening y UX** | COMPLETADA | Proteccion SQLi/XSS/SSRF, Consentimiento de privacidad, Auto-update. |
+| **Fase 13 — Real Distributed Inference** | COMPLETADA | Inferencia real con Qwen2.5-Coder-3B INT4, auto-sharding. |
+
+Ver [ROADMAP.md](ROADMAP.md) para el detalle tecnico de cada fase.
+
+---
+
+## Que hace Cognia
+
+Cognia es una arquitectura cognitiva que aprende, razona y recuerda localmente. A diferencia de un simple chatbot, gestiona un ciclo de vida cognitivo completo incluyendo consolidacion de memoria durante el "sueño" y razonamiento distribuido entre multiples dispositivos.
+
+### Arquitectura Shattering (SRDN)
+
+Cognia v3 introduce **Sparse-Recursive Distillation Network**, permitiendo correr modelos de 3B+ parametros en dispositivos con poca RAM (Android, PCs antiguos) mediante:
+- **Auto-sharding:** El modelo se divide en fragmentos (shards) que pueden ejecutarse en distintos nodos de una red local.
+- **Cuantizacion INT4:** Pesos comprimidos un 75% sin perdida critica de precision, operados puramente en numpy.
+- **Inferencia hibrida:** Combina Ollama (para razonamiento general) con el motor nativo de Cognia (para tareas especializadas).
+
+### Modulos Principales
+
+| Modulo | Funcion |
+|--------|---------|
+| `KnowledgeGraph` | Memoria semantica estructurada y jerarquica. |
+| `InferenceEngine` | Razonamiento transitivo y herencia de propiedades. |
+| `ShatteringOrchestrator` | Gestion de inferencia distribuida y ruteo MoE. |
+| `ConsolidationEngine` | Ciclo de sueño: purga, refuerzo y olvido de memorias. |
+| `SecureStorage` | Cifrado AES-256-GCM de memorias episodicas. |
+| `CogniaMeshNode` | Red P2P para sincronizacion de conocimiento via CRDT. |
+
+---
+
+## Descarga e Instalacion
+
+### Instaladores rapidos
+
+Recomendado para la mayoria de los usuarios. Descarga el repositorio y ejecuta:
+
+**Windows (PowerShell):**
+```powershell
+.\install.ps1
+```
+
+**Linux / macOS (Bash):**
+```bash
+bash install.sh
+```
+
+### Desktop App (Electron)
+
+Para una experiencia visual, puedes construir el instalador de escritorio:
+```bash
+cd cognia_desktop
+npm install
+npm run build:win  # o build:linux / build:mac
+```
+
+---
+
+## Uso — Comandos Principales
+
+### Cognicion y Memoria
+- `aprender <texto> | <etiqueta>`: Enseñar un concepto nuevo.
+- `observar <texto>`: Guardar una observacion sin procesar.
+- `dormir`: Iniciar ciclo de consolidacion y limpieza (sueño).
+- `yo`: Ver estado interno de la memoria y perfil cognitivo.
+- `narrativa <texto>`: Recuperar hilos de episodios relacionados.
+
+### Sistema y Red
+- `doctor`: Diagnostico completo del sistema y dependencias.
+- `update`: Actualizar Cognia, dependencias y migraciones de DB.
+- `seguridad`: Gestionar cifrado y llaves de acceso.
+- `grafo <concepto>`: Visualizar el grafo de conocimiento local.
+- `inferir <concepto>`: Ejecutar razonamiento transitivo sobre un tema.
+
+### Inferencia Distribuida (Qwen2.5)
+```bash
+# Convertir pesos de HuggingFace a shards de Cognia
+python scripts/convert_hf_to_shards.py --hf-dir /path/to/qwen --out-dir model_shards/qwen-q4
+```
+
+---
+
+## Seguridad y Privacidad
+
+- **Local-First:** Tus datos nunca salen de tu maquina a menos que conectes nodos en red mesh de forma explicita.
+- **Cifrado en reposo:** Memorias episodicas cifradas con AES-256-GCM.
+- **Proteccion Anti-Injection:** Filtros estructurales en prompts y consultas SQL parametrizadas.
+- **Privacidad Diferencial:** Ruido estadistico aplicado en sincronizaciones de red para proteger la identidad.
+
+Ver [docs/PRIVACY.md](docs/PRIVACY.md) y [docs/SECURITY.md](docs/SECURITY.md) para mas detalles.
+
+---
+
+## Documentacion
+
+| Documento | Contenido |
+|-----------|-----------|
+| [docs/INSTALL.md](docs/INSTALL.md) | Guia detallada de instalacion y configuracion. |
+| [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md) | Solucion a problemas comunes y diagnostico. |
+| [docs/PRIVACY.md](docs/PRIVACY.md) | Detalles sobre el manejo de datos y privacidad. |
+| [ROADMAP.md](ROADMAP.md) | Plan de desarrollo y estado de las fases. |
+
+---
+
+## Para Colaborar
+
+Lee el [ROADMAP.md](ROADMAP.md) para entender la direccion actual. Cognia prioriza la eficiencia (CPU-only), la privacidad y la estabilidad. No se aceptan dependencias pesadas (PyTorch/Tensorflow) en el motor de inferencia principal.
+
+---
+© 2026 Cognia Project. Distribuido bajo licencia MIT.

cognia_ai-3.2.0/README.md

@@ -0,0 +1,126 @@
+# Cognia v3 — Arquitectura Cognitiva Simbolico-Neural
+
+> IA local, ligera, sin APIs externas. Corre en CPU. Objetivo: 2-5W de consumo.
+> Ahora con inferencia distribuida real (SRDN) y soporte Qwen2.5-Coder.
+
+**Stack:** Python 3.11+ · SQLite · Qwen2.5-Coder (INT4) · sentence-transformers · numpy · FastAPI · Electron
+
+---
+
+## Estado del proyecto (Mayo 2026)
+
+| Fase | Estado | Descripcion |
+|------|--------|-------------|
+| **Fase 1-6 — Estabilizacion y Core** | COMPLETADA | Base limpia, NarrativeThread, MeshNode, Seguridad, Escalado. |
+| **Fase 7 — Shattering (SRDN)** | COMPLETADA | LOGOS/TECHNE/RHETOR sub-models, MoE, NPQ, RST, MLA. |
+| **Fase 8 — Commercial Release** | COMPLETADA | Instaladores, UX, Cifrado por defecto, Documentacion completa. |
+| **Fase 9-12 — Hardening y UX** | COMPLETADA | Proteccion SQLi/XSS/SSRF, Consentimiento de privacidad, Auto-update. |
+| **Fase 13 — Real Distributed Inference** | COMPLETADA | Inferencia real con Qwen2.5-Coder-3B INT4, auto-sharding. |
+
+Ver [ROADMAP.md](ROADMAP.md) para el detalle tecnico de cada fase.
+
+---
+
+## Que hace Cognia
+
+Cognia es una arquitectura cognitiva que aprende, razona y recuerda localmente. A diferencia de un simple chatbot, gestiona un ciclo de vida cognitivo completo incluyendo consolidacion de memoria durante el "sueño" y razonamiento distribuido entre multiples dispositivos.
+
+### Arquitectura Shattering (SRDN)
+
+Cognia v3 introduce **Sparse-Recursive Distillation Network**, permitiendo correr modelos de 3B+ parametros en dispositivos con poca RAM (Android, PCs antiguos) mediante:
+- **Auto-sharding:** El modelo se divide en fragmentos (shards) que pueden ejecutarse en distintos nodos de una red local.
+- **Cuantizacion INT4:** Pesos comprimidos un 75% sin perdida critica de precision, operados puramente en numpy.
+- **Inferencia hibrida:** Combina Ollama (para razonamiento general) con el motor nativo de Cognia (para tareas especializadas).
+
+### Modulos Principales
+
+| Modulo | Funcion |
+|--------|---------|
+| `KnowledgeGraph` | Memoria semantica estructurada y jerarquica. |
+| `InferenceEngine` | Razonamiento transitivo y herencia de propiedades. |
+| `ShatteringOrchestrator` | Gestion de inferencia distribuida y ruteo MoE. |
+| `ConsolidationEngine` | Ciclo de sueño: purga, refuerzo y olvido de memorias. |
+| `SecureStorage` | Cifrado AES-256-GCM de memorias episodicas. |
+| `CogniaMeshNode` | Red P2P para sincronizacion de conocimiento via CRDT. |
+
+---
+
+## Descarga e Instalacion
+
+### Instaladores rapidos
+
+Recomendado para la mayoria de los usuarios. Descarga el repositorio y ejecuta:
+
+**Windows (PowerShell):**
+```powershell
+.\install.ps1
+```
+
+**Linux / macOS (Bash):**
+```bash
+bash install.sh
+```
+
+### Desktop App (Electron)
+
+Para una experiencia visual, puedes construir el instalador de escritorio:
+```bash
+cd cognia_desktop
+npm install
+npm run build:win  # o build:linux / build:mac
+```
+
+---
+
+## Uso — Comandos Principales
+
+### Cognicion y Memoria
+- `aprender <texto> | <etiqueta>`: Enseñar un concepto nuevo.
+- `observar <texto>`: Guardar una observacion sin procesar.
+- `dormir`: Iniciar ciclo de consolidacion y limpieza (sueño).
+- `yo`: Ver estado interno de la memoria y perfil cognitivo.
+- `narrativa <texto>`: Recuperar hilos de episodios relacionados.
+
+### Sistema y Red
+- `doctor`: Diagnostico completo del sistema y dependencias.
+- `update`: Actualizar Cognia, dependencias y migraciones de DB.
+- `seguridad`: Gestionar cifrado y llaves de acceso.
+- `grafo <concepto>`: Visualizar el grafo de conocimiento local.
+- `inferir <concepto>`: Ejecutar razonamiento transitivo sobre un tema.
+
+### Inferencia Distribuida (Qwen2.5)
+```bash
+# Convertir pesos de HuggingFace a shards de Cognia
+python scripts/convert_hf_to_shards.py --hf-dir /path/to/qwen --out-dir model_shards/qwen-q4
+```
+
+---
+
+## Seguridad y Privacidad
+
+- **Local-First:** Tus datos nunca salen de tu maquina a menos que conectes nodos en red mesh de forma explicita.
+- **Cifrado en reposo:** Memorias episodicas cifradas con AES-256-GCM.
+- **Proteccion Anti-Injection:** Filtros estructurales en prompts y consultas SQL parametrizadas.
+- **Privacidad Diferencial:** Ruido estadistico aplicado en sincronizaciones de red para proteger la identidad.
+
+Ver [docs/PRIVACY.md](docs/PRIVACY.md) y [docs/SECURITY.md](docs/SECURITY.md) para mas detalles.
+
+---
+
+## Documentacion
+
+| Documento | Contenido |
+|-----------|-----------|
+| [docs/INSTALL.md](docs/INSTALL.md) | Guia detallada de instalacion y configuracion. |
+| [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md) | Solucion a problemas comunes y diagnostico. |
+| [docs/PRIVACY.md](docs/PRIVACY.md) | Detalles sobre el manejo de datos y privacidad. |
+| [ROADMAP.md](ROADMAP.md) | Plan de desarrollo y estado de las fases. |
+
+---
+
+## Para Colaborar
+
+Lee el [ROADMAP.md](ROADMAP.md) para entender la direccion actual. Cognia prioriza la eficiencia (CPU-only), la privacidad y la estabilidad. No se aceptan dependencias pesadas (PyTorch/Tensorflow) en el motor de inferencia principal.
+
+---
+© 2026 Cognia Project. Distribuido bajo licencia MIT.

cognia_ai-3.2.0/app/main.py

@@ -0,0 +1,53 @@
+"""
+app/main.py
+===========
+Punto de entrada FastAPI para Cognia v3 - Fase 7A
+"""
+
+import os
+import sys
+
+# Asegurar que el root del repo esté en el path para que Cognia importe bien
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, ROOT)
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+
+from app.routes.chat import router as chat_router
+from app.routes.status import router as status_router
+from app.routes.user_data import router as user_data_router
+
+app = FastAPI(
+    title="Cognia v3 API",
+    description="API REST para el sistema de IA Cognia v3",
+    version="7.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost:8765"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(chat_router, prefix="/api")
+app.include_router(status_router, prefix="/api")
+app.include_router(user_data_router, prefix="/api")
+
+# Servir frontend estático
+static_dir = os.path.join(os.path.dirname(__file__), "static")
+if os.path.isdir(static_dir):
+    app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+    @app.get("/", include_in_schema=False)
+    def index():
+        return FileResponse(os.path.join(static_dir, "index.html"))
+
+try:
+    from prometheus_fastapi_instrumentator import Instrumentator
+    Instrumentator().instrument(app).expose(app)
+except ImportError:
+    pass

cognia_ai-3.2.0/app/routes/chat.py

@@ -0,0 +1,101 @@
+"""
+app/routes/chat.py
+==================
+Endpoint POST /api/chat con fallback simbolico cuando Ollama no esta disponible.
+"""
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+router = APIRouter()
+
+_cognia = None
+
+def get_cognia():
+    global _cognia
+    if _cognia is None:
+        from cognia.cognia import Cognia
+        _cognia = Cognia()
+    return _cognia
+
+
+class ChatRequest(BaseModel):
+    input: str
+
+class ChatResponse(BaseModel):
+    response: str
+    stage: str = ""
+    error: str = ""
+
+
+def _respuesta_sin_ollama(ai, pregunta: str) -> dict:
+    """
+    Respuesta usando solo memoria interna de Cognia, sin LLM.
+    Fuerza al LanguageEngine a usar Stage 2 (simbolico) o Stage 5 (fallback)
+    apuntando Ollama a un puerto cerrado para que falle rapido.
+    """
+    try:
+        from language_engine import get_language_engine
+        engine = get_language_engine(ai)
+        original_url = engine.ollama_url
+        engine.ollama_url = "http://127.0.0.1:1"
+        try:
+            result = engine.respond(cognia_instance=ai, question=pregunta)
+            return {"response": result.response, "stage": result.stage_used}
+        finally:
+            engine.ollama_url = original_url
+    except Exception:
+        try:
+            resp = ai.process(pregunta)
+            return {"response": resp or "Mensaje recibido.", "stage": "process"}
+        except Exception:
+            return {
+                "response": (
+                    "Cognia recibio tu mensaje. "
+                    "El modelo de lenguaje (Ollama) no esta disponible en este servidor. "
+                    "Puedes usar comandos como 'yo', 'conceptos', 'dormir' para interactuar "
+                    "con la memoria interna de Cognia."
+                ),
+                "stage": "no_llm",
+            }
+
+
+@router.post("/chat", response_model=ChatResponse)
+def chat(req: ChatRequest):
+    if not req.input.strip():
+        return ChatResponse(response="", error="Mensaje vacio.")
+    try:
+        ai = get_cognia()
+        try:
+            from respuestas_articuladas import responder_articulado
+            resultado = responder_articulado(ai, req.input.strip())
+        except Exception as e:
+            resultado = {"error": str(e)}
+
+        if "error" in resultado:
+            err = str(resultado["error"])
+            ollama_error = any(x in err.lower() for x in [
+                "ollama", "connection refused", "urlerror", "urlopen", "errno 111"
+            ])
+            if ollama_error:
+                fallback = _respuesta_sin_ollama(ai, req.input.strip())
+                return ChatResponse(
+                    response=fallback["response"],
+                    stage=fallback.get("stage", "fallback"),
+                )
+            return ChatResponse(response="", error=err)
+
+        stage = (
+            resultado.get("stage")
+            or resultado.get("language_engine", {}).get("stage", "")
+        )
+        return ChatResponse(
+            response=resultado.get("response", ""),
+            stage=stage,
+        )
+    except Exception as e:
+        return ChatResponse(response="", error=str(e))

cognia_ai-3.2.0/app/routes/status.py

@@ -0,0 +1,68 @@
+"""
+app/routes/status.py
+=====================
+Endpoints GET /api/health, /api/status, /api/conceptos
+"""
+
+import os
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from fastapi import APIRouter
+from app.routes.chat import get_cognia
+
+router = APIRouter()
+
+
+@router.get("/health")
+def health():
+    return {"status": "ok", "service": "cognia-v3"}
+
+
+@router.get("/status")
+def status():
+    try:
+        ai = get_cognia()
+        result = {
+            "status": "ok",
+            "episodios": 0,
+            "conceptos": 0,
+            "escala": {},
+            "usuarios": [],
+        }
+        # Episodios
+        try:
+            from storage.db_pool import db_connect_pooled as db_connect
+            with db_connect(ai.db) as conn:
+                cur = conn.execute("SELECT COUNT(*) FROM episodic_memory")
+                result["episodios"] = cur.fetchone()[0]
+                cur2 = conn.execute("SELECT COUNT(DISTINCT label) FROM episodic_memory")
+                result["conceptos"] = cur2.fetchone()[0]
+        except Exception:
+            pass
+        # Escala
+        try:
+            from cognia.scale_manager import get_scale_manager
+            st = get_scale_manager().status()
+            result["escala"] = {
+                "nivel": st.get("level"),
+                "nombre": st.get("name"),
+                "modelo": st.get("model"),
+                "ram_gb": st.get("ram_gb"),
+            }
+        except Exception:
+            pass
+        return result
+    except Exception as e:
+        return {"status": "error", "detail": str(e)}
+
+
+@router.get("/conceptos")
+def conceptos():
+    try:
+        ai = get_cognia()
+        lista = ai.list_concepts()
+        # list_concepts() devuelve string; si hay un metodo mejor lo usamos
+        return {"conceptos": lista}
+    except Exception as e:
+        return {"error": str(e)}

cognia_ai-3.2.0/app/routes/user_data.py

@@ -0,0 +1,119 @@
+"""
+app/routes/user_data.py
+=======================
+GDPR-aligned user data endpoints:
+  GET  /api/user/data/export  — export all personal episodic memory as JSON
+  DELETE /api/user/data       — soft-delete all episodic memory (right to erasure)
+
+Authentication: X-Admin-Key header must match COGNIA_ADMIN_KEY env var.
+If COGNIA_ADMIN_KEY is not set, both endpoints return 503 (fail-safe).
+"""
+
+import os
+import sys
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from fastapi import APIRouter, HTTPException, Header
+from typing import Optional
+
+router = APIRouter()
+
+_ADMIN_KEY = os.environ.get("COGNIA_ADMIN_KEY", "")
+
+
+def _require_admin_key(x_admin_key: Optional[str] = Header(None)) -> None:
+    if not _ADMIN_KEY:
+        raise HTTPException(
+            status_code=503,
+            detail="User data endpoints are not configured. Set COGNIA_ADMIN_KEY.",
+        )
+    if x_admin_key != _ADMIN_KEY:
+        raise HTTPException(status_code=403, detail="Invalid admin key.")
+
+
+def _get_db_path() -> str:
+    try:
+        from cognia.config import DB_PATH
+        return DB_PATH
+    except ImportError:
+        return "cognia_memory.db"
+
+
+@router.get("/user/data/export")
+def export_user_data(x_admin_key: Optional[str] = Header(None)):
+    """
+    Export all non-forgotten episodic memory rows as JSON.
+    Intended for privacy/GDPR data access requests.
+    """
+    _require_admin_key(x_admin_key)
+
+    try:
+        from cognia.database import db_connect
+        conn = db_connect(_get_db_path())
+        rows = conn.execute(
+            """
+            SELECT id, timestamp, observation, label, confidence,
+                   emotion_label, context_tags, notes
+            FROM episodic_memory
+            WHERE forgotten = 0
+            ORDER BY timestamp DESC
+            """
+        ).fetchall()
+        conn.close()
+    except Exception:
+        raise HTTPException(
+            status_code=503,
+            detail="Could not read user data. Please try again.",
+        )
+
+    records = [
+        {
+            "id":           r[0],
+            "timestamp":    r[1],
+            "observation":  r[2],
+            "label":        r[3],
+            "confidence":   r[4],
+            "emotion":      r[5],
+            "context_tags": r[6],
+            "notes":        r[7],
+        }
+        for r in rows
+    ]
+    return {"count": len(records), "records": records}
+
+
+@router.delete("/user/data")
+def delete_user_data(x_admin_key: Optional[str] = Header(None)):
+    """
+    Soft-delete all episodic memory (sets forgotten=1).
+    Irreversible via API. Right to erasure (GDPR Art. 17).
+
+    WARNING: Cognia is single-user. This endpoint deletes ALL stored memory
+    regardless of which user created it. There is no per-user scoping.
+    """
+    _require_admin_key(x_admin_key)
+
+    try:
+        from cognia.database import db_connect
+        conn = db_connect(_get_db_path())
+        result = conn.execute(
+            "UPDATE episodic_memory SET forgotten=1 WHERE forgotten=0"
+        )
+        deleted = result.rowcount
+        conn.commit()
+        conn.close()
+    except Exception:
+        raise HTTPException(
+            status_code=503,
+            detail="Could not delete user data. Please try again.",
+        )
+
+    return {
+        "deleted": deleted,
+        "status": "ok",
+        "scope": "all",
+        "warning": (
+            "Cognia is single-user. All episodic memory was deleted, "
+            "regardless of origin. There is no per-user scoping."
+        ),
+    }

cognia_ai-3.2.0/cognia/__init__.py

@@ -0,0 +1 @@
+from .cognia import Cognia