yourmemory 1.4.75__tar.gz → 1.4.76__tar.gz

{yourmemory-1.4.75 → yourmemory-1.4.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yourmemory
-Version: 1.4.75
+Version: 1.4.76
 Summary: Persistent memory for Claude — Ebbinghaus forgetting curve, semantic deduplication, MCP-native
 Author: Sachit Misra
 Author-email: mishrasachit1@gmail.com

{yourmemory-1.4.75 → yourmemory-1.4.76}/memory_mcp.py

@@ -924,36 +924,13 @@ def _start_decay_scheduler():
         except Exception:
             pass
 
-    def _compact():
-        if os.getenv("YOURMEMORY_COMPACTION", "0") != "1":
-            return
-        try:
-            from src.services.compaction import compact_user
-            from src.db.connection import get_conn, get_backend
-            b = get_backend(); conn = get_conn()
-            try:
-                if b == "duckdb":
-                    users = [r[0] for r in conn.execute("SELECT DISTINCT user_id FROM memories").fetchall()]
-                else:
-                    cur = conn.cursor(); cur.execute("SELECT DISTINCT user_id FROM memories")
-                    users = [r[0] for r in cur.fetchall()]; cur.close()
-            finally:
-                conn.close()
-            for u in users:
-                try: compact_user(u)
-                except Exception: pass
-        except Exception:
-            pass
-
     def loop():
         run_decay()
         _audit_prune()
-        _compact()
         timer = threading.Event()
         while not timer.wait(timeout=86400):
             run_decay()
             _audit_prune()
-            _compact()
 
     t = threading.Thread(target=loop, daemon=True, name="decay-scheduler")
     t.start()

{yourmemory-1.4.75 → yourmemory-1.4.76}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yourmemory"
-version = "1.4.75"
+version = "1.4.76"
 description = "Persistent memory for Claude — Ebbinghaus forgetting curve, semantic deduplication, MCP-native"
 readme = "README.md"
 requires-python = ">=3.11"

{yourmemory-1.4.75 → yourmemory-1.4.76}/src/app.py

@@ -28,25 +28,8 @@ def _daily_jobs():
         prune_audit()   # retention: drop audit rows older than the (>=90-day) window
     except Exception:
         pass
-    # Opt-in: compress clusters of related memories so the store stays lean over time.
-    if os.getenv("YOURMEMORY_COMPACTION", "0") == "1":
-        try:
-            from src.services.compaction import compact_user
-            from src.db.connection import get_conn, get_backend
-            b = get_backend(); conn = get_conn()
-            try:
-                if b == "duckdb":
-                    users = [r[0] for r in conn.execute("SELECT DISTINCT user_id FROM memories").fetchall()]
-                else:
-                    cur = conn.cursor(); cur.execute("SELECT DISTINCT user_id FROM memories")
-                    users = [r[0] for r in cur.fetchall()]; cur.close()
-            finally:
-                conn.close()
-            for u in users:
-                try: compact_user(u)
-                except Exception: pass
-        except Exception:
-            pass
+    # Note: memory compaction is event-driven (triggered on store when a cluster reaches
+    # N), not a daily sweep — see /auto-store and src/services/compaction.py.
 
 
 @asynccontextmanager
@@ -677,4 +660,18 @@ def auto_store_endpoint(req: AutoStoreRequest):
     except Exception:
         pass
 
+    # Event-driven compaction: if a just-stored fact's cluster now has >= N closely
+    # related memories, compress that cluster immediately so the store stays lean —
+    # no daily sweep needed. On by default; disable with YOURMEMORY_COMPACTION=0.
+    if os.getenv("YOURMEMORY_COMPACTION", "1") == "1" and to_index:
+        try:
+            from src.services.compaction import maybe_compact_around
+            seen = set()
+            for _mid, content, _imp, _cat, _emb in to_index:
+                if content and content not in seen:
+                    seen.add(content)
+                    maybe_compact_around(user_id, content)
+        except Exception:
+            pass
+
     return {"stored": len(stored), "facts": stored}

{yourmemory-1.4.75 → yourmemory-1.4.76}/src/services/compaction.py

@@ -151,6 +151,62 @@ def compact_user(user_id: str, min_cluster: int = None, sim_threshold: float = N
             "summaries": summaries, "scanned": len(mems)}
 
 
+def _fetch_rows_by_ids(user_id: str, ids: list) -> list[dict]:
+    if not ids:
+        return []
+    backend = get_backend()
+    conn = get_conn()
+    cols = "id, content, category, importance, agent_id, visibility, created_at"
+    ph = ",".join(["%s" if backend == "postgres" else "?"] * len(ids))
+    sql = f"SELECT {cols} FROM memories WHERE user_id = {'%s' if backend=='postgres' else '?'} AND id IN ({ph})"
+    params = [user_id, *ids]
+    try:
+        if backend == "duckdb":
+            return duckdb_rows(conn.execute(sql, params))
+        cur = conn.cursor()
+        cur.execute(sql, tuple(params) if backend == "postgres" else params)
+        cn = [d[0] for d in cur.description]
+        rows = [dict(zip(cn, r)) for r in cur.fetchall()]; cur.close(); return rows
+    finally:
+        conn.close()
+
+
+def maybe_compact_around(user_id: str, seed_content: str,
+                         min_cluster: int = None, sim_threshold: float = None) -> int | None:
+    """Event-driven compaction: after a memory is stored, check whether its neighborhood
+    now has >= N closely-related memories; if so, compress just that cluster immediately.
+    Targeted (one similarity lookup, not an O(n^2) full scan). Returns the summary id."""
+    user_id = (user_id or "").strip().lower()
+    min_cluster = min_cluster or MIN_CLUSTER
+    sim = sim_threshold if sim_threshold is not None else SIM_THRESHOLD
+    if not seed_content or len(seed_content) < 4:
+        return None
+    try:
+        from src.services.retrieve import retrieve
+        res = retrieve(user_id, seed_content, top_k=max(min_cluster * 4, 20), no_graph=True)
+    except Exception:
+        return None
+    members = [m for m in res.get("memories", []) if m.get("similarity", 0) >= sim]
+    if len(members) < min_cluster:
+        return None   # not enough of the same thing yet — leave it
+    rows = _fetch_rows_by_ids(user_id, [m["id"] for m in members])
+    if len(rows) < min_cluster:
+        return None
+    summary = _summarize([r["content"] for r in rows])
+    if not summary or len(summary) < 12:
+        return None
+    importance = max(float(r["importance"] or 0.5) for r in rows)
+    category   = categorize(summary)
+    agent_id   = rows[0].get("agent_id")
+    visibility = rows[0].get("visibility") or "shared"
+    summary_id = _apply_compaction(get_backend(), user_id, summary, importance, category,
+                                   agent_id, visibility, rows)
+    if summary_id is not None:
+        log_event("write", "compact", user_id,
+                  detail={"clusters": 1, "archived": len(rows), "trigger": "count"})
+    return summary_id
+
+
 def _apply_compaction(backend, user_id, summary, importance, category, agent_id,
                       visibility, members) -> int | None:
     """Insert the summary memory, archive the originals, delete them. Returns summary id."""

{yourmemory-1.4.75 → yourmemory-1.4.76}/yourmemory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yourmemory
-Version: 1.4.75
+Version: 1.4.76
 Summary: Persistent memory for Claude — Ebbinghaus forgetting curve, semantic deduplication, MCP-native
 Author: Sachit Misra
 Author-email: mishrasachit1@gmail.com