superlocalmemory 3.5.8 → 3.6.0

package/src/superlocalmemory/optimize/storage/schema.py

@@ -0,0 +1,184 @@
+"""DDL for llmcache.db — the Optimize module's dedicated SQLite database.
+
+ISOLATION GUARANTEE: This schema MUST NEVER reference memory.db tables.
+No FKs to profiles, atomic_facts, memories, or any SLM core table.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from typing import Final
+
+CACHE_SCHEMA_VERSION: Final[int] = 1
+
+LLMCACHE_DB_FILENAME: Final[str] = "llmcache.db"
+
+
+_DDL_STATEMENTS: tuple[str, ...] = (
+    """
+    CREATE TABLE IF NOT EXISTS llmcache_schema_version (
+        version     INTEGER NOT NULL,
+        applied_at  TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+        description TEXT    NOT NULL DEFAULT ''
+    )
+    """,
+    """
+    CREATE TABLE IF NOT EXISTS llmcache_entries (
+        entry_id        TEXT    PRIMARY KEY,
+        cache_key       TEXT    NOT NULL,
+        tenant_id       TEXT    NOT NULL DEFAULT 'default',
+        model           TEXT    NOT NULL DEFAULT '',
+        provider        TEXT    NOT NULL DEFAULT '',
+        value_blob      BLOB    NOT NULL,
+        compressed      INTEGER NOT NULL DEFAULT 0,
+        created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+        last_hit_at     TEXT,
+        ttl_expires     REAL,
+        hit_count       INTEGER NOT NULL DEFAULT 0,
+        byte_size       INTEGER NOT NULL DEFAULT 0,
+        tag_json        TEXT    NOT NULL DEFAULT '[]',
+        cache_tier      TEXT    NOT NULL DEFAULT 'exact'
+                                CHECK (cache_tier IN ('exact', 'semantic'))
+    )
+    """,
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_llmcache_key_tenant ON llmcache_entries (cache_key, tenant_id)",
+    "CREATE INDEX IF NOT EXISTS idx_llmcache_ttl ON llmcache_entries (ttl_expires) WHERE ttl_expires IS NOT NULL",
+    "CREATE INDEX IF NOT EXISTS idx_llmcache_tenant ON llmcache_entries (tenant_id)",
+    "CREATE INDEX IF NOT EXISTS idx_llmcache_provider ON llmcache_entries (tenant_id, provider)",
+    "CREATE INDEX IF NOT EXISTS idx_llmcache_lru ON llmcache_entries (last_hit_at)",
+    """
+    CREATE TABLE IF NOT EXISTS llmcache_semantic_vectors (
+        entry_id        TEXT    PRIMARY KEY,
+        tenant_id       TEXT    NOT NULL DEFAULT 'default',
+        vector_blob     BLOB    NOT NULL,
+        vector_dim      INTEGER NOT NULL DEFAULT 768,
+        model_name      TEXT    NOT NULL DEFAULT 'nomic-ai/nomic-embed-text-v1.5',
+        created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    )
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_llmcache_vec_tenant ON llmcache_semantic_vectors (tenant_id)",
+    """
+    CREATE TABLE IF NOT EXISTS llmcache_ccr_originals (
+        ccr_id          TEXT    PRIMARY KEY,
+        tenant_id       TEXT    NOT NULL DEFAULT 'default',
+        original_blob   BLOB    NOT NULL,
+        compressed_hash TEXT    NOT NULL,
+        byte_size_orig  INTEGER NOT NULL DEFAULT 0,
+        byte_size_comp  INTEGER NOT NULL DEFAULT 0,
+        model           TEXT    NOT NULL DEFAULT '',
+        created_at      TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+        ttl_expires     REAL
+    )
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_llmcache_ccr_hash ON llmcache_ccr_originals (compressed_hash)",
+    "CREATE INDEX IF NOT EXISTS idx_llmcache_ccr_tenant ON llmcache_ccr_originals (tenant_id)",
+    "CREATE INDEX IF NOT EXISTS idx_llmcache_ccr_ttl ON llmcache_ccr_originals (ttl_expires) WHERE ttl_expires IS NOT NULL",
+    """
+    CREATE TABLE IF NOT EXISTS llmcache_tags (
+        tag         TEXT NOT NULL,
+        cache_key   TEXT NOT NULL,
+        tenant_id   TEXT NOT NULL DEFAULT 'default',
+        PRIMARY KEY (tag, cache_key, tenant_id)
+    )
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_llmcache_tags_tag ON llmcache_tags (tag)",
+    """
+    CREATE TABLE IF NOT EXISTS llmcache_boundaries (
+        entry_id        TEXT PRIMARY KEY,
+        logistic_t      REAL NOT NULL DEFAULT 0.95,
+        logistic_gamma  REAL NOT NULL DEFAULT 10.0,
+        sample_count    INTEGER NOT NULL DEFAULT 0,
+        updated_at      REAL NOT NULL DEFAULT 0
+    )
+    """,
+    """
+    CREATE TABLE IF NOT EXISTS llmcache_centroids (
+        tenant_id       TEXT PRIMARY KEY,
+        centroid_blob   BLOB NOT NULL,
+        n               INTEGER NOT NULL DEFAULT 0,
+        updated_at      TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    )
+    """,
+    """
+    CREATE TABLE IF NOT EXISTS llmcache_metrics (
+        id                          INTEGER PRIMARY KEY CHECK (id = 1),
+        hits                        INTEGER NOT NULL DEFAULT 0,
+        misses                      INTEGER NOT NULL DEFAULT 0,
+        calls_skipped               INTEGER NOT NULL DEFAULT 0,
+        tokens_saved_input          INTEGER NOT NULL DEFAULT 0,
+        tokens_saved_output         INTEGER NOT NULL DEFAULT 0,
+        tokens_saved_compress       INTEGER NOT NULL DEFAULT 0,
+        evictions                   INTEGER NOT NULL DEFAULT 0,
+        latency_overhead_ms_sum     REAL    NOT NULL DEFAULT 0,
+        latency_samples             INTEGER NOT NULL DEFAULT 0,
+        compress_runs               INTEGER NOT NULL DEFAULT 0,
+        compress_bytes_original     INTEGER NOT NULL DEFAULT 0,
+        compress_bytes_after        INTEGER NOT NULL DEFAULT 0,
+        cache_size_bytes            INTEGER NOT NULL DEFAULT 0,
+        cache_entry_count           INTEGER NOT NULL DEFAULT 0,
+        updated_at                  REAL    NOT NULL DEFAULT 0
+    )
+    """,
+)
+
+
+def create_all_tables(conn: sqlite3.Connection) -> None:
+    """Create all llmcache_* tables, indexes, and seed schema_version.
+
+    Safe to call repeatedly — all DDL uses IF NOT EXISTS.
+    Also seeds the single llmcache_metrics row (id=1) via INSERT OR IGNORE.
+    """
+    for stmt in _DDL_STATEMENTS:
+        conn.execute(stmt)
+    conn.execute("INSERT OR IGNORE INTO llmcache_metrics(id) VALUES (1)")
+    row = conn.execute(
+        "SELECT 1 FROM llmcache_schema_version WHERE version = ?",
+        (CACHE_SCHEMA_VERSION,),
+    ).fetchone()
+    if row is None:
+        conn.execute(
+            "INSERT INTO llmcache_schema_version (version, description) VALUES (?, ?)",
+            (CACHE_SCHEMA_VERSION, ""),
+        )
+
+
+def drop_all_tables(conn: sqlite3.Connection) -> None:
+    """Drop all llmcache_* tables. Testing only."""
+    for name in get_table_names():
+        conn.execute(f"DROP TABLE IF EXISTS {name}")
+
+
+def get_table_names() -> tuple[str, ...]:
+    """Return all table names in creation order."""
+    return (
+        "llmcache_schema_version",
+        "llmcache_entries",
+        "llmcache_semantic_vectors",
+        "llmcache_ccr_originals",
+        "llmcache_tags",
+        "llmcache_boundaries",
+        "llmcache_centroids",
+        "llmcache_metrics",
+    )
+
+
+def assert_no_memory_db_tables(conn: sqlite3.Connection) -> None:
+    """Assert that no memory.db tables are present. Raises RuntimeError on violation.
+
+    Use this after opening a connection to confirm we are NOT talking to memory.db.
+    """
+    rows = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table'"
+    ).fetchall()
+    table_names = {r[0] for r in rows}
+    forbidden = {
+        "memories", "atomic_facts", "profiles", "canonical_entities",
+        "entity_aliases", "consolidation_log", "trust_scores", "bm25_tokens",
+        "fact_retention", "core_memory_blocks", "ccq_consolidated_blocks",
+    }
+    found = forbidden & table_names
+    if found:
+        raise RuntimeError(
+            f"ISOLATION VIOLATION: llmcache.db contains memory.db tables: {sorted(found)}. "
+            "This means the wrong database file was opened. Aborting."
+        )

package/src/superlocalmemory/server/routes/optimize.py

@@ -0,0 +1,166 @@
+# 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
+
+"""Optimize API routes — single canonical route file (INTERFACE-CONTRACT v2 §5 R2-01).
+
+All optimize endpoints live here.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Literal
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+logger = logging.getLogger("superlocalmemory.server.routes.optimize")
+
+router = APIRouter(prefix="/api/optimize", tags=["optimize"])
+
+# F-03 fix: module-level singleton — constructed once, shared by /savings + CLI
+from superlocalmemory.optimize.metrics.estimator import SavingsEstimator as _SavingsEstimator  # noqa: E402
+_savings_estimator = _SavingsEstimator()
+
+
+class ConfigUpdateRequest(BaseModel):
+    """Partial config update — only provided fields are changed."""
+    enabled: bool | None = None
+    cache_enabled: bool | None = None
+    semantic_enabled: bool | None = None
+    compress_enabled: bool | None = None
+    compress_mode: Literal['safe', 'aggressive'] | None = None
+    compress_code: bool | None = None
+    compress_prose: bool | None = None
+    compress_ccr: bool | None = None
+
+
+@router.get("/config")
+async def get_config() -> dict[str, Any]:
+    """Return current optimize config as JSON."""
+    try:
+        from superlocalmemory.optimize.config.store import ConfigStore
+        cfg = ConfigStore().get()
+        return cfg.as_dict()
+    except Exception as exc:
+        logger.warning("GET /api/optimize/config failed: %s", exc)
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.put("/config")
+async def put_config(body: ConfigUpdateRequest) -> dict[str, Any]:
+    """Update optimize config (partial). Daemon hot-reloads within 2s."""
+    try:
+        import dataclasses
+        from superlocalmemory.optimize.config.store import ConfigStore
+        store = ConfigStore()
+        cfg = store.get()
+        updates: dict[str, Any] = {}
+        for field_name in ConfigUpdateRequest.model_fields:
+            val = getattr(body, field_name, None)
+            if val is not None:
+                updates[field_name] = val
+        if updates:
+            cfg = dataclasses.replace(cfg, **updates)
+            store.save(cfg)
+        return {"status": "ok", "updated": list(updates.keys())}
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    except Exception as exc:
+        logger.warning("PUT /api/optimize/config failed: %s", exc)
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.get("/savings")
+async def get_savings() -> dict[str, Any]:
+    """Return savings estimates from live metrics + CacheDB.
+
+    Field names match INTERFACE-CONTRACT §5 exactly.
+    """
+    try:
+        from superlocalmemory.optimize.config.store import ConfigStore
+        from superlocalmemory.optimize.metrics.counters import get_metrics
+        from superlocalmemory.optimize.storage.db import CacheDB
+
+        cfg = ConfigStore().get()
+        collector = get_metrics()
+        db = CacheDB()
+        snap = collector.snapshot(
+            cache_size_bytes=db.db_size_bytes(),
+            cache_entry_count=db.entry_count(),
+        )
+
+        # F-03 fix: use module-level singleton instead of per-request instantiation
+        active_model = getattr(cfg, "active_model", "anthropic")
+        # Determine provider from model
+        provider = "anthropic"
+        for key in ("anthropic", "openai", "gemini"):
+            if key in active_model.lower():
+                provider = key
+                break
+        est = _savings_estimator.estimate(snap, provider=provider)
+
+        # compress_ratio from snap (byte-based, survives restart)
+        if snap.compress_bytes_original > 0:
+            compress_ratio = snap.compress_bytes_after / snap.compress_bytes_original
+        else:
+            compress_ratio = None
+
+        total = snap.hits + snap.misses
+        hit_rate = snap.hits / total if total > 0 else 0.0
+
+        # F-02 fix: response keys match INTERFACE-CONTRACT §5 exactly
+        return {
+            "tokens_saved_input": snap.tokens_saved_input,
+            "tokens_saved_output": snap.tokens_saved_output,
+            "calls_skipped": snap.calls_skipped,
+            "compress_ratio": round(compress_ratio, 4) if compress_ratio is not None else None,
+            "cost_saved": {"usd": est["usd"], "inr": est["inr"]},
+            "hit_rate": round(hit_rate, 4),
+            "cache_bytes": snap.cache_size_bytes,
+            "entries": snap.cache_entry_count,
+            # diagnostic fields — non-conflicting extras
+            "hits": snap.hits,
+            "misses": snap.misses,
+            "tokens_saved_compress": snap.tokens_saved_compress,
+            "is_stale": est["is_stale"],
+            "pricing_date": est["pricing_date"],
+        }
+    except Exception as exc:
+        logger.warning("GET /api/optimize/savings failed: %s", exc)
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.get("/stats")
+async def get_stats() -> dict[str, Any]:
+    """Return raw metrics snapshot as JSON."""
+    try:
+        from superlocalmemory.optimize.metrics.counters import get_metrics
+        from superlocalmemory.optimize.storage.db import CacheDB
+
+        collector = get_metrics()
+        db = CacheDB()
+        snap = collector.snapshot(
+            cache_size_bytes=db.db_size_bytes(),
+            cache_entry_count=db.entry_count(),
+        )
+        # Return all 16 fields as dict
+        import dataclasses
+        return dataclasses.asdict(snap)
+    except Exception as exc:
+        logger.warning("GET /api/optimize/stats failed: %s", exc)
+        raise HTTPException(status_code=500, detail=str(exc))
+
+
+@router.delete("/cache/clear")
+async def delete_cache_clear(tenant: str = "default") -> dict[str, Any]:
+    """Delete all cache entries for a tenant."""
+    try:
+        from superlocalmemory.optimize.storage.db import CacheDB
+        db = CacheDB()
+        deleted = db.clear_tenant(tenant)
+        return {"success": True, "deleted": deleted}
+    except Exception as exc:
+        logger.warning("DELETE /api/optimize/cache/clear failed: %s", exc)
+        raise HTTPException(status_code=500, detail=str(exc))

package/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()

package/src/superlocalmemory/server/unified_daemon.py

@@ -824,8 +824,76 @@ async def lifespan(application: FastAPI):
         )
     logger.info(_ready_msg)
 
+    # Start optimize proxy httpx client if mounted
+    try:
+        _opt_proxy = getattr(application.state, "optimize_proxy", None)
+        if _opt_proxy is not None:
+            await _opt_proxy.startup()
+    except Exception as _exc:  # pragma: no cover — defensive
+        logger.warning("optimize_proxy startup failed (non-fatal): %s", _exc)
+
+    # V3.6: Mount optimize API routes + restore persisted metrics + start flush loop
+    try:
+        from superlocalmemory.server.routes.optimize import router as optimize_router
+        from superlocalmemory.optimize.metrics.counters import MetricsCollector
+        from superlocalmemory.optimize.metrics.persistence import MetricsPersistence
+        from superlocalmemory.optimize.storage.db import CacheDB
+        application.include_router(optimize_router)
+
+        # Restore persisted metrics counters on startup
+        MetricsPersistence().load(MetricsCollector.get_instance(), CacheDB())
+
+        # Periodic flush — every 60s (OPT-005: guard + task ref for shutdown)
+        _metrics_flush_task = getattr(application.state, "_optimize_flush_task", None)
+        if _metrics_flush_task is None or _metrics_flush_task.done():
+            async def _metrics_flush_loop():
+                while True:
+                    await asyncio.sleep(60)
+                    try:
+                        MetricsPersistence().flush(
+                            MetricsCollector.get_instance(), CacheDB()
+                        )
+                    except Exception as e:
+                        logger.warning("metrics flush error: %s", e)
+            application.state._optimize_flush_task = asyncio.create_task(
+                _metrics_flush_loop()
+            )
+    except Exception as e:
+        logger.warning("optimize module not available: %s", e)
+
     yield
 
+    # Cancel optimize metrics flush loop + run final flush before shutdown
+    try:
+        _flush_task = getattr(application.state, "_optimize_flush_task", None)
+        if _flush_task is not None and not _flush_task.done():
+            _flush_task.cancel()
+            try:
+                await _flush_task
+            except asyncio.CancelledError:
+                pass
+        # Final flush to persist the last window (H-04: use singleton)
+        try:
+            from superlocalmemory.optimize.metrics.persistence import MetricsPersistence
+            from superlocalmemory.optimize.metrics.counters import MetricsCollector
+            from superlocalmemory.optimize.storage.db import CacheDB as _FinalCacheDB
+            MetricsPersistence().flush(
+                MetricsCollector.get_instance(),
+                _FinalCacheDB.get_default(),
+            )
+        except Exception:
+            pass
+    except Exception:  # pragma: no cover — defensive
+        pass
+
+    # Shutdown optimize proxy httpx client (symmetric with startup)
+    try:
+        _opt_proxy = getattr(application.state, "optimize_proxy", None)
+        if _opt_proxy is not None:
+            await _opt_proxy.shutdown()
+    except Exception as _exc:  # pragma: no cover — defensive
+        logger.warning("optimize_proxy shutdown failed (non-fatal): %s", _exc)
+
     # S9-W4 C2: symmetric shutdown. Prior version only flushed the
     # observe-buffer + signal_worker + engine. The following long-lived
     # subsystems lived on ``application.state`` but were never
@@ -1062,6 +1130,33 @@ def create_app() -> FastAPI:
     except ImportError as exc:  # pragma: no cover — defensive wiring
         logger.warning("token router not wired: %s", exc)
 
+    # ── Optimize proxy (optional, fail-open) ──────────────────────────────
+    # Mounts on the existing daemon port 8765. Proxy routes carry provider
+    # API keys (x-api-key, Authorization), NOT the SLM API key. Auth-exempt
+    # path prefixes are configured below in the auth_middleware block.
+    try:
+        from superlocalmemory.optimize.config.store import ConfigStore
+        from superlocalmemory.optimize.proxy.server import ProxyApp, build_proxy_router
+
+        _opt_cfg = ConfigStore().get()
+        if _opt_cfg.proxy_enabled:
+            _proxy = ProxyApp(config=_opt_cfg)
+            application.state.optimize_proxy = _proxy
+            _proxy_router = build_proxy_router(_proxy)
+            # prefix="" — proxy claims /v1/*, /v1beta/* directly.
+            application.include_router(_proxy_router, prefix="")
+            logger.info(
+                "optimize.proxy mounted on /v1/*, /v1beta/*  port=8765"
+            )
+        else:
+            application.state.optimize_proxy = None
+    except ImportError:
+        application.state.optimize_proxy = None
+        logger.debug("optimize.proxy not installed — skipping")
+    except Exception as _exc:  # pragma: no cover — defensive
+        application.state.optimize_proxy = None
+        logger.warning("optimize.proxy mount failed (non-fatal): %s", _exc)
+
     # -- Daemon-specific routes --
     _register_daemon_routes(application)
 
@@ -1113,8 +1208,18 @@ def _register_dashboard_routes(application: FastAPI) -> None:
     try:
         from superlocalmemory.infra.auth_middleware import check_api_key
 
+        # Auth-exempt path prefixes — proxy routes carry provider API keys
+        # (x-api-key for Anthropic, Authorization: Bearer for OpenAI, x-goog-api-key
+        # for Gemini), never X-SLM-API-Key. Verified: auth_middleware.py:50-82
+        # returns False for POST when api_key file exists and X-SLM-API-Key
+        # is absent.
+        _AUTH_EXEMPT_PREFIXES = ("/v1/", "/v1beta/")
+
         @application.middleware("http")
         async def auth_middleware(request, call_next):
+            # Exempt proxy paths — LLM clients carry provider keys, not SLM keys.
+            if request.url.path.startswith(_AUTH_EXEMPT_PREFIXES):
+                return await call_next(request)
             is_write = request.method in ("POST", "PUT", "DELETE", "PATCH")
             headers = dict(request.headers)
             if not check_api_key(headers, is_write=is_write):

package/src/superlocalmemory/ui/index.html

@@ -1233,6 +1233,77 @@
                     </div>
                 </div>
             </div>
+
+            <!-- Optimize Tab -->
+            <div class="tab-pane fade" id="optimize-pane">
+                <div class="card mb-3">
+                    <div class="card-header bg-success text-white">
+                        <h6 class="mb-0"><i class="bi bi-speedometer"></i> Optimize Module</h6>
+                    </div>
+                    <div class="card-body">
+                        <div class="row g-3">
+                            <div class="col-md-6">
+                                <h6>Controls</h6>
+                                <div class="form-check form-switch mb-2">
+                                    <input class="form-check-input" type="checkbox" id="opt-enabled">
+                                    <label class="form-check-label" for="opt-enabled">Optimize Enabled</label>
+                                </div>
+                                <div class="form-check form-switch mb-2">
+                                    <input class="form-check-input" type="checkbox" id="opt-cache-enabled">
+                                    <label class="form-check-label" for="opt-cache-enabled">Cache Enabled</label>
+                                </div>
+                                <div class="form-check form-switch mb-2">
+                                    <input class="form-check-input" type="checkbox" id="opt-semantic-enabled">
+                                    <label class="form-check-label" for="opt-semantic-enabled">Semantic Cache</label>
+                                </div>
+                                <div class="form-check form-switch mb-2">
+                                    <input class="form-check-input" type="checkbox" id="opt-compress-enabled">
+                                    <label class="form-check-label" for="opt-compress-enabled">Compression</label>
+                                </div>
+                                <div class="mb-2">
+                                    <label for="opt-compress-mode" class="form-label">Compression Mode</label>
+                                    <select class="form-select form-select-sm" id="opt-compress-mode">
+                                        <option value="safe">Safe</option>
+                                        <option value="aggressive">Aggressive</option>
+                                    </select>
+                                </div>
+                                <div class="form-check form-switch mb-2">
+                                    <input class="form-check-input" type="checkbox" id="opt-compress-code">
+                                    <label class="form-check-label" for="opt-compress-code">Code Compression</label>
+                                </div>
+                                <div class="form-check form-switch mb-2">
+                                    <input class="form-check-input" type="checkbox" id="opt-compress-prose">
+                                    <label class="form-check-label" for="opt-compress-prose">Prose Compression</label>
+                                </div>
+                                <div class="form-check form-switch mb-2">
+                                    <input class="form-check-input" type="checkbox" id="opt-compress-ccr">
+                                    <label class="form-check-label" for="opt-compress-ccr">CCR</label>
+                                </div>
+                                <div class="form-check form-switch mb-2">
+                                    <input class="form-check-input" type="checkbox" id="opt-compress-align">
+                                    <label class="form-check-label" for="opt-compress-align">Alignment Compression</label>
+                                </div>
+                            </div>
+                            <div class="col-md-6">
+                                <h6>Savings</h6>
+                                <table class="table table-sm">
+                                    <tr><td>Tokens Saved</td><td id="opt-tokens-saved">-</td></tr>
+                                    <tr><td>USD Saved</td><td id="opt-usd-saved">-</td></tr>
+                                    <tr><td>INR Saved</td><td id="opt-inr-saved">-</td></tr>
+                                    <tr><td>Hit Rate</td><td id="opt-hit-rate">-</td></tr>
+                                    <tr><td>Cache Entries</td><td id="opt-cache-entries">-</td></tr>
+                                    <tr><td>Cache Size</td><td id="opt-cache-size">-</td></tr>
+                                    <tr><td>Compression Ratio</td><td id="opt-compression-ratio">-</td></tr>
+                                    <tr><td>Pricing Date</td><td id="opt-pricing-date">-</td></tr>
+                                </table>
+                                <div class="small text-muted">Config version: <span id="opt-config-version">-</span></div>
+                                <div id="opt-stale-warning" class="text-warning small mt-1"></div>
+                                <button class="btn btn-sm btn-outline-primary mt-2" id="opt-copy-url">Copy URL</button>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
         </div>
     </div>
 
@@ -1329,6 +1400,33 @@
     <script src="static/js/ng-skills.js?v=3411"></script>
     <script src="static/js/ng-mesh.js?v=345"></script>
     <script src="static/js/ng-shell.js?v=34421g"></script>
+    <!-- Optimize tab (v3.6.0) — runtime config for cache + compress + proxy -->
+    <script src="static/js/optimize.js?v=360"></script>
+
+    <!-- Aggressive compression warning modal (v3.6.0 M-03) -->
+    <div class="modal fade" id="optimizeAggressiveModal" tabindex="-1" aria-labelledby="optimizeAggressiveModalLabel" aria-hidden="true">
+        <div class="modal-dialog modal-dialog-centered">
+            <div class="modal-content" style="background:var(--ng-bg-elevated);border:1px solid var(--ng-status-warning-bg);">
+                <div class="modal-header" style="border-bottom:1px solid var(--ng-border-subtle);">
+                    <h5 class="modal-title" id="optimizeAggressiveModalLabel" style="color:var(--ng-status-warning);">
+                        <i class="bi bi-exclamation-triangle-fill me-2"></i>Aggressive Compression Warning
+                    </h5>
+                </div>
+                <div class="modal-body" style="color:var(--ng-text-secondary);">
+                    <p><strong style="color:var(--ng-text-primary);">Aggressive mode may reduce output fidelity.</strong></p>
+                    <ul>
+                        <li>Do NOT use for: code generation, legal text, exact-output tasks, math.</li>
+                        <li>Safe for: summarization, brainstorming, open-ended chat.</li>
+                    </ul>
+                    <p class="mb-0">Switch to Aggressive mode anyway?</p>
+                </div>
+                <div class="modal-footer" style="border-top:1px solid var(--ng-border-subtle);">
+                    <button type="button" class="btn btn-outline-secondary" id="optimize-aggressive-cancel">Keep Safe Mode</button>
+                    <button type="button" class="btn btn-warning" id="optimize-aggressive-confirm">I Understand — Use Aggressive</button>
+                </div>
+            </div>
+        </div>
+    </div>
 
     <footer style="text-align:center; padding:24px; border-top:1px solid var(--bs-border-color); font-size:0.8125rem;">
         <div style="display:flex; align-items:center; justify-content:center; gap:8px; margin-bottom:8px;">