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.pyindex 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.25def __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 lookupsself._id_to_index: Dict[str, int] = {}self._lock = threading.Lock()@@ -616,16 +619,47 @@ class DenseMemory(MemoryBackend):self._matrix = vectorselse: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 += 1return 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 sortn = 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 resultsdef 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 Truedef 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 = 0def 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.pyindex 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