diff --git a/src/memos/graph_dbs/base.py b/src/memos/graph_dbs/base.py index bd2e9b166..20f93abde 100644 --- a/src/memos/graph_dbs/base.py +++ b/src/memos/graph_dbs/base.py @@ -374,3 +374,16 @@ def add_nodes_batch(self, nodes: list[dict[str, Any]], user_name: str | None = N - metadata: dict[str, Any] - Node metadata user_name: Optional user name (will use config default if not provided) """ + + def get_all_user_names(self) -> list[str]: + """ + List every tenant (user_name) that currently has data in the graph store. + + Default fallback for backends that do not support tenant enumeration: + returns only the configured default user_name (if any), preserving the + previous single-tenant behavior. Backends with tenant isolation (e.g. + Neo4j) override this with a real implementation. + """ + config = getattr(self, "config", None) + user_name = getattr(config, "user_name", None) + return [user_name] if isinstance(user_name, str) and user_name.strip() else [] diff --git a/src/memos/graph_dbs/neo4j.py b/src/memos/graph_dbs/neo4j.py index 56c3e08a0..be1427309 100644 --- a/src/memos/graph_dbs/neo4j.py +++ b/src/memos/graph_dbs/neo4j.py @@ -194,6 +194,38 @@ def node_not_exist(self, scope: str, user_name: str | None = None) -> int: ) return result.single() is None + def get_all_user_names(self) -> list[str]: + """List every tenant (user_name) that currently has Memory nodes. + + Used by the structure reorganizer to optimize all tenants instead of + only the configured default one. Falls back to the configured + ``user_name`` when the query fails or the graph has no named tenants, + so callers keep the previous single-tenant behavior. + """ + user_name = self.config.user_name + fallback = [user_name] if isinstance(user_name, str) and user_name.strip() else [] + if self.config.use_multi_db: + return fallback + try: + query = """ + MATCH (n:Memory) + WHERE n.user_name IS NOT NULL + RETURN DISTINCT n.user_name AS user_name + """ + with self.driver.session(database=self.db_name) as session: + result = session.run(query) + user_names = sorted( + { + record["user_name"] + for record in result + if isinstance(record["user_name"], str) and record["user_name"].strip() + } + ) + return user_names or fallback + except Exception as e: + logger.warning("[get_all_user_names] Failed to enumerate tenants: %s", e) + return fallback + def remove_oldest_memory( self, memory_type: str, keep_latest: int, user_name: str | None = None ) -> None: diff --git a/src/memos/memories/textual/tree_text_memory/organize/reorganizer.py b/src/memos/memories/textual/tree_text_memory/organize/reorganizer.py index b7fb6b1a0..eddbc7b8f 100644 --- a/src/memos/memories/textual/tree_text_memory/organize/reorganizer.py +++ b/src/memos/memories/textual/tree_text_memory/organize/reorganizer.py @@ -1,10 +1,12 @@ import json +import re import time import traceback from collections import defaultdict from concurrent.futures import as_completed from queue import PriorityQueue +from threading import Event from typing import Literal import numpy as np @@ -93,13 +95,14 @@ def __init__( self.is_reorganize = is_reorganize self._reorganize_needed = True + self._stop_scheduler = False + self._scheduler_stop_event = Event() + self._is_optimizing = {"LongTermMemory": False, "UserMemory": False} if self.is_reorganize: # ____ 1. For queue message driven thread ___________ self.thread = ContextThread(target=self._run_message_consumer_loop) self.thread.start() # ____ 2. For periodic structure optimization _______ - self._stop_scheduler = False - self._is_optimizing = {"LongTermMemory": False, "UserMemory": False} self.structure_optimizer_thread = ContextThread( target=self._run_structure_organizer_loop ) @@ -155,20 +158,66 @@ def _run_structure_organizer_loop(self): """ import schedule - schedule.every(100).seconds.do(self.optimize_structure, scope="LongTermMemory") - schedule.every(100).seconds.do(self.optimize_structure, scope="UserMemory") - + scheduler = schedule.Scheduler() + jobs = [ + scheduler.every(100).seconds.do(self._optimize_all_users, scope=scope) + for scope in ("LongTermMemory", "UserMemory") + ] logger.info("Structure optimizer schedule started.") - while not getattr(self, "_stop_scheduler", False): - if any(self._is_optimizing.values()): - time.sleep(1) - continue - if self._reorganize_needed: - logger.info("[Reorganizer] Triggering optimize_structure due to new nodes.") - self.optimize_structure(scope="LongTermMemory") - self.optimize_structure(scope="UserMemory") - self._reorganize_needed = False - time.sleep(30) + try: + while not self._stop_scheduler: + if not any(self._is_optimizing.values()): + if self._reorganize_needed: + # Clear before work so arrivals during optimization remain pending. + self._reorganize_needed = False + for job in jobs: + job.run() + else: + scheduler.run_pending() + self._scheduler_stop_event.wait(30) + finally: + scheduler.clear() + + def _optimize_all_users(self, scope: str, **kwargs) -> None: + """Optimize named tenants independently, with an explicit backend fallback.""" + config = getattr(self.graph_store, "config", None) + get_user_names = getattr(self.graph_store, "get_all_user_names", None) + try: + names = get_user_names() if callable(get_user_names) else [] + if isinstance(names, str): + names = [] + user_names = list( + dict.fromkeys( + name for name in names or [] if isinstance(name, str) and name.strip() + ) + ) + except Exception as exc: + logger.warning("Failed to enumerate graph tenants: %s", exc) + user_names = [] + + if not user_names: + default = getattr(config, "user_name", None) + if isinstance(default, str) and default.strip(): + user_names = [default] + elif getattr(config, "use_multi_db", False) is True: + # This backend's configured database is already the isolation boundary. + user_names = [None] + else: + logger.warning("Skipping graph optimization without a tenant scope") + return + + for user_name in user_names: + if self._stop_scheduler: + return + try: + self.optimize_structure(scope=scope, user_name=user_name, **kwargs) + except Exception: + logger.warning( + "Graph optimization failed for tenant %s, scope %s", + user_name, + scope, + exc_info=True, + ) def stop(self): """ @@ -177,10 +226,11 @@ def stop(self): if not self.is_reorganize: return + self._stop_scheduler = True + self._scheduler_stop_event.set() self.add_message(QueueMessage(op="end")) self.thread.join() logger.info("Reorganize thread stopped.") - self._stop_scheduler = True self.structure_optimizer_thread.join() logger.info("Structure optimizer stopped.") @@ -330,17 +380,20 @@ def _process_cluster_and_write( if len(sub_nodes) < min_cluster_size: continue # Skip tiny noise sub_parent_node = self._summarize_cluster(sub_nodes, scope) + if sub_parent_node is None: + continue # LLM output was not a valid JSON object; skip this sub-cluster self._create_parent_node(sub_parent_node, user_name=user_name) self._link_cluster_nodes(sub_parent_node, sub_nodes, user_name=user_name) sub_parents.append(sub_parent_node) if sub_parents and len(sub_parents) >= min_cluster_size: cluster_parent_node = self._summarize_cluster(cluster_nodes, scope) - self._create_parent_node(cluster_parent_node, user_name=user_name) - for sub_parent in sub_parents: - self.graph_store.add_edge( - cluster_parent_node.id, sub_parent.id, "PARENT", user_name=user_name - ) + if cluster_parent_node is not None: + self._create_parent_node(cluster_parent_node, user_name=user_name) + for sub_parent in sub_parents: + self.graph_store.add_edge( + cluster_parent_node.id, sub_parent.id, "PARENT", user_name=user_name + ) logger.info("Adding relations/reasons") nodes_to_check = cluster_nodes @@ -436,13 +489,25 @@ def _local_subcluster( messages = [{"role": "user", "content": prompt}] response_text = self.llm.generate(messages) response_json = self._parse_json_result(response_text) + if response_json is None: + logger.warning( + "[GraphStructureReorganize] Skip local sub-clustering: " + "LLM returned no valid JSON object." + ) + return [] assigned_ids = set() result_subclusters = [] - for cluster in response_json.get("clusters", []): + clusters = response_json.get("clusters", []) + if not isinstance(clusters, list): + return [] + known_ids = {node.id for node in cluster_nodes} + for cluster in clusters: + if not isinstance(cluster, dict) or not isinstance(cluster.get("ids"), list): + continue ids = [] - for nid in cluster.get("ids", []): - if nid not in assigned_ids: + for nid in cluster["ids"]: + if isinstance(nid, str) and nid in known_ids and nid not in assigned_ids: ids.append(nid) assigned_ids.add(nid) sub_nodes = [node for node in cluster_nodes if node.id in ids] @@ -547,9 +612,14 @@ def recursive_clustering(nodes_list, depth=0): return filtered_clusters - def _summarize_cluster(self, cluster_nodes: list[GraphDBNode], scope: str) -> GraphDBNode: + def _summarize_cluster( + self, cluster_nodes: list[GraphDBNode], scope: str + ) -> GraphDBNode | None: """ Generate a cluster label using LLM, based on top keys in the cluster. + + Returns ``None`` when the LLM does not return a valid JSON object, so + the caller can skip the cluster instead of writing an empty parent node. """ if not cluster_nodes: raise ValueError("Cluster nodes cannot be empty.") @@ -567,12 +637,31 @@ def _summarize_cluster(self, cluster_nodes: list[GraphDBNode], scope: str) -> Gr messages = [{"role": "user", "content": prompt}] response_text = self.llm.generate(messages) response_json = self._parse_json_result(response_text) + if response_json is None: + logger.warning( + "[GraphStructureReorganize] Skip cluster summary: " + "LLM returned no valid JSON object." + ) + return None - # Extract fields - parent_key = response_json.get("key", "").strip() - parent_value = response_json.get("value", "").strip() + parent_key = response_json.get("key") + parent_value = response_json.get("value") parent_tags = response_json.get("tags", []) - parent_background = response_json.get("summary", "").strip() + parent_background = response_json.get("summary", "") + if not ( + isinstance(parent_key, str) + and parent_key.strip() + and isinstance(parent_value, str) + and parent_value.strip() + and isinstance(parent_tags, list) + and all(isinstance(tag, str) for tag in parent_tags) + and isinstance(parent_background, str) + ): + logger.warning("Skipping cluster summary with invalid or empty fields") + return None + parent_key = parent_key.strip() + parent_value = parent_value.strip() + parent_background = parent_background.strip() embedding = self.embedder.embed([parent_value])[0] @@ -595,16 +684,25 @@ def _summarize_cluster(self, cluster_nodes: list[GraphDBNode], scope: str) -> Gr ) return parent_node - def _parse_json_result(self, response_text): + def _parse_json_result(self, response_text: str | None) -> dict | None: + """Read an object from plain or fenced JSON, allowing surrounding prose.""" + if not isinstance(response_text, str) or not response_text.strip(): + return None + text = response_text.strip() + fence = re.fullmatch(r"```(?:json)?\s*(.*?)\s*```", text, flags=re.DOTALL | re.IGNORECASE) + if fence: + text = fence.group(1) try: - response_text = response_text.replace("```", "").replace("json", "") - response_json = extract_first_to_last_brace(response_text)[1] - return response_json - except json.JSONDecodeError as e: - logger.warning( - f"Failed to parse LLM response as JSON: {e}\nRaw response:\n{response_text}" - ) - return {} + result = json.loads(text) + except json.JSONDecodeError: + if text.startswith("["): + return None + try: + result = extract_first_to_last_brace(text)[1] + except json.JSONDecodeError: + logger.warning("Skipping malformed JSON in graph reorganization") + return None + return result if isinstance(result, dict) else None def _create_parent_node(self, parent_node: GraphDBNode, user_name: str | None = None) -> None: """ diff --git a/tests/graph_dbs/test_get_all_user_names.py b/tests/graph_dbs/test_get_all_user_names.py new file mode 100644 index 000000000..a0ba03c5c --- /dev/null +++ b/tests/graph_dbs/test_get_all_user_names.py @@ -0,0 +1,87 @@ +"""Offline tests for Neo4jGraphDB.get_all_user_names (issue #2480). + +The structure reorganizer needs to enumerate every tenant (user_name) present +in the graph so optimization covers all tenants instead of only the configured +default one. These tests stub the Neo4j driver; no server is required. +""" + +from unittest.mock import MagicMock, patch + +import pytest + +from memos.configs.graph_db import Neo4jGraphDBConfig + + +@pytest.fixture +def neo4j_db(): + config = Neo4jGraphDBConfig( + uri="bolt://localhost:7687", + user="neo4j", + password="test", + db_name="test_memory_db", + auto_create=False, + use_multi_db=False, + embedding_dimension=3, + user_name="memosdefault", + ) + with patch("neo4j.GraphDatabase") as mock_gd: + mock_driver = MagicMock() + mock_gd.driver.return_value = mock_driver + from memos.graph_dbs.neo4j import Neo4jGraphDB + + db = Neo4jGraphDB(config) + db.driver = mock_driver + yield db + + +class TestNeo4jGetAllUserNames: + def test_returns_distinct_user_names(self, neo4j_db): + session_mock = neo4j_db.driver.session.return_value.__enter__.return_value + session_mock.run.return_value = [ + {"user_name": "alice"}, + {"user_name": "bob"}, + {"user_name": "memosdefault"}, + ] + + assert neo4j_db.get_all_user_names() == ["alice", "bob", "memosdefault"] + + def test_ignores_null_and_blank_user_names(self, neo4j_db): + session_mock = neo4j_db.driver.session.return_value.__enter__.return_value + session_mock.run.return_value = [ + {"user_name": "alice"}, + {"user_name": None}, + {"user_name": ""}, + ] + + assert neo4j_db.get_all_user_names() == ["alice"] + + def test_empty_graph_falls_back_to_configured_user_name(self, neo4j_db): + session_mock = neo4j_db.driver.session.return_value.__enter__.return_value + session_mock.run.return_value = [] + + assert neo4j_db.get_all_user_names() == ["memosdefault"] + + def test_query_failure_falls_back_to_configured_user_name(self, neo4j_db): + session_mock = neo4j_db.driver.session.return_value.__enter__.return_value + session_mock.run.side_effect = RuntimeError("driver closed") + + assert neo4j_db.get_all_user_names() == ["memosdefault"] + + +def test_database_isolated_mode_does_not_enumerate_node_tenants(neo4j_db): + neo4j_db.config.use_multi_db = True + neo4j_db.driver.reset_mock() + assert neo4j_db.get_all_user_names() == ["memosdefault"] + neo4j_db.driver.session.assert_not_called() + + +def test_invalid_user_names_are_excluded(neo4j_db): + session = neo4j_db.driver.session.return_value.__enter__.return_value + session.run.return_value = [ + {"user_name": "alice"}, + {"user_name": "alice"}, + {"user_name": " "}, + {"user_name": None}, + {"user_name": 1}, + ] + assert neo4j_db.get_all_user_names() == ["alice"] diff --git a/tests/memories/test_reorganizer.py b/tests/memories/test_reorganizer.py new file mode 100644 index 000000000..333824e9a --- /dev/null +++ b/tests/memories/test_reorganizer.py @@ -0,0 +1,501 @@ +"""Offline unit tests for GraphStructureReorganizer (issue #2480). + +Covers three defects: +1. The periodic/_reorganize_needed optimization only ever touched the default + configured tenant; it must enumerate all tenants present in the graph. +2. The schedule-based jobs were dead code: the loop never called + ``schedule.run_pending()``. +3. A non-JSON LLM reply crashed the whole optimization round via + ``AttributeError`` (and the ``JSONDecodeError`` path silently produced empty + parent nodes). + +Graph store / LLM / embedder are all stubbed; no Neo4j, LLM service, network, +or embedder is required. +""" + +from types import SimpleNamespace +from unittest.mock import MagicMock + +import pytest + +import memos.memories.textual.tree_text_memory.organize.reorganizer as reorganizer_module + +from memos.graph_dbs.base import BaseGraphDB +from memos.memories.textual.tree_text_memory.organize.reorganizer import ( + GraphStructureReorganizer, + extract_first_to_last_brace, +) + + +def make_node(node_id: str, memory: str, key: str = "k", background: str = ""): + return SimpleNamespace( + id=node_id, + memory=memory, + metadata=SimpleNamespace(key=key, background=background), + ) + + +@pytest.fixture() +def reorganizer(): + graph_store = MagicMock() + graph_store.config = SimpleNamespace(user_name="memosdefault", use_multi_db=False) + llm = MagicMock() + embedder = MagicMock() + # Avoid background threads: is_reorganize=False. + return GraphStructureReorganizer(graph_store, llm, embedder, is_reorganize=False) + + +EMPTY_RELATION_RESULTS = { + "relations": [], + "inferred_nodes": [], + "sequence_links": [], + "aggregate_nodes": [], +} + + +# --------------------------------------------------------------------------- +# Defect C: LLM output parsing must never crash the optimization round +# --------------------------------------------------------------------------- + + +def test_extract_first_to_last_brace_without_braces_yields_none(): + """Upstream sentinel: no braces -> ("", None), must not raise.""" + json_str, parsed = extract_first_to_last_brace("sorry, I cannot answer that") + assert json_str == "" + assert parsed is None + + +def test_parse_json_result_plain_text_returns_none(reorganizer): + assert reorganizer._parse_json_result("sorry, I cannot answer that") is None + + +def test_parse_json_result_malformed_json_returns_none(reorganizer): + """Braces present but invalid JSON -> None (previously {}).""" + assert reorganizer._parse_json_result('{"key": "broken') is None + + +def test_parse_json_result_interior_brace_invalid_json_returns_none(reorganizer): + """Braces exist but the enclosed text is invalid JSON -> None (previously {}).""" + assert reorganizer._parse_json_result('noise {"key": "broken} more noise') is None + + +def test_summarize_cluster_returns_none_on_malformed_json_no_empty_parent(reorganizer): + """The JSONDecodeError path must not silently build an empty parent node.""" + reorganizer.llm.generate.return_value = 'noise {"key": "broken} more noise' + + result = reorganizer._summarize_cluster([make_node("n1", "m1")], "LongTermMemory") + + assert result is None + reorganizer.embedder.embed.assert_not_called() + + +def test_parse_json_result_non_object_json_returns_none(reorganizer, monkeypatch): + """A parsed JSON value that is not an object must not be passed through.""" + monkeypatch.setattr( + reorganizer_module, + "extract_first_to_last_brace", + lambda text: (text, [{"key": "a"}]), + ) + assert reorganizer._parse_json_result("whatever") is None + + +def test_parse_json_result_empty_text_returns_none(reorganizer): + assert reorganizer._parse_json_result("") is None + assert reorganizer._parse_json_result(None) is None + + +def test_parse_json_result_object_passthrough(reorganizer): + text = 'Here you go:\n```json\n{"key": "travel", "value": "likes Kyoto"}\n```' + assert reorganizer._parse_json_result(text) == {"key": "travel", "value": "likes Kyoto"} + + +def test_summarize_cluster_returns_none_on_non_json_llm_output(reorganizer): + reorganizer.llm.generate.return_value = "sorry, I cannot answer that" + + result = reorganizer._summarize_cluster([make_node("n1", "m1")], "LongTermMemory") + + assert result is None + reorganizer.embedder.embed.assert_not_called() + + +def test_summarize_cluster_builds_parent_node_from_llm_json(reorganizer): + reorganizer.llm.generate.return_value = ( + '{"key": "travel", "value": "User likes Kyoto", ' + '"tags": ["travel"], "summary": "travel preference"}' + ) + reorganizer.embedder.embed.return_value = [[0.1, 0.2, 0.3]] + + parent = reorganizer._summarize_cluster([make_node("n1", "m1")], "LongTermMemory") + + assert parent is not None + assert parent.memory == "User likes Kyoto" + assert parent.metadata.key == "travel" + reorganizer.embedder.embed.assert_called_once_with(["User likes Kyoto"]) + + +def test_local_subcluster_returns_empty_on_non_json_llm_output(reorganizer): + reorganizer.llm.generate.return_value = "no json for you" + + assert reorganizer._local_subcluster([make_node("n1", "m1")]) == [] + + +def test_local_subcluster_parses_valid_clusters(reorganizer): + reorganizer.llm.generate.return_value = '{"clusters": [{"ids": ["a", "b"]}]}' + nodes = [make_node("a", "ma"), make_node("b", "mb")] + + assert reorganizer._local_subcluster(nodes) == [nodes] + + +def test_process_cluster_skips_failed_summary_without_writing_empty_parents(reorganizer): + reorganizer.llm.generate.return_value = "sorry, I cannot answer that" + reorganizer.embedder.embed.return_value = [[0.1]] + reorganizer.relation_detector.process_node = MagicMock( + return_value=dict(EMPTY_RELATION_RESULTS) + ) + cluster = [make_node(f"n{i}", f"m{i}") for i in range(4)] + + # Must not raise, and must not create any (empty) parent node. + reorganizer._process_cluster_and_write( + cluster, "LongTermMemory", local_tree_threshold=10, min_cluster_size=2 + ) + + reorganizer.graph_store.add_node.assert_not_called() + reorganizer.graph_store.add_edge.assert_not_called() + + +# --------------------------------------------------------------------------- +# Defect A: optimization must cover all graph tenants, not only the default one +# --------------------------------------------------------------------------- + + +def test_optimize_all_users_enumerates_graph_tenants(reorganizer): + reorganizer.graph_store.get_all_user_names.return_value = ["alice", "bob", "memosdefault"] + reorganizer.optimize_structure = MagicMock() + + reorganizer._optimize_all_users(scope="LongTermMemory") + + assert [ + (call.kwargs["scope"], call.kwargs["user_name"]) + for call in reorganizer.optimize_structure.call_args_list + ] == [ + ("LongTermMemory", "alice"), + ("LongTermMemory", "bob"), + ("LongTermMemory", "memosdefault"), + ] + + +def test_optimize_all_users_tolerates_single_tenant_failure(reorganizer): + reorganizer.graph_store.get_all_user_names.return_value = ["alice", "bob"] + reorganizer.optimize_structure = MagicMock( + side_effect=[RuntimeError("neo4j unavailable"), None] + ) + + # The failing first tenant must not abort the second one. + reorganizer._optimize_all_users(scope="UserMemory") + + assert reorganizer.optimize_structure.call_count == 2 + reorganizer.optimize_structure.assert_any_call(scope="UserMemory", user_name="bob") + + +def test_optimize_all_users_falls_back_without_tenant_enumeration(reorganizer): + """Backends without get_all_user_names keep the previous single-tenant call.""" + del reorganizer.graph_store.get_all_user_names + reorganizer.optimize_structure = MagicMock() + + reorganizer._optimize_all_users(scope="LongTermMemory") + + reorganizer.optimize_structure.assert_called_once_with( + scope="LongTermMemory", user_name="memosdefault" + ) + + +def test_optimize_all_users_falls_back_on_enumeration_error(reorganizer): + reorganizer.graph_store.get_all_user_names.side_effect = RuntimeError("driver closed") + reorganizer.optimize_structure = MagicMock() + + reorganizer._optimize_all_users(scope="UserMemory") + + reorganizer.optimize_structure.assert_called_once_with( + scope="UserMemory", user_name="memosdefault" + ) + + +def test_base_graph_db_default_returns_configured_user_name(): + """Backends that do not implement enumeration fall back to config.user_name.""" + dummy = SimpleNamespace(config=SimpleNamespace(user_name="tenant-a")) + + assert BaseGraphDB.get_all_user_names(dummy) == ["tenant-a"] + + +def test_base_graph_db_default_handles_missing_config(): + dummy = SimpleNamespace() # no .config at all + + assert BaseGraphDB.get_all_user_names(dummy) == [] + + +# --------------------------------------------------------------------------- +# Defect B: the loop must actually run the scheduled jobs +# --------------------------------------------------------------------------- + + +def _run_one_loop_iteration(monkeypatch, reorganizer): + """Run _run_structure_organizer_loop until its first sleep, then stop.""" + import schedule + + # State normally initialized in __init__ only when is_reorganize=True + # (the loop thread is never started otherwise). + reorganizer._stop_scheduler = False + reorganizer._is_optimizing = {"LongTermMemory": False, "UserMemory": False} + + scheduler = schedule.Scheduler() + run_pending = MagicMock() + scheduler.run_pending = run_pending + monkeypatch.setattr(schedule, "Scheduler", lambda: scheduler) + + def fake_sleep(_seconds): + reorganizer._stop_scheduler = True + + reorganizer._scheduler_stop_event = SimpleNamespace(wait=fake_sleep) + reorganizer._run_structure_organizer_loop() + return run_pending + + +def test_loop_calls_schedule_run_pending(monkeypatch, reorganizer): + reorganizer._reorganize_needed = False + reorganizer.graph_store.get_all_user_names.return_value = ["alice"] + reorganizer.optimize_structure = MagicMock() + + run_pending = _run_one_loop_iteration(monkeypatch, reorganizer) + + run_pending.assert_called() + + +def test_reorganize_trigger_covers_all_tenants(monkeypatch, reorganizer): + reorganizer.graph_store.get_all_user_names.return_value = ["alice", "bob"] + reorganizer.optimize_structure = MagicMock() + reorganizer._reorganize_needed = True + + _run_one_loop_iteration(monkeypatch, reorganizer) + + assert not reorganizer._reorganize_needed + assert { + (call.kwargs["scope"], call.kwargs["user_name"]) + for call in reorganizer.optimize_structure.call_args_list + } == { + ("LongTermMemory", "alice"), + ("LongTermMemory", "bob"), + ("UserMemory", "alice"), + ("UserMemory", "bob"), + } + + +def test_parse_preserves_json_word_in_memory_text(reorganizer): + value = {"key": "json tools", "value": "Uses json.loads for work"} + import json + + assert reorganizer._parse_json_result(json.dumps(value)) == value + + +@pytest.mark.parametrize("response", ['[{"key": "x", "value": "y"}]', "null", "42", "true"]) +def test_parse_rejects_top_level_non_objects(reorganizer, response): + assert reorganizer._parse_json_result(response) is None + + +@pytest.mark.parametrize( + "response", + [ + "{}", + '{"key": "", "value": "x"}', + '{"key": "x", "value": ""}', + '{"key": null, "value": "x"}', + '{"key": "x", "value": []}', + '{"key": "x", "value": "y", "tags": "bad"}', + ], +) +def test_summary_rejects_empty_or_invalid_fields_before_embedding(reorganizer, response): + reorganizer.llm.generate.return_value = response + assert reorganizer._summarize_cluster([make_node("n1", "m1")], "LongTermMemory") is None + reorganizer.embedder.embed.assert_not_called() + + +@pytest.mark.parametrize( + "response", + [ + '{"clusters": null}', + '{"clusters": "bad"}', + '{"clusters": [null, {"ids": null}, {"ids": ["a", "b"]}]}', + ], +) +def test_local_subcluster_tolerates_wrong_shapes(reorganizer, response): + reorganizer.llm.generate.return_value = response + nodes = [make_node("a", "ma"), make_node("b", "mb")] + result = reorganizer._local_subcluster(nodes) + assert result == ([nodes] if '"a"' in response else []) + + +def test_fallback_failure_is_isolated(reorganizer): + reorganizer.graph_store.get_all_user_names.return_value = [] + reorganizer.graph_store.config = SimpleNamespace(user_name="default") + reorganizer.optimize_structure = MagicMock(side_effect=OSError("Synthetic failure")) + reorganizer._optimize_all_users("LongTermMemory") + reorganizer.optimize_structure.assert_called_once_with( + scope="LongTermMemory", user_name="default" + ) + + +def test_missing_tenant_scope_cannot_run_unscoped(reorganizer): + reorganizer.graph_store.get_all_user_names.return_value = [None, "", " "] + reorganizer.graph_store.config = SimpleNamespace(user_name=None, use_multi_db=False) + reorganizer.optimize_structure = MagicMock() + reorganizer._optimize_all_users("LongTermMemory") + reorganizer.optimize_structure.assert_not_called() + + +def test_tenant_names_are_validated_and_deduplicated(reorganizer): + reorganizer.graph_store.get_all_user_names.return_value = ["alice", "alice", None, "bob", ""] + reorganizer.optimize_structure = MagicMock() + reorganizer._optimize_all_users("LongTermMemory") + assert [call.kwargs["user_name"] for call in reorganizer.optimize_structure.call_args_list] == [ + "alice", + "bob", + ] + + +def test_disabled_reorganizer_supports_explicit_optimization(reorganizer): + reorganizer.graph_store.node_not_exist.return_value = True + reorganizer.optimize_structure(scope="LongTermMemory", user_name="alice") + + +def test_scheduler_is_private_and_preserves_new_triggers(monkeypatch, reorganizer): + import schedule + + sentinel = schedule.every(1000).seconds.do(lambda: None) + before = list(schedule.jobs) + reorganizer.graph_store.get_all_user_names.return_value = ["alice"] + calls = [] + + def optimize(**kwargs): + calls.append(kwargs) + reorganizer._reorganize_needed = True + + reorganizer.optimize_structure = optimize + + def stop_after_cycle(_seconds): + reorganizer._stop_scheduler = True + + monkeypatch.setattr(reorganizer_module.time, "sleep", stop_after_cycle) + # The corrected implementation uses an interruptible event wait. + reorganizer._scheduler_stop_event = SimpleNamespace(wait=stop_after_cycle) + try: + reorganizer._run_structure_organizer_loop() + assert schedule.jobs == before + assert reorganizer._reorganize_needed + assert len(calls) == 2 + finally: + schedule.cancel_job(sentinel) + for job in list(schedule.jobs): + if job not in before: + schedule.cancel_job(job) + + +def test_real_scheduler_runs_due_jobs_for_every_tenant(monkeypatch, reorganizer): + from datetime import datetime, timedelta + + import schedule + + scheduler = schedule.Scheduler() + monkeypatch.setattr(schedule, "Scheduler", lambda: scheduler) + reorganizer._reorganize_needed = False + reorganizer.graph_store.get_all_user_names.return_value = ["alice", "bob"] + reorganizer.optimize_structure = MagicMock() + waits = [] + + def advance_then_stop(_seconds): + waits.append(None) + if len(waits) == 1: + for job in scheduler.jobs: + job.next_run = datetime.now() - timedelta(seconds=1) + else: + reorganizer._stop_scheduler = True + + reorganizer._scheduler_stop_event = SimpleNamespace(wait=advance_then_stop) + reorganizer._run_structure_organizer_loop() + + assert { + (call.kwargs["scope"], call.kwargs["user_name"]) + for call in reorganizer.optimize_structure.call_args_list + } == { + ("LongTermMemory", "alice"), + ("LongTermMemory", "bob"), + ("UserMemory", "alice"), + ("UserMemory", "bob"), + } + assert scheduler.jobs == [] + + +def test_multi_tenant_optimization_scopes_candidate_reads_and_graph_writes(reorganizer): + from uuid import uuid4 + + graph = reorganizer.graph_store + graph.get_all_user_names.return_value = ["alice", "bob"] + graph.node_not_exist.return_value = False + graph.get_memory_count.return_value = 3 + graph.edge_exists.return_value = False + tenants = { + name: [ + { + "id": str(uuid4()), + "memory": f"{name} memory {index}", + "metadata": {"memory_type": "LongTermMemory", "key": "topic", "embedding": [0.1]}, + } + for index in range(3) + ] + for name in ("alice", "bob") + } + graph.get_structure_optimization_candidates.side_effect = lambda scope, user_name: tenants[ + user_name + ] + reorganizer._partition = lambda nodes: [nodes] + reorganizer._local_subcluster = lambda nodes: [nodes] + reorganizer.llm.generate.return_value = '{"key": "topic", "value": "Summary", "tags": []}' + reorganizer.embedder.embed.return_value = [[0.1]] + reorganizer.relation_detector.process_node = MagicMock(return_value=EMPTY_RELATION_RESULTS) + + reorganizer._optimize_all_users("LongTermMemory", min_group_size=3, min_cluster_size=2) + + assert [ + call.kwargs["user_name"] + for call in graph.get_structure_optimization_candidates.call_args_list + ] == ["alice", "bob"] + assert [call.kwargs["user_name"] for call in graph.add_node.call_args_list] == ["alice", "bob"] + assert len(graph.add_edge.call_args_list) == 6 + for call in graph.add_edge.call_args_list: + tenant = call.kwargs["user_name"] + assert call.args[1] in {node["id"] for node in tenants[tenant]} + + +def test_stop_interrupts_scheduler_wait(reorganizer): + reorganizer.is_reorganize = True + reorganizer.thread = MagicMock() + reorganizer.structure_optimizer_thread = MagicMock() + + reorganizer.stop() + + assert reorganizer._stop_scheduler + assert reorganizer._scheduler_stop_event.is_set() + reorganizer.thread.join.assert_called_once() + reorganizer.structure_optimizer_thread.join.assert_called_once() + + +def test_database_isolated_backend_can_optimize_its_configured_database(reorganizer): + reorganizer.graph_store.get_all_user_names.return_value = [] + reorganizer.graph_store.config = SimpleNamespace(user_name=None, use_multi_db=True) + reorganizer.optimize_structure = MagicMock() + + reorganizer._optimize_all_users("LongTermMemory") + + reorganizer.optimize_structure.assert_called_once_with(scope="LongTermMemory", user_name=None) + + +def test_malformed_array_is_not_reinterpreted_as_a_summary_object(reorganizer): + assert reorganizer._parse_json_result('[{"key": "x", "value": "y"},]') is None diff --git a/tests/memories/test_reorganizer_neo4j.py b/tests/memories/test_reorganizer_neo4j.py new file mode 100644 index 000000000..dedc6675a --- /dev/null +++ b/tests/memories/test_reorganizer_neo4j.py @@ -0,0 +1,108 @@ +"""Opt-in graph reorganization checks against an isolated Neo4j instance.""" + +import json +import os +import re + +from unittest.mock import MagicMock +from uuid import uuid4 + +import pytest + +from memos.configs.graph_db import Neo4jGraphDBConfig +from memos.graph_dbs.neo4j import Neo4jGraphDB +from memos.graph_dbs.neo4j_community import Neo4jCommunityGraphDB +from memos.memories.textual.tree_text_memory.organize.reorganizer import GraphStructureReorganizer + + +@pytest.fixture(params=[Neo4jGraphDB, Neo4jCommunityGraphDB]) +def graph(request): + uri = os.getenv("MEMOS_TEST_REORGANIZE_NEO4J_URI") + if not uri: + pytest.skip("Configure isolated MEMOS_TEST_REORGANIZE_NEO4J_URI") + neo4j = pytest.importorskip("neo4j") + run = uuid4().hex + tenants = [f"reorganize-{run}-alice", f"reorganize-{run}-bob"] + db = request.param.__new__(request.param) + db.config = Neo4jGraphDBConfig( + uri=uri, + user="neo4j", + password="test-password", + db_name="neo4j", + use_multi_db=False, + auto_create=False, + user_name=f"reorganize-{run}-default", + embedding_dimension=3, + ) + db.db_name = "neo4j" + db.driver = neo4j.GraphDatabase.driver(uri, auth=("neo4j", "test-password")) + if isinstance(db, Neo4jCommunityGraphDB): + db.vec_db = MagicMock() + db.vec_db.get_by_id.return_value = None + try: + for tenant in tenants: + for index in range(3): + db.add_node( + str(uuid4()), + f"{tenant} synthetic memory {index}", + { + "memory_type": "LongTermMemory", + "status": "activated", + "key": "topic", + "embedding": [0.1, 0.2, 0.3], + }, + user_name=tenant, + ) + yield db, tenants + finally: + with db.driver.session(database="neo4j") as session: + session.run( + "MATCH (n:Memory) WHERE n.user_name IN $tenants DETACH DELETE n", + tenants=tenants, + ).consume() + db.driver.close() + + +@pytest.mark.parametrize("malformed_tenant", [False, True]) +def test_native_reorganization_keeps_tenants_isolated(graph, malformed_tenant): + db, tenants = graph + llm = MagicMock() + + def generate(messages): + prompt = messages[0]["content"] + if malformed_tenant and tenants[1] in prompt: + return "Synthetic non-JSON completion" + if '"clusters"' in prompt: + ids = re.findall(r"- ID: (\S+) \|", prompt) + return json.dumps({"clusters": [{"ids": ids}]}) + return '{"key": "topic", "value": "Synthetic summary", "tags": [], "summary": ""}' + + llm.generate.side_effect = generate + embedder = MagicMock() + embedder.embed.return_value = [[0.1, 0.2, 0.3]] + reorganizer = GraphStructureReorganizer(db, llm, embedder, is_reorganize=False) + + assert db.get_all_user_names() == sorted(tenants) + reorganizer._optimize_all_users("LongTermMemory", min_group_size=3, min_cluster_size=2) + + with db.driver.session(database="neo4j") as session: + parents = [ + dict(record) + for record in session.run( + "MATCH (n:Memory) WHERE n.user_name IN $tenants AND n.type = 'topic' " + "RETURN n.user_name AS tenant", + tenants=tenants, + ) + ] + edges = [ + dict(record) + for record in session.run( + "MATCH (a:Memory)-[:PARENT]->(b:Memory) WHERE a.user_name IN $tenants " + "RETURN a.user_name AS source_tenant, b.user_name AS target_tenant", + tenants=tenants, + ) + ] + expected = tenants[:1] if malformed_tenant else tenants + assert sorted(parent["tenant"] for parent in parents) == sorted(expected) + assert len(edges) == 3 * len(expected) + assert all(edge["source_tenant"] == edge["target_tenant"] for edge in edges)