superlocalmemory 3.6.10 → 3.6.12

package/src/superlocalmemory/cli/daemon.py

@@ -408,410 +408,3 @@ def _wait_for_workers_dead(timeout: int = 10) -> None:
         time.sleep(0.5)
 
     logger.warning("Some SLM workers still alive after %ds timeout", timeout)
-
-
-# ---------------------------------------------------------------------------
-# Server: HTTP request handler with engine singleton
-# ---------------------------------------------------------------------------
-
-_engine = None
-_last_activity = time.monotonic()
-
-# ---------------------------------------------------------------------------
-# V3.3.28: Observation debounce buffer.
-#
-# When 20+ file edits arrive in quick succession (from parallel AI agents,
-# git checkout, or batch sed), we buffer observations for _OBSERVE_DEBOUNCE_SEC
-# seconds and deduplicate by content hash. This reduces 20 observations → 1-3
-# batches, each processed by the singleton engine (1 embedding worker).
-# ---------------------------------------------------------------------------
-
-_OBSERVE_DEBOUNCE_SEC = float(os.environ.get("SLM_OBSERVE_DEBOUNCE_SEC", "3.0"))
-_observe_buffer: list[str] = []
-_observe_seen: set[str] = set()  # content hashes for dedup within window
-_observe_lock = threading.Lock()
-_observe_timer: threading.Timer | None = None
-
-
-def _flush_observe_buffer() -> None:
-    """Process all buffered observations as a single batch."""
-    global _observe_timer
-    with _observe_lock:
-        if not _observe_buffer:
-            return
-        batch = list(_observe_buffer)
-        _observe_buffer.clear()
-        _observe_seen.clear()
-        _observe_timer = None
-
-    # Process each unique observation (already deduped)
-    engine = _get_engine()
-    from superlocalmemory.hooks.auto_capture import AutoCapture
-    auto = AutoCapture(engine=engine)
-
-    for content in batch:
-        try:
-            decision = auto.evaluate(content)
-            if decision.capture:
-                auto.capture(content, category=decision.category)
-        except Exception as exc:
-            # Swallow per-observation to protect the batch, but log so
-            # a pattern of dropped observations is visible.
-            logger.warning("observation dropped during batch: %s", exc)
-
-    logger.info("Observe debounce: processed %d observations (from buffer)", len(batch))
-
-
-def _enqueue_observation(content: str) -> dict:
-    """Add an observation to the debounce buffer. Returns immediate response."""
-    global _observe_timer
-    import hashlib
-    content_hash = hashlib.md5(content.encode()).hexdigest()
-
-    with _observe_lock:
-        if content_hash in _observe_seen:
-            return {"captured": False, "reason": "duplicate within debounce window"}
-
-        _observe_seen.add(content_hash)
-        _observe_buffer.append(content)
-        buf_size = len(_observe_buffer)
-
-        # Reset debounce timer
-        if _observe_timer is not None:
-            _observe_timer.cancel()
-        _observe_timer = threading.Timer(_OBSERVE_DEBOUNCE_SEC, _flush_observe_buffer)
-        _observe_timer.daemon = True
-        _observe_timer.start()
-
-    return {"captured": True, "queued": True, "buffer_size": buf_size,
-            "debounce_sec": _OBSERVE_DEBOUNCE_SEC}
-
-
-def _get_engine():
-    global _engine
-    if _engine is None:
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.core.engine import MemoryEngine
-
-        config = SLMConfig.load()
-        _engine = MemoryEngine(config)
-        _engine.initialize()
-
-        # Force reranker warmup (blocking — daemon can afford to wait)
-        retrieval_eng = getattr(_engine, '_retrieval_engine', None)
-        if retrieval_eng:
-            reranker = getattr(retrieval_eng, '_reranker', None)
-            if reranker and hasattr(reranker, 'warmup_sync'):
-                reranker.warmup_sync(timeout=120)
-
-        logger.info("Daemon engine initialized and warm")
-    return _engine
-
-
-class DaemonHandler(BaseHTTPRequestHandler):
-    """Lightweight HTTP handler for daemon requests."""
-
-    def log_message(self, format, *args):
-        """Suppress default access logging."""
-        pass
-
-    def _send_json(self, status: int, data: dict) -> None:
-        self.send_response(status)
-        self.send_header("Content-Type", "application/json")
-        self.end_headers()
-        self.wfile.write(json.dumps(data).encode())
-
-    def _read_body(self) -> dict:
-        length = int(self.headers.get("Content-Length", 0))
-        if length == 0:
-            return {}
-        return json.loads(self.rfile.read(length).decode())
-
-    def do_GET(self) -> None:
-        global _last_activity
-        _last_activity = time.monotonic()
-
-        if self.path == "/health":
-            self._send_json(200, {"status": "ok", "pid": os.getpid()})
-            return
-
-        if self.path.startswith("/recall"):
-            try:
-                # Parse query from URL params
-                from urllib.parse import urlparse, parse_qs
-                params = parse_qs(urlparse(self.path).query)
-                query = params.get("q", [""])[0]
-                limit = int(params.get("limit", ["20"])[0])
-
-                # S9-DASH-02: session_id for outcome-queue enqueue.
-                # Priority: ?session_id= query arg > X-SLM-Session-Id
-                # header > synthetic "cli:<ts>". Without any of these
-                # the recall still works — it just doesn't produce a
-                # pending_outcome (hook-based signals can't match).
-                session_id = params.get("session_id", [""])[0]
-                if not session_id:
-                    session_id = self.headers.get("X-SLM-Session-Id", "")
-                if not session_id:
-                    import time as _t
-                    session_id = f"http:{int(_t.time() * 1000)}"
-
-                engine = _get_engine()
-                raw_fast = params.get("fast", ["false"])[0]
-                fast = raw_fast.lower() in ("true", "1")
-                response = engine.recall(
-                    query, limit=limit, session_id=session_id, fast=fast,
-                )
-                # Return the same field shape as recall_worker._handle_recall,
-                # so MCP processes that proxy through the daemon get recall_trace-
-                # compatible data without a second round trip.
-                memory_ids = list({
-                    r.fact.memory_id for r in response.results[:limit]
-                    if r.fact.memory_id
-                })
-                memory_map = (
-                    engine._db.get_memory_content_batch(memory_ids)
-                    if memory_ids else {}
-                )
-                results = []
-                for r in response.results[:limit]:
-                    fact_type = getattr(r.fact, "fact_type", None)
-                    lifecycle = getattr(r.fact, "lifecycle", None)
-                    # v3.5.1: sanitize control chars that break JSON (newlines, tabs in content).
-                    clean = r.fact.content.replace("\r", " ").replace("\n", " ").replace("\t", " ")
-                    sc_raw = memory_map.get(r.fact.memory_id, "")
-                    sc_clean = sc_raw.replace("\r", " ").replace("\n", " ").replace("\t", " ") if sc_raw else ""
-                    results.append({
-                        "fact_id": r.fact.fact_id,
-                        "memory_id": r.fact.memory_id,
-                        "content": clean,
-                        "source_content": sc_clean,
-                        "score": round(r.score, 4),
-                        "confidence": round(r.confidence, 4),
-                        "trust_score": round(r.trust_score, 4),
-                        "channel_scores": {
-                            k: round(v, 4)
-                            for k, v in (r.channel_scores or {}).items()
-                        },
-                        "fact_type": fact_type.value
-                            if fact_type and hasattr(fact_type, "value") else "",
-                        "lifecycle": lifecycle.value
-                            if lifecycle and hasattr(lifecycle, "value") else "",
-                        "access_count": getattr(r.fact, "access_count", 0),
-                        "evidence_chain": list(
-                            getattr(r, "evidence_chain", []) or []
-                        ),
-                    })
-                self._send_json(200, {
-                    "ok": True,
-                    "query": query,
-                    "query_type": response.query_type,
-                    "result_count": len(results),
-                    "retrieval_time_ms": round(response.retrieval_time_ms, 1),
-                    "channel_weights": {
-                        k: round(v, 3)
-                        for k, v in (response.channel_weights or {}).items()
-                    },
-                    "total_candidates": getattr(response, "total_candidates", 0),
-                    "results": results,
-                    "count": len(results),  # backward compat alias
-                })
-            except Exception as exc:
-                self._send_json(500, {"error": str(exc)})
-            return
-
-        if self.path == "/list":
-            try:
-                engine = _get_engine()
-                facts = engine.list_facts(limit=50)
-                items = [
-                    {"content": f.content[:100], "fact_type": getattr(f.fact_type, 'value', str(f.fact_type)),
-                     "created_at": (f.created_at or "")[:19], "fact_id": f.fact_id}
-                    for f in facts
-                ]
-                self._send_json(200, {"results": items, "count": len(items)})
-            except Exception as exc:
-                self._send_json(500, {"error": str(exc)})
-            return
-
-        if self.path == "/status":
-            engine = _get_engine()
-            uptime = time.monotonic() - _server_start_time
-            self._send_json(200, {
-                "status": "running", "pid": os.getpid(),
-                "uptime_s": round(uptime),
-                "mode": engine._config.mode.value,
-                "fact_count": engine.fact_count,
-                "idle_s": round(time.monotonic() - _last_activity),
-            })
-            return
-
-        self._send_json(404, {"error": "not found"})
-
-    def do_POST(self) -> None:
-        global _last_activity
-        _last_activity = time.monotonic()
-
-        if self.path == "/remember":
-            try:
-                body = self._read_body()
-                content = body.get("content", "")
-                tags = body.get("tags", "")
-                extra_meta = body.get("metadata") or {}
-                if not content:
-                    self._send_json(400, {"error": "content required"})
-                    return
-
-                engine = _get_engine()
-                metadata = {"tags": tags} if tags else {}
-                if isinstance(extra_meta, dict):
-                    metadata.update(extra_meta)
-                fact_ids = engine.store(content, metadata=metadata)
-                self._send_json(200, {
-                    "ok": True,
-                    "fact_ids": fact_ids,
-                    "count": len(fact_ids),
-                })
-            except Exception as exc:
-                self._send_json(500, {"error": str(exc)})
-            return
-
-        if self.path == "/observe":
-            try:
-                body = self._read_body()
-                content = body.get("content", "")
-                if not content:
-                    self._send_json(400, {"error": "content required"})
-                    return
-
-                # V3.3.28: Debounced observation processing.
-                # Buffers observations for 3s, deduplicates, processes as batch.
-                # Returns immediately — the actual capture happens asynchronously
-                # via the debounce timer, using the singleton engine.
-                result = _enqueue_observation(content)
-                self._send_json(200, result)
-            except Exception as exc:
-                self._send_json(500, {"error": str(exc)})
-            return
-
-        if self.path == "/stop":
-            self._send_json(200, {"status": "stopping"})
-            Thread(target=_shutdown_server, daemon=True).start()
-            return
-
-        self._send_json(404, {"error": "not found"})
-
-
-# ---------------------------------------------------------------------------
-# Server lifecycle
-# ---------------------------------------------------------------------------
-
-_server: HTTPServer | None = None
-_server_start_time = time.monotonic()
-
-
-def _shutdown_server() -> None:
-    global _engine, _server
-    try:
-        _flush_observe_buffer()
-    except Exception as exc:
-        logger.warning("flush observe buffer on shutdown failed: %s", exc)
-    time.sleep(0.5)
-    if _engine is not None:
-        try:
-            _engine.close()
-        except Exception as exc:
-            logger.warning("engine close on shutdown failed: %s", exc)
-        _engine = None
-    if _server is not None:
-        _server.shutdown()
-    _PID_FILE.unlink(missing_ok=True)
-    _PORT_FILE.unlink(missing_ok=True)
-
-
-def _idle_watchdog(timeout: int) -> None:
-    """Auto-shutdown after idle timeout."""
-    global _last_activity
-    while True:
-        time.sleep(30)
-        idle = time.monotonic() - _last_activity
-        if idle > timeout:
-            logger.info("Daemon idle for %ds, shutting down", int(idle))
-            _shutdown_server()
-            os._exit(0)
-
-
-def start_server(port: int = _DEFAULT_PORT, idle_timeout: int | None = None) -> None:
-    """Start the daemon HTTP server. Blocks until stopped."""
-    global _server, _server_start_time, _last_activity
-
-    idle_timeout = idle_timeout or int(os.environ.get(
-        "SLM_DAEMON_IDLE_TIMEOUT", str(_DEFAULT_IDLE_TIMEOUT),
-    ))
-
-    # Banner is advisory — a broken data dir must never prevent the daemon
-    # from starting, so the swallow here is intentional.
-    try:
-        from superlocalmemory import __version__ as _slm_ver
-        from superlocalmemory.cli.version_banner import check_and_emit_upgrade_banner
-        check_and_emit_upgrade_banner(_slm_ver)
-    except Exception as exc:
-        logger.warning("upgrade banner on daemon start failed: %s", exc)
-
-    # Apply the v3.4.26 data-dir migration now — the daemon is the
-    # authoritative holder of the DB, so this is the right place to do
-    # it unconditionally (``migrate`` is idempotent).
-    try:
-        from pathlib import Path as _P
-        from superlocalmemory.migrations.v3_4_25_to_v3_4_26 import (
-            is_ready as _is_ready, migrate as _migrate,
-        )
-        _data = _P(os.environ.get("SLM_DATA_DIR")
-                   or _P.home() / ".superlocalmemory")
-        if not _is_ready(_data):
-            _migrate(_data)
-    except Exception as exc:
-        logger.warning("v3.4.26 migration on daemon start failed: %s", exc)
-
-    # Write PID + port files
-    _PID_FILE.parent.mkdir(parents=True, exist_ok=True)
-    _PID_FILE.write_text(str(os.getpid()))
-    _PORT_FILE.write_text(str(port))
-
-    # Handle SIGTERM for graceful shutdown
-    signal.signal(signal.SIGTERM, lambda *_: _shutdown_server() or os._exit(0))
-
-    # Pre-warm engine (this is the cold start — daemon absorbs it once)
-    logger.info("Daemon starting — warming engine...")
-    _get_engine()
-    logger.info("Engine warm. Daemon ready on port %d (idle timeout: %ds)", port, idle_timeout)
-
-    _server_start_time = time.monotonic()
-    _last_activity = time.monotonic()
-
-    # Start idle watchdog
-    Thread(target=_idle_watchdog, args=(idle_timeout,), daemon=True, name="idle-watchdog").start()
-
-    # Start HTTP server
-    # SO_REUSEADDR must be set on the class BEFORE __init__ calls bind()
-    HTTPServer.allow_reuse_address = True
-    _server = HTTPServer(("127.0.0.1", port), DaemonHandler)
-    try:
-        _server.serve_forever()
-    except KeyboardInterrupt:
-        pass
-    finally:
-        _shutdown_server()
-
-
-# ---------------------------------------------------------------------------
-# CLI entry point
-# ---------------------------------------------------------------------------
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
-    if "--start" in sys.argv:
-        start_server()
-    elif "--stop" in sys.argv:
-        stop_daemon()
-    else:
-        print("Usage: python -m superlocalmemory.cli.daemon --start|--stop")

package/src/superlocalmemory/cli/main.py

@@ -183,7 +183,9 @@ def main() -> None:
         help="Wait for completion (default: async background processing)",
     )
 
-    recall_p = sub.add_parser("recall", help="Semantic search with 4-channel retrieval")
+    # v3.6.12 (parity-3): `search` is an alias of `recall` so the CLI has the
+    # same search verb the MCP exposes (handlers dict maps both to cmd_recall).
+    recall_p = sub.add_parser("recall", aliases=["search"], help="Semantic search with 4-channel retrieval")
     recall_p.add_argument("query", help="Search query")
     recall_p.add_argument("--limit", type=int, default=10, help="Max results (default 10)")
     recall_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")

package/src/superlocalmemory/core/context_cache.py

@@ -205,7 +205,10 @@ class ContextCache:
         Does NOT run LRU sweep inline (PERF-01-07) — that's a background
         task on the daemon.
         """
-        content = redact_secrets(entry.content)[:MAX_CONTENT_CHARS]
+        # v3.6.12 (redact-1): scrub dashboard/cached content at HIGH aggression
+        # so Bearer/GitHub-PAT/Anthropic/OpenAI/GENERIC_KEY patterns are caught
+        # (the default 'normal' skipped them, leaking those shapes to the UI).
+        content = redact_secrets(entry.content, aggression="high")[:MAX_CONTENT_CHARS]
         fact_ids_json = json.dumps(list(entry.fact_ids))
         byte_size = (
             len(content.encode("utf-8"))

package/src/superlocalmemory/core/fact_consolidator.py

@@ -367,7 +367,10 @@ def _summarize_with_ollama(
         if config and hasattr(config, 'llm'):
             api_base = getattr(config.llm, 'api_base', api_base) or api_base
             model = getattr(config.llm, 'model', model) or model
-            timeout = getattr(config.llm, 'timeout', timeout) or timeout
+            # v3.6.12 (modeb-4): the LLMConfig field is `timeout_seconds`, not
+            # `timeout` — the old read always missed and silently used 30s.
+            timeout = getattr(config.llm, 'timeout_seconds', None) or \
+                getattr(config.llm, 'timeout', None) or timeout
 
         fact_texts = "\n".join(f"- {f['content']}" for f in facts[:_MAX_CLUSTER_SIZE])
         prompt = (

package/src/superlocalmemory/core/remote_mode.py

@@ -0,0 +1,197 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Distributed / LAN deployment mode — the single ``SLM_REMOTE`` switch.
+
+SuperLocalMemory historically assumes every dashboard browser, MCP client,
+and API caller lives on ``127.0.0.1``. That assumption breaks three things
+for users who deploy SLM on a server and reach it across a LAN (issue #39):
+
+  1. ``/internal/token`` refuses any non-loopback client → Brain page can't
+     fetch the install token → "Couldn't load Brain".
+  2. The MCP Streamable-HTTP transport is **stateful** — every call must
+     replay the ``Mcp-Session-Id`` from the ``initialize`` handshake. A
+     gateway/hub that forwards a tool call without replaying it gets
+     ``-32600 Session not found``.
+  3. Dashboard CSRF origin checks only accept loopback origins.
+
+``SLM_REMOTE=1`` flips all three assumptions at once, **default OFF** so the
+loopback-only security posture is unchanged for the 99% local case. LAN
+access is still gated by an explicit IP allowlist (``SLM_MCP_ALLOWED_HOSTS``)
+— remote mode alone does not throw the doors open.
+
+Granular overrides (each implied by ``SLM_REMOTE=1`` but usable alone):
+  * ``SLM_MCP_STATELESS=1`` — stateless MCP transport only (gateway fix),
+    without opening the dashboard token endpoint.
+
+Security note (WORSTCASE): stateless MCP drops per-session isolation, and
+serving the install token to a LAN host lets any allowlisted machine read
+the brain. Keep the allowlist specific (never blanket ``*`` unless the
+network is fully trusted) — see ``docs/distributed-deployment.md``.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import os
+
+_TRUTHY = frozenset({"1", "true", "yes", "on"})
+
+
+def _is_truthy(value: str | None) -> bool:
+    return bool(value) and value.strip().lower() in _TRUTHY
+
+
+def is_remote_mode() -> bool:
+    """True iff ``SLM_REMOTE`` opts this daemon into LAN/distributed mode."""
+    return _is_truthy(os.environ.get("SLM_REMOTE"))
+
+
+def mcp_stateless() -> bool:
+    """True iff the MCP transport should run stateless (no session id required).
+
+    Enabled by ``SLM_REMOTE=1`` (umbrella) or ``SLM_MCP_STATELESS=1`` (granular).
+    Stateless mode lets any gateway/hub forward ``tools/call`` without replaying
+    the ``Mcp-Session-Id`` handshake — the fix for issue #39 Issue 3.
+    """
+    return is_remote_mode() or _is_truthy(os.environ.get("SLM_MCP_STATELESS"))
+
+
+def _allowlist_entries() -> list[str]:
+    """Trusted-client allowlist, from ``SLM_MCP_ALLOWED_HOSTS``.
+
+    Reuses the existing LAN allowlist the user already sets for MCP DNS-rebinding
+    protection so there is ONE place to configure trusted hosts. Entries are
+    comma-separated and may be: ``*`` (any), an exact IP, a CIDR block
+    (``192.168.1.0/24``), or a prefix wildcard (``192.168.*``). A trailing
+    ``:port`` / ``:*`` (host-header style) is ignored for client-IP matching.
+    """
+    raw = os.environ.get("SLM_MCP_ALLOWED_HOSTS", "").strip()
+    return [e.strip() for e in raw.split(",") if e.strip()]
+
+
+def _strip_port(entry: str) -> str:
+    """Drop a trailing ``:port`` / ``:*`` host-header suffix.
+
+    Handles plain ``host[:port]`` and CIDR ``a.b.c.d/n[:port]`` (v3.6.12 lan-1:
+    a CIDR written with a host-header port suffix used to fail ip_network() and
+    silently deny ALL clients). Bracketless IPv6 literals (≥2 colons, no '/')
+    are left untouched.
+    """
+    e = entry.strip()
+    if "/" in e:
+        # CIDR — strip anything after the network prefix (a stray :port/:*)
+        return e.partition(":")[0]
+    if e.count(":") == 1:  # host:port or host:* (IPv4 / hostname)
+        return e.split(":", 1)[0]
+    return e
+
+
+def _host_matches(entry: str, client_host: str, client_ip) -> bool:
+    host = _strip_port(entry).strip()
+    if not host:
+        return False
+    if host == "*":
+        return True
+    if "/" in host and client_ip is not None:
+        try:
+            return client_ip in ipaddress.ip_network(host, strict=False)
+        except ValueError:
+            return False
+    if host.endswith("*"):
+        # STRING prefix match (not CIDR). client_host is always the numeric
+        # socket peer IP (never a resolvable hostname), and a dotted prefix like
+        # "192.168." rejects "192.1680.x". Prefer CIDR (192.168.0.0/16) for
+        # unambiguous network matching; wildcards are a convenience.
+        return client_host.startswith(host[:-1])
+    return host == client_host
+
+
+def is_lan_client_allowed(client_host: str) -> bool:
+    """True iff remote mode is ON and ``client_host`` is in the trusted allowlist.
+
+    Loopback is handled separately by callers — this governs *non*-loopback LAN
+    clients only. Returns False whenever remote mode is off or the allowlist is
+    empty, so the default posture stays loopback-only.
+    """
+    if not is_remote_mode() or not client_host:
+        return False
+    entries = _allowlist_entries()
+    if not entries:
+        return False
+    try:
+        client_ip = ipaddress.ip_address(client_host)
+    except ValueError:
+        client_ip = None
+    return any(_host_matches(e, client_host, client_ip) for e in entries)
+
+
+def is_remote_origin_allowed(origin: str) -> bool:
+    """True iff remote mode is ON and ``origin``'s host is in the allowlist.
+
+    ``origin`` is a full URL (``http://192.168.50.144:8765``). Empty origin is
+    not this function's concern (loopback callers handle that). Used to relax
+    the dashboard CSRF origin guard for trusted LAN dashboards.
+    """
+    if not is_remote_mode() or not origin:
+        return False
+    # Extract host from scheme://host[:port]
+    rest = origin.split("://", 1)[-1]
+    host = rest.split("/", 1)[0]
+    # Strip a trailing :port (IPv4/hostname); leave bracketed IPv6 alone.
+    if host.startswith("["):
+        host = host.split("]", 1)[0].lstrip("[")
+    elif host.count(":") == 1:
+        host = host.split(":", 1)[0]
+    return is_lan_client_allowed(host)
+
+
+def _env_int(name: str, default: int) -> int:
+    """Read a positive int from env, falling back to ``default`` on any error."""
+    raw = os.environ.get(name, "").strip()
+    if not raw:
+        return default
+    try:
+        val = int(raw)
+    except ValueError:
+        return default
+    return val if val > 0 else default
+
+
+def rate_limit_config() -> tuple[int, int, int]:
+    """(write_max, read_max, window_seconds) for the dashboard rate limiter.
+
+    Issue #40 Issue 3: the limiter was hardcoded (30 writes / 120 reads per 60s)
+    with no way to raise it for distributed/LAN debugging, so a remote browser
+    that retried a failing Brain load hit ``429 Too Many Requests``. These are
+    now tunable via ``SLM_RATE_LIMIT_WRITE`` / ``SLM_RATE_LIMIT_READ`` /
+    ``SLM_RATE_LIMIT_WINDOW`` (defaults unchanged for the local case).
+    """
+    write_max = _env_int("SLM_RATE_LIMIT_WRITE", 30)
+    read_max = _env_int("SLM_RATE_LIMIT_READ", 120)
+    window = _env_int("SLM_RATE_LIMIT_WINDOW", 60)
+    return write_max, read_max, window
+
+
+def is_rate_limit_exempt(client_host: str) -> bool:
+    """True iff ``client_host`` should bypass the dashboard rate limiter.
+
+    Loopback is always exempt (the dashboard polls itself rapidly). In remote
+    mode, an allowlisted LAN client is the user's own remote browser doing the
+    same rapid reads, so it is exempt too — otherwise normal dashboard polling
+    trips the limiter (issue #40 Issue 3).
+    """
+    if client_host in ("127.0.0.1", "::1", "localhost"):
+        return True
+    return is_lan_client_allowed(client_host)
+
+
+__all__ = (
+    "is_remote_mode",
+    "mcp_stateless",
+    "is_lan_client_allowed",
+    "is_remote_origin_allowed",
+    "rate_limit_config",
+    "is_rate_limit_exempt",
+)

package/src/superlocalmemory/core/summarizer.py

@@ -124,8 +124,11 @@ class Summarizer:
         """
         import httpx
         model = getattr(self._config.llm, 'model', None) or "llama3.1:8b"
+        # v3.6.12 (modeb-2): honor the configured endpoint instead of hardcoding
+        # localhost:11434, so a remote/non-default Ollama host works in Mode B.
+        _base = (getattr(self._config.llm, 'api_base', '') or "http://localhost:11434").rstrip("/")
         with httpx.Client(timeout=httpx.Timeout(30.0)) as client:
-            resp = client.post("http://localhost:11434/api/generate", json={
+            resp = client.post(f"{_base}/api/generate", json={
                 "model": model,
                 "prompt": prompt,
                 "stream": False,

package/src/superlocalmemory/llm/backbone.py

@@ -138,7 +138,13 @@ class LLMBackbone:
             return False
         if self._provider == "ollama":
             return True
-        return bool(self._api_key)
+        # v3.6.12 (modeb-1): a custom local OpenAI-compatible endpoint
+        # (llama.cpp, LM Studio, vLLM) needs NO API key — _build_openai already
+        # omits the Authorization header when the key is empty. Treat a
+        # configured base_url as sufficient, otherwise Mode B silently falls
+        # back to Mode A extraction for keyless local endpoints.
+        _base = getattr(self, "_base_url", "") or getattr(self, "_api_base", "")
+        return bool(self._api_key) or bool(_base)
 
     @property
     def provider(self) -> str: