Skip to content

Personal AI, On Personal Devices

Python

Optimize DenseMemory delete path (#826)

Ricky Bobbyc3d8ca66676d
diff --git a/src/openjarvis/tools/storage/dense.py b/src/openjarvis/tools/storage/dense.py
index 6547d545..2c0a6d0b 100644
--- a/src/openjarvis/tools/storage/dense.py
+++ b/src/openjarvis/tools/storage/dense.py
@@ -552,6 +552,7 @@ class DenseMemory(MemoryBackend):
"""
backend_id = "dense"
+ _COMPACTION_TOMBSTONE_RATIO = 0.25
def __init__(self, embedder: Optional[Embedder] = None) -> None:
self._embedder: Optional[Embedder] = embedder
@@ -561,6 +562,8 @@ class DenseMemory(MemoryBackend):
self._sources: List[str] = []
self._metadatas: List[Dict[str, Any]] = []
self._doc_ids: List[str] = []
+ self._active: List[bool] = []
+ self._live_count = 0
# id -> index; lets us delete in O(1) for lookups
self._id_to_index: Dict[str, int] = {}
self._lock = threading.Lock()
@@ -616,16 +619,47 @@ class DenseMemory(MemoryBackend):
self._matrix = vectors
else:
self._matrix = np.concatenate([self._matrix, vectors], axis=0)
- for i, (c, s, m, doc_id) in enumerate(
- zip(contents, sources, metadatas, new_ids),
- ):
+ for c, s, m, doc_id in zip(contents, sources, metadatas, new_ids):
self._contents.append(c)
self._sources.append(s)
self._metadatas.append(dict(m))
self._doc_ids.append(doc_id)
+ self._active.append(True)
self._id_to_index[doc_id] = len(self._contents) - 1
+ self._live_count += 1
return new_ids
+ def _compact_if_needed(self) -> None:
+ """Drop soft-deleted rows once the tombstone ratio grows too large."""
+ if self._matrix is None or not self._contents:
+ return
+ dead_count = len(self._contents) - self._live_count
+ if dead_count == 0:
+ return
+ if dead_count / len(self._contents) < self._COMPACTION_TOMBSTONE_RATIO:
+ return
+
+ keep = [i for i, is_live in enumerate(self._active) if is_live]
+ if not keep:
+ self._matrix = None
+ self._contents.clear()
+ self._sources.clear()
+ self._metadatas.clear()
+ self._doc_ids.clear()
+ self._active.clear()
+ self._id_to_index.clear()
+ self._live_count = 0
+ return
+
+ self._matrix = self._matrix[keep]
+ self._contents = [self._contents[i] for i in keep]
+ self._sources = [self._sources[i] for i in keep]
+ self._metadatas = [dict(self._metadatas[i]) for i in keep]
+ self._doc_ids = [self._doc_ids[i] for i in keep]
+ self._active = [True] * len(self._contents)
+ self._id_to_index = {doc_id: idx for idx, doc_id in enumerate(self._doc_ids)}
+ self._live_count = len(self._contents)
+
def retrieve(
self,
query: str,
@@ -650,18 +684,28 @@ class DenseMemory(MemoryBackend):
sources = list(self._sources)
metadatas = [dict(m) for m in self._metadatas]
doc_ids = list(self._doc_ids)
+ active = list(self._active)
if matrix_snapshot is None or matrix_snapshot.shape[0] == 0:
return []
+ live_count = sum(active)
+ if live_count == 0:
+ return []
+
emb = self._get_embedder()
q_vec = emb.embed([query]) # shape (1, dim), normalized
- # Single matrix-vector mult
- scores = matrix_snapshot @ q_vec[0] # shape (n,)
+ # Compute against the bounded physical matrix, then mask tombstoned
+ # scores in-place. Advanced row indexing would copy an O(n * dim)
+ # active matrix on every query; compaction keeps the extra dot-product
+ # work below the named tombstone threshold without that allocation.
+ scores = matrix_snapshot @ q_vec[0] # shape (n_physical,)
+ active_mask = np.asarray(active, dtype=bool)
+ scores[~active_mask] = -np.inf
# Top-k via argpartition then sort
n = scores.shape[0]
- k = min(top_k, n)
+ k = min(top_k, live_count)
if k <= 0:
return []
if k < n:
@@ -685,23 +729,15 @@ class DenseMemory(MemoryBackend):
return results
def delete(self, doc_id: str) -> bool:
- """Remove a document by id. Returns True if it existed."""
- import numpy as np
-
+ """Soft-delete a document by id. Returns True if it existed."""
with self._lock:
- idx = self._id_to_index.pop(doc_id, None)
- if idx is None:
+ idx = self._id_to_index.get(doc_id)
+ if idx is None or not self._active[idx]:
return False
- # Remove row from matrix
- self._matrix = np.delete(self._matrix, idx, axis=0)
- self._contents.pop(idx)
- self._sources.pop(idx)
- self._metadatas.pop(idx)
- self._doc_ids.pop(idx)
- # Rebuild id -> index for entries after the removed one
- for did, i in list(self._id_to_index.items()):
- if i > idx:
- self._id_to_index[did] = i - 1
+ self._active[idx] = False
+ self._id_to_index.pop(doc_id, None)
+ self._live_count -= 1
+ self._compact_if_needed()
return True
def clear(self) -> None:
@@ -712,12 +748,14 @@ class DenseMemory(MemoryBackend):
self._sources.clear()
self._metadatas.clear()
self._doc_ids.clear()
+ self._active.clear()
self._id_to_index.clear()
+ self._live_count = 0
def count(self) -> int:
"""Number of stored documents."""
with self._lock:
- return len(self._contents)
+ return self._live_count
__all__ = [
diff --git a/tests/tools/storage/test_dense.py b/tests/tools/storage/test_dense.py
index 1e8b3d40..34414610 100644
--- a/tests/tools/storage/test_dense.py
+++ b/tests/tools/storage/test_dense.py
@@ -225,6 +225,20 @@ def _mk(content: str, source: str) -> MdChunk:
return MdChunk(content=f"Header\n\n{content}", source=source, breadcrumb="Header")
+class _FakeEmbedder:
+ def embed(self, texts):
+ import numpy as np
+
+ vectors = []
+ for text in texts:
+ text = text.lower().strip()
+ seed = sum(ord(ch) for ch in text) % 3
+ vec = [0.0, 0.0, 0.0]
+ vec[seed] = 1.0
+ vectors.append(vec)
+ return np.asarray(vectors, dtype=float)
+
+
class TestDedupeChunks:
def test_no_dedupe_when_under_threshold_files(self):
"""Two identical chunks across two files should NOT be deduped (need 3+)."""
@@ -369,6 +383,99 @@ class TestDedupeChunks:
assert report.output_count + report.removed_count == report.input_count
+def test_dense_backend_delete_is_soft_and_live_count_accurate():
+ backend = DenseMemory(embedder=_FakeEmbedder())
+ doc_a = backend.store("alpha")
+ doc_b = backend.store("beta")
+
+ assert backend.count() == 2
+ assert backend.delete(doc_a) is True
+ assert backend.count() == 1
+ assert backend.delete(doc_a) is False
+
+ hits = backend.retrieve("beta", top_k=5)
+ assert hits
+ assert hits[0].metadata["doc_id"] == doc_b
+
+
+def test_dense_delete_compacts_at_named_tombstone_threshold():
+ backend = DenseMemory(embedder=_FakeEmbedder())
+ doc_ids = backend.store_many([f"doc-{i}" for i in range(8)])
+
+ assert backend.delete(doc_ids[0]) is True
+ assert backend._matrix.shape[0] == 8
+ assert backend.delete(doc_ids[1]) is True
+
+ assert backend.count() == 6
+ assert backend._matrix.shape[0] == 6
+ assert backend._active == [True] * 6
+ assert set(backend._id_to_index) == set(doc_ids[2:])
+
+
+def test_dense_delete_all_resets_every_internal_collection():
+ backend = DenseMemory(embedder=_FakeEmbedder())
+ doc_ids = backend.store_many(["alpha", "beta", "gamma"])
+
+ assert all(backend.delete(doc_id) for doc_id in doc_ids)
+
+ assert backend.count() == 0
+ assert backend._matrix is None
+ assert backend._contents == []
+ assert backend._sources == []
+ assert backend._metadatas == []
+ assert backend._doc_ids == []
+ assert backend._active == []
+ assert backend._id_to_index == {}
+ assert backend.retrieve("alpha") == []
+
+
+def test_dense_retrieve_masks_tombstones_without_copying_matrix_rows():
+ import numpy as np
+
+ class _NoRowIndexMatrix:
+ def __init__(self, matrix):
+ self._matrix = matrix
+ self.shape = matrix.shape
+
+ def __matmul__(self, other):
+ return self._matrix @ other
+
+ def __getitem__(self, key):
+ raise AssertionError("retrieve must not advanced-index the matrix")
+
+ backend = DenseMemory(embedder=_FakeEmbedder())
+ doc_ids = backend.store_many([f"doc-{i}" for i in range(8)])
+ deleted_id = doc_ids[0]
+ assert backend.delete(deleted_id)
+ backend._matrix = _NoRowIndexMatrix(np.asarray(backend._matrix))
+
+ hits = backend.retrieve("doc-0", top_k=20)
+
+ assert len(hits) == 7
+ assert deleted_id not in {hit.metadata["doc_id"] for hit in hits}
+
+
+def test_dense_concurrent_delete_and_retrieve_preserve_consistent_state():
+ from concurrent.futures import ThreadPoolExecutor
+
+ backend = DenseMemory(embedder=_FakeEmbedder())
+ doc_ids = backend.store_many([f"doc-{i}" for i in range(64)])
+ to_delete = doc_ids[:32]
+
+ with ThreadPoolExecutor(max_workers=12) as pool:
+ delete_futures = [pool.submit(backend.delete, doc_id) for doc_id in to_delete]
+ read_futures = [
+ pool.submit(backend.retrieve, "doc-63", top_k=64) for _ in range(32)
+ ]
+
+ assert all(future.result() is True for future in delete_futures)
+ assert all(isinstance(future.result(), list) for future in read_futures)
+ assert backend.count() == 32
+ assert {
+ hit.metadata["doc_id"] for hit in backend.retrieve("doc-63", top_k=64)
+ } == set(doc_ids[32:])
+
+
# ---------------------------------------------------------------------------
# Retrieval quality tests (require Ollama + nomic-embed-text)
# ---------------------------------------------------------------------------
@@ -441,9 +548,10 @@ def test_paraphrase_matches_semantically(indexed_backend):
assert results, "expected at least one hit"
# Top-3 should all be from the topical docs (engines.md or hardware.md)
topical = {r.source for r in results[:3]}
- assert topical <= {"engines.md", "hardware.md"}, (
- f"off-topic sources in top-3: {topical}"
- )
+ assert topical <= {
+ "engines.md",
+ "hardware.md",
+ }, f"off-topic sources in top-3: {topical}"
top_lc = results[0].content.lower()
assert "llama.cpp" in top_lc or "cpu" in top_lc