superlocalmemory 3.4.52__tar.gz → 3.4.53__tar.gz

{superlocalmemory-3.4.52/src/superlocalmemory.egg-info → superlocalmemory-3.4.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.52
+Version: 3.4.53
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later

{superlocalmemory-3.4.52 → superlocalmemory-3.4.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.52"
+version = "3.4.53"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

{superlocalmemory-3.4.52 → superlocalmemory-3.4.53}/src/superlocalmemory/__init__.py

@@ -3,7 +3,7 @@
 import os
 os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
 
-__version__ = "3.4.52"
+__version__ = "3.4.53"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

{superlocalmemory-3.4.52 → superlocalmemory-3.4.53}/src/superlocalmemory/retrieval/engine.py

@@ -451,7 +451,17 @@ class RetrievalEngine:
     def _run_channels(
         self, query: str, profile_id: str, strat: QueryStrategy,
     ) -> dict[str, list[tuple[str, float]]]:
-        """Run active retrieval channels. Respects disabled_channels config for ablation."""
+        """Run active retrieval channels.
+
+        v3.4.53: channels run in PARALLEL via ThreadPoolExecutor. Industry
+        standard (EverMemOS, szl-recall, ContentPilot 2026): all channels
+        are independent after embedding; running them serially wastes time
+        equal to the sum of all channel latencies. Parallel execution brings
+        total channel time from sum(semantic+bm25+entity+temporal+hopfield+sa)
+        down to max(semantic,bm25,entity,temporal,hopfield,sa) — roughly a
+        3-5x speedup for the channel phase.
+        """
+        import concurrent.futures
         out: dict[str, list[tuple[str, float]]] = {}
         # Skip channels listed in disabled_channels (ablation support)
         # V3.4.40: union with per-recall extra_disabled set (e.g. --fast skip)
@@ -475,51 +485,55 @@ class RetrievalEngine:
             except Exception as exc:
                 logger.warning("Query embedding failed: %s", exc)
 
-        if self._semantic is not None and q_emb is not None and "semantic" not in disabled:
-            try:
-                r = self._semantic.search(q_emb, profile_id, self._config.semantic_top_k)
-                if r:
-                    out["semantic"] = r
-            except Exception as exc:
-                logger.warning("Semantic channel: %s", exc)
-
-        if self._bm25 is not None and "bm25" not in disabled:
-            try:
-                r = self._bm25.search(query, profile_id, self._config.bm25_top_k)
-                if r:
-                    out["bm25"] = r
-            except Exception as exc:
-                logger.warning("BM25 channel: %s", exc)
-
-        # V3.4.12: entity_graph is now a signal enhancer (post-RRF boost),
-        # not an independent channel. Removed from channel execution to avoid
-        # running spreading activation twice. See score_candidates() in engine.recall().
-
-        if self._temporal is not None and "temporal" not in disabled:
-            try:
-                r = self._temporal.search(query, profile_id, top_k=self._config.bm25_top_k)
-                if r:
-                    out["temporal"] = r
-            except Exception as exc:
-                logger.warning("Temporal channel: %s", exc)
+        # v3.4.53: collect channel callables and run in parallel.
+        # Each channel is a standalone search — no shared mutable state,
+        # no ordering dependencies. SQLite WAL mode permits concurrent reads.
+        futures: dict[str, concurrent.futures.Future] = {}
 
-        # Phase G: Hopfield channel (6th) — energy-based pattern completion
-        if self._hopfield is not None and q_emb is not None and "hopfield" not in disabled:
+        def _safe_channel(name: str, fn, *args):
+            """Run a single channel, returning (name, result_or_None)."""
             try:
-                r = self._hopfield.search(q_emb, profile_id, self._config.hopfield_top_k)
-                if r:
-                    out["hopfield"] = r
+                res = fn(*args)
+                return (name, res if res else None)
             except Exception as exc:
-                logger.warning("Hopfield channel: %s", exc)
+                logger.warning("%s channel: %s", name, exc)
+                return (name, None)
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=6) as executor:
+            if self._semantic is not None and q_emb is not None and "semantic" not in disabled:
+                futures["semantic"] = executor.submit(
+                    _safe_channel, "semantic",
+                    self._semantic.search, q_emb, profile_id, self._config.semantic_top_k,
+                )
+            if self._bm25 is not None and "bm25" not in disabled:
+                futures["bm25"] = executor.submit(
+                    _safe_channel, "bm25",
+                    self._bm25.search, query, profile_id, self._config.bm25_top_k,
+                )
+            if self._temporal is not None and "temporal" not in disabled:
+                futures["temporal"] = executor.submit(
+                    _safe_channel, "temporal",
+                    self._temporal.search, query, profile_id, self._config.bm25_top_k,
+                )
+            if self._hopfield is not None and q_emb is not None and "hopfield" not in disabled:
+                futures["hopfield"] = executor.submit(
+                    _safe_channel, "hopfield",
+                    self._hopfield.search, q_emb, profile_id, self._config.hopfield_top_k,
+                )
+            if self._spreading_activation is not None and q_emb is not None and "spreading_activation" not in disabled:
+                futures["spreading_activation"] = executor.submit(
+                    _safe_channel, "spreading_activation",
+                    self._spreading_activation.search, q_emb, profile_id, self._config.bm25_top_k,
+                )
 
-        # Phase 3: Spreading Activation channel (5th) — graph-based associative recall
-        if self._spreading_activation is not None and q_emb is not None and "spreading_activation" not in disabled:
-            try:
-                r = self._spreading_activation.search(q_emb, profile_id, self._config.bm25_top_k)
-                if r:
-                    out["spreading_activation"] = r
-            except Exception as exc:
-                logger.warning("Spreading activation channel: %s", exc)
+            # Collect results as channels complete
+            for name, fut in futures.items():
+                try:
+                    ch_name, result = fut.result(timeout=30)
+                    if result:
+                        out[ch_name] = result
+                except Exception as exc:
+                    logger.warning("Channel %s timed out or failed: %s", name, exc)
 
         # Apply registered post-retrieval filters (forgetting filter, etc.)
         if hasattr(self, '_registry') and self._registry._filters:

{superlocalmemory-3.4.52 → superlocalmemory-3.4.53}/src/superlocalmemory/retrieval/reranker.py

@@ -56,7 +56,11 @@ _IDLE_TIMEOUT_SECONDS = 300  # V3.4.37: 5 min (was 30) — balance cold-start vs
 # V3.4.19: Bumped from 120 → 1800 in lock-step with the embedding worker.
 # Set ``SLM_RERANKER_IDLE_TIMEOUT=120`` + ``slm restart`` to revert.
 _IDLE_TIMEOUT_SECONDS = int(os.environ.get("SLM_RERANKER_IDLE_TIMEOUT", _IDLE_TIMEOUT_SECONDS))
-_SUBPROCESS_RESPONSE_TIMEOUT = 180  # V3.3.12: 180s (was 120s) for stressed system respawns
+_SUBPROCESS_RESPONSE_TIMEOUT = 15  # v3.4.52: 15s (was 180s). Long timeout blocked the
+# entire FastAPI event loop — a dead reranker subprocess held ALL
+# endpoints hostage for 3 minutes. 15s is enough for ONNX inference
+# cold start; if the worker can't respond, we fall back to fusion
+# scores without reranking.
 _WORKER_RECYCLE_AFTER = 500  # Recycle after N requests
 
 
@@ -231,16 +235,26 @@ class CrossEncoderReranker:
             logger.warning("Failed to spawn reranker worker: %s", exc)
             self._worker_proc = None
 
-    def _send_request(self, req: dict, timeout: float | None = None) -> dict | None:
+    def _send_request(self, req: dict, timeout: float | None = None,
+                      block: bool = True) -> dict | None:
         """Send JSON request to worker, get response. Thread-safe.
 
         Uses a short timeout (10s) for rerank requests since the model
         should already be loaded by the background warmup. Uses the full
         timeout only for explicit load/ping commands.
+
+        v3.4.52: when ``block=False``, uses ``try_lock`` instead of
+        ``lock.acquire()``. If another thread is already using the
+        reranker subprocess, returns ``None`` immediately (the caller
+        falls back to fusion scores without reranking). This prevents
+        concurrent recall requests from serialising on the lock.
         """
         effective_timeout = timeout or _SUBPROCESS_RESPONSE_TIMEOUT
 
-        with self._lock:
+        acquired = self._lock.acquire(blocking=block)
+        if not acquired:
+            return None  # another request is using the subprocess
+        try:
             if self._request_count >= _WORKER_RECYCLE_AFTER and self._worker_proc is not None:
                 logger.info("Recycling reranker worker after %d requests", self._request_count)
                 self._kill_worker()
@@ -253,31 +267,32 @@ class CrossEncoderReranker:
             if self._worker_proc is None:
                 return None
 
-            try:
-                msg = json.dumps(req) + "\n"
-                self._worker_proc.stdin.write(msg)
-                self._worker_proc.stdin.flush()
+            msg = json.dumps(req) + "\n"
+            self._worker_proc.stdin.write(msg)
+            self._worker_proc.stdin.flush()
 
-                resp_line = self._readline_with_timeout(
-                    self._worker_proc.stdout,
-                    effective_timeout,
-                )
-                if not resp_line:
-                    logger.warning("Reranker worker timed out after %ds", effective_timeout)
-                    self._kill_worker()
-                    self._model_loaded = False
-                    return None
-
-                resp = json.loads(resp_line)
-                self._reset_idle_timer()
-                self._request_count += 1
-                return resp
-            except (BrokenPipeError, OSError, json.JSONDecodeError) as exc:
-                logger.warning("Reranker worker communication failed: %s", exc)
+            resp_line = self._readline_with_timeout(
+                self._worker_proc.stdout,
+                effective_timeout,
+            )
+            if not resp_line:
+                logger.warning("Reranker worker timed out after %ds", effective_timeout)
                 self._kill_worker()
                 self._model_loaded = False
                 return None
 
+            resp = json.loads(resp_line)
+            self._reset_idle_timer()
+            self._request_count += 1
+            return resp
+        except (BrokenPipeError, OSError, json.JSONDecodeError) as exc:
+            logger.warning("Reranker worker communication failed: %s", exc)
+            self._kill_worker()
+            self._model_loaded = False
+            return None
+        finally:
+            self._lock.release()
+
     @staticmethod
     def _readline_with_timeout(stream: Any, timeout_seconds: float) -> str:
         """Read a line from stream with timeout. Returns '' on timeout."""
@@ -363,14 +378,16 @@ class CrossEncoderReranker:
 
         documents = [fact.content for fact, _ in candidates]
 
-        # V3.3.16: Timeout 180s — ONNX CoreML compilation can take 30-60s on
-        # first inference even after model load. The warmup_inference in the
-        # worker should prevent this, but 180s is a safety net.
+        # v3.4.53: block=False — if another recall is using the reranker
+        # subprocess, skip reranking and return fusion scores directly.
+        # This prevents concurrent recalls from serialising on the lock.
+        # 15s timeout (was 180s) — warm ONNX inference takes ~100ms; if
+        # the worker can't respond in 15s it's dead and we fall back.
         resp = self._send_request({
             "cmd": "rerank",
             "query": query,
             "documents": documents,
-        }, timeout=180.0)
+        }, timeout=15.0, block=False)
 
         if resp is None or not resp.get("ok"):
             # Fallback: return by existing score

{superlocalmemory-3.4.52 → superlocalmemory-3.4.53}/src/superlocalmemory/server/unified_daemon.py

@@ -156,6 +156,13 @@ from superlocalmemory.core.recall_gate import (
 # daemon startup via engine._process_pending_memories().
 _engine = None
 
+# v3.4.53: Limit concurrent full (non-fast) recalls. Without this, N parallel
+# /recall calls spawn N × 6-channel threads → Ollama serialises, reranker
+# lock queues, and total wall time is N × single-recall-time. 3 concurrent
+# full recalls gives parallelism benefit without resource oversaturation.
+import asyncio as _asyncio
+_recall_semaphore = _asyncio.Semaphore(3)
+
 # v3.4.52: Embedding model warm state. Set to True by the async pre-warm
 # thread once Ollama has loaded the embedding model. /health reports this
 # so MCP clients can wait for warm state before issuing recall calls.
@@ -1167,9 +1174,22 @@ def _register_daemon_routes(application: FastAPI) -> None:
             import time as _t
             effective_sid = f"http:{int(_t.time() * 1000)}"
         # v3.4.32: mark recall in-flight so the pending materializer pauses
+        # v3.4.52: run engine.recall() in a thread-pool executor so the
+        # FastAPI event loop stays responsive for /health, /remember, and
+        # concurrent /recall requests. Without this, a single slow full
+        # recall (reranker timeout, cold embedder) blocks ALL endpoints.
+        import asyncio
         _begin_recall()
+        # v3.4.53: Full (non-fast) recalls are gated by a semaphore to
+        # prevent resource oversaturation. Ollama serialises concurrent
+        # embedding calls and the reranker subprocess has a single lock —
+        # queuing more than ~3 concurrent full recalls just adds latency.
+        # Fast recalls (SQLite/BM25 only) skip the semaphore.
+        if not fast:
+            await _recall_semaphore.acquire()
         try:
-            response = engine.recall(
+            response = await asyncio.to_thread(
+                engine.recall,
                 search_query, limit=limit, session_id=effective_sid,
                 fast=fast,
             )
@@ -1228,6 +1248,8 @@ def _register_daemon_routes(application: FastAPI) -> None:
         except Exception as exc:
             raise HTTPException(500, detail=str(exc))
         finally:
+            if not fast:
+                _recall_semaphore.release()
             _end_recall()
 
     @application.post("/remember")

{superlocalmemory-3.4.52 → superlocalmemory-3.4.53/src/superlocalmemory.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.52
+Version: 3.4.53
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later