superlocalmemory 3.6.9 → 3.6.11

package/src/superlocalmemory/mcp/tools_optimize.py

@@ -0,0 +1,304 @@
+# 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
+
+"""SLM v3.6.11 — Surface B: MCP Optimize Tools.
+
+Five proxy-free tools exposing compression (reversible via CCR) and
+routed-result caching WITHOUT touching ANTHROPIC_BASE_URL, so the full
+1M context window is preserved on any Claude subscription.
+
+Primary Claude conversation turns CANNOT be cached without a proxy.
+These tools cache results the agent explicitly routes through SLM.
+
+Fail-open: every tool body is wrapped in try/except Exception.
+Any internal error returns the input unchanged with ok:False — never raises.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import threading
+import time
+
+from mcp.types import ToolAnnotations
+
+from superlocalmemory.mcp.agent_context import get_current_agent_id
+from superlocalmemory.optimize.compress.ccr import CCRStore, _UUID4_RE
+from superlocalmemory.optimize.compress.router import CompressRouter
+from superlocalmemory.optimize.storage.db import CacheDB, _normalize_tenant_id
+
+logger = logging.getLogger("slm.mcp.tools_optimize")
+
+# ─── Size caps (CWE-400 guards) ───────────────────────────────────────────────
+
+_MAX_COMPRESS_BYTES: int = 1_000_000
+_MAX_KV_VALUE_BYTES: int = 1_000_000
+_MAX_KV_KEY_CHARS: int = 512
+
+# ─── Exported tool name list (used by server.py + tests) ─────────────────────
+
+_OPTIMIZE_TOOL_NAMES = (
+    "slm_compress",
+    "slm_retrieve",
+    "slm_cache_set",
+    "slm_cache_get",
+    "slm_optimize_stats",
+)
+
+# ─── In-module KV counters (thread-safe; MetricsCollector is process-scoped) ─
+
+_kv_lock = threading.Lock()
+_kv_hits: int = 0
+_kv_misses: int = 0
+
+
+def _tenant() -> str:
+    # get_current_agent_id() never returns ""; "mcp_client" is its stdio sentinel.
+    return get_current_agent_id()
+
+
+# ─── Tool registration ────────────────────────────────────────────────────────
+
+
+def register_optimize_tools(server) -> None:
+    """Register the 5 Surface B optimize tools on *server*.
+
+    *server* is duck-typed: must support @server.tool() decorator pattern.
+    Compatible with FastMCP, _FilteredServer, and test _MockServer.
+    """
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False))
+    async def slm_compress(
+        content: str,
+        mode: str = "auto",
+        reversible: bool = True,
+        ttl_seconds: int = 86400,
+    ) -> dict:
+        """Compress text or tool output to reduce context window usage.
+
+        Returns compressed text. If lossy and reversible=True, also returns a
+        ccr_id — pass it to slm_retrieve to recover the exact original.
+
+        Args:
+            content: Text to compress (max 1MB).
+            mode: "normalize" (lossless whitespace) | "auto" | "aggressive".
+            reversible: Store original in CCR for later retrieval.
+            ttl_seconds: CCR lifetime in seconds (default 24h).
+        """
+        try:
+            if not isinstance(content, str) or not content:
+                return {
+                    "ok": False, "compressed": content or "",
+                    "strategy": "none", "tokens_before": 0, "tokens_after": 0,
+                    "ratio": 1.0, "lossy": False, "ccr_id": None,
+                    "note": "empty input",
+                }
+
+            note_parts: list[str] = []
+            if len(content.encode("utf-8")) > _MAX_COMPRESS_BYTES:
+                reversible = False
+                note_parts.append("content over 1MB: ccr skipped")
+
+            if mode == "normalize":
+                # @staticmethod — lossless whitespace collapse, no config/daemon dep.
+                normalized = CompressRouter._normalize_whitespace(content)
+                tb = len(content.split())
+                ta = len(normalized.split())
+                ratio = round(ta / tb, 4) if tb else 1.0
+                return {
+                    "ok": True, "compressed": normalized, "strategy": "normalize",
+                    "tokens_before": tb, "tokens_after": ta, "ratio": ratio,
+                    "lossy": False, "ccr_id": None,
+                    "note": " | ".join(note_parts) or None,
+                }
+
+            if mode == "aggressive":
+                note_parts.append(
+                    "aggressive mode requires daemon compress_mode=aggressive in config"
+                )
+
+            res = CompressRouter.get_instance().compress_text(content)
+
+            ccr_id = None
+            if res.lossy and reversible:
+                stored = CCRStore.get_instance().store(
+                    content.encode("utf-8"),
+                    tenant_id=_tenant(),
+                    ttl_seconds=ttl_seconds,
+                )
+                ccr_id = stored or None
+                if ccr_id:
+                    note_parts.append("reversible: call slm_retrieve with this ccr_id")
+
+            ratio = (
+                round(res.tokens_after / res.tokens_before, 4)
+                if res.tokens_before else 1.0
+            )
+            return {
+                "ok": True, "compressed": res.compressed_text, "strategy": res.strategy,
+                "tokens_before": res.tokens_before, "tokens_after": res.tokens_after,
+                "ratio": ratio, "lossy": res.lossy, "ccr_id": ccr_id,
+                "note": " | ".join(note_parts) or None,
+            }
+
+        except Exception as exc:
+            logger.error("slm_compress failed (fail-open): %s", exc)
+            t = len(content.split()) if isinstance(content, str) else 0
+            return {
+                "ok": False,
+                "compressed": content if isinstance(content, str) else "",
+                "strategy": "none", "tokens_before": t, "tokens_after": t,
+                "ratio": 1.0, "lossy": False, "ccr_id": None,
+                "note": f"internal error: {exc}",
+            }
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    async def slm_retrieve(ccr_id: str) -> dict:
+        """Retrieve original text stored during a lossy slm_compress call.
+
+        Do not log or share ccr_ids — they are unguessable session tokens, but
+        if exposed they allow retrieval by anyone with the daemon's decryption key.
+
+        Args:
+            ccr_id: UUID4 returned by slm_compress when reversible=True.
+        """
+        try:
+            if not ccr_id or not _UUID4_RE.match(ccr_id):
+                return {
+                    "ok": False, "content": None, "size_bytes": 0,
+                    "error": "ccr_id must be a UUID4",
+                }
+            original = CCRStore.get_instance().retrieve(ccr_id)
+            if original is None:
+                return {
+                    "ok": False, "content": None, "size_bytes": 0,
+                    "error": "not found (expired / never stored / wrong id)",
+                }
+            size = len(original)
+            try:
+                text = original.decode("utf-8")
+            except UnicodeDecodeError:
+                text = original.decode("latin-1")
+            return {"ok": True, "content": text, "size_bytes": size, "error": None}
+
+        except Exception as exc:
+            logger.error("slm_retrieve failed (fail-open): %s", exc)
+            return {
+                "ok": False, "content": None, "size_bytes": 0,
+                "error": f"internal error: {exc}",
+            }
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=False, destructiveHint=False))
+    async def slm_cache_set(key: str, value: str, ttl_seconds: int = 86400) -> dict:
+        """Cache a result you want to reuse (tool output, file read, search result).
+
+        This caches results the agent explicitly routes through SLM — NOT the
+        Claude conversation turn (impossible without a proxy).
+
+        Do not cache secrets, credentials, or ccr_ids via this tool.
+
+        Args:
+            key: Cache key (max 512 chars). Namespaced per agent automatically.
+            value: Value to store as string (max 1MB).
+            ttl_seconds: Time-to-live in seconds (default 24h).
+        """
+        try:
+            if not key or len(key) > _MAX_KV_KEY_CHARS:
+                return {
+                    "ok": False, "stored": False,
+                    "note": f"key must be 1–{_MAX_KV_KEY_CHARS} chars",
+                }
+            value_bytes = value.encode("utf-8")
+            if len(value_bytes) > _MAX_KV_VALUE_BYTES:
+                return {"ok": False, "stored": False, "note": "value exceeds 1MB limit"}
+
+            tenant = _tenant()
+            cache_key = hashlib.sha256(f"mcpkv:{tenant}:{key}".encode()).hexdigest()
+            norm_tid = _normalize_tenant_id(tenant)
+            ttl_exp = time.time() + ttl_seconds
+
+            CacheDB.get_default().set(
+                cache_key, norm_tid, value_bytes,
+                model="mcp-kv", ttl_expires=ttl_exp, tags=["mcp-kv"],
+            )
+            return {"ok": True, "stored": True, "note": None}
+
+        except Exception as exc:
+            logger.error("slm_cache_set failed (fail-open): %s", exc)
+            return {"ok": False, "stored": False, "note": f"internal error: {exc}"}
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    async def slm_cache_get(key: str) -> dict:
+        """Retrieve a previously cached result.
+
+        Returns hit:True + value if the key exists and has not expired.
+        Returns hit:False (never raises) on miss, expiry, or any error.
+
+        Args:
+            key: Cache key used in slm_cache_set.
+        """
+        global _kv_hits, _kv_misses
+        try:
+            if not key or len(key) > _MAX_KV_KEY_CHARS:
+                return {
+                    "ok": False, "hit": False, "value": None,
+                    "note": f"key must be 1–{_MAX_KV_KEY_CHARS} chars",
+                }
+            tenant = _tenant()
+            cache_key = hashlib.sha256(f"mcpkv:{tenant}:{key}".encode()).hexdigest()
+            norm_tid = _normalize_tenant_id(tenant)
+
+            blob = CacheDB.get_default().get_value(cache_key, norm_tid)
+            if blob is None:
+                with _kv_lock:
+                    _kv_misses += 1
+                return {"ok": True, "hit": False, "value": None, "note": None}
+            with _kv_lock:
+                _kv_hits += 1
+            return {"ok": True, "hit": True, "value": blob.decode("utf-8"), "note": None}
+
+        except Exception as exc:
+            logger.error("slm_cache_get failed (fail-open): %s", exc)
+            return {
+                "ok": False, "hit": False, "value": None,
+                "note": f"internal error: {exc}",
+            }
+
+    @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
+    async def slm_optimize_stats() -> dict:
+        """Return compression and cache statistics.
+
+        Proxy/compress stats are daemon-persisted (accurate across restarts).
+        KV stats are in-module counters for this MCP process session only.
+        """
+        try:
+            snap = CacheDB.get_default().metrics_load()
+            with _kv_lock:
+                kv_h = _kv_hits
+                kv_m = _kv_misses
+            return {
+                "ok": True,
+                "compress_runs": snap.compress_runs,
+                "tokens_saved_compress": snap.tokens_saved_compress,
+                "cache_proxy_hits": snap.hits,
+                "cache_proxy_misses": snap.misses,
+                "cache_kv_hits": kv_h,
+                "cache_kv_misses": kv_m,
+                "ccr_note": (
+                    "CCR entry count not tracked per-session; "
+                    "see daemon /api/v1/metrics"
+                ),
+                "note": "proxy stats are daemon-persisted; kv stats are this session only",
+            }
+        except Exception as exc:
+            logger.error("slm_optimize_stats failed (fail-open): %s", exc)
+            return {
+                "ok": False,
+                "compress_runs": 0, "tokens_saved_compress": 0,
+                "cache_proxy_hits": 0, "cache_proxy_misses": 0,
+                "cache_kv_hits": 0, "cache_kv_misses": 0,
+                "ccr_note": None,
+                "note": f"internal error: {exc}",
+            }

package/src/superlocalmemory/optimize/cache/boundary_store.py

@@ -93,19 +93,23 @@ class PerItemBoundaryRecord:
         query_sim: float,
         delta: float = 0.05,
         epsilon_grid: tuple[float, ...] = (0.01, 0.02, 0.05, 0.10),
+        return_threshold: float = 1.0,
     ) -> float:
         """Compute τ̂ — the vCache exploration probability (Eq. 11).
 
         Args:
-            query_sim: Cosine similarity s(x) ∈ [0, 1] for the incoming query.
-            delta:     δ — user-defined maximum error rate.
-                       Theorem 4.1 guarantee: Pr(correct) ≥ 1 - δ.
-            epsilon_grid: ε values for the Eq. 11 min sweep.
-                          Distinct from δ; controls CI conservativeness.
+            query_sim:        Cosine similarity s(x) ∈ [0, 1] for the incoming query.
+            delta:            δ — user-defined maximum error rate.
+                              Theorem 4.1 guarantee: Pr(correct) ≥ 1 - δ.
+            epsilon_grid:     ε values for the Eq. 11 min sweep.
+                              Distinct from δ; controls CI conservativeness.
+            return_threshold: Semantic return threshold from config (semantic_return_threshold).
+                              C-03 fix: during cold start, exploit directly when
+                              query_sim >= return_threshold instead of always exploring.
 
         Returns:
             τ̂ ∈ [0.0, 1.0]. Lower = more exploitation.
-            Cold start (n < 3): returns 1.0 (always explore).
+            Cold start (n < 3): 0.0 if query_sim >= return_threshold, else 1.0.
 
         Eq. 11 derivation (from the paper):
           1. I_tt = Σ γ̂² · p_i(1 - p_i)            [Fisher info diagonal]
@@ -117,7 +121,12 @@ class PerItemBoundaryRecord:
         """
         n = len(self.samples)
         if n < 3:
-            return 1.0  # cold start — always explore
+            # ARCH-02 note: this function serves dual purpose — (a) warm-phase vCache
+            # Eq. 11 tau computation and (b) cold-start similarity gate. The cold-start
+            # branch (n < 3) is intentionally simple: if the query is already above the
+            # return threshold, serve it (tau=0.0 → exploit); otherwise explore (tau=1.0).
+            # C-03: honor return_threshold — avoids 100% miss until 3 samples are accumulated.
+            return 0.0 if query_sim >= return_threshold else 1.0
 
         # Step 1: Fisher-information SE
         i_tt = 0.0
@@ -144,12 +153,17 @@ class PerItemBoundaryRecord:
 
         return best_tau
 
-    def should_explore(self, query_sim: float, delta: float = 0.05) -> bool:
+    def should_explore(
+        self,
+        query_sim: float,
+        delta: float = 0.05,
+        return_threshold: float = 1.0,
+    ) -> bool:
         """Return True (explore = LLM call) or False (exploit = serve cache).
 
         Source: vCache Algorithm 2: draw u ~ Uniform(0, 1); explore iff u ≤ τ̂.
         """
-        tau = self.compute_tau(query_sim, delta=delta)
+        tau = self.compute_tau(query_sim, delta=delta, return_threshold=return_threshold)
         return _RNG.random() <= tau
 
     def add_sample(

package/src/superlocalmemory/optimize/cache/exact.py

@@ -3,11 +3,13 @@
 from __future__ import annotations
 
 import json
+import logging
 import time
 from typing import Any
 
 from superlocalmemory.optimize.cache.key_builder import CacheConfig
 
+logger = logging.getLogger(__name__)
 
 _NON_CACHEABLE_FINISH_REASONS: frozenset[str] = frozenset({
     "tool_use",
@@ -20,17 +22,21 @@ _NON_CACHEABLE_FINISH_REASONS: frozenset[str] = frozenset({
 def _is_cacheable_response(response: dict) -> bool:
     finish = response.get("stop_reason") or response.get("finish_reason") or ""
     if finish in _NON_CACHEABLE_FINISH_REASONS:
+        logger.debug("exact: skip cache (finish_reason=%r)", finish)
         return False
     choices = response.get("choices") or []
     for choice in choices:
         fr = (choice.get("finish_reason") or "")
         if fr in _NON_CACHEABLE_FINISH_REASONS:
+            logger.debug("exact: skip cache (choice.finish_reason=%r)", fr)
             return False
         msg = choice.get("message") or {}
         if msg.get("tool_calls"):
+            logger.debug("exact: skip cache (choice.message.tool_calls present)")
             return False
     for block in response.get("content") or []:
         if isinstance(block, dict) and block.get("type") == "tool_use":
+            logger.debug("exact: skip cache (tool_use content block)")
             return False
     return True
 
@@ -46,9 +52,6 @@ class ExactCache:
         row = self._db.get(key, tenant_id)
         if row is None:
             return None
-        if row.ttl_expires is not None and row.ttl_expires < time.time():
-            self._db.delete(key, tenant_id)
-            return None
         return json.loads(row.value.decode("utf-8"))
 
     def set(
@@ -74,7 +77,7 @@ class ExactCache:
             value=encoded,
             model=model,
             ttl_expires=expires_at,
-            tags=[],
+            tags=tags,
         )
         return True
 

package/src/superlocalmemory/optimize/cache/key_builder.py

@@ -4,10 +4,13 @@ from __future__ import annotations
 
 import hashlib
 import json
+import logging
 import re
 from dataclasses import dataclass, field
 from typing import Any
 
+logger = logging.getLogger(__name__)
+
 DETERMINISTIC_PARAMS: frozenset[str] = frozenset({
     "max_tokens", "stop", "stop_sequences", "top_p", "top_k",
     "response_format", "tools", "tool_choice",
@@ -62,6 +65,16 @@ class KeyBuilder:
             temperature = 0.0
 
         if temperature != 0 and not self._config.allow_nonzero_temperature_cache:
+            logger.debug(
+                "cache skip: temperature=%.2f allow_nonzero=%s",
+                temperature,
+                self._config.allow_nonzero_temperature_cache,
+            )
+            try:
+                from superlocalmemory.optimize.metrics.counters import MetricsCollector
+                MetricsCollector.get_instance().increment_skipped_temperature()
+            except Exception:
+                pass
             return None
 
         deterministic_params: dict[str, Any] = {}

package/src/superlocalmemory/optimize/cache/manager.py

@@ -2,12 +2,17 @@
 
 from __future__ import annotations
 
+import hashlib as _hashlib
+import json as _json_mod
 import logging
 import threading
 import time
 from abc import ABC, abstractmethod
 from typing import Any, Callable
 
+# C-08: precomputed hash for the common "default" tenant — avoids sha256 on every request
+_DEFAULT_TENANT_HASH: str = _hashlib.sha256(b"default").hexdigest()
+
 from superlocalmemory.optimize.cache.exact import ExactCache
 from superlocalmemory.optimize.cache.invalidation import InvalidationEngine
 from superlocalmemory.optimize.cache.key_builder import CacheConfig, KeyBuilder
@@ -230,6 +235,26 @@ class CacheManager:
                 ttl_seconds=0,
             )
         self._metrics.exact_misses += 1
+
+        # C-01: semantic fallback on exact miss (only when explicitly enabled)
+        if self._semantic.is_enabled():
+            try:
+                sem_result = self._semantic.lookup(req, tenant_id, None)
+                if sem_result is not None:
+                    self._metrics.semantic_hits += 1
+                    if isinstance(sem_result, CachedResponse):
+                        return sem_result
+                    # VCacheSemantic may return a response dict — wrap it
+                    return CachedResponse(
+                        hit=True,
+                        data=_json_mod.dumps(sem_result, ensure_ascii=False).encode(),
+                        cache_key=key,
+                        ttl_seconds=0,
+                    )
+            except Exception as exc:
+                logger.warning("SemanticTier.lookup raised (fail-open): %s", exc)
+            self._metrics.semantic_misses += 1
+
         # Return miss WITH the key so callers can use it for cache storage.
         return CachedResponse(hit=False, data=None, cache_key=key, ttl_seconds=0)
 
@@ -258,6 +283,13 @@ class CacheManager:
         self._invalidation.register(key, tenant_id, tags)
         self._metrics.sets += 1
 
+        # C-02: index in semantic tier after exact write (fail-open)
+        if self._semantic.is_enabled():
+            try:
+                self._semantic.index_entry(req, tenant_id, None, response_dict)
+            except Exception as exc:
+                logger.warning("SemanticTier.index_entry raised (fail-open): %s", exc)
+
     # ---- CacheHook protocol implementation (INTERFACE-CONTRACT §3) ----
 
     def check(self, req: ProxyRequest) -> "CachedResponse | None":
@@ -269,7 +301,7 @@ class CacheManager:
         cache-miss result.
         """
         try:
-            result = self.get(req, tenant_id="default")
+            result = self.get(req, tenant_id=_DEFAULT_TENANT_HASH)
             if result is not None and not result.hit:
                 MetricsCollector.get_instance().on_miss()
             return result
@@ -280,21 +312,51 @@ class CacheManager:
     def store(self, req: ProxyRequest, resp: ProviderResponse) -> None:
         """CacheHook.store() — persist response; fail-open on error."""
         try:
-            self.set(req, resp, tenant_id="default")
+            self.set(req, resp, tenant_id=_DEFAULT_TENANT_HASH)
         except Exception as exc:
             logger.warning("CacheManager.store raised (fail-open): %s", exc)
 
     def on_hit(self, req: ProxyRequest, resp: bytes, tokens_saved: int) -> None:
         """CacheHook.on_hit() — forward token savings to MetricsCollector.
-        
-        Contract §7: cache skip saves BOTH input+output tokens (whole call avoided).
-        tokens_saved = input tokens saved (from request).
-        Output tokens estimated from response body size (~4 bytes per token).
+
+        M-01: compute input tokens from request body when caller passes 0.
+        M-02: parse real output tokens from cached response usage field.
+        All counts are estimates for display — not billing-accurate.
         """
+        import json as _json
+
+        # M-01: estimate input tokens from message content
+        if tokens_saved == 0 and isinstance(req, ProxyRequest):
+            try:
+                body = req.body or {}
+                total_chars = 0
+                for m in (body.get("messages") or []):
+                    c = m.get("content", "")
+                    if isinstance(c, str):
+                        total_chars += len(c)
+                    elif isinstance(c, list):
+                        for blk in c:
+                            if isinstance(blk, dict):
+                                total_chars += len(blk.get("text", "") or "")
+                total_chars += len(body.get("system", "") or "")
+                tokens_saved = max(0, total_chars // 4)
+            except Exception:
+                pass
+
+        # M-02: parse real output tokens from stored response
         output_tokens = 0
         if resp:
-            # Rough estimate: 4 bytes per token for English text
-            output_tokens = len(resp) // 4
+            try:
+                data = _json.loads(resp)
+                usage = data.get("usage") or {}
+                output_tokens = (
+                    usage.get("output_tokens")
+                    or usage.get("completion_tokens")
+                    or 0
+                )
+            except Exception:
+                output_tokens = len(resp) // 4  # fallback byte-estimate
+
         MetricsCollector.get_instance().on_hit(
             tokens_saved_input=tokens_saved,
             tokens_saved_output=output_tokens,

package/src/superlocalmemory/optimize/cache/semantic.py

@@ -294,7 +294,8 @@ class VCacheSemantic(SemanticTier):
         # Step 5: vCache exploit/explore (MLE τ̂ via record_outcome updates)
         record = self._boundary_store.get(best_entry_id)
         delta = float(getattr(cfg, "semantic_error_target", _DEFAULT_ERROR_TARGET))
-        if record.should_explore(best_score, delta=delta):
+        sem_return_threshold = float(getattr(cfg, "semantic_return_threshold", _DEFAULT_RETURN_THRESHOLD))
+        if record.should_explore(best_score, delta=delta, return_threshold=sem_return_threshold):
             logger.debug(
                 "VCacheSemantic: explore (score=%.4f entry=%s t_hat=%.4f)",
                 best_score, best_entry_id, record.t_hat,
@@ -363,11 +364,11 @@ class VCacheSemantic(SemanticTier):
                     self._index[tenant_id] = []
                 return
             entries: list[tuple[str, str, np.ndarray]] = []
-            for entry_id, blob in rows:
+            for entry_id, blob, ctx_fp in rows:  # C-10: unpack persisted context_fp
                 try:
                     v = np.frombuffer(blob, dtype=np.float32).copy()
                     if v.shape[0] == _EMBED_DIM:
-                        entries.append((entry_id, "", v))
+                        entries.append((entry_id, ctx_fp, v))
                 except Exception:
                     continue
             with self._index_lock:
@@ -422,13 +423,17 @@ class VCacheSemantic(SemanticTier):
             )
             return
 
-        # Store vector in DB
+        # Store vector in DB — C-10: persist context_fp alongside the vector
         vec_bytes = vec.tobytes()
         self._db.vec_add(
             entry_id=entry_id,
             tenant_id=tenant_id,
             vector=vec_bytes,
-            meta={"model": "nomic-ai/nomic-embed-text-v1.5", "dim": _EMBED_DIM},
+            meta={
+                "model": "nomic-ai/nomic-embed-text-v1.5",
+                "dim": _EMBED_DIM,
+                "context_fp": context_fp,
+            },
         )
 
         # Initialize boundary record if new

package/src/superlocalmemory/optimize/compress/prose_llmlingua.py

@@ -32,16 +32,10 @@ class LLMLinguaCompressor:
 
     def __init__(
         self,
-        model_name: str = _MODEL_BERT,
+        model_name: str = _MODEL_XLM,
         device_map: str = "cpu",
         rate: float = _DEFAULT_RATE,
     ) -> None:
-        import os
-        if os.environ.get("SLM_DISABLE_HF_DOWNLOAD", "0") == "1":
-            raise ImportError(
-                "LLMLingua-2 model download blocked: SLM_DISABLE_HF_DOWNLOAD=1. "
-                "Set compress_llmlingua_allow_download=true in optimize.json."
-            )
         try:
             from llmlingua import PromptCompressor  # type: ignore[import]
         except ImportError as e: