The Memory Layer for AI Agents - Drop-in memory infrastructure for AI agents and apps. Context that persists. Built for production.
Python agentic-memoryagentic-memory-systemagentsaiai-agentschatgptgenaillmlong-term-memorymemorymemory-managementpythonragstate-management
fix: clean up graph store data on Memory.delete() (#4505)
Utkarsh533274196166
diff --git a/mem0/graphs/neptune/base.py b/mem0/graphs/neptune/base.pyindex 458c51755..2732ceab3 100644--- a/mem0/graphs/neptune/base.py+++ b/mem0/graphs/neptune/base.py@@ -409,6 +409,28 @@ class NeptuneBase(ABC):"""pass+ def delete(self, data, filters):+ """+ Delete graph entities associated with the given memory text.++ Extracts entities and relationships from the memory text using the same+ pipeline as add(), then deletes the matching relationships in the graph.++ Args:+ data (str): The memory text whose graph entities should be removed.+ filters (dict): Scope filters (user_id, agent_id, run_id).+ """+ try:+ entity_type_map = self._retrieve_nodes_from_data(data, filters)+ if not entity_type_map:+ logger.debug("No entities found in memory text, skipping graph cleanup")+ return+ to_be_deleted = self._establish_nodes_relations_from_data(data, filters, entity_type_map)+ if to_be_deleted:+ self._delete_entities(to_be_deleted, filters["user_id"])+ except Exception as e:+ logger.error(f"Error during graph cleanup for memory delete: {e}")+def delete_all(self, filters):cypher, params = self._delete_all_cypher(filters)self.graph.query(cypher, params=params)diff --git a/mem0/memory/apache_age_memory.py b/mem0/memory/apache_age_memory.pyindex 74c51b555..e3c69f1a4 100644--- a/mem0/memory/apache_age_memory.py+++ b/mem0/memory/apache_age_memory.py@@ -246,6 +246,28 @@ class MemoryGraph:logger.info(f"Returned {len(search_results)} search results")return search_results+ def delete(self, data, filters):+ """+ Delete graph entities associated with the given memory text.++ Extracts entities and relationships from the memory text using the same+ pipeline as add(), then deletes the matching relationships in the graph.++ Args:+ data (str): The memory text whose graph entities should be removed.+ filters (dict): Scope filters (user_id, agent_id, run_id).+ """+ try:+ entity_type_map = self._retrieve_nodes_from_data(data, filters)+ if not entity_type_map:+ logger.debug("No entities found in memory text, skipping graph cleanup")+ return+ to_be_deleted = self._establish_nodes_relations_from_data(data, filters, entity_type_map)+ if to_be_deleted:+ self._delete_entities(to_be_deleted, filters)+ except Exception as e:+ logger.error(f"Error during graph cleanup for memory delete: {e}")+def delete_all(self, filters):"""Delete all nodes and relationships for a user or specific agent."""where_parts = ["n.user_id = %s"]diff --git a/mem0/memory/graph_memory.py b/mem0/memory/graph_memory.pyindex a0c89cf76..86e49099e 100644--- a/mem0/memory/graph_memory.py+++ b/mem0/memory/graph_memory.py@@ -129,6 +129,28 @@ class MemoryGraph:return search_results+ def delete(self, data, filters):+ """+ Delete graph entities associated with the given memory text.++ Extracts entities and relationships from the memory text using the same+ pipeline as add(), then soft-deletes the matching relationships in the graph.++ Args:+ data (str): The memory text whose graph entities should be removed.+ filters (dict): Scope filters (user_id, agent_id, run_id).+ """+ try:+ entity_type_map = self._retrieve_nodes_from_data(data, filters)+ if not entity_type_map:+ logger.debug("No entities found in memory text, skipping graph cleanup")+ return+ to_be_deleted = self._establish_nodes_relations_from_data(data, filters, entity_type_map)+ if to_be_deleted:+ self._delete_entities(to_be_deleted, filters)+ except Exception as e:+ logger.error(f"Error during graph cleanup for memory delete: {e}")+def delete_all(self, filters):# Build node properties for filteringnode_props = ["user_id: $user_id"]diff --git a/mem0/memory/kuzu_memory.py b/mem0/memory/kuzu_memory.pyindex a025aec36..1ed769fb4 100644--- a/mem0/memory/kuzu_memory.py+++ b/mem0/memory/kuzu_memory.py@@ -149,6 +149,28 @@ class MemoryGraph:return search_results+ def delete(self, data, filters):+ """+ Delete graph entities associated with the given memory text.++ Extracts entities and relationships from the memory text using the same+ pipeline as add(), then deletes the matching relationships in the graph.++ Args:+ data (str): The memory text whose graph entities should be removed.+ filters (dict): Scope filters (user_id, agent_id, run_id).+ """+ try:+ entity_type_map = self._retrieve_nodes_from_data(data, filters)+ if not entity_type_map:+ logger.debug("No entities found in memory text, skipping graph cleanup")+ return+ to_be_deleted = self._establish_nodes_relations_from_data(data, filters, entity_type_map)+ if to_be_deleted:+ self._delete_entities(to_be_deleted, filters)+ except Exception as e:+ logger.error(f"Error during graph cleanup for memory delete: {e}")+def delete_all(self, filters):# Build node properties for filteringnode_props = ["user_id: $user_id"]diff --git a/mem0/memory/main.py b/mem0/memory/main.pyindex 84b760790..c9b67c75c 100644--- a/mem0/memory/main.py+++ b/mem0/memory/main.py@@ -1101,7 +1101,27 @@ class Memory(MemoryBase):memory_id (str): ID of the memory to delete."""capture_event("mem0.delete", self, {"memory_id": memory_id, "sync_type": "sync"})- self._delete_memory(memory_id)++ existing_memory = self.vector_store.get(vector_id=memory_id)+ if existing_memory is None:+ raise ValueError(f"Memory with id {memory_id} not found")++ # Clean up graph entities before deleting from vector store+ if self.enable_graph:+ try:+ memory_text = existing_memory.payload.get("data", "")+ if memory_text:+ filters = {}+ for key in ("user_id", "agent_id", "run_id"):+ val = existing_memory.payload.get(key)+ if val:+ filters[key] = val+ if filters.get("user_id"):+ self.graph.delete(memory_text, filters)+ except Exception as e:+ logger.error(f"Error cleaning up graph for memory {memory_id}: {e}")++ self._delete_memory(memory_id, existing_memory)return {"message": "Memory deleted successfully!"}def delete_all(self, user_id: Optional[str] = None, agent_id: Optional[str] = None, run_id: Optional[str] = None):@@ -1277,11 +1297,12 @@ class Memory(MemoryBase):)return memory_id- def _delete_memory(self, memory_id):+ def _delete_memory(self, memory_id, existing_memory=None):logger.info(f"Deleting memory with {memory_id=}")- existing_memory = self.vector_store.get(vector_id=memory_id)if existing_memory is None:- raise ValueError(f"Memory with id {memory_id} not found")+ existing_memory = self.vector_store.get(vector_id=memory_id)+ if existing_memory is None:+ raise ValueError(f"Memory with id {memory_id} not found")prev_value = existing_memory.payload.get("data", "")self.vector_store.delete(vector_id=memory_id)self.db.add_history(@@ -2174,7 +2195,27 @@ class AsyncMemory(MemoryBase):memory_id (str): ID of the memory to delete."""capture_event("mem0.delete", self, {"memory_id": memory_id, "sync_type": "async"})- await self._delete_memory(memory_id)++ existing_memory = await asyncio.to_thread(self.vector_store.get, vector_id=memory_id)+ if existing_memory is None:+ raise ValueError(f"Memory with id {memory_id} not found")++ # Clean up graph entities before deleting from vector store+ if self.enable_graph:+ try:+ memory_text = existing_memory.payload.get("data", "")+ if memory_text:+ filters = {}+ for key in ("user_id", "agent_id", "run_id"):+ val = existing_memory.payload.get(key)+ if val:+ filters[key] = val+ if filters.get("user_id"):+ await asyncio.to_thread(self.graph.delete, memory_text, filters)+ except Exception as e:+ logger.error(f"Error cleaning up graph for memory {memory_id}: {e}")++ await self._delete_memory(memory_id, existing_memory)return {"message": "Memory deleted successfully!"}async def delete_all(self, user_id=None, agent_id=None, run_id=None):@@ -2375,11 +2416,12 @@ class AsyncMemory(MemoryBase):)return memory_id- async def _delete_memory(self, memory_id):+ async def _delete_memory(self, memory_id, existing_memory=None):logger.info(f"Deleting memory with {memory_id=}")- existing_memory = await asyncio.to_thread(self.vector_store.get, vector_id=memory_id)if existing_memory is None:- raise ValueError(f"Memory with id {memory_id} not found")+ existing_memory = await asyncio.to_thread(self.vector_store.get, vector_id=memory_id)+ if existing_memory is None:+ raise ValueError(f"Memory with id {memory_id} not found")prev_value = existing_memory.payload.get("data", "")await asyncio.to_thread(self.vector_store.delete, vector_id=memory_id)diff --git a/mem0/memory/memgraph_memory.py b/mem0/memory/memgraph_memory.pyindex 84b6d0ca8..c7f52ad79 100644--- a/mem0/memory/memgraph_memory.py+++ b/mem0/memory/memgraph_memory.py@@ -134,6 +134,28 @@ class MemoryGraph:return search_results+ def delete(self, data, filters):+ """+ Delete graph entities associated with the given memory text.++ Extracts entities and relationships from the memory text using the same+ pipeline as add(), then deletes the matching relationships in the graph.++ Args:+ data (str): The memory text whose graph entities should be removed.+ filters (dict): Scope filters (user_id, agent_id).+ """+ try:+ entity_type_map = self._retrieve_nodes_from_data(data, filters)+ if not entity_type_map:+ logger.debug("No entities found in memory text, skipping graph cleanup")+ return+ to_be_deleted = self._establish_nodes_relations_from_data(data, filters, entity_type_map)+ if to_be_deleted:+ self._delete_entities(to_be_deleted, filters)+ except Exception as e:+ logger.error(f"Error during graph cleanup for memory delete: {e}")+def delete_all(self, filters):"""Delete all nodes and relationships for a user or specific agent."""if filters.get("agent_id"):diff --git a/tests/test_graph_delete.py b/tests/test_graph_delete.pynew file mode 100644index 000000000..a54d6d4f6--- /dev/null+++ b/tests/test_graph_delete.py@@ -0,0 +1,517 @@+"""Tests for graph cleanup on memory deletion (issue #3245)."""++from unittest.mock import MagicMock, patch++import pytest++from mem0.configs.base import MemoryConfig+++class MockVectorMemory:+ def __init__(self, memory_id, payload, score=0.8):+ self.id = memory_id+ self.payload = payload+ self.score = score+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+def test_delete_calls_graph_cleanup_when_graph_enabled(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """When graph is enabled, delete() should call graph.delete() with memory text and filters."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ # Enable graph with a mock+ memory.enable_graph = True+ memory.graph = MagicMock()++ # Set up vector store to return a memory with graph-relevant data+ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1",+ {+ "data": "Alice likes Bob",+ "user_id": "user-1",+ "agent_id": "agent-1",+ "hash": "abc",+ },+ )++ memory.delete("mem-1")++ # graph.delete should have been called with the memory text and filters+ memory.graph.delete.assert_called_once_with(+ "Alice likes Bob", {"user_id": "user-1", "agent_id": "agent-1"}+ )++ # _delete_memory should still have been called (vector store + history cleanup)+ mock_vector_store.delete.assert_called_once_with(vector_id="mem-1")+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+def test_delete_skips_graph_when_not_enabled(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """When graph is not enabled, delete() should not attempt graph cleanup."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ assert memory.enable_graph is False++ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1", {"data": "Alice likes Bob", "user_id": "user-1", "hash": "abc"}+ )++ result = memory.delete("mem-1")++ assert result == {"message": "Memory deleted successfully!"}+ mock_vector_store.delete.assert_called_once_with(vector_id="mem-1")+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+def test_delete_continues_if_graph_cleanup_fails(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """If graph cleanup raises an exception, delete() should still succeed."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()+ memory.graph.delete.side_effect = RuntimeError("Neo4j connection lost")++ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1", {"data": "Alice likes Bob", "user_id": "user-1", "hash": "abc"}+ )++ # Should not raise+ result = memory.delete("mem-1")+ assert result == {"message": "Memory deleted successfully!"}++ # Vector store deletion should still proceed+ mock_vector_store.delete.assert_called_once_with(vector_id="mem-1")+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+def test_delete_skips_graph_when_no_user_id(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """Graph cleanup should be skipped if the memory has no user_id."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()++ # Memory with no user_id+ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1", {"data": "Some data", "hash": "abc"}+ )++ memory.delete("mem-1")++ # graph.delete should NOT have been called since there's no user_id+ memory.graph.delete.assert_not_called()+ mock_vector_store.delete.assert_called_once_with(vector_id="mem-1")+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+def test_delete_skips_graph_when_no_memory_text(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """Graph cleanup should be skipped if the memory has no text data."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()++ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1", {"user_id": "user-1", "hash": "abc"}+ )++ memory.delete("mem-1")++ memory.graph.delete.assert_not_called()+ mock_vector_store.delete.assert_called_once_with(vector_id="mem-1")+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+def test_delete_passes_all_filters_to_graph(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """Graph cleanup should include all available filters (user_id, agent_id, run_id)."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()++ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1",+ {+ "data": "Alice likes Bob",+ "user_id": "user-1",+ "agent_id": "agent-1",+ "run_id": "run-1",+ "hash": "abc",+ },+ )++ memory.delete("mem-1")++ memory.graph.delete.assert_called_once_with(+ "Alice likes Bob",+ {"user_id": "user-1", "agent_id": "agent-1", "run_id": "run-1"},+ )+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+async def test_async_delete_calls_graph_cleanup(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """Async delete() should also perform graph cleanup."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import AsyncMemory++ config = MemoryConfig()+ memory = AsyncMemory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()++ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1",+ {+ "data": "Alice likes Bob",+ "user_id": "user-1",+ "hash": "abc",+ },+ )++ result = await memory.delete("mem-1")++ assert result == {"message": "Memory deleted successfully!"}+ memory.graph.delete.assert_called_once_with("Alice likes Bob", {"user_id": "user-1"})+ mock_vector_store.delete.assert_called_once_with(vector_id="mem-1")+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+async def test_async_delete_continues_if_graph_cleanup_fails(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """Async delete() should continue even if graph cleanup fails."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import AsyncMemory++ config = MemoryConfig()+ memory = AsyncMemory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()+ memory.graph.delete.side_effect = RuntimeError("Graph error")++ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1", {"data": "Alice likes Bob", "user_id": "user-1", "hash": "abc"}+ )++ result = await memory.delete("mem-1")+ assert result == {"message": "Memory deleted successfully!"}+ mock_vector_store.delete.assert_called_once_with(vector_id="mem-1")+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+def test_delete_raises_for_nonexistent_memory_with_graph_enabled(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """delete() should raise ValueError for non-existent memory even with graph enabled."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()++ mock_vector_store.get.return_value = None++ with pytest.raises(ValueError, match="Memory with id non-existent not found"):+ memory.delete("non-existent")++ memory.graph.delete.assert_not_called()+ mock_vector_store.delete.assert_not_called()+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+async def test_async_delete_raises_for_nonexistent_memory_with_graph_enabled(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """Async delete() should raise ValueError for non-existent memory even with graph enabled."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_store.get.return_value = None+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import AsyncMemory++ config = MemoryConfig()+ memory = AsyncMemory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()++ with pytest.raises(ValueError, match="Memory with id non-existent not found"):+ await memory.delete("non-existent")++ memory.graph.delete.assert_not_called()+ mock_vector_store.delete.assert_not_called()+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+def test_delete_all_does_not_trigger_per_memory_graph_cleanup(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """delete_all() should use graph.delete_all(), not per-memory graph.delete()."""+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()++ mem1 = MockVectorMemory("mem-1", {"data": "Alice likes Bob", "user_id": "user-1"})+ mem2 = MockVectorMemory("mem-2", {"data": "Bob likes Charlie", "user_id": "user-1"})+ mock_vector_store.list.return_value = ([mem1, mem2], 2)+ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1", {"data": "Alice likes Bob", "user_id": "user-1"}+ )++ memory.delete_all(user_id="user-1")++ # graph.delete (per-memory) should NOT be called+ memory.graph.delete.assert_not_called()+ # graph.delete_all (bulk) SHOULD be called+ memory.graph.delete_all.assert_called_once_with({"user_id": "user-1"})+++@patch("mem0.utils.factory.EmbedderFactory.create")+@patch("mem0.utils.factory.VectorStoreFactory.create")+@patch("mem0.utils.factory.LlmFactory.create")+@patch("mem0.memory.storage.SQLiteManager")+def test_internal_delete_memory_does_not_trigger_graph_cleanup(+ mock_sqlite, mock_llm_factory, mock_vector_factory, mock_embedder_factory+):+ """_delete_memory() should NOT call graph.delete() — only the public delete() does.++ This ensures that the DELETE branch inside _add_to_vector_store() (which calls+ _delete_memory directly) does not interfere with the parallel graph pipeline+ running in _add_to_graph().+ """+ mock_embedder_factory.return_value = MagicMock()+ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store+ mock_llm_factory.return_value = MagicMock()+ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ memory.enable_graph = True+ memory.graph = MagicMock()++ mock_vector_store.get.return_value = MockVectorMemory(+ "mem-1", {"data": "Alice likes Bob", "user_id": "user-1", "hash": "abc"}+ )++ # Call _delete_memory directly (as _add_to_vector_store does for DELETE events)+ memory._delete_memory("mem-1")++ # graph.delete should NOT have been called — graph cleanup is only in delete()+ memory.graph.delete.assert_not_called()+ # But vector store deletion should proceed+ mock_vector_store.delete.assert_called_once_with(vector_id="mem-1")+++def test_graph_memory_delete_calls_internal_methods():+ """Test that MemoryGraph.delete() calls the expected internal pipeline methods."""+ from unittest.mock import patch as _patch++ # We need to mock the Neo4j import+ with _patch.dict("sys.modules", {"langchain_neo4j": MagicMock(), "rank_bm25": MagicMock()}):+ from mem0.memory.graph_memory import MemoryGraph++ with _patch.object(MemoryGraph, "__init__", return_value=None):+ graph = MemoryGraph.__new__(MemoryGraph)++ # Mock the internal methods+ graph._retrieve_nodes_from_data = MagicMock(+ return_value={"alice": "person", "bob": "person"}+ )+ graph._establish_nodes_relations_from_data = MagicMock(+ return_value=[+ {"source": "alice", "destination": "bob", "relationship": "likes"}+ ]+ )+ graph._delete_entities = MagicMock(return_value=[])++ filters = {"user_id": "user-1"}+ graph.delete("Alice likes Bob", filters)++ graph._retrieve_nodes_from_data.assert_called_once_with("Alice likes Bob", filters)+ graph._establish_nodes_relations_from_data.assert_called_once_with(+ "Alice likes Bob", filters, {"alice": "person", "bob": "person"}+ )+ graph._delete_entities.assert_called_once_with(+ [{"source": "alice", "destination": "bob", "relationship": "likes"}],+ filters,+ )+++def test_graph_memory_delete_skips_when_no_entities():+ """Test that MemoryGraph.delete() does nothing when no entities are extracted."""+ from unittest.mock import patch as _patch++ with _patch.dict("sys.modules", {"langchain_neo4j": MagicMock(), "rank_bm25": MagicMock()}):+ from mem0.memory.graph_memory import MemoryGraph++ with _patch.object(MemoryGraph, "__init__", return_value=None):+ graph = MemoryGraph.__new__(MemoryGraph)++ graph._retrieve_nodes_from_data = MagicMock(return_value={})+ graph._establish_nodes_relations_from_data = MagicMock()+ graph._delete_entities = MagicMock()++ graph.delete("Some text", {"user_id": "user-1"})++ graph._retrieve_nodes_from_data.assert_called_once()+ graph._establish_nodes_relations_from_data.assert_not_called()+ graph._delete_entities.assert_not_called()+++def test_graph_memory_delete_handles_exception():+ """Test that MemoryGraph.delete() catches exceptions without raising."""+ from unittest.mock import patch as _patch++ with _patch.dict("sys.modules", {"langchain_neo4j": MagicMock(), "rank_bm25": MagicMock()}):+ from mem0.memory.graph_memory import MemoryGraph++ with _patch.object(MemoryGraph, "__init__", return_value=None):+ graph = MemoryGraph.__new__(MemoryGraph)++ graph._retrieve_nodes_from_data = MagicMock(+ side_effect=RuntimeError("LLM error")+ )++ # Should not raise+ graph.delete("Some text", {"user_id": "user-1"})diff --git a/tests/test_graph_delete_docker.py b/tests/test_graph_delete_docker.pynew file mode 100644index 000000000..091f32c22--- /dev/null+++ b/tests/test_graph_delete_docker.py@@ -0,0 +1,821 @@+"""+End-to-end tests for graph cleanup on memory deletion against real+Neo4j, Memgraph, and Apache AGE instances running in Docker.++Requires:+ docker run -d --name mem0-neo4j-test -p 7687:7687 -e NEO4J_AUTH=neo4j/testpassword neo4j:5.23+ docker run -d --name mem0-memgraph-test -p 7688:7687 memgraph/memgraph:latest+ docker run -d --name mem0-age-test -p 5432:5432 -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=testpassword -e POSTGRES_DB=testdb apache/age:latest++Tests are skipped automatically if the databases or required Python+packages are not available.+"""++import hashlib+import sys+import warnings+from unittest.mock import MagicMock++import pytest++warnings.filterwarnings("ignore")++EMBEDDING_DIMS = 64++# ---------------------------------------------------------------------------+# Deterministic embedding helper (shared across backends)+# ---------------------------------------------------------------------------+++def _make_deterministic_embedder():+ cache = {}+ counter = [0]++ def embed(text, *args, **kwargs):+ t = text.lower().strip()+ if t not in cache:+ vec = [0.0] * EMBEDDING_DIMS+ idx = counter[0] % EMBEDDING_DIMS+ vec[idx] = 1.0+ h = hashlib.sha256(t.encode()).digest()+ for i in range(EMBEDDING_DIMS):+ vec[i] += float(h[i % len(h)]) / 25500.0+ norm = sum(v * v for v in vec) ** 0.5+ cache[t] = [v / norm for v in vec]+ counter[0] += 1+ return cache[t]++ mock = MagicMock()+ mock.embed.side_effect = embed+ mock.config.embedding_dims = EMBEDDING_DIMS+ return mock+++def _make_mock_llm(entities, relations):+ """Create an LLM mock that returns specific entities and relations."""+ mock = MagicMock()++ def generate_response(messages, tools):+ tool_names = []+ for t in tools:+ if isinstance(t, dict):+ fn = t.get("function", t)+ tool_names.append(fn.get("name", ""))+ else:+ tool_names.append(getattr(t, "name", str(t)))++ if any("extract_entities" in n for n in tool_names):+ return {+ "tool_calls": [+ {"name": "extract_entities", "arguments": {"entities": entities}}+ ]+ }+ elif any("establish" in n or "relation" in n for n in tool_names):+ return {+ "tool_calls": [+ {"name": "establish_nodes_relations", "arguments": {"entities": relations}}+ ]+ }+ elif any("delete" in n for n in tool_names):+ return {"tool_calls": []}+ return {"tool_calls": []}++ mock.generate_response.side_effect = generate_response+ return mock+++# ===========================================================================+# NEO4J+# ===========================================================================+++def _port_open(host, port, timeout=1):+ """Quick TCP check — avoids slow driver-level timeouts."""+ import socket++ try:+ with socket.create_connection((host, port), timeout=timeout):+ return True+ except OSError:+ return False+++def _neo4j_available():+ if not _port_open("localhost", 7687):+ return False+ try:+ from langchain_neo4j import Neo4jGraph++ g = Neo4jGraph(+ url="bolt://localhost:7687",+ username="neo4j",+ password="testpassword",+ refresh_schema=False,+ driver_config={"notifications_min_severity": "OFF"},+ )+ g.query("RETURN 1")+ return True+ except Exception:+ return False+++requires_neo4j = pytest.mark.skipif(not _neo4j_available(), reason="Neo4j not available")+++def neo4j_graph():+ """Create a Neo4j-backed MemoryGraph with mocked LLM/embedder."""+ from langchain_neo4j import Neo4jGraph+ from mem0.memory.graph_memory import MemoryGraph++ mg = MemoryGraph.__new__(MemoryGraph)+ mg.graph = Neo4jGraph(+ url="bolt://localhost:7687",+ username="neo4j",+ password="testpassword",+ refresh_schema=False,+ driver_config={"notifications_min_severity": "OFF"},+ )+ mg.graph.query("MATCH (n) DETACH DELETE n")++ mg.node_label = ":`__Entity__`"+ mg.llm_provider = "openai"+ mg.user_id = None+ mg.threshold = 0.99+ mg.embedding_model = _make_deterministic_embedder()+ mg.llm = MagicMock()+ mg.config = MagicMock()+ mg.config.graph_store.custom_prompt = None+ mg.config.graph_store.config.base_label = True++ yield mg++ mg.graph.query("MATCH (n) DETACH DELETE n")+++@requires_neo4j+class TestNeo4jDeleteE2E:+ def _node_count(self, mg):+ return mg.graph.query("MATCH (n) RETURN count(n) AS cnt")[0]["cnt"]++ def _valid_edge_count(self, mg):+ return mg.graph.query(+ "MATCH ()-[r]->() WHERE r.valid IS NULL OR r.valid = true RETURN count(r) AS cnt"+ )[0]["cnt"]++ def _invalid_edge_count(self, mg):+ return mg.graph.query(+ "MATCH ()-[r]->() WHERE r.valid = false RETURN count(r) AS cnt"+ )[0]["cnt"]++ def test_add_creates_graph_data(self, neo4j_graph):+ mg = neo4j_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._node_count(mg) == 2+ assert self._valid_edge_count(mg) == 1++ def test_delete_soft_deletes_relationships(self, neo4j_graph):+ """Neo4j delete() should set r.valid=false (soft-delete), not hard-delete."""+ mg = neo4j_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._valid_edge_count(mg) == 1+ assert self._invalid_edge_count(mg) == 0++ mg.delete("Alice likes Bob", {"user_id": "u1"})++ assert self._valid_edge_count(mg) == 0+ assert self._invalid_edge_count(mg) == 1 # soft-deleted, not removed+ assert self._node_count(mg) == 2 # nodes preserved++ def test_delete_preserves_other_relationships(self, neo4j_graph):+ mg = neo4j_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})++ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Charlie", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Charlie", "relationship": "knows"}],+ )+ mg.add("Alice knows Charlie", {"user_id": "u1"})+ assert self._valid_edge_count(mg) == 2++ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.delete("Alice likes Bob", {"user_id": "u1"})++ assert self._valid_edge_count(mg) == 1+ assert self._invalid_edge_count(mg) == 1++ def test_delete_user_isolation(self, neo4j_graph):+ mg = neo4j_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ mg.add("Alice likes Bob", {"user_id": "u2"})+ assert self._valid_edge_count(mg) == 2++ mg.delete("Alice likes Bob", {"user_id": "u1"})+ assert self._valid_edge_count(mg) == 1++ def test_delete_all_hard_deletes(self, neo4j_graph):+ mg = neo4j_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._node_count(mg) == 2++ mg.delete_all({"user_id": "u1"})+ assert self._node_count(mg) == 0++ def test_add_delete_add_cycle(self, neo4j_graph):+ mg = neo4j_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )++ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._valid_edge_count(mg) == 1++ mg.delete("Alice likes Bob", {"user_id": "u1"})+ assert self._valid_edge_count(mg) == 0++ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._valid_edge_count(mg) == 1+++# ===========================================================================+# MEMGRAPH+# ===========================================================================+++def _memgraph_available():+ if not _port_open("localhost", 7688):+ return False+ try:+ from langchain_memgraph.graphs.memgraph import Memgraph++ g = Memgraph("bolt://localhost:7688", "memgraph", "memgraph")+ g.query("RETURN 1")+ return True+ except Exception:+ return False+++requires_memgraph = pytest.mark.skipif(+ not _memgraph_available(), reason="Memgraph not available"+)+++def memgraph_graph():+ """Create a Memgraph-backed MemoryGraph with mocked LLM/embedder."""+ from langchain_memgraph.graphs.memgraph import Memgraph+ from mem0.memory.memgraph_memory import MemoryGraph++ mg = MemoryGraph.__new__(MemoryGraph)+ mg.graph = Memgraph("bolt://localhost:7688", "memgraph", "memgraph")+ mg.graph.query("MATCH (n) DETACH DELETE n")++ try:+ mg.graph.query("DROP VECTOR INDEX memzero;")+ except Exception:+ pass+ mg.graph.query(+ f"CREATE VECTOR INDEX memzero ON :Entity(embedding) "+ f"WITH CONFIG {{'dimension': {EMBEDDING_DIMS}, 'capacity': 1000, 'metric': 'cos'}};"+ )+ try:+ mg.graph.query("CREATE INDEX ON :Entity(user_id);")+ except Exception:+ pass+ try:+ mg.graph.query("CREATE INDEX ON :Entity;")+ except Exception:+ pass++ mg.llm_provider = "openai"+ mg.user_id = None+ mg.threshold = 0.99+ mg.embedding_model = _make_deterministic_embedder()+ mg.llm = MagicMock()+ mg.config = MagicMock()+ mg.config.graph_store.custom_prompt = None+ mg.config.embedder.config = {"embedding_dims": EMBEDDING_DIMS}++ yield mg++ mg.graph.query("MATCH (n) DETACH DELETE n")+++@requires_memgraph+class TestMemgraphDeleteE2E:+ def _node_count(self, mg):+ return mg.graph.query("MATCH (n:Entity) RETURN count(n) AS cnt")[0]["cnt"]++ def _edge_count(self, mg):+ return mg.graph.query("MATCH ()-[r]->() RETURN count(r) AS cnt")[0]["cnt"]++ def test_add_creates_graph_data(self, memgraph_graph):+ mg = memgraph_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._node_count(mg) == 2+ assert self._edge_count(mg) == 1++ def test_delete_hard_deletes_relationships(self, memgraph_graph):+ """Memgraph delete() should hard-delete the relationship (DELETE r)."""+ mg = memgraph_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._edge_count(mg) == 1++ mg.delete("Alice likes Bob", {"user_id": "u1"})++ assert self._edge_count(mg) == 0+ assert self._node_count(mg) == 2++ def test_delete_preserves_other_relationships(self, memgraph_graph):+ mg = memgraph_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})++ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Charlie", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Charlie", "relationship": "knows"}],+ )+ mg.add("Alice knows Charlie", {"user_id": "u1"})+ assert self._edge_count(mg) == 2++ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.delete("Alice likes Bob", {"user_id": "u1"})++ assert self._edge_count(mg) == 1++ def test_delete_user_isolation(self, memgraph_graph):+ mg = memgraph_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ mg.add("Alice likes Bob", {"user_id": "u2"})+ assert self._edge_count(mg) == 2++ mg.delete("Alice likes Bob", {"user_id": "u1"})+ assert self._edge_count(mg) == 1++ def test_delete_all_hard_deletes(self, memgraph_graph):+ mg = memgraph_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._node_count(mg) == 2++ mg.delete_all({"user_id": "u1"})+ assert self._node_count(mg) == 0+ assert self._edge_count(mg) == 0++ def test_add_delete_add_cycle(self, memgraph_graph):+ mg = memgraph_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._edge_count(mg) == 1++ mg.delete("Alice likes Bob", {"user_id": "u1"})+ assert self._edge_count(mg) == 0++ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert self._edge_count(mg) == 1+++# ===========================================================================+# APACHE AGE+# ===========================================================================+++def _age_available():+ if not _port_open("localhost", 5432):+ return False+ try:+ import age++ ag = age.connect(+ host="localhost",+ port=5432,+ dbname="testdb",+ user="postgres",+ password="testpassword",+ )+ with ag.connection.cursor() as cur:+ cur.execute("CREATE EXTENSION IF NOT EXISTS age;")+ cur.execute("SET search_path = ag_catalog, '$user', public;")+ ag.connection.commit()+ ag.close()+ return True+ except Exception:+ return False+++requires_age = pytest.mark.skipif(not _age_available(), reason="Apache AGE not available")+++def age_graph():+ """Create an Apache AGE-backed MemoryGraph with mocked LLM/embedder."""+ import age++ from mem0.memory.apache_age_memory import MemoryGraph++ graph_name = "mem0_test_delete"++ ag = age.connect(+ graph=graph_name,+ host="localhost",+ port=5432,+ dbname="testdb",+ user="postgres",+ password="testpassword",+ )+ with ag.connection.cursor() as cur:+ cur.execute("CREATE EXTENSION IF NOT EXISTS age;")+ cur.execute("SET search_path = ag_catalog, '$user', public;")+ ag.connection.commit()+ age.setUpAge(ag.connection, graph_name)+ ag.connection.commit()++ mg = MemoryGraph.__new__(MemoryGraph)+ mg.ag = ag+ mg.graph_name = graph_name+ mg.llm_provider = "openai"+ mg.user_id = None+ mg.threshold = 0.99+ mg.embedding_model = _make_deterministic_embedder()+ mg.llm = MagicMock()+ mg.config = MagicMock()+ mg.config.graph_store.custom_prompt = None++ try:+ ag.execCypher("MATCH (n) DETACH DELETE n")+ ag.commit()+ except Exception:+ ag.rollback()++ yield mg++ try:+ ag.execCypher("MATCH (n) DETACH DELETE n")+ ag.commit()+ except Exception:+ ag.rollback()+ ag.close()+++def _age_node_count(mg):+ cursor = mg.ag.execCypher("MATCH (n) RETURN count(n)", cols=["cnt"])+ rows = cursor.fetchall()+ return rows[0][0] if rows else 0+++def _age_edge_count(mg):+ cursor = mg.ag.execCypher("MATCH ()-[r]->() RETURN count(r)", cols=["cnt"])+ rows = cursor.fetchall()+ return rows[0][0] if rows else 0+++@requires_age+class TestApacheAgeDeleteE2E:++ def test_add_creates_graph_data(self, age_graph):+ mg = age_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert _age_node_count(mg) == 2+ assert _age_edge_count(mg) == 1++ def test_delete_hard_deletes_relationships(self, age_graph):+ """Apache AGE delete() should hard-delete the relationship."""+ mg = age_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert _age_edge_count(mg) == 1++ mg.delete("Alice likes Bob", {"user_id": "u1"})++ assert _age_edge_count(mg) == 0+ assert _age_node_count(mg) == 2++ def test_delete_preserves_other_relationships(self, age_graph):+ mg = age_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})++ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Charlie", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Charlie", "relationship": "knows"}],+ )+ mg.add("Alice knows Charlie", {"user_id": "u1"})+ assert _age_edge_count(mg) == 2++ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.delete("Alice likes Bob", {"user_id": "u1"})+ assert _age_edge_count(mg) == 1++ def test_delete_user_isolation(self, age_graph):+ mg = age_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ mg.add("Alice likes Bob", {"user_id": "u2"})+ assert _age_edge_count(mg) == 2++ mg.delete("Alice likes Bob", {"user_id": "u1"})+ assert _age_edge_count(mg) == 1++ def test_delete_all_hard_deletes(self, age_graph):+ mg = age_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert _age_node_count(mg) == 2++ mg.delete_all({"user_id": "u1"})+ assert _age_node_count(mg) == 0+ assert _age_edge_count(mg) == 0++ def test_add_delete_add_cycle(self, age_graph):+ mg = age_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert _age_edge_count(mg) == 1++ mg.delete("Alice likes Bob", {"user_id": "u1"})+ assert _age_edge_count(mg) == 0++ mg.add("Alice likes Bob", {"user_id": "u1"})+ assert _age_edge_count(mg) == 1+++# ===========================================================================+# NEPTUNE (tested via Neo4j OpenCypher — same query language)+# ===========================================================================+++def _neptune_test_available():+ """Neptune uses OpenCypher — we test NeptuneBase.delete() against Neo4j."""+ if not _port_open("localhost", 7687):+ return False+ try:+ # Mock langchain_aws so NeptuneBase can be imported without AWS deps+ sys.modules.setdefault("langchain_aws", MagicMock())+ sys.modules.setdefault("botocore", MagicMock())+ sys.modules.setdefault("botocore.config", MagicMock())++ from mem0.graphs.neptune.base import NeptuneBase # noqa: F401+ from langchain_neo4j import Neo4jGraph++ g = Neo4jGraph(+ url="bolt://localhost:7687",+ username="neo4j",+ password="testpassword",+ refresh_schema=False,+ driver_config={"notifications_min_severity": "OFF"},+ )+ g.query("RETURN 1")+ return True+ except Exception:+ return False+++requires_neptune_test = pytest.mark.skipif(+ not _neptune_test_available(),+ reason="Neo4j not available (used as OpenCypher backend for Neptune tests)",+)+++def _make_concrete_neptune_subclass():+ """Create a concrete NeptuneBase subclass for testing, backed by Neo4j."""+ # Ensure mocks are in place for import+ sys.modules.setdefault("langchain_aws", MagicMock())+ sys.modules.setdefault("botocore", MagicMock())+ sys.modules.setdefault("botocore.config", MagicMock())++ from mem0.graphs.neptune.base import NeptuneBase++ class TestableNeptune(NeptuneBase):+ def __init__(self):+ pass++ def _delete_entities_cypher(self, source, destination, relationship, user_id):+ cypher = f"""+ MATCH (n:`__Entity__` {{name: $source_name, user_id: $user_id}})+ -[r:{relationship}]->+ (m:`__Entity__` {{name: $dest_name, user_id: $user_id}})+ DELETE r+ RETURN n.name AS source, m.name AS target, type(r) AS relationship+ """+ return cypher, {"source_name": source, "dest_name": destination, "user_id": user_id}++ def _delete_all_cypher(self, filters):+ return (+ "MATCH (n:`__Entity__` {user_id: $user_id}) DETACH DELETE n",+ {"user_id": filters["user_id"]},+ )++ # Stubs for abstract methods not used in delete path+ def _add_entities_by_source_cypher(self, *a, **kw): pass+ def _add_entities_by_destination_cypher(self, *a, **kw): pass+ def _add_relationship_entities_cypher(self, *a, **kw): pass+ def _add_new_entities_cypher(self, *a, **kw): pass+ def _search_source_node_cypher(self, *a, **kw): pass+ def _search_destination_node_cypher(self, *a, **kw): pass+ def _get_all_cypher(self, *a, **kw): pass+ def _search_graph_db_cypher(self, *a, **kw): pass++ return TestableNeptune+++def neptune_graph():+ """NeptuneBase subclass backed by a real Neo4j container."""+ from langchain_neo4j import Neo4jGraph++ cls = _make_concrete_neptune_subclass()+ mg = cls()+ mg.graph = Neo4jGraph(+ url="bolt://localhost:7687",+ username="neo4j",+ password="testpassword",+ refresh_schema=False,+ driver_config={"notifications_min_severity": "OFF"},+ )+ mg.graph.query("MATCH (n) DETACH DELETE n")++ mg.node_label = ":`__Entity__`"+ mg.llm_provider = "openai"+ mg.user_id = None+ mg.threshold = 0.99+ mg.embedding_model = _make_deterministic_embedder()+ mg.llm = MagicMock()+ mg.config = MagicMock()+ mg.config.graph_store.custom_prompt = None++ yield mg++ mg.graph.query("MATCH (n) DETACH DELETE n")+++def _neptune_node_count(mg):+ return mg.graph.query("MATCH (n) RETURN count(n) AS cnt")[0]["cnt"]+++def _neptune_edge_count(mg):+ return mg.graph.query("MATCH ()-[r]->() RETURN count(r) AS cnt")[0]["cnt"]+++def _neptune_create_entities(mg, user_id):+ """Create test entities directly via Cypher."""+ mg.graph.query(f"""+ CREATE (a:`__Entity__` {{name: 'alice', user_id: '{user_id}'}})+ CREATE (b:`__Entity__` {{name: 'bob', user_id: '{user_id}'}})+ CREATE (a)-[:likes]->(b)+ """)+++@requires_neptune_test+class TestNeptuneDeleteE2E:+ """Test NeptuneBase.delete() using Neo4j as the OpenCypher backend.++ Neptune uses standard OpenCypher, the same query language as Neo4j.+ This validates that:+ - NeptuneBase.delete() correctly calls _delete_entities(to_be_deleted, user_id) with a string+ - The generated Cypher from _delete_entities_cypher runs correctly+ - User isolation works+ """++ def test_delete_removes_relationship(self, neptune_graph):+ mg = neptune_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ _neptune_create_entities(mg, "u1")+ assert _neptune_edge_count(mg) == 1++ mg.delete("Alice likes Bob", {"user_id": "u1"})++ assert _neptune_edge_count(mg) == 0+ assert _neptune_node_count(mg) == 2++ def test_delete_user_isolation(self, neptune_graph):+ mg = neptune_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ _neptune_create_entities(mg, "u1")+ _neptune_create_entities(mg, "u2")+ assert _neptune_edge_count(mg) == 2++ mg.delete("Alice likes Bob", {"user_id": "u1"})+ assert _neptune_edge_count(mg) == 1++ def test_delete_passes_user_id_string_not_dict(self, neptune_graph):+ """Verify NeptuneBase.delete() passes filters['user_id'] (string) to _delete_entities."""+ mg = neptune_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )++ original = mg._delete_entities+ call_args = []++ def spy(to_be_deleted, user_id):+ call_args.append(("to_be_deleted", to_be_deleted, "user_id", user_id))+ return original(to_be_deleted, user_id)++ mg._delete_entities = spy++ _neptune_create_entities(mg, "u1")+ mg.delete("Alice likes Bob", {"user_id": "u1"})++ assert len(call_args) == 1+ assert call_args[0][3] == "u1"+ assert isinstance(call_args[0][3], str)++ def test_delete_all(self, neptune_graph):+ mg = neptune_graph+ _neptune_create_entities(mg, "u1")+ assert _neptune_node_count(mg) == 2++ mg.delete_all({"user_id": "u1"})+ assert _neptune_node_count(mg) == 0++ def test_add_delete_add_cycle(self, neptune_graph):+ mg = neptune_graph+ mg.llm = _make_mock_llm(+ [{"entity": "Alice", "entity_type": "person"}, {"entity": "Bob", "entity_type": "person"}],+ [{"source": "Alice", "destination": "Bob", "relationship": "likes"}],+ )+ _neptune_create_entities(mg, "u1")+ assert _neptune_edge_count(mg) == 1++ mg.delete("Alice likes Bob", {"user_id": "u1"})+ assert _neptune_edge_count(mg) == 0++ _neptune_create_entities(mg, "u1")+ assert _neptune_edge_count(mg) == 1diff --git a/tests/test_graph_delete_e2e.py b/tests/test_graph_delete_e2e.pynew file mode 100644index 000000000..0169d2ce0--- /dev/null+++ b/tests/test_graph_delete_e2e.py@@ -0,0 +1,736 @@+"""+End-to-end tests for graph cleanup on memory deletion (issue #3245).++Uses a real Kuzu embedded database to verify that graph entities are+correctly cleaned up when memories are deleted. LLM and embedding calls+are mocked to provide deterministic entity extraction.++Tests are skipped automatically if kuzu is not installed.+"""++import shutil+import tempfile+from unittest.mock import MagicMock, patch++import pytest++from mem0.configs.base import MemoryConfig++try:+ import kuzu # noqa: F401+ _kuzu_available = True+except ImportError:+ _kuzu_available = False++requires_kuzu = pytest.mark.skipif(not _kuzu_available, reason="kuzu is not installed")++# ---------------------------------------------------------------------------+# Helpers+# ---------------------------------------------------------------------------+++def _node_count(kuzu_graph):+ """Return total node count in the Kuzu graph."""+ result = kuzu_graph.execute("MATCH (n:Entity) RETURN count(n) AS cnt")+ rows = list(result.rows_as_dict())+ return int(rows[0]["cnt"])+++def _edge_count(kuzu_graph):+ """Return total edge count in the Kuzu graph."""+ result = kuzu_graph.execute("MATCH ()-[r:CONNECTED_TO]->() RETURN count(r) AS cnt")+ rows = list(result.rows_as_dict())+ return int(rows[0]["cnt"])+++def _get_edges(kuzu_graph):+ """Return all edges as list of (source, relationship, destination) tuples."""+ result = kuzu_graph.execute(+ "MATCH (s:Entity)-[r:CONNECTED_TO]->(d:Entity) "+ "RETURN s.name AS src, r.name AS rel, d.name AS dst"+ )+ return [(row["src"], row["rel"], row["dst"]) for row in result.rows_as_dict()]+++def _get_nodes(kuzu_graph):+ """Return all node names."""+ result = kuzu_graph.execute("MATCH (n:Entity) RETURN n.name AS name, n.user_id AS uid")+ return [(row["name"], row["uid"]) for row in result.rows_as_dict()]+++# ---------------------------------------------------------------------------+# Fixtures+# ---------------------------------------------------------------------------+++class MockVectorMemory:+ """Mimics the object returned by vector_store.get()."""++ def __init__(self, memory_id, payload, score=0.8):+ self.id = memory_id+ self.payload = payload+ self.score = score+++def kuzu_graph_memory():+ """+ Create a real Kuzu-backed MemoryGraph with mocked LLM and embedder.+ Yields (graph_memory_instance, kuzu_connection) then cleans up.+ """+ import os++ import kuzu++ tmpdir = tempfile.mkdtemp()+ db_path = os.path.join(tmpdir, "test.kuzu")+ db = kuzu.Database(db_path)+ conn = kuzu.Connection(db)++ # We'll construct the MemoryGraph by bypassing __init__ and setting up manually+ from mem0.memory.kuzu_memory import MemoryGraph++ mg = MemoryGraph.__new__(MemoryGraph)++ # Real Kuzu connection+ mg.db = db+ mg.graph = conn+ mg.node_label = ":Entity"+ mg.rel_label = ":CONNECTED_TO"+ mg.kuzu_create_schema()++ # Deterministic embedding: use one-hot-style vectors per entity name+ # to avoid accidental cosine similarity matches between different entities+ embedding_dims = 64+ mg.embedding_dims = embedding_dims++ _embed_cache = {}+ _embed_counter = [0]++ def deterministic_embed(text):+ """Generate a deterministic, near-orthogonal embedding for each unique text."""+ text_lower = text.lower().strip()+ if text_lower not in _embed_cache:+ # Create a sparse vector — set a unique dimension to 1.0+ vec = [0.0] * embedding_dims+ idx = _embed_counter[0] % embedding_dims+ vec[idx] = 1.0+ # Add small noise to other dims so it's not exactly zero+ import hashlib++ h = hashlib.sha256(text_lower.encode()).digest()+ for i in range(embedding_dims):+ vec[i] += float(h[i % len(h)]) / 25500.0 # tiny noise+ norm = sum(v * v for v in vec) ** 0.5+ _embed_cache[text_lower] = [v / norm for v in vec]+ _embed_counter[0] += 1+ return _embed_cache[text_lower]++ mock_embedder = MagicMock()+ mock_embedder.embed.side_effect = deterministic_embed+ mock_embedder.config.embedding_dims = embedding_dims+ mg.embedding_model = mock_embedder++ # Mock LLM — configured per-test via mock_embedder+ mg.llm = MagicMock()+ mg.llm_provider = "openai"+ mg.user_id = None+ # High threshold so only identical entity names merge, not similar ones+ mg.threshold = 0.99+ mg.config = MagicMock()+ mg.config.graph_store.custom_prompt = None++ yield mg, conn++ # Cleanup+ conn.close()+ shutil.rmtree(tmpdir, ignore_errors=True)+++def _setup_llm_for_entities(mg, entities, relations):+ """+ Configure the mock LLM to return specific entities and relations.++ entities: list of {"entity": str, "entity_type": str}+ relations: list of {"source": str, "destination": str, "relationship": str}+ """++ def generate_response(messages, tools):+ # Detect which tool is being called based on tool definition names+ tool_names = []+ for t in tools:+ if isinstance(t, dict):+ fn = t.get("function", t)+ tool_names.append(fn.get("name", ""))+ else:+ tool_names.append(getattr(t, "name", str(t)))++ if any("extract_entities" in n for n in tool_names):+ return {+ "tool_calls": [+ {+ "name": "extract_entities",+ "arguments": {"entities": entities},+ }+ ]+ }+ elif any("establish" in n or "relation" in n for n in tool_names):+ return {+ "tool_calls": [+ {+ "name": "establish_nodes_relations",+ "arguments": {"entities": relations},+ }+ ]+ }+ elif any("delete" in n for n in tool_names):+ # For _get_delete_entities_from_search_output during add() — return nothing to delete+ return {"tool_calls": []}+ return {"tool_calls": []}++ mg.llm.generate_response.side_effect = generate_response+++# ---------------------------------------------------------------------------+# End-to-end tests+# ---------------------------------------------------------------------------+++@requires_kuzu+class TestKuzuGraphDeleteE2E:+ """End-to-end tests using a real Kuzu database."""++ def test_add_creates_nodes_and_edges(self, kuzu_graph_memory):+ """Baseline: verify add() actually creates graph data."""+ mg, conn = kuzu_graph_memory++ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )++ filters = {"user_id": "test_user"}+ mg.add("Alice likes Bob", filters)++ assert _node_count(conn) == 2+ assert _edge_count(conn) == 1+ edges = _get_edges(conn)+ assert ("alice", "likes", "bob") in edges++ def test_delete_removes_edges_created_by_add(self, kuzu_graph_memory):+ """Core test: delete() should remove the relationships that add() created."""+ mg, conn = kuzu_graph_memory++ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )++ filters = {"user_id": "test_user"}+ mg.add("Alice likes Bob", filters)++ assert _edge_count(conn) == 1++ # Now delete using the same text — should remove the relationship+ mg.delete("Alice likes Bob", filters)++ assert _edge_count(conn) == 0+ # Nodes remain (we don't delete nodes on single memory delete)+ assert _node_count(conn) == 2++ def test_delete_only_removes_matching_edges(self, kuzu_graph_memory):+ """delete() should only remove edges matching the extracted relationships."""+ mg, conn = kuzu_graph_memory++ # First add: Alice likes Bob+ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )+ filters = {"user_id": "test_user"}+ mg.add("Alice likes Bob", filters)++ # Second add: Alice knows Charlie+ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Charlie", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Charlie", "relationship": "knows"},+ ],+ )+ mg.add("Alice knows Charlie", filters)++ assert _edge_count(conn) == 2++ # Delete only the "Alice likes Bob" memory+ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )+ mg.delete("Alice likes Bob", filters)++ assert _edge_count(conn) == 1+ edges = _get_edges(conn)+ assert ("alice", "knows", "charlie") in edges+ assert ("alice", "likes", "bob") not in edges++ def test_delete_with_different_user_id_does_not_affect_other_users(self, kuzu_graph_memory):+ """delete() scoped to user_id should not touch another user's graph data."""+ mg, conn = kuzu_graph_memory++ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )++ # Add for user1+ mg.add("Alice likes Bob", {"user_id": "user1"})+ # Add same data for user2+ mg.add("Alice likes Bob", {"user_id": "user2"})++ assert _edge_count(conn) == 2++ # Delete only user1's data+ mg.delete("Alice likes Bob", {"user_id": "user1"})++ assert _edge_count(conn) == 1+ # Remaining edge belongs to user2+ nodes = _get_nodes(conn)+ user2_nodes = [n for n in nodes if n[1] == "user2"]+ assert len(user2_nodes) == 2++ def test_delete_nonexistent_relationship_is_safe(self, kuzu_graph_memory):+ """delete() on data that doesn't exist in the graph should be a no-op."""+ mg, conn = kuzu_graph_memory++ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "hates"},+ ],+ )++ filters = {"user_id": "test_user"}++ # Nothing in the graph yet+ assert _edge_count(conn) == 0+ assert _node_count(conn) == 0++ # Should not raise+ mg.delete("Alice hates Bob", filters)++ assert _edge_count(conn) == 0+ assert _node_count(conn) == 0++ def test_delete_with_llm_failure_does_not_raise(self, kuzu_graph_memory):+ """If LLM fails during entity extraction, delete() should not raise."""+ mg, conn = kuzu_graph_memory++ # Make LLM raise+ mg.llm.generate_response.side_effect = RuntimeError("LLM service down")++ filters = {"user_id": "test_user"}++ # Should not raise+ mg.delete("Alice likes Bob", filters)++ def test_delete_with_empty_entity_extraction(self, kuzu_graph_memory):+ """If LLM returns no entities, delete() should be a no-op."""+ mg, conn = kuzu_graph_memory++ # Add real data+ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )+ filters = {"user_id": "test_user"}+ mg.add("Alice likes Bob", filters)+ assert _edge_count(conn) == 1++ # Now delete but LLM returns no entities+ _setup_llm_for_entities(mg, entities=[], relations=[])+ mg.delete("some text", filters)++ # Data should still be there+ assert _edge_count(conn) == 1++ def test_delete_all_removes_everything_for_user(self, kuzu_graph_memory):+ """delete_all() should remove all nodes/edges for a user (baseline behavior)."""+ mg, conn = kuzu_graph_memory++ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )+ filters = {"user_id": "test_user"}+ mg.add("Alice likes Bob", filters)++ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Bob", "entity_type": "person"},+ {"entity": "Charlie", "entity_type": "person"},+ ],+ relations=[+ {"source": "Bob", "destination": "Charlie", "relationship": "knows"},+ ],+ )+ mg.add("Bob knows Charlie", filters)++ assert _node_count(conn) >= 3+ assert _edge_count(conn) == 2++ mg.delete_all(filters)++ assert _node_count(conn) == 0+ assert _edge_count(conn) == 0++ def test_add_delete_add_cycle(self, kuzu_graph_memory):+ """Verify that add → delete → re-add works correctly."""+ mg, conn = kuzu_graph_memory++ _setup_llm_for_entities(+ mg,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )+ filters = {"user_id": "test_user"}++ # Add+ mg.add("Alice likes Bob", filters)+ assert _edge_count(conn) == 1++ # Delete+ mg.delete("Alice likes Bob", filters)+ assert _edge_count(conn) == 0++ # Re-add+ mg.add("Alice likes Bob", filters)+ assert _edge_count(conn) == 1+ edges = _get_edges(conn)+ assert ("alice", "likes", "bob") in edges+++@requires_kuzu+class TestMemoryDeleteWithGraphE2E:+ """+ End-to-end tests for Memory.delete() with graph enabled.++ Uses a real Kuzu database for the graph store and mocks for+ the vector store, LLM, and embedder.+ """++ @pytest.fixture+ def memory_with_graph(self):+ """Create a Memory instance with a real Kuzu graph backend."""+ import os++ import kuzu++ tmpdir = tempfile.mkdtemp()++ with (+ patch("mem0.utils.factory.EmbedderFactory.create") as mock_embedder_factory,+ patch("mem0.utils.factory.VectorStoreFactory.create") as mock_vector_factory,+ patch("mem0.utils.factory.LlmFactory.create") as mock_llm_factory,+ patch("mem0.memory.storage.SQLiteManager") as mock_sqlite,+ ):+ _mem_embed_cache = {}+ _mem_embed_counter = [0]++ def _mem_deterministic_embed(text, *args, **kwargs):+ text_lower = text.lower().strip()+ if text_lower not in _mem_embed_cache:+ import hashlib++ vec = [0.0] * 64+ idx = _mem_embed_counter[0] % 64+ vec[idx] = 1.0+ h = hashlib.sha256(text_lower.encode()).digest()+ for i in range(64):+ vec[i] += float(h[i % len(h)]) / 25500.0+ norm = sum(v * v for v in vec) ** 0.5+ _mem_embed_cache[text_lower] = [v / norm for v in vec]+ _mem_embed_counter[0] += 1+ return _mem_embed_cache[text_lower]++ mock_embedder = MagicMock()+ mock_embedder.embed.side_effect = _mem_deterministic_embed+ mock_embedder.config.embedding_dims = 64+ mock_embedder_factory.return_value = mock_embedder++ mock_vector_store = MagicMock()+ mock_vector_factory.return_value = mock_vector_store++ mock_llm = MagicMock()+ mock_llm_factory.return_value = mock_llm++ mock_sqlite.return_value = MagicMock()++ from mem0.memory.main import Memory++ config = MemoryConfig()+ memory = Memory(config)++ # Now wire up a real Kuzu graph+ db_path = os.path.join(tmpdir, "test.kuzu")+ db = kuzu.Database(db_path)+ conn = kuzu.Connection(db)++ from mem0.memory.kuzu_memory import MemoryGraph as KuzuMemoryGraph++ graph = KuzuMemoryGraph.__new__(KuzuMemoryGraph)+ graph.db = db+ graph.graph = conn+ graph.node_label = ":Entity"+ graph.rel_label = ":CONNECTED_TO"+ graph.kuzu_create_schema()+ graph.embedding_dims = 64+ graph.embedding_model = mock_embedder+ graph.llm = mock_llm+ graph.llm_provider = "openai"+ graph.user_id = None+ graph.threshold = 0.99+ graph.config = MagicMock()+ graph.config.graph_store.custom_prompt = None++ memory.graph = graph+ memory.enable_graph = True++ yield memory, mock_vector_store, mock_llm, conn++ conn.close()+ shutil.rmtree(tmpdir, ignore_errors=True)++ def test_memory_delete_triggers_graph_cleanup(self, memory_with_graph):+ """+ Full integration: Memory.delete() should clean up both vector store and graph.+ """+ memory, mock_vs, mock_llm, conn = memory_with_graph++ # 1. Manually add entities to the graph (simulating what add() would do)+ _setup_llm_for_memory_graph(+ mock_llm,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )+ memory.graph.add("Alice likes Bob", {"user_id": "user-1"})+ assert _edge_count(conn) == 1++ # 2. Set up mock vector store to return this memory+ mock_vs.get.return_value = MockVectorMemory(+ "mem-1",+ {"data": "Alice likes Bob", "user_id": "user-1", "hash": "abc"},+ )++ # 3. Delete the memory+ result = memory.delete("mem-1")++ assert result == {"message": "Memory deleted successfully!"}++ # 4. Verify graph was cleaned up+ assert _edge_count(conn) == 0++ # 5. Verify vector store was also cleaned up+ mock_vs.delete.assert_called_once_with(vector_id="mem-1")++ def test_memory_delete_with_graph_preserves_other_users_data(self, memory_with_graph):+ """Deleting user1's memory should not affect user2's graph data."""+ memory, mock_vs, mock_llm, conn = memory_with_graph++ _setup_llm_for_memory_graph(+ mock_llm,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )++ # Add data for two users+ memory.graph.add("Alice likes Bob", {"user_id": "user-1"})+ memory.graph.add("Alice likes Bob", {"user_id": "user-2"})+ assert _edge_count(conn) == 2++ # Delete only user-1's memory+ mock_vs.get.return_value = MockVectorMemory(+ "mem-1",+ {"data": "Alice likes Bob", "user_id": "user-1", "hash": "abc"},+ )+ memory.delete("mem-1")++ # user-2's data should be intact+ assert _edge_count(conn) == 1+ nodes = _get_nodes(conn)+ remaining_user_ids = set(uid for _, uid in nodes)+ assert "user-2" in remaining_user_ids++ def test_memory_delete_graph_failure_still_deletes_vector(self, memory_with_graph):+ """If graph cleanup fails, vector store deletion should still proceed."""+ memory, mock_vs, mock_llm, conn = memory_with_graph++ # Make LLM raise during entity extraction (graph cleanup will fail)+ mock_llm.generate_response.side_effect = RuntimeError("LLM exploded")++ mock_vs.get.return_value = MockVectorMemory(+ "mem-1",+ {"data": "Alice likes Bob", "user_id": "user-1", "hash": "abc"},+ )++ result = memory.delete("mem-1")++ assert result == {"message": "Memory deleted successfully!"}+ mock_vs.delete.assert_called_once_with(vector_id="mem-1")++ def test_memory_delete_all_uses_bulk_not_per_memory(self, memory_with_graph):+ """delete_all() should use delete_all() on graph, not per-memory delete()."""+ memory, mock_vs, mock_llm, conn = memory_with_graph++ _setup_llm_for_memory_graph(+ mock_llm,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )+ memory.graph.add("Alice likes Bob", {"user_id": "user-1"})+ assert _edge_count(conn) == 1++ # Set up vector store to return memories for deletion+ mem1 = MockVectorMemory("mem-1", {"data": "Alice likes Bob", "user_id": "user-1"})+ mock_vs.list.return_value = ([mem1], 1)+ mock_vs.get.return_value = mem1++ memory.delete_all(user_id="user-1")++ # After delete_all, graph should be empty (via graph.delete_all)+ assert _edge_count(conn) == 0+ assert _node_count(conn) == 0++ def test_memory_delete_nonexistent_raises_without_graph_side_effects(self, memory_with_graph):+ """Deleting a non-existent memory should raise ValueError without touching graph."""+ memory, mock_vs, mock_llm, conn = memory_with_graph++ # Add some graph data that should NOT be affected+ _setup_llm_for_memory_graph(+ mock_llm,+ entities=[+ {"entity": "Alice", "entity_type": "person"},+ {"entity": "Bob", "entity_type": "person"},+ ],+ relations=[+ {"source": "Alice", "destination": "Bob", "relationship": "likes"},+ ],+ )+ memory.graph.add("Alice likes Bob", {"user_id": "user-1"})+ assert _edge_count(conn) == 1++ # Memory doesn't exist in vector store+ mock_vs.get.return_value = None++ with pytest.raises(ValueError, match="Memory with id non-existent not found"):+ memory.delete("non-existent")++ # Graph data should be untouched+ assert _edge_count(conn) == 1+++def _setup_llm_for_memory_graph(mock_llm, entities, relations):+ """Configure mock LLM for the Memory-level graph operations."""++ def generate_response(messages, tools):+ tool_names = []+ for t in tools:+ if isinstance(t, dict):+ fn = t.get("function", t)+ tool_names.append(fn.get("name", ""))+ else:+ tool_names.append(getattr(t, "name", str(t)))++ if any("extract_entities" in n for n in tool_names):+ return {+ "tool_calls": [+ {+ "name": "extract_entities",+ "arguments": {"entities": entities},+ }+ ]+ }+ elif any("establish" in n or "relation" in n for n in tool_names):+ return {+ "tool_calls": [+ {+ "name": "establish_nodes_relations",+ "arguments": {"entities": relations},+ }+ ]+ }+ elif any("delete" in n for n in tool_names):+ return {"tool_calls": []}+ return {"tool_calls": []}++ mock_llm.generate_response.side_effect = generate_responsediff --git a/tests/test_main.py b/tests/test_main.pyindex e179f3715..96bcb77fc 100644--- a/tests/test_main.py+++ b/tests/test_main.py@@ -186,7 +186,9 @@ def test_delete(memory_instance):result = memory_instance.delete("test_id")- memory_instance._delete_memory.assert_called_once_with("test_id")+ # delete() now fetches the memory first and passes it to _delete_memory+ existing_memory = memory_instance.vector_store.get.return_value+ memory_instance._delete_memory.assert_called_once_with("test_id", existing_memory)assert result["message"] == "Memory deleted successfully!"