superlocalmemory 3.3.0__tar.gz → 3.3.2__tar.gz

{superlocalmemory-3.3.0/src/superlocalmemory.egg-info → superlocalmemory-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.3.0
+Version: 3.3.2
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: MIT
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.11
+Requires-Python: <3.15,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
@@ -43,11 +43,13 @@ Requires-Dist: lightgbm>=4.0.0
 Requires-Dist: diskcache>=5.6.0
 Requires-Dist: orjson>=3.9.0
 Provides-Extra: search
-Requires-Dist: sentence-transformers<4.0.0,>=2.5.0; extra == "search"
+Requires-Dist: sentence-transformers>=4.0.0; extra == "search"
+Requires-Dist: sentence-transformers[onnx]>=4.0.0; extra == "search"
 Requires-Dist: einops>=0.8.2; extra == "search"
 Requires-Dist: torch>=2.2.0; extra == "search"
 Requires-Dist: scikit-learn<2.0.0,>=1.3.0; extra == "search"
 Requires-Dist: geoopt>=0.5.0; extra == "search"
+Requires-Dist: onnxruntime>=1.17.0; extra == "search"
 Provides-Extra: ui
 Requires-Dist: fastapi[all]>=0.135.1; extra == "ui"
 Requires-Dist: uvicorn>=0.42.0; extra == "ui"
@@ -62,6 +64,7 @@ Requires-Dist: superlocalmemory[learning,performance,search,ui]; extra == "full"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: sqlite-vec>=0.1.6; extra == "dev"
 Dynamic: license-file
 
 <p align="center">

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "superlocalmemory"
-version = "3.3.0"
+version = "3.3.2"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "MIT"}
-requires-python = ">=3.11"
+requires-python = ">=3.11,<3.15"
 authors = [
     {name = "Varun Pratap Bhardwaj", email = "admin@superlocalmemory.com"},
 ]
@@ -48,11 +48,13 @@ dependencies = [
 
 [project.optional-dependencies]
 search = [
-    "sentence-transformers>=2.5.0,<4.0.0",
+    "sentence-transformers>=4.0.0",
+    "sentence-transformers[onnx]>=4.0.0",
     "einops>=0.8.2",
     "torch>=2.2.0",
     "scikit-learn>=1.3.0,<2.0.0",
     "geoopt>=0.5.0",
+    "onnxruntime>=1.17.0",
 ]
 ui = [
     "fastapi[all]>=0.135.1",
@@ -72,6 +74,7 @@ full = [
 dev = [
     "pytest>=8.0",
     "pytest-cov>=4.1",
+    "sqlite-vec>=0.1.6",
 ]
 
 [project.urls]

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/src/superlocalmemory/cli/commands.py

@@ -993,35 +993,64 @@ def cmd_dashboard(args: Namespace) -> None:
         print("Or install manually: pip install 'fastapi[all]' uvicorn")
         sys.exit(1)
 
+    import os
+    import signal
     import socket
 
     port = getattr(args, "port", 8765)
 
-    def _find_port(preferred: int) -> int:
-        for p in [preferred] + list(range(preferred + 1, preferred + 20)):
-            try:
-                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                    s.bind(("127.0.0.1", p))
-                    return p
-            except OSError:
-                continue
-        return preferred
+    def _kill_existing_on_port(target_port: int) -> None:
+        """Kill any existing SLM dashboard on the target port.
 
-    ui_port = _find_port(port)
-    if ui_port != port:
-        print(f"  Port {port} in use — using {ui_port} instead")
+        V3.3.2: ONE port, no auto-increment. If port is busy with
+        another SLM instance, kill it. If busy with a non-SLM process,
+        warn and exit — never silently shift to a different port.
+        """
+        if sys.platform == "win32":
+            return  # Windows: user must close manually
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["lsof", "-ti", f":{target_port}"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                pids = result.stdout.strip().split("\n")
+                for pid_str in pids:
+                    pid = int(pid_str.strip())
+                    if pid == os.getpid():
+                        continue
+                    # Check if it's an SLM/Python process
+                    ps_result = subprocess.run(
+                        ["ps", "-p", str(pid), "-o", "command="],
+                        capture_output=True, text=True, timeout=5,
+                    )
+                    cmd = ps_result.stdout.strip().lower()
+                    if "superlocalmemory" in cmd or "slm" in cmd or "uvicorn" in cmd:
+                        os.kill(pid, signal.SIGTERM)
+                        print(f"  Stopped previous dashboard (PID {pid})")
+                        import time
+                        time.sleep(1)
+        except Exception:
+            pass  # Best-effort
+
+    _kill_existing_on_port(port)
+
+    # Brief wait for port to fully release after killing old process
+    import time
+    time.sleep(1)
 
     print("=" * 60)
     print("  SuperLocalMemory V3 — Web Dashboard")
     print("=" * 60)
-    print(f"  Dashboard:  http://localhost:{ui_port}")
-    print(f"  API Docs:   http://localhost:{ui_port}/api/docs")
+    print(f"  Dashboard:  http://localhost:{port}")
+    print(f"  API Docs:   http://localhost:{port}/api/docs")
     print("  Press Ctrl+C to stop\n")
 
     from superlocalmemory.server.ui import create_app
 
     app = create_app()
-    uvicorn.run(app, host="127.0.0.1", port=ui_port, log_level="info")
+    uvicorn.run(app, host="127.0.0.1", port=port, log_level="info")
 
 
 # -- Profiles (supports --json) -------------------------------------------
@@ -1129,27 +1158,122 @@ def cmd_hooks(args: Namespace) -> None:
 
 
 def cmd_session_context(args: Namespace) -> None:
-    """Print session context (for hook scripts and piping)."""
-    from superlocalmemory.hooks.auto_recall import AutoRecall
+    """Print session context (for hook scripts and piping).
+
+    Uses a FAST PATH that queries SQLite directly (no engine/Ollama needed).
+    This ensures the SessionStart hook completes within its 15s timeout even
+    when Ollama requires a 60s+ cold start.  The fast path returns:
+      - Core Memory blocks (always-on context)
+      - Recent high-importance memories (last 7 days)
+      - Session summary from last session
+    Falls back to the full engine path only if --full is passed explicitly.
+    """
+    import sqlite3
+    from pathlib import Path
     from superlocalmemory.core.config import SLMConfig
-    from superlocalmemory.core.engine import MemoryEngine
 
+    use_full = getattr(args, "full", False)
+
+    if use_full:
+        # Full engine path (slow, requires Ollama) — for explicit CLI use
+        try:
+            from superlocalmemory.hooks.auto_recall import AutoRecall
+            from superlocalmemory.core.engine import MemoryEngine
+            config = SLMConfig.load()
+            engine = MemoryEngine(config)
+            engine.initialize()
+            auto = AutoRecall(
+                engine=engine,
+                config={"enabled": True, "max_memories_injected": 10, "relevance_threshold": 0.3},
+            )
+            context = auto.get_session_context(
+                query=getattr(args, "query", "") or "recent decisions and important context",
+            )
+            if context:
+                print(context)
+        except Exception as exc:
+            logger.debug("session-context (full) failed: %s", exc)
+        return
+
+    # ── FAST PATH: direct SQLite, no engine, <500ms ──────────────
     try:
         config = SLMConfig.load()
-        engine = MemoryEngine(config)
-        engine.initialize()
+        db_path = config.base_dir / "memory.db"
+        if not db_path.exists():
+            return
 
-        auto = AutoRecall(
-            engine=engine,
-            config={"enabled": True, "max_memories_injected": 10, "relevance_threshold": 0.3},
-        )
-        context = auto.get_session_context(
-            query=getattr(args, "query", "") or "recent decisions and important context",
-        )
-        if context:
-            print(context)
+        pid = config.active_profile
+        conn = sqlite3.connect(str(db_path))
+        conn.row_factory = sqlite3.Row
+        sections = []
+
+        # 1. Core Memory blocks (compiled high-value context)
+        try:
+            rows = conn.execute(
+                "SELECT block_type, content FROM core_memory_blocks "
+                "WHERE profile_id = ? ORDER BY block_type",
+                (pid,),
+            ).fetchall()
+            if rows:
+                blocks = [f"[{r['block_type']}] {r['content']}" for r in rows]
+                sections.append("## Core Memory\n" + "\n".join(blocks))
+        except sqlite3.OperationalError:
+            pass
+
+        # 2. Recent important memories (last 7 days, top 10 by importance)
+        try:
+            rows = conn.execute(
+                "SELECT content, fact_type, created_at FROM atomic_facts "
+                "WHERE profile_id = ? "
+                "AND created_at >= datetime('now', '-7 days') "
+                "AND lifecycle = 'active' "
+                "ORDER BY importance DESC, created_at DESC LIMIT 10",
+                (pid,),
+            ).fetchall()
+            if rows:
+                items = []
+                for r in rows:
+                    content = r["content"][:200]
+                    items.append(f"- [{r['fact_type'] or 'fact'}] {content}")
+                sections.append("## Recent Context (7 days)\n" + "\n".join(items))
+        except sqlite3.OperationalError:
+            pass
+
+        # 3. Session markers (last session summary)
+        try:
+            rows = conn.execute(
+                "SELECT content, created_at FROM atomic_facts "
+                "WHERE profile_id = ? AND content LIKE 'Session%' "
+                "ORDER BY created_at DESC LIMIT 3",
+                (pid,),
+            ).fetchall()
+            if rows:
+                items = [f"- {r['content'][:150]}" for r in rows]
+                sections.append("## Recent Sessions\n" + "\n".join(items))
+        except sqlite3.OperationalError:
+            pass
+
+        # 4. V3.3 Soft prompts (auto-learned patterns)
+        try:
+            rows = conn.execute(
+                "SELECT category, content FROM soft_prompt_templates "
+                "WHERE profile_id = ? AND active = 1 "
+                "ORDER BY confidence DESC LIMIT 5",
+                (pid,),
+            ).fetchall()
+            if rows:
+                items = [f"- [{r['category']}] {r['content'][:150]}" for r in rows]
+                sections.append("## Learned Patterns\n" + "\n".join(items))
+        except sqlite3.OperationalError:
+            pass
+
+        conn.close()
+
+        if sections:
+            header = f"# SLM Session Context — {config.active_profile}"
+            print(header + "\n\n" + "\n\n".join(sections))
     except Exception as exc:
-        logger.debug("session-context failed: %s", exc)
+        logger.debug("session-context (fast) failed: %s", exc)
 
 
 def cmd_observe(args: Namespace) -> None:

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/src/superlocalmemory/core/config.py

@@ -152,9 +152,10 @@ class RetrievalConfig:
     entity_graph_max_hops: int = 3
     temporal_proximity_days: int = 30
 
-    # Reranking
+    # Reranking (V3.3.2: ONNX backend enabled for all modes)
     use_cross_encoder: bool = True
-    cross_encoder_model: str = "BAAI/bge-reranker-v2-m3"
+    cross_encoder_model: str = "cross-encoder/ms-marco-MiniLM-L-6-v2"
+    cross_encoder_backend: str = "onnx"  # "onnx" (~200MB) or "" (PyTorch, ~1.5GB)
 
     # Agentic (Mode C only)
     agentic_max_rounds: int = 3
@@ -611,6 +612,15 @@ class SLMConfig:
 
         rt = data.get("retrieval", {})
         if rt:
+            # V3.3.2 migration: auto-enable ONNX cross-encoder.
+            # Pre-3.3.2 configs had use_cross_encoder=False because the
+            # PyTorch cross-encoder used ~1.5GB RAM. With ONNX backend
+            # (~200MB), it's now safe for all modes. Detect old configs
+            # by the absence of cross_encoder_backend field.
+            if "cross_encoder_backend" not in rt:
+                rt["use_cross_encoder"] = True
+                rt["cross_encoder_model"] = "cross-encoder/ms-marco-MiniLM-L-6-v2"
+                rt["cross_encoder_backend"] = "onnx"
             config.retrieval = RetrievalConfig(**{
                 k: v for k, v in rt.items()
                 if k in RetrievalConfig.__dataclass_fields__
@@ -650,6 +660,8 @@ class SLMConfig:
             },
             "retrieval": {
                 "use_cross_encoder": self.retrieval.use_cross_encoder,
+                "cross_encoder_model": self.retrieval.cross_encoder_model,
+                "cross_encoder_backend": self.retrieval.cross_encoder_backend,
             },
         }
 
@@ -725,8 +737,8 @@ class SLMConfig:
                 ),
                 llm=LLMConfig(),  # No LLM
                 retrieval=RetrievalConfig(
-                    # Mode A: no cross-encoder (saves ~1.5GB PyTorch RAM)
-                    use_cross_encoder=False,
+                    # V3.3.2: ONNX cross-encoder enabled for all modes (~200MB)
+                    use_cross_encoder=True,
                 ),
                 math=MathConfig(
                     sheaf_contradiction_threshold=0.45,  # 768d threshold
@@ -750,8 +762,8 @@ class SLMConfig:
                     api_key=llm_api_key or "",
                 ),
                 retrieval=RetrievalConfig(
-                    # Mode B: no cross-encoder (saves ~1.5GB PyTorch RAM)
-                    use_cross_encoder=False,
+                    # V3.3.2: ONNX cross-encoder enabled for all modes (~200MB)
+                    use_cross_encoder=True,
                 ),
             )
 

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/src/superlocalmemory/core/embedding_worker.py

@@ -23,6 +23,7 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 from __future__ import annotations
 
 import json
+import signal
 import sys
 import os
 
@@ -34,6 +35,11 @@ os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 os.environ["TORCH_DEVICE"] = "cpu"
 
+# SIGTERM bridge: Docker/systemd send SIGTERM to stop processes.
+# Without this, the worker ignores SIGTERM and becomes a zombie.
+if sys.platform != "win32":
+    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
+
 
 def _worker_main() -> None:
     """Main loop: read JSON requests from stdin, write responses to stdout."""
@@ -97,7 +103,14 @@ def _worker_main() -> None:
                     _respond({"ok": False, "error": f"Model load failed: {exc}"})
                     continue
             try:
-                vecs = model.encode(texts, normalize_embeddings=True)
+                # torch.inference_mode prevents autograd graph accumulation
+                # which causes silent memory leaks over long-running sessions.
+                try:
+                    import torch
+                    with torch.inference_mode():
+                        vecs = model.encode(texts, normalize_embeddings=True)
+                except ImportError:
+                    vecs = model.encode(texts, normalize_embeddings=True)
                 if isinstance(vecs, np.ndarray) and vecs.ndim == 2:
                     result = [vecs[i].tolist() for i in range(vecs.shape[0])]
                 else:

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/src/superlocalmemory/core/embeddings.py

@@ -45,7 +45,8 @@ class DimensionMismatchError(RuntimeError):
 
 
 _IDLE_TIMEOUT_SECONDS = 120  # 2 minutes — kill worker after idle
-_SUBPROCESS_RESPONSE_TIMEOUT = 60  # seconds — max wait for worker response
+_SUBPROCESS_RESPONSE_TIMEOUT = 120  # V3.3.2: 120s for ONNX cold start
+_WORKER_RECYCLE_AFTER = 1000  # Recycle worker after N requests (C++ fragmentation prevention)
 
 
 class EmbeddingService:
@@ -66,6 +67,7 @@ class EmbeddingService:
         self._last_used: float = 0.0
         self._idle_timer: threading.Timer | None = None
         self._worker_ready = False
+        self._request_count: int = 0
 
     @property
     def is_available(self) -> bool:
@@ -144,6 +146,13 @@ class EmbeddingService:
         never hangs indefinitely on cold model loads or network issues.
         """
         with self._lock:
+            # Worker recycling: restart after N requests to prevent
+            # C++ allocator fragmentation over long-running sessions.
+            if self._request_count >= _WORKER_RECYCLE_AFTER and self._worker_proc is not None:
+                logger.info("Recycling embedding worker after %d requests", self._request_count)
+                self._kill_worker()
+                self._request_count = 0
+
             self._ensure_worker()
             if self._worker_proc is None:
                 return None
@@ -176,6 +185,7 @@ class EmbeddingService:
                     logger.warning("Worker error: %s", resp.get("error"))
                     return None
                 self._reset_idle_timer()
+                self._request_count += 1
                 return resp["vectors"]
             except (BrokenPipeError, OSError, json.JSONDecodeError) as exc:
                 logger.warning(
@@ -235,6 +245,7 @@ class EmbeddingService:
                 text=True,
                 bufsize=1,
                 env=env,
+                start_new_session=True,  # Prevent terminal signals bleeding to worker
             )
             logger.info("Embedding worker spawned (PID %d)", self._worker_proc.pid)
             self._worker_ready = True

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/src/superlocalmemory/core/engine_wiring.py

@@ -437,7 +437,10 @@ def init_retrieval(
 
     reranker = None
     if config.retrieval.use_cross_encoder:
-        reranker = CrossEncoderReranker(config.retrieval.cross_encoder_model)
+        reranker = CrossEncoderReranker(
+            config.retrieval.cross_encoder_model,
+            backend=config.retrieval.cross_encoder_backend,
+        )
 
     profile_ch = ProfileChannel(db)
     bridge = BridgeDiscovery(db)

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/src/superlocalmemory/core/modes.py

@@ -68,7 +68,7 @@ MODE_A = ModeCapabilities(
     description=(
         "Local Guardian — Zero LLM, zero cloud. "
         "Uses nomic-embed-text-v1.5 encoder (768d, 8K context) for embeddings. "
-        "spaCy + rules for extraction. Cross-encoder for reranking. "
+        "spaCy + rules for extraction. ONNX cross-encoder reranking (~200MB). "
         "Full EU AI Act compliance. Target: 65%+"
     ),
 )
@@ -89,6 +89,7 @@ MODE_B = ModeCapabilities(
     description=(
         "Smart Local — Local Ollama LLM (Phi-3, Llama 3.2). "
         "LLM-quality extraction and classification, fully local. "
+        "ONNX cross-encoder reranking (~200MB). "
         "No cloud, no data export. EU AI Act compliant. Target: 75-80%"
     ),
 )

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/src/superlocalmemory/core/recall_worker.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 
 import json
 import os
+import signal
 import sys
 
 # Force CPU BEFORE any torch import
@@ -28,6 +29,11 @@ os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 os.environ["TORCH_DEVICE"] = "cpu"
 
+# SIGTERM bridge: Docker/systemd send SIGTERM to stop processes.
+# Without this, the worker ignores SIGTERM and becomes a zombie.
+if sys.platform != "win32":
+    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
+
 _engine = None
 
 
@@ -223,14 +229,14 @@ def _worker_main() -> None:
             continue
 
         if cmd == "warmup":
-            # Pre-load engine + all models (embedding, reranker, BM25, LLM)
-            # Called at dashboard/MCP startup so first real request is fast.
-            # A dummy recall triggers lazy-loaded components (cross-encoder, BM25 index).
+            # Pre-load engine + database + embeddings only.
+            # V3.3.2: Do NOT run a dummy recall — it triggers the ONNX
+            # cross-encoder export (~30s) which combined with engine init
+            # exceeds the worker timeout. The cross-encoder loads lazily
+            # in a background thread on the first real recall instead.
             try:
                 engine = _get_engine()
                 fact_count = engine._db.get_fact_count(engine._profile_id) if engine._db else 0
-                if fact_count > 0:
-                    engine.recall("warmup", limit=1)
                 _respond({"ok": True, "message": "Engine warm", "facts": fact_count})
             except Exception as exc:
                 _respond({"ok": False, "error": f"Warmup failed: {exc}"})

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/src/superlocalmemory/core/worker_pool.py

@@ -29,8 +29,9 @@ import time
 logger = logging.getLogger(__name__)
 
 _IDLE_TIMEOUT = 120   # 2 min — kill worker after idle
-_REQUEST_TIMEOUT = 60  # 60 sec max per request
-_WARMUP_TIMEOUT = 120  # 2 min — first cold start loads PyTorch + models
+_REQUEST_TIMEOUT = 120  # 120 sec per request (V3.3.2: ONNX cold start can take 30-60s)
+_WARMUP_TIMEOUT = 180  # 3 min — first cold start: engine + ONNX export + models
+_WORKER_RECYCLE_AFTER = 1000  # Recycle worker after N requests (C++ fragmentation prevention)
 
 
 class WorkerPool:
@@ -49,6 +50,7 @@ class WorkerPool:
         self._proc: subprocess.Popen | None = None
         self._idle_timer: threading.Timer | None = None
         self._last_used: float = 0.0
+        self._request_count: int = 0
 
     @classmethod
     def shared(cls) -> WorkerPool:
@@ -146,6 +148,13 @@ class WorkerPool:
     def _send_with_timeout(self, request: dict, timeout: float) -> dict:
         """Send request with configurable timeout. Thread-safe."""
         with self._lock:
+            # Worker recycling: restart after N requests to prevent
+            # C++ allocator fragmentation over long-running sessions.
+            if self._request_count >= _WORKER_RECYCLE_AFTER and self._proc is not None:
+                logger.info("Recycling recall worker after %d requests", self._request_count)
+                self._kill()
+                self._request_count = 0
+
             self._ensure_worker()
             if self._proc is None:
                 return {"ok": False, "error": "Worker failed to start"}
@@ -168,6 +177,7 @@ class WorkerPool:
                     return {"ok": False, "error": "Worker died"}
 
                 self._reset_idle_timer()
+                self._request_count += 1
                 return json.loads(resp_line)
 
             except (BrokenPipeError, OSError, json.JSONDecodeError) as exc:
@@ -227,6 +237,7 @@ class WorkerPool:
                 text=True,
                 bufsize=1,
                 env=env,
+                start_new_session=True,  # Prevent terminal signals bleeding to worker
             )
             logger.info("Recall worker spawned (PID %d)", self._proc.pid)
         except Exception as exc:

{superlocalmemory-3.3.0 → superlocalmemory-3.3.2}/src/superlocalmemory/hooks/ide_connector.py

@@ -194,6 +194,7 @@ class IDEConnector:
             data["mcpServers"] = {}
 
         data["mcpServers"]["superlocalmemory"] = {
+            "type": "stdio",
             "command": "slm",
             "args": ["mcp"],
             "enabled": True,