superlocalmemory 3.5.7__tar.gz → 3.5.9__tar.gz

{superlocalmemory-3.5.7/src/superlocalmemory.egg-info → superlocalmemory-3.5.9}/PKG-INFO

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

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/pyproject.toml

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

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/__init__.py

@@ -28,7 +28,7 @@ if "OMP_NUM_THREADS" not in os.environ:
     os.environ["OMP_NUM_THREADS"] = "2"
 # ---------------------------------------------------------------------------
 
-__version__ = "3.5.7"
+__version__ = "3.5.9"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/cli/commands.py

@@ -1661,6 +1661,26 @@ def cmd_trace(args: Namespace) -> None:
 
 def cmd_mcp(_args: Namespace) -> None:
     """Start the V3 MCP server (stdio transport for IDE integration)."""
+    # SINGLETON GUARD (v3.5.8): Reap fresh orphans before binding stdio.
+    # Root cause: every IDE session spawns a new `slm mcp`; dead sessions'
+    # processes survive indefinitely (~400 MB each) because the reaper's
+    # 1-hour age gate misses them. Fix: run find_orphans with age_threshold=0
+    # so any `slm mcp` whose parent IDE/Claude process has died is killed
+    # immediately. Only orphans (dead parent) are killed — live sessions safe.
+    # CRITICAL: No stdout anywhere below — MCP stdio transport, any print
+    # corrupts the JSON-RPC protocol.
+    try:
+        from superlocalmemory.infra.process_reaper import (
+            ReaperConfig,
+            find_orphans,
+            kill_orphan,
+        )
+        _reaper_cfg = ReaperConfig(orphan_age_threshold_hours=0.0)
+        for _orphan in find_orphans(_reaper_cfg):
+            kill_orphan(_orphan.pid, graceful_timeout_seconds=1.0)
+    except Exception:
+        pass  # Never block MCP startup on cleanup failure
+
     # Auto-install hooks on MCP startup (fast path: ~0.1ms if already current)
     # CRITICAL: No stdout — MCP uses stdio transport, any print corrupts protocol
     try:
@@ -2553,6 +2573,11 @@ def cmd_reap(args: Namespace) -> None:
     """Find and kill orphaned SLM processes."""
     use_json = getattr(args, "json", False)
     dry_run = not getattr(args, "force", False)
+    # V3.5.9: --all bypasses orphan detection and kills every slm mcp process
+    # except the current one. Use after switching IDEs to clear stale sessions.
+    use_force_all = getattr(args, "all", False)
+    if use_force_all:
+        dry_run = False  # --all always kills; --force is implied
 
     try:
         from superlocalmemory.infra.process_reaper import (
@@ -2561,7 +2586,7 @@ def cmd_reap(args: Namespace) -> None:
         )
 
         config = ReaperConfig()
-        result = cleanup_all_orphans(config, dry_run=dry_run)
+        result = cleanup_all_orphans(config, dry_run=dry_run, force=use_force_all)
     except Exception as exc:
         if use_json:
             from superlocalmemory.cli.json_output import json_print
@@ -2580,7 +2605,8 @@ def cmd_reap(args: Namespace) -> None:
             "killed": result.get("killed", 0),
             "skipped": result.get("skipped", 0),
         }, next_actions=[
-            {"command": "slm reap --force --json", "description": "Kill orphans"},
+            {"command": "slm reap --force --json", "description": "Kill orphan processes"},
+            {"command": "slm reap --all --json", "description": "Kill ALL slm mcp sessions (IDE switch)"},
             {"command": "slm status --json", "description": "Check status"},
         ])
         return
@@ -2600,3 +2626,4 @@ def cmd_reap(args: Namespace) -> None:
     print(f"  Skipped:             {skipped}")
     if dry_run and orphans > 0:
         print("\n  Use --force to kill orphaned processes.")
+        print("  Use --all to kill ALL slm mcp sessions (after IDE switch).")

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/cli/main.py

@@ -349,6 +349,10 @@ def main() -> None:
         "--force", action="store_true",
         help="Kill orphans (default: dry run only)",
     )
+    reap_p.add_argument(
+        "--all", action="store_true", dest="all",
+        help="Kill ALL slm mcp processes regardless of orphan status (use after IDE switch)",
+    )
     reap_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
     # V3.4.3: Ingestion adapters

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/core/config.py

@@ -691,6 +691,9 @@ class SLMConfig:
         mode = Mode(data.get("mode", "a"))
         llm_data = data.get("llm", {})
         emb_data = data.get("embedding", {})
+        # V3.5.9: read base_dir before constructing config so for_mode() builds
+        # db_path from the user's directory, not DEFAULT_BASE_DIR.
+        raw_base_dir = Path(data.get("base_dir", str(DEFAULT_BASE_DIR)))
         config = cls.for_mode(
             mode,
             llm_provider=llm_data.get("provider", ""),
@@ -703,6 +706,7 @@ class SLMConfig:
             embedding_deployment=emb_data.get("deployment_name", ""),
             embedding_model_name=emb_data.get("model_name", ""),
             embedding_dimension=int(emb_data.get("dimension", 0) or 0),
+            base_dir=raw_base_dir,
         )
         config.active_profile = data.get("active_profile", "default")
 
@@ -813,6 +817,7 @@ class SLMConfig:
         data = {
             "mode": effective_mode,
             "active_profile": self.active_profile,
+            "base_dir": str(self.base_dir),  # V3.5.9: persist so load() can restore custom paths
             "llm": {
                 "provider": self.llm.provider,
                 "model": self.llm.model,

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/core/engine.py

@@ -126,6 +126,10 @@ class MemoryEngine:
 
         if self._capabilities is Capabilities.FULL:
             self._init_heavy_layer()
+        else:
+            # V3.5.9: LIGHT mode — try to get embedder from running daemon so that
+            # memories stored via MCP have real embeddings (fixes PR #30 NULL embedder).
+            self._try_init_proxy()
 
         self._initialized = True
         logger.info(
@@ -187,6 +191,25 @@ class MemoryEngine:
         from superlocalmemory.learning.adaptive import AdaptiveLearner
         self._adaptive_learner = AdaptiveLearner(self._db)
 
+    def _try_init_proxy(self) -> None:
+        """V3.5.9: Attach McpEmbedderProxy when running in LIGHT mode.
+
+        If the daemon is reachable, the proxy delegates embed calls over HTTP
+        so that MCP-stored facts have real embeddings (fixes PR #30). Silently
+        skips if the daemon is not running — keyword recall still works.
+        """
+        try:
+            from superlocalmemory.core.mcp_embedder_proxy import McpEmbedderProxy
+            port = getattr(self._config, "daemon_port", 8765)
+            proxy = McpEmbedderProxy(port=port)
+            if proxy.is_available():
+                self._embedder = proxy
+                logger.info("MCP embedder proxy attached (daemon port %d)", port)
+            else:
+                logger.debug("Daemon not reachable — MCP will run without embedder")
+        except Exception as exc:
+            logger.debug("McpEmbedderProxy init skipped: %s", exc)
+
     def _init_heavy_layer(self) -> None:
         from superlocalmemory.llm.backbone import LLMBackbone
         from superlocalmemory.core.engine_wiring import (

superlocalmemory-3.5.9/src/superlocalmemory/core/mcp_embedder_proxy.py

@@ -0,0 +1,89 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com
+
+"""V3.5.9 — McpEmbedderProxy: lightweight embedder for the MCP (LIGHT) process.
+
+Problem: MemoryEngine(Capabilities.LIGHT) skips _init_heavy_layer(), leaving
+_embedder=None permanently. Any memory stored via MCP tools has NULL embeddings
+→ semantic search silently broken; health() lies, reporting unavailable.
+
+Solution: a thin proxy that delegates embed_batch() to the running daemon via
+its POST /api/embed endpoint over localhost HTTP. The daemon runs a FULL engine
+with one real ONNX/Ollama worker. No second ONNX process is spawned.
+
+Usage (engine.py LIGHT branch):
+    proxy = McpEmbedderProxy(port=8765)
+    if proxy.is_available():
+        engine._embedder = proxy
+"""
+
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_TIMEOUT = 5.0  # seconds — fast enough for inline store() calls
+
+
+class McpEmbedderProxy:
+    """Proxy embedder: MCP process → daemon's /api/embed over localhost HTTP."""
+
+    def __init__(self, port: int = 8765, timeout: float = _DEFAULT_TIMEOUT) -> None:
+        self._base_url = f"http://127.0.0.1:{port}"
+        self._timeout = timeout
+        self._available: bool | None = None  # cached after first is_available() call
+
+    def is_available(self) -> bool:
+        """Ping daemon's embed endpoint. Cached after first success."""
+        if self._available is True:
+            return True
+        try:
+            import httpx
+            resp = httpx.get(f"{self._base_url}/api/v3/embed/ping", timeout=2.0)
+            self._available = resp.status_code == 200
+        except Exception:
+            self._available = False
+        return bool(self._available)
+
+    # -- Embedder interface (matches embeddings.py / ollama_embedder.py) ------
+
+    def embed(self, text: str) -> list[float] | None:
+        """Embed a single text via daemon. Returns None on any error."""
+        results = self.embed_batch([text])
+        return results[0] if results else None
+
+    def embed_batch(self, texts: list[str]) -> list[list[float] | None]:
+        """Embed a batch of texts via daemon's /api/embed endpoint."""
+        if not texts:
+            return []
+        try:
+            import httpx
+            resp = httpx.post(
+                f"{self._base_url}/api/v3/embed",
+                json={"texts": texts},
+                timeout=self._timeout,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            embeddings = data.get("embeddings", [])
+            # Pad with None if daemon returned fewer results than requested
+            while len(embeddings) < len(texts):
+                embeddings.append(None)
+            return embeddings
+        except Exception as exc:
+            logger.debug("McpEmbedderProxy.embed_batch failed: %s", exc)
+            return [None] * len(texts)
+
+    def compute_fisher_params(
+        self, embedding: list[float]
+    ) -> tuple[list[float] | None, list[float] | None]:
+        """Fisher-Rao params stay in daemon's FULL engine; proxy returns None.
+
+        The MCP LIGHT process stores facts with embedding=<vector> but
+        fisher_mean=None, fisher_variance=None. The daemon's consolidation
+        pass fills these in asynchronously — same behaviour as the
+        write-through remember path.
+        """
+        return None, None

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/infra/process_reaper.py

@@ -185,7 +185,18 @@ else:
             if not line:
                 continue
 
-            if "superlocalmemory" not in line:
+            # v3.5.8: Expand detection to include entry-point launched `slm mcp`
+            # processes. Previously only `python -m superlocalmemory.*` was caught;
+            # `/opt/homebrew/bin/slm mcp` processes were invisible to the reaper,
+            # causing zombie accumulation (55 processes / ~5 GB RAM observed).
+            _slm_identifiers = (
+                "superlocalmemory",
+                "/slm ",
+                "slm mcp",
+                "slm serve",
+                "slm daemon",
+            )
+            if not any(kw in line for kw in _slm_identifiers):
                 continue
 
             try:

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/llm/backbone.py

@@ -233,17 +233,23 @@ class LLMBackbone:
         self, prompt: str, system: str, max_tokens: int, temperature: float,
     ) -> tuple[str, dict[str, str], dict]:
         messages = self._make_messages(system, prompt)
-        headers = {
-            "Authorization": f"Bearer {self._api_key}",
-            "Content-Type": "application/json",
-        }
+        # V3.5.9: Skip Authorization header when api_key is empty so unauthenticated
+        # local endpoints (llama.cpp, LM Studio, etc.) don't reject with HTTP 401.
+        headers = {"Content-Type": "application/json"}
+        if self._api_key:
+            headers["Authorization"] = f"Bearer {self._api_key}"
         payload = {
             "model": self._model,
             "messages": messages,
             "max_tokens": max_tokens,
             "temperature": temperature,
         }
+        # V3.5.9: If base_url is a bare base (e.g. "http://host:port/v1") without
+        # the /chat/completions path, append it — matching OpenAI SDK behaviour and
+        # fixing the /v1/v1 duplication reported in issue #29.
         url = self._base_url or _OPENAI_URL
+        if self._base_url and not self._base_url.rstrip("/").endswith("chat/completions"):
+            url = f"{self._base_url.rstrip('/')}/chat/completions"
         return url, headers, payload
 
     def _build_ollama(

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/mcp/server.py

@@ -278,5 +278,39 @@ _watchdog_thread = threading.Thread(target=_parent_watchdog, daemon=True, name="
 _watchdog_thread.start()
 
 
+# V3.5.9: Stdin EOF monitor — complements the parent watchdog for the case where
+# the IDE starts a new MCP session WITHOUT quitting the app. The old stdio pipe
+# is abandoned (write-end closed) but the parent process stays alive, so the
+# watchdog never fires. Without this, each IDE reconnect adds a zombie process
+# (22 seen in production causing 12 GB swap on the M5 Pro).
+#
+# Uses kqueue(2) KQ_EV_EOF on macOS — fires when the write-end of the stdin pipe
+# closes WITHOUT consuming any bytes, so it cannot race with FastMCP's asyncio
+# stdin reader. On Linux (no kqueue), the watchdog alone provides coverage.
+def _stdin_eof_monitor() -> None:
+    """Exit when the IDE closes our stdin pipe (kqueue — macOS only)."""
+    import select as _sel, os as _os_eof
+    _mlog = logging.getLogger(__name__ + ".stdin_monitor")
+    if not hasattr(_sel, "kqueue"):
+        return  # Linux / non-macOS: watchdog covers process death
+    try:
+        fd = sys.stdin.fileno()
+        kq = _sel.kqueue()
+        ke = _sel.kevent(fd, filter=_sel.KQ_FILTER_READ, flags=_sel.KQ_EV_ADD | _sel.KQ_EV_EOF)
+        kq.control([ke], 0)  # register without waiting
+        while True:
+            evs = kq.control(None, 4, 30.0)  # 30 s poll — low cost
+            for ev in evs:
+                if ev.flags & _sel.KQ_EV_EOF:
+                    _mlog.info("stdin write-end closed (kqueue EOF), self-terminating")
+                    _os_eof._exit(0)
+    except Exception as exc:
+        _mlog.debug("stdin EOF monitor error: %s — watchdog will cover", exc)
+
+
+_stdin_monitor_thread = threading.Thread(target=_stdin_eof_monitor, daemon=True, name="stdin-eof-monitor")
+_stdin_monitor_thread.start()
+
+
 if __name__ == "__main__":
     server.run(transport="stdio")

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/mcp/tools_v3.py

@@ -161,9 +161,13 @@ def register_v3_tools(server, get_engine: Callable) -> None:
                 "fact_count": fact_count,
             }
 
-            # Embedding service
+            # Embedding service — distinguish real embedder from V3.5.9 daemon proxy
+            _emb = engine._embedder
+            from superlocalmemory.core.mcp_embedder_proxy import McpEmbedderProxy
+            _is_proxy = isinstance(_emb, McpEmbedderProxy)
             status["components"]["embedder"] = {
-                "status": "ok" if engine._embedder else "unavailable",
+                "status": "ok" if _emb else "unavailable",
+                "source": "daemon_proxy" if _is_proxy else "local",
                 "model": engine._config.embedding.model_name,
             }
 

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory/server/routes/v3_api.py

@@ -365,6 +365,51 @@ async def test_embedding_endpoint(request: Request):
         return {"success": False, "error": type(e).__name__}
 
 
+@router.get("/embed/ping")
+async def embed_ping():
+    """V3.5.9: Liveness probe for McpEmbedderProxy. Returns 200 when daemon
+    embedder is ready so the proxy knows the daemon is reachable."""
+    try:
+        from .helpers import get_engine_lazy
+        # We just need to confirm the route is alive — engine check is optional
+        return {"ok": True}
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=503)
+
+
+@router.post("/embed")
+async def embed_texts(request: Request):
+    """V3.5.9: Embed texts via daemon's FULL engine for McpEmbedderProxy.
+
+    MCP processes run LIGHT engines (no ONNX worker). This endpoint lets them
+    delegate embed_batch() to the daemon's single real embedder — one ONNX
+    worker total across all sessions (fixes PR #30 NULL embedder bug).
+    """
+    import asyncio
+    try:
+        body = await request.json()
+        texts = body.get("texts", [])
+        if not texts:
+            return {"embeddings": []}
+
+        from .helpers import get_engine_lazy
+        engine = get_engine_lazy(request.app.state)
+        if engine is None or engine._embedder is None:
+            return JSONResponse(
+                {"error": "Embedder not available in daemon"},
+                status_code=503,
+            )
+
+        loop = asyncio.get_event_loop()
+        embeddings = await loop.run_in_executor(
+            None,
+            lambda: engine._embedder.embed_batch(texts),
+        )
+        return {"embeddings": embeddings}
+    except Exception as e:
+        return JSONResponse({"error": str(e)}, status_code=500)
+
+
 @router.post("/provider/test")
 async def test_provider(request: Request):
     """Test connectivity to an LLM provider."""
@@ -400,8 +445,25 @@ async def test_provider(request: Request):
                 return {"success": True, "message": "OpenRouter connected, key valid"}
 
         if provider == "openai":
+            # V3.5.9: custom/local endpoint — api_key is optional (llama.cpp, LM Studio etc.)
+            custom_endpoint = body.get("base_url", "").strip() or body.get("endpoint", "").strip()
+            if custom_endpoint:
+                headers_test = {"Content-Type": "application/json"}
+                if api_key:
+                    headers_test["Authorization"] = f"Bearer {api_key}"
+                base = custom_endpoint.rstrip("/")
+                if not base.endswith("chat/completions"):
+                    base = f"{base}/chat/completions"
+                with httpx.Client(timeout=httpx.Timeout(10.0)) as c:
+                    # Probe with a minimal chat request (models list not universal on local servers)
+                    probe = {"model": body.get("model", "test"), "messages": [{"role": "user", "content": "hi"}], "max_tokens": 1}
+                    resp = c.post(base, headers=headers_test, json=probe)
+                    if resp.status_code in (200, 400, 422):
+                        return {"success": True, "message": f"Custom endpoint reachable (HTTP {resp.status_code})"}
+                    resp.raise_for_status()
+                    return {"success": True, "message": "Custom OpenAI-compatible endpoint connected"}
             if not api_key:
-                return {"success": False, "error": "API key required"}
+                return {"success": False, "error": "API key required for official OpenAI endpoint"}
             with httpx.Client(timeout=httpx.Timeout(10.0)) as c:
                 resp = c.get("https://api.openai.com/v1/models", headers={"Authorization": f"Bearer {api_key}"})
                 resp.raise_for_status()

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9/src/superlocalmemory.egg-info}/PKG-INFO

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

{superlocalmemory-3.5.7 → superlocalmemory-3.5.9}/src/superlocalmemory.egg-info/SOURCES.txt

@@ -90,6 +90,7 @@ src/superlocalmemory/core/injection.py
 src/superlocalmemory/core/loop_watchdog.py
 src/superlocalmemory/core/maintenance.py
 src/superlocalmemory/core/maintenance_scheduler.py
+src/superlocalmemory/core/mcp_embedder_proxy.py
 src/superlocalmemory/core/modes.py
 src/superlocalmemory/core/ollama_embedder.py
 src/superlocalmemory/core/platform_utils.py