From a6d065efdc19a045e687b7430ea01b766c9507a5 Mon Sep 17 00:00:00 2001 From: AutoDev Bot Date: Wed, 2 Sep 2026 18:13:48 +0800 Subject: [PATCH 1/4] fix: purge vec_db vectors in delete_node_by_prams of Neo4jCommunityGraphDB (#2331) --- src/memos/graph_dbs/neo4j_community.py | 43 ++++--- tests/graph_dbs/test_delete_vec_cleanup.py | 140 +++++++++++++++++++++ 2 files changed, 166 insertions(+), 17 deletions(-) create mode 100644 tests/graph_dbs/test_delete_vec_cleanup.py diff --git a/src/memos/graph_dbs/neo4j_community.py b/src/memos/graph_dbs/neo4j_community.py index b5c92f40a..c12ad8dcb 100644 --- a/src/memos/graph_dbs/neo4j_community.py +++ b/src/memos/graph_dbs/neo4j_community.py @@ -1038,36 +1038,45 @@ def delete_node_by_prams( f"[delete_node_by_prams] Deleting nodes - memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}" ) - # First count matching nodes to get accurate count - count_query = f"MATCH (n:Memory) WHERE {ids_where} RETURN count(n) AS node_count" - logger.info(f"[delete_node_by_prams] count_query: {count_query}") - print(f"[delete_node_by_prams] count_query: {count_query}") + # Collect IDs before deletion so we can purge vectors from vec_db afterwards. + id_collect_query = f"MATCH (n:Memory) WHERE {ids_where} RETURN n.id AS id" + logger.info(f"[delete_node_by_prams] id_collect_query: {id_collect_query}") - # Then delete nodes + # Delete nodes delete_query = f"MATCH (n:Memory) WHERE {ids_where} DETACH DELETE n" logger.info(f"[delete_node_by_prams] delete_query: {delete_query}") - print(f"[delete_node_by_prams] delete_query: {delete_query}") - print(f"[delete_node_by_prams] params: {params}") deleted_count = 0 + collected_ids: list[str] = [] try: with self.driver.session(database=self.db_name) as session: - # Count nodes before deletion - count_result = session.run(count_query, **params) - count_record = count_result.single() - expected_count = 0 - if count_record: - expected_count = count_record["node_count"] or 0 - - # Delete nodes + # Collect IDs of nodes that are about to be deleted + id_result = session.run(id_collect_query, **params) + collected_ids = [record["id"] for record in id_result] + deleted_count = len(collected_ids) + + # Delete nodes from graph session.run(delete_query, **params) - # Use the count from before deletion as the actual deleted count - deleted_count = expected_count except Exception as e: logger.error(f"[delete_node_by_prams] Failed to delete nodes: {e}", exc_info=True) raise + # Purge corresponding embedding vectors so they are no longer searchable. + # This is the fix for #2331: the graph node was removed but stale vectors + # in vec_db caused deleted memories to resurface in search results. + if collected_ids: + try: + self.vec_db.delete(collected_ids) + logger.info( + "[delete_node_by_prams] Purged %d vectors from vec_db", len(collected_ids) + ) + except Exception as e: + logger.warning( + "[delete_node_by_prams] vec_db cleanup failed (graph deletion already succeeded): %s", + e, + ) + logger.info(f"[delete_node_by_prams] Successfully deleted {deleted_count} nodes") return deleted_count diff --git a/tests/graph_dbs/test_delete_vec_cleanup.py b/tests/graph_dbs/test_delete_vec_cleanup.py new file mode 100644 index 000000000..752811ed5 --- /dev/null +++ b/tests/graph_dbs/test_delete_vec_cleanup.py @@ -0,0 +1,140 @@ +""" +Regression tests for #2331: delete_node_by_prams must also purge vectors from vec_db. + +When a memory is deleted via Neo4jCommunityGraphDB.delete_node_by_prams the +corresponding embedding vector must be removed from vec_db so that subsequent +searches no longer surface the deleted node. +""" + +from unittest.mock import MagicMock + +import pytest + +from memos.configs.graph_db import Neo4jGraphDBConfig + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + + +def _make_db(config: Neo4jGraphDBConfig) -> "Neo4jCommunityGraphDB": # noqa: F821 + """Build a Neo4jCommunityGraphDB with all heavy dependencies mocked out. + + Uses __new__ to skip __init__ entirely so no real Neo4j driver or Qdrant + connection is attempted. + """ + from memos.graph_dbs.neo4j_community import Neo4jCommunityGraphDB + + db = Neo4jCommunityGraphDB.__new__(Neo4jCommunityGraphDB) + db.config = config + db.driver = MagicMock() + db.db_name = config.db_name + db.vec_db = MagicMock() + db._schema_ready = True + return db + + +@pytest.fixture +def community_config(): + return Neo4jGraphDBConfig( + uri="bolt://localhost:7687", + user="neo4j", + password="test", + db_name="test_db", + auto_create=False, + use_multi_db=False, + user_name="alice", + embedding_dimension=3, + ) + + +# --------------------------------------------------------------------------- +# Tests - vec_db cleanup is called for every delete mode +# --------------------------------------------------------------------------- + + +class TestDeleteNodeByPramsVecCleanup: + """delete_node_by_prams must remove vectors from vec_db after graph deletion.""" + + def _make_session_mock(self, db: "Neo4jCommunityGraphDB", ids_to_delete: list[str]): # noqa: F821 + """Wire a session that returns `ids_to_delete` from the pre-delete ID query. + + The fixed implementation makes exactly 2 session.run calls: + 1) id_collect_query — MATCH ... RETURN n.id AS id + 2) delete_query — MATCH ... DETACH DELETE n + """ + session_ctx = MagicMock() + session_ctx.__enter__ = MagicMock(return_value=session_ctx) + session_ctx.__exit__ = MagicMock(return_value=False) + + # First run: id_collect_query — yields records with record["id"] == the node id + id_records = [] + for nid in ids_to_delete: + record = MagicMock() + # capture nid via default argument to avoid late-binding closure + record.__getitem__ = MagicMock( + side_effect=lambda k, _id=nid: _id if k == "id" else None + ) + id_records.append(record) + id_result = MagicMock() + id_result.__iter__ = MagicMock(return_value=iter(id_records)) + + # Second run: delete_query — return value is not inspected + delete_result = MagicMock() + + session_ctx.run.side_effect = [id_result, delete_result] + db.driver.session.return_value = session_ctx + return session_ctx + + def test_delete_by_memory_ids_cleans_vec_db(self, community_config): + """Deleting by memory_ids must call vec_db.delete with those IDs.""" + db = _make_db(community_config) + ids = ["aaa-111", "bbb-222"] + self._make_session_mock(db, ids) + + db.delete_node_by_prams(memory_ids=ids) + + db.vec_db.delete.assert_called_once_with(ids) + + def test_delete_by_filter_cleans_vec_db(self, community_config): + """Deleting by filter must call vec_db.delete with all matched IDs.""" + db = _make_db(community_config) + matched_ids = ["ccc-333", "ddd-444"] + + # get_by_metadata is called internally for filter path + db.get_by_metadata = MagicMock(return_value=matched_ids) + self._make_session_mock(db, matched_ids) + + db.delete_node_by_prams(filter={"user_id": "alice"}) + + db.vec_db.delete.assert_called_once_with(matched_ids) + + def test_delete_by_memory_ids_empty_list_no_vec_call(self, community_config): + """Empty memory_ids must not call vec_db.delete (early-return path).""" + db = _make_db(community_config) + + result = db.delete_node_by_prams(memory_ids=[]) + + db.vec_db.delete.assert_not_called() + assert result == 0 + + def test_delete_no_args_no_vec_call(self, community_config): + """No delete args must return 0 and not touch vec_db.""" + db = _make_db(community_config) + + result = db.delete_node_by_prams() + + db.vec_db.delete.assert_not_called() + assert result == 0 + + def test_vec_db_delete_failure_does_not_raise(self, community_config): + """A vec_db failure during cleanup must log a warning, not crash the request.""" + db = _make_db(community_config) + ids = ["eee-555"] + self._make_session_mock(db, ids) + db.vec_db.delete.side_effect = RuntimeError("qdrant unavailable") + + # Should not raise — graph deletion already succeeded + result = db.delete_node_by_prams(memory_ids=ids) + assert result >= 0 From 55178d01f9194f8bebd58a1f8812732ca7cf0c5a Mon Sep 17 00:00:00 2001 From: AutoDev Bot Date: Wed, 2 Sep 2026 18:25:53 +0800 Subject: [PATCH 2/4] fix: address OCR review comments on delete_node_by_prams - Filter None ids out of collected_ids before vec_db.delete to avoid passing Null neo4j values to the vector store. - Use lazy %-style formatting for id_collect_query log call, matching the sibling log line's style. - Assert get_by_metadata is called in the filter-path regression test so the mock actually exercises the branch it documents. --- src/memos/graph_dbs/neo4j_community.py | 4 ++-- tests/graph_dbs/test_delete_vec_cleanup.py | 1 + 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/memos/graph_dbs/neo4j_community.py b/src/memos/graph_dbs/neo4j_community.py index c12ad8dcb..08c30c5a8 100644 --- a/src/memos/graph_dbs/neo4j_community.py +++ b/src/memos/graph_dbs/neo4j_community.py @@ -1040,7 +1040,7 @@ def delete_node_by_prams( # Collect IDs before deletion so we can purge vectors from vec_db afterwards. id_collect_query = f"MATCH (n:Memory) WHERE {ids_where} RETURN n.id AS id" - logger.info(f"[delete_node_by_prams] id_collect_query: {id_collect_query}") + logger.info("[delete_node_by_prams] id_collect_query: %s", id_collect_query) # Delete nodes delete_query = f"MATCH (n:Memory) WHERE {ids_where} DETACH DELETE n" @@ -1052,7 +1052,7 @@ def delete_node_by_prams( with self.driver.session(database=self.db_name) as session: # Collect IDs of nodes that are about to be deleted id_result = session.run(id_collect_query, **params) - collected_ids = [record["id"] for record in id_result] + collected_ids = [record["id"] for record in id_result if record["id"] is not None] deleted_count = len(collected_ids) # Delete nodes from graph diff --git a/tests/graph_dbs/test_delete_vec_cleanup.py b/tests/graph_dbs/test_delete_vec_cleanup.py index 752811ed5..f5c90c1cb 100644 --- a/tests/graph_dbs/test_delete_vec_cleanup.py +++ b/tests/graph_dbs/test_delete_vec_cleanup.py @@ -108,6 +108,7 @@ def test_delete_by_filter_cleans_vec_db(self, community_config): db.delete_node_by_prams(filter={"user_id": "alice"}) + db.get_by_metadata.assert_called_once() db.vec_db.delete.assert_called_once_with(matched_ids) def test_delete_by_memory_ids_empty_list_no_vec_call(self, community_config): From 67958ed69fac304e98e4d108d8410b618b096df9 Mon Sep 17 00:00:00 2001 From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com> Date: Thu, 19 Nov 2026 19:35:22 +0800 Subject: [PATCH 3/4] fix(graph-db): keep vector deletion failures retryable --- src/memos/graph_dbs/neo4j_community.py | 76 +++------ src/memos/memories/textual/tree.py | 3 +- tests/api/test_memory_handler_delete.py | 19 +++ tests/graph_dbs/test_delete_vec_cleanup.py | 89 +++++++---- .../test_delete_vec_cleanup_integration.py | 148 ++++++++++++++++++ tests/memories/textual/test_tree.py | 10 ++ 6 files changed, 264 insertions(+), 81 deletions(-) create mode 100644 tests/graph_dbs/test_delete_vec_cleanup_integration.py diff --git a/src/memos/graph_dbs/neo4j_community.py b/src/memos/graph_dbs/neo4j_community.py index 08c30c5a8..6f0c84ba2 100644 --- a/src/memos/graph_dbs/neo4j_community.py +++ b/src/memos/graph_dbs/neo4j_community.py @@ -5,6 +5,7 @@ from typing import Any from memos.configs.graph_db import Neo4jGraphDBConfig +from memos.exceptions import VectorDBError from memos.graph_dbs.neo4j import ( Neo4jGraphDB, _flatten_info_fields, @@ -957,10 +958,11 @@ def delete_node_by_prams( int: Number of nodes deleted. """ logger.info( - f"[delete_node_by_prams] memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}, writable_cube_ids: {writable_cube_ids}" - ) - print( - f"[delete_node_by_prams] memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}, writable_cube_ids: {writable_cube_ids}" + "[delete_node_by_prams] memory_count=%d, file_count=%d, cube_count=%d, has_filter=%s", + len(memory_ids or []), + len(file_ids or []), + len(writable_cube_ids or []), + bool(filter), ) # file_ids deletion must be scoped by writable_cube_ids. @@ -1031,53 +1033,27 @@ def delete_node_by_prams( else: ids_where = data_conditions - logger.info( - f"[delete_node_by_prams] Deleting nodes - memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}" + # Return IDs from the deletion itself so concurrent matches cannot drift + # between a separate ID lookup and the graph mutation. + delete_query = ( + f"MATCH (n:Memory) WHERE {ids_where} WITH n, n.id AS id DETACH DELETE n RETURN id" ) - print( - f"[delete_node_by_prams] Deleting nodes - memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}" - ) - - # Collect IDs before deletion so we can purge vectors from vec_db afterwards. - id_collect_query = f"MATCH (n:Memory) WHERE {ids_where} RETURN n.id AS id" - logger.info("[delete_node_by_prams] id_collect_query: %s", id_collect_query) - - # Delete nodes - delete_query = f"MATCH (n:Memory) WHERE {ids_where} DETACH DELETE n" - logger.info(f"[delete_node_by_prams] delete_query: {delete_query}") - - deleted_count = 0 - collected_ids: list[str] = [] - try: - with self.driver.session(database=self.db_name) as session: - # Collect IDs of nodes that are about to be deleted - id_result = session.run(id_collect_query, **params) - collected_ids = [record["id"] for record in id_result if record["id"] is not None] - deleted_count = len(collected_ids) - - # Delete nodes from graph - session.run(delete_query, **params) - - except Exception as e: - logger.error(f"[delete_node_by_prams] Failed to delete nodes: {e}", exc_info=True) - raise - - # Purge corresponding embedding vectors so they are no longer searchable. - # This is the fix for #2331: the graph node was removed but stale vectors - # in vec_db caused deleted memories to resurface in search results. - if collected_ids: - try: - self.vec_db.delete(collected_ids) - logger.info( - "[delete_node_by_prams] Purged %d vectors from vec_db", len(collected_ids) - ) - except Exception as e: - logger.warning( - "[delete_node_by_prams] vec_db cleanup failed (graph deletion already succeeded): %s", - e, - ) - - logger.info(f"[delete_node_by_prams] Successfully deleted {deleted_count} nodes") + with ( + self.driver.session(database=self.db_name) as session, + session.begin_transaction() as transaction, + ): + records = list(transaction.run(delete_query, **params)) + deleted_ids = [record["id"] for record in records if record["id"] is not None] + if deleted_ids: + try: + self.vec_db.delete(deleted_ids) + except Exception as exc: + # Leave graph nodes available for a retry if vector cleanup fails. + raise VectorDBError("Failed to delete memory vectors; retry deletion") from exc + transaction.commit() + + deleted_count = len(records) + logger.info("[delete_node_by_prams] Successfully deleted %d nodes", deleted_count) return deleted_count def clear(self, user_name: str | None = None) -> None: diff --git a/src/memos/memories/textual/tree.py b/src/memos/memories/textual/tree.py index 426a2359b..c1402422e 100644 --- a/src/memos/memories/textual/tree.py +++ b/src/memos/memories/textual/tree.py @@ -414,7 +414,8 @@ def delete_by_memory_ids(self, memory_ids: list[str]) -> None: try: self.graph_store.delete_node_by_prams(memory_ids=memory_ids) except Exception as e: - logger.error(f"An error occurred while deleting memories by memory_ids: {e}") + logger.error("Failed to delete memories by memory_ids: %s", e) + raise def delete_all(self, user_name: str | None = None) -> None: """Delete all memories and their relationships from the graph store.""" diff --git a/tests/api/test_memory_handler_delete.py b/tests/api/test_memory_handler_delete.py index 7d60f946b..33e249ae9 100644 --- a/tests/api/test_memory_handler_delete.py +++ b/tests/api/test_memory_handler_delete.py @@ -140,3 +140,22 @@ def test_delete_memories_with_pref_mem_disabled(): writable_cube_ids=None, filter={"and": [{"user_id": "u_1"}]}, ) + + +def test_vector_delete_failure_reaches_api_response(): + from types import SimpleNamespace + + from memos.exceptions import VectorDBError + from memos.memories.textual.tree import TreeTextMemory + + memory = TreeTextMemory.__new__(TreeTextMemory) + memory.graph_store = Mock() + memory.graph_store.get_nodes.return_value = [] + memory.graph_store.delete_node_by_prams.side_effect = VectorDBError("Synthetic vector outage") + cube = SimpleNamespace(text_mem=memory) + request = DeleteMemoryRequest(memory_ids=["synthetic-id"]) + + response = handle_delete_memories(request, cube) + + assert response.data["status"] == "failure" + memory.graph_store.delete_node_by_prams.assert_called_once_with(memory_ids=["synthetic-id"]) diff --git a/tests/graph_dbs/test_delete_vec_cleanup.py b/tests/graph_dbs/test_delete_vec_cleanup.py index f5c90c1cb..9611c9c35 100644 --- a/tests/graph_dbs/test_delete_vec_cleanup.py +++ b/tests/graph_dbs/test_delete_vec_cleanup.py @@ -11,6 +11,7 @@ import pytest from memos.configs.graph_db import Neo4jGraphDBConfig +from memos.exceptions import VectorDBError # --------------------------------------------------------------------------- @@ -58,32 +59,13 @@ class TestDeleteNodeByPramsVecCleanup: """delete_node_by_prams must remove vectors from vec_db after graph deletion.""" def _make_session_mock(self, db: "Neo4jCommunityGraphDB", ids_to_delete: list[str]): # noqa: F821 - """Wire a session that returns `ids_to_delete` from the pre-delete ID query. - - The fixed implementation makes exactly 2 session.run calls: - 1) id_collect_query — MATCH ... RETURN n.id AS id - 2) delete_query — MATCH ... DETACH DELETE n - """ + """Wire deletion records returned from an explicit graph transaction.""" session_ctx = MagicMock() session_ctx.__enter__ = MagicMock(return_value=session_ctx) session_ctx.__exit__ = MagicMock(return_value=False) - # First run: id_collect_query — yields records with record["id"] == the node id - id_records = [] - for nid in ids_to_delete: - record = MagicMock() - # capture nid via default argument to avoid late-binding closure - record.__getitem__ = MagicMock( - side_effect=lambda k, _id=nid: _id if k == "id" else None - ) - id_records.append(record) - id_result = MagicMock() - id_result.__iter__ = MagicMock(return_value=iter(id_records)) - - # Second run: delete_query — return value is not inspected - delete_result = MagicMock() - - session_ctx.run.side_effect = [id_result, delete_result] + transaction = session_ctx.begin_transaction.return_value.__enter__.return_value + transaction.run.return_value = [{"id": nid} for nid in ids_to_delete] db.driver.session.return_value = session_ctx return session_ctx @@ -129,13 +111,60 @@ def test_delete_no_args_no_vec_call(self, community_config): db.vec_db.delete.assert_not_called() assert result == 0 - def test_vec_db_delete_failure_does_not_raise(self, community_config): - """A vec_db failure during cleanup must log a warning, not crash the request.""" + def test_vec_db_delete_failure_propagates_without_graph_commit(self, community_config): db = _make_db(community_config) - ids = ["eee-555"] - self._make_session_mock(db, ids) - db.vec_db.delete.side_effect = RuntimeError("qdrant unavailable") + session = self._make_session_mock(db, ["eee-555"]) + transaction = session.begin_transaction.return_value.__enter__.return_value + db.vec_db.delete.side_effect = OSError("Synthetic vector outage") + + with pytest.raises(VectorDBError): + db.delete_node_by_prams(memory_ids=["eee-555"]) + + transaction.commit.assert_not_called() + + def test_deletion_uses_one_graph_statement_and_purges_before_commit(self, community_config): + db = _make_db(community_config) + session = self._make_session_mock(db, ["aaa-111"]) + transaction = session.begin_transaction.return_value.__enter__.return_value + order = [] + db.vec_db.delete.side_effect = lambda ids: order.append(("vectors", ids)) + transaction.commit.side_effect = lambda: order.append(("commit", None)) + + result = db.delete_node_by_prams(writable_cube_ids=["alice"], memory_ids=["aaa-111"]) + + assert result == 1 + session.run.assert_not_called() + transaction.run.assert_called_once() + query = transaction.run.call_args.args[0] + assert "DETACH DELETE n" in query + assert "RETURN id" in query + assert transaction.run.call_args.kwargs["cube_id_0"] == "alice" + assert order == [("vectors", ["aaa-111"]), ("commit", None)] + + def test_graph_statement_failure_does_not_remove_vectors(self, community_config): + db = _make_db(community_config) + session = self._make_session_mock(db, ["aaa-111"]) + transaction = session.begin_transaction.return_value.__enter__.return_value + transaction.run.side_effect = OSError("Synthetic graph outage") + + with pytest.raises(OSError): + db.delete_node_by_prams(memory_ids=["aaa-111"]) + + db.vec_db.delete.assert_not_called() + transaction.commit.assert_not_called() + + def test_no_matching_nodes_does_not_remove_vectors(self, community_config): + db = _make_db(community_config) + self._make_session_mock(db, []) + + assert db.delete_node_by_prams(memory_ids=["absent"]) == 0 + db.vec_db.delete.assert_not_called() - # Should not raise — graph deletion already succeeded - result = db.delete_node_by_prams(memory_ids=ids) - assert result >= 0 + def test_file_deletion_requires_cube_scope(self, community_config): + db = _make_db(community_config) + + with pytest.raises(ValueError, match="writable_cube_ids"): + db.delete_node_by_prams(file_ids=["file-1"]) + + db.driver.session.assert_not_called() + db.vec_db.delete.assert_not_called() diff --git a/tests/graph_dbs/test_delete_vec_cleanup_integration.py b/tests/graph_dbs/test_delete_vec_cleanup_integration.py new file mode 100644 index 000000000..2ea8bd362 --- /dev/null +++ b/tests/graph_dbs/test_delete_vec_cleanup_integration.py @@ -0,0 +1,148 @@ +"""Opt-in deletion tests using isolated Neo4j and Qdrant services.""" + +import os + +from uuid import uuid4 + +import pytest + +from memos.configs.graph_db import Neo4jGraphDBConfig +from memos.configs.vec_db import QdrantVecDBConfig +from memos.exceptions import VectorDBError +from memos.graph_dbs.neo4j_community import Neo4jCommunityGraphDB +from memos.vec_dbs.item import VecDBItem +from memos.vec_dbs.qdrant import QdrantVecDB + + +@pytest.fixture +def stores(): + uri = os.getenv("MEMOS_TEST_DELETE_NEO4J_URI") + url = os.getenv("MEMOS_TEST_DELETE_QDRANT_URL") + if not uri or not url: + pytest.skip( + "Configure isolated MEMOS_TEST_DELETE_NEO4J_URI and MEMOS_TEST_DELETE_QDRANT_URL" + ) + neo4j = pytest.importorskip("neo4j") + run_id = uuid4().hex + scope = f"delete-test-{run_id}" + db = Neo4jCommunityGraphDB.__new__(Neo4jCommunityGraphDB) + db.config = Neo4jGraphDBConfig( + uri=uri, + user="neo4j", + password="test-password", + db_name="neo4j", + user_name=scope, + auto_create=False, + use_multi_db=False, + ) + db.db_name = "neo4j" + db.driver = neo4j.GraphDatabase.driver(uri, auth=("neo4j", "test-password")) + db.vec_db = QdrantVecDB( + QdrantVecDBConfig( + url=url, + collection_name=f"delete_{run_id}", + vector_dimension=3, + distance_metric="cosine", + ) + ) + ids = [str(uuid4()), str(uuid4())] + nodes = [ + {"id": ids[0], "user_name": scope}, + {"id": ids[1], "user_name": scope + "-other"}, + ] + try: + with db.driver.session(database="neo4j") as session: + session.run( + "UNWIND $nodes AS row CREATE (n:Memory) SET n = row, " + "n.test_run = $run, n.file_ids = ['synthetic-file'], " + "n.user_id = 'synthetic-user'", + nodes=nodes, + run=run_id, + ).consume() + db.vec_db.add( + [ + VecDBItem( + id=node["id"], + vector=[0.1, 0.2, 0.3], + payload={"user_name": node["user_name"]}, + ) + for node in nodes + ] + ) + yield db, ids, scope + finally: + with db.driver.session(database="neo4j") as session: + session.run("MATCH (n:Memory {test_run: $run}) DETACH DELETE n", run=run_id).consume() + db.vec_db.delete_collection(db.vec_db.config.collection_name) + db.vec_db.client.close() + db.driver.close() + + +def remaining_graph_ids(db): + with db.driver.session(database="neo4j") as session: + return {record["id"] for record in session.run("MATCH (n:Memory) RETURN n.id AS id")} + + +@pytest.mark.parametrize("delete_mode", ["ids", "file", "filter"]) +def test_successful_delete_removes_both_stores_only_in_requested_cube(stores, delete_mode): + db, ids, scope = stores + arguments = { + "ids": {"memory_ids": ids}, + "file": {"file_ids": ["synthetic-file"]}, + "filter": {"filter": {"user_id": "synthetic-user"}}, + }[delete_mode] + + assert db.delete_node_by_prams(writable_cube_ids=[scope], **arguments) == 1 + + assert ids[0] not in remaining_graph_ids(db) + assert ids[1] in remaining_graph_ids(db) + assert db.vec_db.get_by_ids([ids[0]]) == [] + assert [item.id for item in db.vec_db.get_by_ids([ids[1]])] == [ids[1]] + assert db.delete_node_by_prams(writable_cube_ids=[scope], **arguments) == 0 + + +@pytest.mark.parametrize("partial_vector_delete", [False, True]) +def test_vector_failure_rolls_back_graph_and_can_be_retried( + stores, monkeypatch, partial_vector_delete +): + db, ids, scope = stores + delete_vectors = db.vec_db.delete + + def fail(_ids): + if partial_vector_delete: + delete_vectors(_ids) + raise OSError("Synthetic vector outage") + + monkeypatch.setattr(db.vec_db, "delete", fail) + with pytest.raises(VectorDBError): + db.delete_node_by_prams(writable_cube_ids=[scope], memory_ids=[ids[0]]) + + assert ids[0] in remaining_graph_ids(db) + remaining_vectors = db.vec_db.get_by_ids([ids[0]]) + assert [item.id for item in remaining_vectors] == ([] if partial_vector_delete else [ids[0]]) + + monkeypatch.setattr(db.vec_db, "delete", delete_vectors) + assert db.delete_node_by_prams(writable_cube_ids=[scope], memory_ids=[ids[0]]) == 1 + assert ids[0] not in remaining_graph_ids(db) + assert db.vec_db.get_by_ids([ids[0]]) == [] + + +def test_graph_commit_failure_remains_retryable_after_vector_cleanup(stores, monkeypatch): + db, ids, scope = stores + with db.driver.session(database="neo4j") as session, session.begin_transaction() as transaction: + transaction_type = type(transaction) + commit = transaction_type.commit + + def fail_commit(self): + raise OSError("Synthetic graph commit failure") + + monkeypatch.setattr(transaction_type, "commit", fail_commit) + with pytest.raises(OSError, match="Synthetic graph commit failure"): + db.delete_node_by_prams(writable_cube_ids=[scope], memory_ids=[ids[0]]) + + assert ids[0] in remaining_graph_ids(db) + assert db.vec_db.get_by_ids([ids[0]]) == [] + + monkeypatch.setattr(transaction_type, "commit", commit) + assert db.delete_node_by_prams(writable_cube_ids=[scope], memory_ids=[ids[0]]) == 1 + assert ids[0] not in remaining_graph_ids(db) diff --git a/tests/memories/textual/test_tree.py b/tests/memories/textual/test_tree.py index a72709ec5..5243f0847 100644 --- a/tests/memories/textual/test_tree.py +++ b/tests/memories/textual/test_tree.py @@ -166,3 +166,13 @@ def test_add_returns_ids(mock_tree_text_memory): mock_tree_text_memory.memory_manager.add.assert_called_once_with( mock_items, user_name=None, mode="sync" ) + + +def test_delete_by_memory_ids_propagates_storage_failure(mock_tree_text_memory): + from memos.exceptions import VectorDBError + + mock_tree_text_memory.graph_store.delete_node_by_prams.side_effect = VectorDBError( + "Synthetic vector outage" + ) + with pytest.raises(VectorDBError): + mock_tree_text_memory.delete_by_memory_ids(["synthetic-id"]) From ab18338167af973a6bc317310811519ad082ca0f Mon Sep 17 00:00:00 2001 From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com> Date: Thu, 19 Nov 2026 19:36:43 +0800 Subject: [PATCH 4/4] chore(ci): validate deletion fix against dev base