superlocalmemory 3.8.13 → 4.0.0

package/src/superlocalmemory/retrieval/temporal_validity_filter.py

@@ -2,30 +2,55 @@
 # Licensed under AGPL-3.0-or-later - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
-"""Bi-temporal validity filter for the retrieval pipeline (Phase 4, T1).
-
-Post-retrieval filter for *system-invalidated* facts — a fact whose temporal
-record has ``system_expired_at`` set was superseded/contradicted by a newer
-fact (see ``invalidate_fact_temporal`` / conflict-resolution supersession).
-
-P5-INT-01 (non-destructive supersession): such a fact is DEMOTED, not hidden.
-Its per-channel score is multiplied by ``superseded_demotion_factor`` (default
-0.25) and the channel lists are re-sorted, so currently-valid facts rank above
-it — but nothing valid silently vanishes. This is the Mem0-2026 design that
-wins long-term-memory benchmarks: keep every fact recallable and let
-retrieval-time recency resolve conflicts, rather than destructively deleting on
-a write-time contradiction guess (which over-fires: two complementary facts
-about the same entity diverge past the coboundary threshold and one would be
-wrongly hidden). A factor of 0.0 restores the legacy hide behaviour (a demoted
-score of 0 is gated out by the evidence floor).
-
-The filter runs on the per-channel candidate dict BEFORE RRF fusion, so fused
-ranks reflect the demotion. It queries validity only for the bounded candidate
-set (never the full ``get_valid_facts`` set) — an indexed, O(candidates) lookup
-on the hot path, no full-table scan.
-
-Pure SQL, no LLM → safe in every mode including Mode A. A no-op when nothing is
-invalidated and when config.enabled is False.
+"""Bi-temporal validity filter for the retrieval pipeline (Phase 4, T1 + T1b).
+
+Post-retrieval filter that demotes facts whose bi-temporal validity window
+makes them ineligible for the current recall point in time. Two independent
+demotion axes:
+
+**Axis 1 — Transaction-time supersession (P5-INT-01, existing):**
+A fact whose temporal record has ``system_expired_at`` set was superseded or
+contradicted by a newer fact (see ``invalidate_fact_temporal`` /
+conflict-resolution supersession). Its per-channel score is multiplied by
+``superseded_demotion_factor`` (default 0.25).
+
+**Axis 2 — Event-time expiry (Phase 4 T1b, new):**
+A fact whose ``valid_until`` has passed (in wall-clock time) was true in the
+real world only up to that date. Its per-channel score is multiplied by
+``event_time_demotion_factor`` (default 0.5, softer than supersession). A
+separate "not-yet-valid" demotion applies when ``as_of`` is set for
+point-in-time time-travel recall: facts whose ``valid_from > as_of`` are
+also demoted.
+
+**Zero-regression guarantee (default path):**
+Almost all existing facts have ``valid_until = NULL`` (open-ended / still
+valid). The event-time expiry lookup therefore returns an empty set on the
+default path, so no scores change and default recall output is identical.
+Additionally, when ``include_expired_in_history = True`` (the config default)
+AND no explicit ``as_of`` is requested, event-time demotion is skipped
+entirely — the guard ensures historical recall modes that intentionally want
+to surface expired facts are unaffected.
+
+**As-of time-travel:**
+When ``as_of`` is packed into the filter context dict (``{"as_of": "..."}``),
+event-time demotion is always applied regardless of
+``include_expired_in_history``, because the caller explicitly requested a
+point-in-time view. Facts not yet valid at ``as_of`` (``valid_from > as_of``)
+and facts already expired at ``as_of`` (``valid_until <= as_of``, half-open) are
+both demoted.
+
+**Demotion priority:**
+- System-invalidated facts: score × ``superseded_demotion_factor`` (0.25).
+- Event-time-expired only (not system-invalidated): score × ``event_time_demotion_factor`` (0.5).
+- Both: system-invalidated wins (the harder demotion, 0.25, is applied; event-time
+  demotion is not stacked to avoid excessive double-penalty).
+
+All demotions are non-destructive (P5-INT-01): facts stay in the candidate
+list but rank below valid facts. A factor of 0.0 restores the legacy hide
+behaviour (a score of zero is gated out by the evidence floor).
+
+Both lookups are bounded (candidate ids only), chunked, indexed, and
+fail-open: a DB error returns results unchanged.
 
 Integrates with ChannelRegistry.register_filter() using the FilterFn signature:
     (all_channel_results, profile_id, context) -> filtered_results
@@ -46,17 +71,43 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# Module-level fallback for event-time demotion factor.
+# Used when the config object does not yet carry ``event_time_demotion_factor``
+# (e.g. older serialised configs loaded from disk). Softer than the supersession
+# factor (0.25) because event-time expiry is a softer signal — the boundary may
+# be approximate or the fact may still be conceptually relevant.
+_EVENT_TIME_DEMOTION_FACTOR: float = 0.5
+
 
 class TemporalValidityFilter:
-    """Demotes system-invalidated (superseded) facts in retrieval candidates."""
+    """Demotes bi-temporally invalid facts in retrieval candidates.
+
+    Two demotion axes:
+    - Axis 1: system-invalidated (superseded) facts — existing behaviour.
+    - Axis 2: event-time-expired facts — new in Phase 4 T1b.
+
+    Both are non-destructive: facts stay recallable but rank below valid ones.
+    """
 
-    __slots__ = ("_db", "_demotion_factor")
+    __slots__ = (
+        "_db",
+        "_demotion_factor",
+        "_event_time_factor",
+        "_include_expired_in_history",
+    )
 
-    def __init__(self, db: DatabaseManager, demotion_factor: float = 0.25) -> None:
+    def __init__(
+        self,
+        db: DatabaseManager,
+        demotion_factor: float = 0.25,
+        event_time_factor: float = _EVENT_TIME_DEMOTION_FACTOR,
+        include_expired_in_history: bool = True,
+    ) -> None:
         self._db = db
-        # Clamp to [0, 1]. 0.0 = legacy hide (evidence floor drops zero-score
-        # facts); 1.0 = no demotion.
+        # Clamp to [0, 1]. 0.0 = legacy hide; 1.0 = no demotion.
         self._demotion_factor = max(0.0, min(1.0, float(demotion_factor)))
+        self._event_time_factor = max(0.0, min(1.0, float(event_time_factor)))
+        self._include_expired_in_history = bool(include_expired_in_history)
 
     def filter(
         self,
@@ -64,20 +115,23 @@ class TemporalValidityFilter:
         profile_id: str,
         context: Any,
     ) -> dict[str, list[tuple[str, float]]]:
-        """Demote superseded fact_ids in every channel's candidate list.
+        """Demote bi-temporally invalid fact_ids in every channel's candidate list.
 
         Matches FilterFn signature from channel_registry.py.
 
         Args:
             all_results: Channel name -> [(fact_id, score)] dict.
             profile_id: Current profile.
-            context: Optional context (unused).
+            context: Optional dict that may carry ``as_of`` (ISO 8601 string)
+                for point-in-time time-travel recall. None or any non-dict value
+                means "current time, no time-travel" — the default path.
 
         Returns:
-            A new dict where system-invalidated facts keep their channel
-            presence but have their score scaled by the demotion factor and the
-            channel lists re-sorted (so valid facts rank above them). Inputs are
-            never mutated (immutability). Unchanged when nothing is invalidated.
+            A new dict where invalid facts keep their channel presence but have
+            their score scaled by the appropriate demotion factor and the channel
+            lists re-sorted so valid facts rank above them. Inputs are never
+            mutated (immutability contract). Returns the input unchanged when
+            nothing is invalid (fast path).
         """
         # Collect all unique candidate fact_ids across every channel.
         all_fact_ids: set[str] = set()
@@ -88,27 +142,73 @@ class TemporalValidityFilter:
         if not all_fact_ids:
             return all_results
 
+        # Extract as_of FIRST — needed for both Axis 1 and Axis 2. Must happen
+        # before any DB call so as_of is available for transaction-time gating.
+        # None context = legacy/default; non-dict = upstream caller without
+        # as_of support. Both treated as "no time-travel, current time".
+        as_of: str | None = (
+            context.get("as_of") if isinstance(context, dict) else None
+        )
+        # UTC-normalize at the filter boundary to guarantee format consistency
+        # before forwarding to DB comparisons.
+        if as_of is not None:
+            from superlocalmemory.retrieval.temporal_utils import normalize_as_of
+            as_of = normalize_as_of(as_of)
+            # normalize_as_of returns None on invalid input; treat as no as_of.
+
+        # --- Axis 1: Transaction-time supersession ---
+        # When as_of is set: only supersessions that occurred AT OR BEFORE
+        # as_of contribute (Phase 4b bi-temporal fix). Supersessions after
+        # as_of are invisible — the fact was still valid at the query point.
         try:
             invalid = self._db.get_invalidated_fact_ids(
-                list(all_fact_ids), profile_id,
+                list(all_fact_ids), profile_id, as_of=as_of,
             )
         except Exception as exc:
             # Fail-open: a validity-lookup error must never break retrieval.
             logger.warning("Temporal validity lookup failed: %s", exc)
             return all_results
 
-        if not invalid:
+        # --- Axis 2: Event-time expiry (Phase 4 T1b) ---
+        # Guard: skip event-time demotion when the caller signals it wants
+        # historical / all-expired-included mode AND no explicit as_of point
+        # is requested.  Config default is include_expired_in_history=True,
+        # so the default recall path always takes this skip branch — the two
+        # new DB calls are never made, and no scores change.
+        apply_event_time = (as_of is not None) or (not self._include_expired_in_history)
+
+        event_expired: set[str] = set()
+        if apply_event_time:
+            try:
+                event_expired = self._db.get_event_time_expired_fact_ids(
+                    list(all_fact_ids), profile_id, as_of=as_of,
+                )
+            except Exception as exc:
+                # Fail-open: continue with empty event_expired set.
+                logger.warning("Event-time expiry lookup failed: %s", exc)
+
+        # Fast path: nothing to demote — return input unchanged.
+        if not invalid and not event_expired:
             return all_results
 
-        factor = self._demotion_factor
+        system_factor = self._demotion_factor
+        event_factor = self._event_time_factor
+        # event_time_only: expired by event-time but NOT system-invalidated.
+        # System-invalid already carries the harder demotion (0.25 < 0.5).
+        # We do not stack both factors to avoid excessive double-penalty.
+        event_time_only = event_expired - invalid
+
         demoted: dict[str, list[tuple[str, float]]] = {}
         for channel_name, channel_results in all_results.items():
             new_list = [
-                (fact_id, score * factor if fact_id in invalid else score)
+                (fact_id,
+                 score * system_factor if fact_id in invalid
+                 else score * event_factor if fact_id in event_time_only
+                 else score)
                 for fact_id, score in channel_results
             ]
-            # Re-sort descending so demoted (superseded) facts fall below
-            # currently-valid facts in this channel's rank order.
+            # Re-sort descending so demoted facts fall below currently-valid
+            # facts in this channel's rank order.
             new_list.sort(key=lambda pair: pair[1], reverse=True)
             demoted[channel_name] = new_list
         return demoted
@@ -123,6 +223,10 @@ def register_temporal_validity_filter(
 
     Does nothing if config.enabled is False.
 
+    Reads ``event_time_demotion_factor`` from the config with a fallback to the
+    module constant ``_EVENT_TIME_DEMOTION_FACTOR`` (0.5) so older serialised
+    configs without this field work without a migration.
+
     Args:
         registry: Channel registry to register with.
         db: Database manager for validity queries.
@@ -131,5 +235,14 @@ def register_temporal_validity_filter(
     if not getattr(config, "enabled", True):
         return
     factor = getattr(config, "superseded_demotion_factor", 0.25)
-    f = TemporalValidityFilter(db, demotion_factor=factor)
+    event_time_factor = getattr(
+        config, "event_time_demotion_factor", _EVENT_TIME_DEMOTION_FACTOR,
+    )
+    include_expired_in_history = getattr(config, "include_expired_in_history", True)
+    f = TemporalValidityFilter(
+        db,
+        demotion_factor=factor,
+        event_time_factor=event_time_factor,
+        include_expired_in_history=include_expired_in_history,
+    )
     registry.register_filter(f.filter)

package/src/superlocalmemory/retrieval/vector_store.py

@@ -15,6 +15,7 @@ License: AGPL-3.0-or-later
 from __future__ import annotations
 
 import logging
+import re
 import sqlite3
 import threading
 from contextlib import contextmanager
@@ -137,8 +138,50 @@ class VectorStore:
 
     # -- Table creation -----------------------------------------------------
 
+    @staticmethod
+    def _read_stored_dimension(conn: sqlite3.Connection) -> int | None:
+        """Return the embedding dimension of the existing vec0 table, or None.
+
+        Reads the CREATE VIRTUAL TABLE DDL from sqlite_master and extracts the
+        float[N] declaration.  Falls back to embedding_metadata.dimension if
+        the DDL is absent or unparseable.  Returns None when the table does not
+        yet exist, which means no rebuild is needed.
+        """
+        try:
+            row = conn.execute(
+                "SELECT sql FROM sqlite_master WHERE name = 'fact_embeddings'"
+            ).fetchone()
+            if row is not None:
+                sql = row["sql"] or row[0]
+                if sql:
+                    m = re.search(r'float\[(\d+)\]', sql, re.IGNORECASE)
+                    if m:
+                        return int(m.group(1))
+        except Exception:
+            pass
+
+        # Fallback: read dimension from the most recent metadata row.
+        try:
+            row = conn.execute(
+                "SELECT dimension FROM embedding_metadata LIMIT 1"
+            ).fetchone()
+            if row is not None:
+                return int(row["dimension"])
+        except sqlite3.OperationalError:
+            pass  # metadata table does not exist yet
+
+        return None
+
     def _ensure_vec0_table(self) -> None:
-        """Create the vec0 virtual table and embedding_metadata if not exist."""
+        """Create or rebuild the vec0 virtual table and embedding_metadata.
+
+        If the existing vec0 table was built at a different embedding dimension
+        than self._config.dimension, both tables are dropped and recreated at
+        the new dimension.  Old embeddings are lost; callers that want to
+        re-populate should call rebuild_from_facts() afterward.
+
+        Same-dimension opens are a no-op (IF NOT EXISTS guard).
+        """
         dim = self._config.dimension
         vec0_ddl = (
             f"CREATE VIRTUAL TABLE IF NOT EXISTS fact_embeddings USING vec0("
@@ -162,12 +205,41 @@ class VectorStore:
         meta_idx_profile = (
             "CREATE INDEX IF NOT EXISTS idx_embmeta_profile ON embedding_metadata (profile_id)"
         )
+        row_map_ddl = (
+            "CREATE TABLE IF NOT EXISTS vector_row_map ("
+            "fact_id TEXT NOT NULL PRIMARY KEY, "
+            "profile_id TEXT NOT NULL, "
+            "vec_rowid INTEGER NOT NULL"
+            ")"
+        )
+        row_map_idx = (
+            "CREATE INDEX IF NOT EXISTS idx_vector_row_map_profile "
+            "ON vector_row_map (profile_id)"
+        )
         try:
             with self._managed_connection() as conn:
+                stored_dim = self._read_stored_dimension(conn)
+                if stored_dim is not None and stored_dim != dim:
+                    logger.info(
+                        "Embedding dimension changed %d→%d: rebuilding vector index",
+                        stored_dim,
+                        dim,
+                    )
+                    # Drop metadata first (no FK enforcement, but cleaner ordering).
+                    # Indexes on embedding_metadata are dropped automatically.
+                    conn.execute("DROP TABLE IF EXISTS embedding_metadata")
+                    conn.execute("DROP TABLE IF EXISTS vector_row_map")
+                    conn.execute("DROP TABLE IF EXISTS fact_embeddings")
+                    # Commit the drops before recreating so that the virtual-table
+                    # shadow tables are fully removed before the new CREATE runs.
+                    conn.commit()
+
                 conn.execute(vec0_ddl)
                 conn.execute(meta_ddl)
                 conn.execute(meta_idx_fact)
                 conn.execute(meta_idx_profile)
+                conn.execute(row_map_ddl)
+                conn.execute(row_map_idx)
                 conn.commit()
         except Exception as exc:
             logger.debug("vec0 table creation failed: %s", exc)
@@ -255,13 +327,30 @@ class VectorStore:
                                 # Older self-heal code could insert metadata
                                 # before sqlite-vec, or row-id drift could point
                                 # metadata at another profile's vector.  Neither
-                                # is a valid projection pair.  Remove only the
-                                # stale pointer and rebuild at a fresh rowid;
-                                # never overwrite the other profile's payload.
+                                # is a valid projection pair.  Remove the stale
+                                # pointer and rebuild at a fresh rowid; never
+                                # overwrite the other profile's payload.
                                 conn.execute(
                                     "DELETE FROM embedding_metadata WHERE fact_id = ?",
                                     (fact_id,),
                                 )
+                                # The old vec0 row is orphaned unless another
+                                # projection pair still references it. Reclaim it
+                                # so drift-repair never abandons raw payload.
+                                still_referenced = conn.execute(
+                                    "SELECT 1 FROM embedding_metadata "
+                                    "WHERE vec_rowid = ? LIMIT 1",
+                                    (rowid,),
+                                ).fetchone()
+                                if still_referenced is None:
+                                    conn.execute(
+                                        "DELETE FROM fact_embeddings WHERE rowid = ?",
+                                        (rowid,),
+                                    )
+                                conn.execute(
+                                    "DELETE FROM vector_row_map WHERE fact_id = ?",
+                                    (fact_id,),
+                                )
                                 row = None
 
                         if row is None:
@@ -301,6 +390,14 @@ class VectorStore:
                                 ),
                             )
 
+                        conn.execute(
+                            "INSERT INTO vector_row_map (fact_id, profile_id, vec_rowid) "
+                            "VALUES (?, ?, ?) "
+                            "ON CONFLICT(fact_id) DO UPDATE SET "
+                            "profile_id = excluded.profile_id, "
+                            "vec_rowid = excluded.vec_rowid",
+                            (fact_id, profile_id, rowid),
+                        )
                         conn.commit()
                     return True
                 except Exception as exc:
@@ -415,16 +512,33 @@ class VectorStore:
                             (fact_id,),
                         ).fetchone()
 
-                        if row is None:
+                        rowid = None
+                        owner_profile = None
+                        if row is not None:
+                            rowid = row["vec_rowid"]
+                            owner_profile = str(row["profile_id"])
+                        else:
+                            # Metadata-less orphan: resolve the rowid via the
+                            # fact-addressable map so the raw vec0 row is still
+                            # removable by fact_id.
+                            mrow = conn.execute(
+                                "SELECT vec_rowid, profile_id "
+                                "FROM vector_row_map WHERE fact_id = ?",
+                                (fact_id,),
+                            ).fetchone()
+                            if mrow is not None:
+                                rowid = mrow["vec_rowid"]
+                                owner_profile = str(mrow["profile_id"])
+
+                        if rowid is None:
                             return False
 
-                        rowid = row["vec_rowid"]
                         vector_row = conn.execute(
                             "SELECT profile_id FROM fact_embeddings WHERE rowid = ?",
                             (rowid,),
                         ).fetchone()
-                        if vector_row is not None and str(vector_row["profile_id"]) == str(
-                            row["profile_id"]
+                        if vector_row is not None and (
+                            str(vector_row["profile_id"]) == owner_profile
                         ):
                             conn.execute(
                                 "DELETE FROM fact_embeddings WHERE rowid = ?",
@@ -434,12 +548,54 @@ class VectorStore:
                             "DELETE FROM embedding_metadata WHERE vec_rowid = ?",
                             (rowid,),
                         )
+                        conn.execute(
+                            "DELETE FROM vector_row_map WHERE fact_id = ?",
+                            (fact_id,),
+                        )
                         conn.commit()
                     return True
                 except Exception as exc:
                     logger.debug("delete failed for fact_id=%s: %s", fact_id, exc)
                     return False
 
+    def raw_vector_present(self, fact_id: str) -> bool:
+        if not self._available:
+            try:
+                conn = sqlite3.connect(str(self._db_path))
+                try:
+                    row = conn.execute(
+                        "SELECT 1 FROM vector_row_map WHERE fact_id = ? LIMIT 1",
+                        (fact_id,),
+                    ).fetchone()
+                    return row is not None
+                finally:
+                    conn.close()
+            except Exception:
+                return False
+        try:
+            with self._managed_connection() as conn:
+                row = conn.execute(
+                    "SELECT 1 FROM vector_row_map vrm "
+                    "WHERE vrm.fact_id = ? "
+                    "AND EXISTS (SELECT 1 FROM fact_embeddings fe "
+                    "WHERE fe.rowid = vrm.vec_rowid)",
+                    (fact_id,),
+                ).fetchone()
+                return row is not None
+        except Exception:
+            try:
+                conn2 = sqlite3.connect(str(self._db_path))
+                try:
+                    row = conn2.execute(
+                        "SELECT 1 FROM vector_row_map WHERE fact_id = ? LIMIT 1",
+                        (fact_id,),
+                    ).fetchone()
+                    return row is not None
+                finally:
+                    conn2.close()
+            except Exception:
+                return False
+
     def count(self, profile_id: str | None = None) -> int:
         """Count complete metadata/vector pairs in the store.
 
@@ -493,6 +649,56 @@ class VectorStore:
             logger.debug("indexed_fact_ids failed: %s", exc)
             return set()
 
+    def gc_orphaned_vectors(self, profile_id: str | None = None) -> int:
+        """Physically remove vec0 rows not referenced by any fact-addressable
+        mapping (neither embedding_metadata nor vector_row_map).
+
+        Such rows are unreachable by fact_id and would otherwise persist forever.
+        Returns the count removed. No-op when the vector backend is unavailable.
+        """
+        if not self._available:
+            return 0
+
+        _wl = get_write_lock(self._db_path)
+        with _wl:
+            with self._lock:
+                try:
+                    with self._managed_connection() as conn:
+                        conn.execute("BEGIN IMMEDIATE")
+                        orphans = self._orphan_rowids(conn, profile_id)
+                        for rowid in orphans:
+                            conn.execute(
+                                "DELETE FROM fact_embeddings WHERE rowid = ?",
+                                (rowid,),
+                            )
+                        conn.commit()
+                    return len(orphans)
+                except Exception as exc:
+                    logger.debug("gc_orphaned_vectors failed: %s", exc)
+                    return 0
+
+    @staticmethod
+    def _orphan_rowids(conn: sqlite3.Connection, profile_id: str | None) -> set[int]:
+        """vec0 rowids not referenced by embedding_metadata or vector_row_map."""
+        if profile_id is not None:
+            all_rowids = {r[0] for r in conn.execute(
+                "SELECT rowid FROM fact_embeddings WHERE profile_id = ?",
+                (profile_id,)).fetchall()}
+            ref_meta = {r[0] for r in conn.execute(
+                "SELECT vec_rowid FROM embedding_metadata WHERE profile_id = ?",
+                (profile_id,)).fetchall()}
+            ref_map = {r[0] for r in conn.execute(
+                "SELECT vec_rowid FROM vector_row_map WHERE profile_id = ?",
+                (profile_id,)).fetchall()}
+        else:
+            all_rowids = {r[0] for r in conn.execute(
+                "SELECT rowid FROM fact_embeddings").fetchall()}
+            ref_meta = {r[0] for r in conn.execute(
+                "SELECT vec_rowid FROM embedding_metadata").fetchall()}
+            ref_map = {r[0] for r in conn.execute(
+                "SELECT vec_rowid FROM vector_row_map").fetchall()}
+        return all_rowids - ref_meta - ref_map
+
     def rebuild_from_facts(
         self,
         facts: list[tuple[str, str, list[float]]],

package/src/superlocalmemory/server/api.py

@@ -109,8 +109,8 @@ async def lifespan(application: FastAPI):
 def create_app() -> FastAPI:
     """Create and configure the FastAPI application."""
     application = FastAPI(
-        title="SuperLocalMemory V3 API",
-        description="V3 Memory Engine REST API",
+        title="SuperLocalMemory V4 API",
+        description="V4 Memory Engine REST API",
         version=SLM_VERSION,
         lifespan=lifespan,
     )
@@ -240,9 +240,9 @@ def create_app() -> FastAPI:
         index_path = UI_DIR / "index.html"
         if not index_path.exists():
             return (
-                "<html><head><title>SuperLocalMemory V3</title></head>"
+                "<html><head><title>SuperLocalMemory V4</title></head>"
                 "<body style='font-family:Arial;padding:40px'>"
-                "<h1>SuperLocalMemory V3 API Server Running</h1>"
+                "<h1>SuperLocalMemory V4 API Server Running</h1>"
                 "<p><a href='/docs'>API Documentation</a></p>"
                 "</body></html>"
             )
@@ -272,7 +272,7 @@ def create_app() -> FastAPI:
 if __name__ == "__main__":
     app = create_app()
     print("=" * 60)
-    print("SuperLocalMemory V3 - API Server (standalone mode)")
+    print("SuperLocalMemory V4 - API Server (standalone mode)")
     print("=" * 60)
     print(f"Database: {DB_PATH}")
     print(f"UI Directory: {UI_DIR}")