From f528bca7336f6ea4331398c8d2b9400a8da8ebe7 Mon Sep 17 00:00:00 2001 From: Ziyang Guo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 1 Jul 2026 22:55:30 +0800 Subject: [PATCH 1/6] feat: route composite cube writes by responsibility --- src/memos/multi_mem_cube/composite_cube.py | 80 +++++++++++++++--- tests/multi_mem_cube/test_composite_cube.py | 94 +++++++++++++++++++++ 2 files changed, 161 insertions(+), 13 deletions(-) create mode 100644 tests/multi_mem_cube/test_composite_cube.py diff --git a/src/memos/multi_mem_cube/composite_cube.py b/src/memos/multi_mem_cube/composite_cube.py index 11c5245ba..f7a4ff9f2 100644 --- a/src/memos/multi_mem_cube/composite_cube.py +++ b/src/memos/multi_mem_cube/composite_cube.py @@ -19,21 +19,65 @@ class CompositeCubeView(MemCubeView): """ A composite view over multiple logical cubes. - For now (fast mode), it simply fan-out writes to all cubes; - later we can add smarter routing / slow mode here. + By default, writes keep the legacy fan-out behavior. If request metadata + explicitly names a target cube or responsibility, writes are routed only to + matching cube views and fall back to fan-out when nothing matches. """ cube_views: list[SingleCubeView] logger: Any + def _request_info(self, request: Any) -> dict[str, Any]: + info = getattr(request, "info", None) + return info if isinstance(info, dict) else {} + + def _view_responsibilities(self, view: SingleCubeView) -> set[str]: + values: set[str] = set() + for attr in ("responsibility", "responsibilities"): + raw = getattr(view, attr, None) + if isinstance(raw, str): + values.add(raw) + elif isinstance(raw, (list, tuple, set)): + values.update(str(item) for item in raw if item) + return values + + def _route_views(self, request: Any) -> list[SingleCubeView]: + info = self._request_info(request) + target_cube_id = info.get("target_cube_id") or info.get("cube_id") + if target_cube_id: + routed = [view for view in self.cube_views if view.cube_id == target_cube_id] + if routed: + return routed + self.logger.warning( + "[CompositeCubeView] target cube %s not found; fallback to fan-out", + target_cube_id, + ) + + responsibility = info.get("responsibility") or info.get("cube_responsibility") + if responsibility: + routed = [ + view + for view in self.cube_views + if responsibility in self._view_responsibilities(view) + ] + if routed: + return routed + self.logger.warning( + "[CompositeCubeView] responsibility %s not matched; fallback to fan-out", + responsibility, + ) + + return self.cube_views + def add_memories(self, add_req: APIADDRequest) -> list[dict[str, Any]]: all_results: list[dict[str, Any]] = [] - cube_count = len(self.cube_views) + target_views = self._route_views(add_req) + cube_count = len(target_views) with timed_stage("add", "multi_cube", cube_count=cube_count): - for idx, view in enumerate(self.cube_views): + for idx, view in enumerate(target_views): self.logger.info( - "[CompositeCubeView] fan-out add to cube=%s (%d/%d)", + "[CompositeCubeView] route add to cube=%s (%d/%d)", view.cube_id, idx + 1, cube_count, @@ -66,13 +110,22 @@ def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: } for future in as_completed(future_to_view): + view = future_to_view[future] cube_result = future.result() - merged_results["text_mem"].extend(cube_result.get("text_mem", [])) - merged_results["act_mem"].extend(cube_result.get("act_mem", [])) - merged_results["para_mem"].extend(cube_result.get("para_mem", [])) - merged_results["pref_mem"].extend(cube_result.get("pref_mem", [])) - merged_results["tool_mem"].extend(cube_result.get("tool_mem", [])) - merged_results["skill_mem"].extend(cube_result.get("skill_mem", [])) + memory_keys = ( + "text_mem", + "act_mem", + "para_mem", + "pref_mem", + "tool_mem", + "skill_mem", + ) + for key in memory_keys: + memories = cube_result.get(key, []) + for memory in memories: + if isinstance(memory, dict): + memory.setdefault("cube_id", view.cube_id) + merged_results[key].extend(memories) note = cube_result.get("pref_note") if note: if merged_results["pref_note"]: @@ -84,9 +137,10 @@ def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: def feedback_memories(self, feedback_req: APIFeedbackRequest) -> list[dict[str, Any]]: all_results: list[dict[str, Any]] = [] + target_views = self._route_views(feedback_req) - for view in self.cube_views: - self.logger.info(f"[CompositeCubeView] fan-out add to cube={view.cube_id}") + for view in target_views: + self.logger.info(f"[CompositeCubeView] route feedback to cube={view.cube_id}") results = view.feedback_memories(feedback_req) all_results.extend(results) diff --git a/tests/multi_mem_cube/test_composite_cube.py b/tests/multi_mem_cube/test_composite_cube.py new file mode 100644 index 000000000..3057a79c3 --- /dev/null +++ b/tests/multi_mem_cube/test_composite_cube.py @@ -0,0 +1,94 @@ +import logging + +from dataclasses import dataclass, field +from types import SimpleNamespace +from typing import Any + +from memos.multi_mem_cube.composite_cube import CompositeCubeView + + +@dataclass +class FakeCubeView: + cube_id: str + responsibility: str | None = None + result: list[dict[str, Any]] = field(default_factory=list) + search_result: dict[str, Any] = field(default_factory=dict) + add_calls: int = 0 + feedback_calls: int = 0 + + def add_memories(self, _add_req): + self.add_calls += 1 + return list(self.result) + + def feedback_memories(self, _feedback_req): + self.feedback_calls += 1 + return list(self.result) + + def search_memories(self, _search_req): + return dict(self.search_result) + + +def test_composite_routes_add_to_explicit_target_cube(): + general = FakeCubeView(cube_id="general", result=[{"memory": "g"}]) + product = FakeCubeView(cube_id="product", result=[{"memory": "p"}]) + composite = CompositeCubeView( + cube_views=[general, product], + logger=logging.getLogger("test.composite"), + ) + + result = composite.add_memories(SimpleNamespace(info={"target_cube_id": "product"})) + + assert result == [{"memory": "p"}] + assert general.add_calls == 0 + assert product.add_calls == 1 + + +def test_composite_routes_feedback_by_responsibility(): + general = FakeCubeView(cube_id="general", responsibility="general") + product = FakeCubeView(cube_id="product", responsibility="shopping", result=[{"ok": True}]) + composite = CompositeCubeView( + cube_views=[general, product], + logger=logging.getLogger("test.composite"), + ) + + result = composite.feedback_memories(SimpleNamespace(info={"responsibility": "shopping"})) + + assert result == [{"ok": True}] + assert general.feedback_calls == 0 + assert product.feedback_calls == 1 + + +def test_composite_falls_back_to_fanout_without_route_match(): + general = FakeCubeView(cube_id="general", result=[{"memory": "g"}]) + product = FakeCubeView(cube_id="product", result=[{"memory": "p"}]) + composite = CompositeCubeView( + cube_views=[general, product], + logger=logging.getLogger("test.composite"), + ) + + result = composite.add_memories(SimpleNamespace(info={"responsibility": "unknown"})) + + assert result == [{"memory": "g"}, {"memory": "p"}] + assert general.add_calls == 1 + assert product.add_calls == 1 + + +def test_composite_search_adds_missing_cube_provenance(): + general = FakeCubeView( + cube_id="general", + search_result={"text_mem": [{"memory": "g"}], "pref_note": "general note"}, + ) + product = FakeCubeView( + cube_id="product", + search_result={"text_mem": [{"memory": "p", "cube_id": "existing"}]}, + ) + composite = CompositeCubeView( + cube_views=[general, product], + logger=logging.getLogger("test.composite"), + ) + + result = composite.search_memories(SimpleNamespace()) + + by_memory = {item["memory"]: item for item in result["text_mem"]} + assert by_memory["g"]["cube_id"] == "general" + assert by_memory["p"]["cube_id"] == "existing" From 9bb004e302995c4ce5646274c5eb0900a608dc93 Mon Sep 17 00:00:00 2001 From: Ziyang Guo <121015044+RerankerGuo@users.noreply.github.com> Date: Thu, 2 Jul 2026 11:04:56 +0800 Subject: [PATCH 2/6] fix: satisfy ruff isinstance union check --- src/memos/multi_mem_cube/composite_cube.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/memos/multi_mem_cube/composite_cube.py b/src/memos/multi_mem_cube/composite_cube.py index f7a4ff9f2..67beed671 100644 --- a/src/memos/multi_mem_cube/composite_cube.py +++ b/src/memos/multi_mem_cube/composite_cube.py @@ -37,7 +37,7 @@ def _view_responsibilities(self, view: SingleCubeView) -> set[str]: raw = getattr(view, attr, None) if isinstance(raw, str): values.add(raw) - elif isinstance(raw, (list, tuple, set)): + elif isinstance(raw, list | tuple | set): values.update(str(item) for item in raw if item) return values From 41b752fdb8aec5e04b1f4337f105202e0cec37b1 Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 5 Aug 2026 13:20:32 +0800 Subject: [PATCH 3/6] fix(memcube): address composite routing review feedback Narrow routing to explicit target_cube_id metadata, verify the real AddHandler construction path, and isolate partial cube failures across add, search, and feedback. Raise MemCubeError only when every selected cube fails. --- src/memos/multi_mem_cube/composite_cube.py | 112 ++++++++++++----- tests/multi_mem_cube/test_composite_cube.py | 131 ++++++++++++++++---- 2 files changed, 186 insertions(+), 57 deletions(-) diff --git a/src/memos/multi_mem_cube/composite_cube.py b/src/memos/multi_mem_cube/composite_cube.py index 67beed671..2080b1d92 100644 --- a/src/memos/multi_mem_cube/composite_cube.py +++ b/src/memos/multi_mem_cube/composite_cube.py @@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any from memos.context.context import ContextThreadPoolExecutor +from memos.exceptions import MemCubeError from memos.multi_mem_cube.views import MemCubeView from memos.utils import timed_stage @@ -20,8 +21,12 @@ class CompositeCubeView(MemCubeView): A composite view over multiple logical cubes. By default, writes keep the legacy fan-out behavior. If request metadata - explicitly names a target cube or responsibility, writes are routed only to - matching cube views and fall back to fan-out when nothing matches. + explicitly names ``info.target_cube_id``, writes are routed only to that + writable cube and fall back to fan-out when it does not match. + + Cube operations are isolated from each other. A partial failure is logged + and successful results are returned; if every selected cube fails, the + operation raises ``MemCubeError``. """ cube_views: list[SingleCubeView] @@ -31,19 +36,8 @@ def _request_info(self, request: Any) -> dict[str, Any]: info = getattr(request, "info", None) return info if isinstance(info, dict) else {} - def _view_responsibilities(self, view: SingleCubeView) -> set[str]: - values: set[str] = set() - for attr in ("responsibility", "responsibilities"): - raw = getattr(view, attr, None) - if isinstance(raw, str): - values.add(raw) - elif isinstance(raw, list | tuple | set): - values.update(str(item) for item in raw if item) - return values - def _route_views(self, request: Any) -> list[SingleCubeView]: - info = self._request_info(request) - target_cube_id = info.get("target_cube_id") or info.get("cube_id") + target_cube_id = self._request_info(request).get("target_cube_id") if target_cube_id: routed = [view for view in self.cube_views if view.cube_id == target_cube_id] if routed: @@ -53,26 +47,42 @@ def _route_views(self, request: Any) -> list[SingleCubeView]: target_cube_id, ) - responsibility = info.get("responsibility") or info.get("cube_responsibility") - if responsibility: - routed = [ - view - for view in self.cube_views - if responsibility in self._view_responsibilities(view) - ] - if routed: - return routed + return self.cube_views + + def _handle_failures( + self, + operation: str, + attempted_count: int, + succeeded_count: int, + failures: list[tuple[str, Exception]], + ) -> None: + if not failures: + return + + failed_cube_ids = [cube_id for cube_id, _ in failures] + if succeeded_count: self.logger.warning( - "[CompositeCubeView] responsibility %s not matched; fallback to fan-out", - responsibility, + "[CompositeCubeView] partial failure operation=%s succeeded=%d failed=%d " + "failed_cubes=%s", + operation, + succeeded_count, + len(failures), + failed_cube_ids, ) + return - return self.cube_views + message = ( + f"Composite cube {operation} failed for all {attempted_count} selected cubes: " + f"{failed_cube_ids}" + ) + raise MemCubeError(message) from failures[0][1] def add_memories(self, add_req: APIADDRequest) -> list[dict[str, Any]]: all_results: list[dict[str, Any]] = [] target_views = self._route_views(add_req) cube_count = len(target_views) + succeeded_count = 0 + failures: list[tuple[str, Exception]] = [] with timed_stage("add", "multi_cube", cube_count=cube_count): for idx, view in enumerate(target_views): @@ -82,9 +92,20 @@ def add_memories(self, add_req: APIADDRequest) -> list[dict[str, Any]]: idx + 1, cube_count, ) - results = view.add_memories(add_req) - all_results.extend(results) - + try: + results = view.add_memories(add_req) + except Exception as exc: + failures.append((view.cube_id, exc)) + self.logger.error( + "[CompositeCubeView] add failed for cube=%s", + view.cube_id, + exc_info=True, + ) + else: + succeeded_count += 1 + all_results.extend(results) + + self._handle_failures("add", cube_count, succeeded_count, failures) return all_results def search_memories(self, search_req: APISearchRequest) -> dict[str, Any]: @@ -98,6 +119,8 @@ def search_memories(self, search_req: APISearchRequest) -> dict[str, Any]: "tool_mem": [], "skill_mem": [], } + succeeded_count = 0 + failures: list[tuple[str, Exception]] = [] def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: self.logger.info(f"[CompositeCubeView] fan-out search to cube={view.cube_id}") @@ -111,7 +134,18 @@ def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: for future in as_completed(future_to_view): view = future_to_view[future] - cube_result = future.result() + try: + cube_result = future.result() + except Exception as exc: + failures.append((view.cube_id, exc)) + self.logger.error( + "[CompositeCubeView] search failed for cube=%s", + view.cube_id, + exc_info=True, + ) + continue + + succeeded_count += 1 memory_keys = ( "text_mem", "act_mem", @@ -133,15 +167,29 @@ def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: else: merged_results["pref_note"] = note + self._handle_failures("search", len(self.cube_views), succeeded_count, failures) return merged_results def feedback_memories(self, feedback_req: APIFeedbackRequest) -> list[dict[str, Any]]: all_results: list[dict[str, Any]] = [] target_views = self._route_views(feedback_req) + succeeded_count = 0 + failures: list[tuple[str, Exception]] = [] for view in target_views: self.logger.info(f"[CompositeCubeView] route feedback to cube={view.cube_id}") - results = view.feedback_memories(feedback_req) - all_results.extend(results) + try: + results = view.feedback_memories(feedback_req) + except Exception as exc: + failures.append((view.cube_id, exc)) + self.logger.error( + "[CompositeCubeView] feedback failed for cube=%s", + view.cube_id, + exc_info=True, + ) + else: + succeeded_count += 1 + all_results.extend(results) + self._handle_failures("feedback", len(target_views), succeeded_count, failures) return all_results diff --git a/tests/multi_mem_cube/test_composite_cube.py b/tests/multi_mem_cube/test_composite_cube.py index 3057a79c3..0e79ed0c9 100644 --- a/tests/multi_mem_cube/test_composite_cube.py +++ b/tests/multi_mem_cube/test_composite_cube.py @@ -4,58 +4,70 @@ from types import SimpleNamespace from typing import Any +import pytest + +from memos.exceptions import MemCubeError from memos.multi_mem_cube.composite_cube import CompositeCubeView @dataclass class FakeCubeView: cube_id: str - responsibility: str | None = None result: list[dict[str, Any]] = field(default_factory=list) search_result: dict[str, Any] = field(default_factory=dict) + error: Exception | None = None add_calls: int = 0 feedback_calls: int = 0 def add_memories(self, _add_req): self.add_calls += 1 + if self.error: + raise self.error return list(self.result) def feedback_memories(self, _feedback_req): self.feedback_calls += 1 + if self.error: + raise self.error return list(self.result) def search_memories(self, _search_req): + if self.error: + raise self.error return dict(self.search_result) -def test_composite_routes_add_to_explicit_target_cube(): - general = FakeCubeView(cube_id="general", result=[{"memory": "g"}]) - product = FakeCubeView(cube_id="product", result=[{"memory": "p"}]) - composite = CompositeCubeView( - cube_views=[general, product], - logger=logging.getLogger("test.composite"), - ) - - result = composite.add_memories(SimpleNamespace(info={"target_cube_id": "product"})) +def test_add_handler_routes_to_explicit_target_cube(monkeypatch): + from memos.api.handlers.add_handler import AddHandler + from memos.api.handlers.base_handler import HandlerDependencies + from memos.api.product_models import APIADDRequest - assert result == [{"memory": "p"}] - assert general.add_calls == 0 - assert product.add_calls == 1 + handler = AddHandler( + HandlerDependencies( + naive_mem_cube=object(), + mem_reader=object(), + mem_scheduler=object(), + feedback_server=object(), + ) + ) + request = APIADDRequest( + user_id="user", + writable_cube_ids=["general", "product"], + info={"target_cube_id": "product"}, + ) + composite = handler._build_cube_view(request) + calls: list[str] = [] + def add_memories(view, _request): + calls.append(view.cube_id) + return [{"memory": view.cube_id}] -def test_composite_routes_feedback_by_responsibility(): - general = FakeCubeView(cube_id="general", responsibility="general") - product = FakeCubeView(cube_id="product", responsibility="shopping", result=[{"ok": True}]) - composite = CompositeCubeView( - cube_views=[general, product], - logger=logging.getLogger("test.composite"), - ) + monkeypatch.setattr(type(composite.cube_views[0]), "add_memories", add_memories) - result = composite.feedback_memories(SimpleNamespace(info={"responsibility": "shopping"})) + result = composite.add_memories(request) - assert result == [{"ok": True}] - assert general.feedback_calls == 0 - assert product.feedback_calls == 1 + assert result == [{"memory": "product"}] + assert calls == ["product"] def test_composite_falls_back_to_fanout_without_route_match(): @@ -66,7 +78,7 @@ def test_composite_falls_back_to_fanout_without_route_match(): logger=logging.getLogger("test.composite"), ) - result = composite.add_memories(SimpleNamespace(info={"responsibility": "unknown"})) + result = composite.add_memories(SimpleNamespace(info={"target_cube_id": "unknown"})) assert result == [{"memory": "g"}, {"memory": "p"}] assert general.add_calls == 1 @@ -92,3 +104,72 @@ def test_composite_search_adds_missing_cube_provenance(): by_memory = {item["memory"]: item for item in result["text_mem"]} assert by_memory["g"]["cube_id"] == "general" assert by_memory["p"]["cube_id"] == "existing" + + +def test_composite_add_continues_after_partial_failure(caplog): + failing = FakeCubeView(cube_id="failing", error=ValueError("unavailable")) + healthy = FakeCubeView(cube_id="healthy", result=[{"memory": "saved"}]) + composite = CompositeCubeView( + cube_views=[failing, healthy], + logger=logging.getLogger("test.composite"), + ) + + with caplog.at_level(logging.WARNING): + result = composite.add_memories(SimpleNamespace(info={})) + + assert result == [{"memory": "saved"}] + assert "partial failure operation=add" in caplog.text + assert "failing" in caplog.text + + +def test_composite_search_continues_after_partial_failure(caplog): + failing = FakeCubeView(cube_id="failing", error=ValueError("unavailable")) + healthy = FakeCubeView( + cube_id="healthy", + search_result={"text_mem": [{"memory": "found"}]}, + ) + composite = CompositeCubeView( + cube_views=[failing, healthy], + logger=logging.getLogger("test.composite"), + ) + + with caplog.at_level(logging.WARNING): + result = composite.search_memories(SimpleNamespace()) + + assert result["text_mem"] == [{"memory": "found", "cube_id": "healthy"}] + assert "partial failure operation=search" in caplog.text + + +def test_composite_feedback_continues_after_partial_failure(caplog): + failing = FakeCubeView(cube_id="failing", error=ValueError("unavailable")) + healthy = FakeCubeView(cube_id="healthy", result=[{"ok": True}]) + composite = CompositeCubeView( + cube_views=[failing, healthy], + logger=logging.getLogger("test.composite"), + ) + + with caplog.at_level(logging.WARNING): + result = composite.feedback_memories(SimpleNamespace(info={})) + + assert result == [{"ok": True}] + assert "partial failure operation=feedback" in caplog.text + + +@pytest.mark.parametrize("operation", ["add", "search", "feedback"]) +def test_composite_raises_memcube_error_when_all_cubes_fail(operation): + composite = CompositeCubeView( + cube_views=[ + FakeCubeView(cube_id="first", error=ValueError("first failure")), + FakeCubeView(cube_id="second", error=ValueError("second failure")), + ], + logger=logging.getLogger("test.composite"), + ) + request = SimpleNamespace(info={}) + + with pytest.raises(MemCubeError, match=f"{operation} failed for all 2 selected cubes"): + if operation == "add": + composite.add_memories(request) + elif operation == "search": + composite.search_memories(request) + else: + composite.feedback_memories(request) From 2125f84c1bf9307a2c94d7eace620294fffb5b54 Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 5 Aug 2026 15:35:34 +0800 Subject: [PATCH 4/6] fix(memcube): address composite search review findings --- src/memos/multi_mem_cube/composite_cube.py | 25 +++++++++---- tests/multi_mem_cube/test_composite_cube.py | 41 +++++++++++++++++++-- 2 files changed, 54 insertions(+), 12 deletions(-) diff --git a/src/memos/multi_mem_cube/composite_cube.py b/src/memos/multi_mem_cube/composite_cube.py index 2080b1d92..a2f5f1da7 100644 --- a/src/memos/multi_mem_cube/composite_cube.py +++ b/src/memos/multi_mem_cube/composite_cube.py @@ -20,9 +20,9 @@ class CompositeCubeView(MemCubeView): """ A composite view over multiple logical cubes. - By default, writes keep the legacy fan-out behavior. If request metadata - explicitly names ``info.target_cube_id``, writes are routed only to that - writable cube and fall back to fan-out when it does not match. + By default, operations keep the legacy fan-out behavior. If request metadata + explicitly names ``info.target_cube_id``, operations are routed only to that + cube and fall back to fan-out when it does not match. Cube operations are isolated from each other. A partial failure is logged and successful results are returned; if every selected cube fails, the @@ -75,7 +75,9 @@ def _handle_failures( f"Composite cube {operation} failed for all {attempted_count} selected cubes: " f"{failed_cube_ids}" ) - raise MemCubeError(message) from failures[0][1] + error = MemCubeError(message) + error.causes = [exc for _, exc in failures] + raise error from failures[0][1] def add_memories(self, add_req: APIADDRequest) -> list[dict[str, Any]]: all_results: list[dict[str, Any]] = [] @@ -119,17 +121,21 @@ def search_memories(self, search_req: APISearchRequest) -> dict[str, Any]: "tool_mem": [], "skill_mem": [], } + target_views = self._route_views(search_req) succeeded_count = 0 failures: list[tuple[str, Exception]] = [] def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: - self.logger.info(f"[CompositeCubeView] fan-out search to cube={view.cube_id}") + self.logger.info( + "[CompositeCubeView] route search to cube=%s", + view.cube_id, + ) return view.search_memories(search_req) # parallel search for each cube with ContextThreadPoolExecutor(max_workers=2) as executor: future_to_view = { - executor.submit(_search_single_cube, view): view for view in self.cube_views + executor.submit(_search_single_cube, view): view for view in target_views } for future in as_completed(future_to_view): @@ -167,7 +173,7 @@ def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: else: merged_results["pref_note"] = note - self._handle_failures("search", len(self.cube_views), succeeded_count, failures) + self._handle_failures("search", len(target_views), succeeded_count, failures) return merged_results def feedback_memories(self, feedback_req: APIFeedbackRequest) -> list[dict[str, Any]]: @@ -177,7 +183,10 @@ def feedback_memories(self, feedback_req: APIFeedbackRequest) -> list[dict[str, failures: list[tuple[str, Exception]] = [] for view in target_views: - self.logger.info(f"[CompositeCubeView] route feedback to cube={view.cube_id}") + self.logger.info( + "[CompositeCubeView] route feedback to cube=%s", + view.cube_id, + ) try: results = view.feedback_memories(feedback_req) except Exception as exc: diff --git a/tests/multi_mem_cube/test_composite_cube.py b/tests/multi_mem_cube/test_composite_cube.py index 0e79ed0c9..604f0aa44 100644 --- a/tests/multi_mem_cube/test_composite_cube.py +++ b/tests/multi_mem_cube/test_composite_cube.py @@ -1,3 +1,4 @@ +import copy import logging from dataclasses import dataclass, field @@ -17,6 +18,7 @@ class FakeCubeView: search_result: dict[str, Any] = field(default_factory=dict) error: Exception | None = None add_calls: int = 0 + search_calls: int = 0 feedback_calls: int = 0 def add_memories(self, _add_req): @@ -32,9 +34,10 @@ def feedback_memories(self, _feedback_req): return list(self.result) def search_memories(self, _search_req): + self.search_calls += 1 if self.error: raise self.error - return dict(self.search_result) + return copy.deepcopy(self.search_result) def test_add_handler_routes_to_explicit_target_cube(monkeypatch): @@ -104,6 +107,31 @@ def test_composite_search_adds_missing_cube_provenance(): by_memory = {item["memory"]: item for item in result["text_mem"]} assert by_memory["g"]["cube_id"] == "general" assert by_memory["p"]["cube_id"] == "existing" + assert general.search_result == { + "text_mem": [{"memory": "g"}], + "pref_note": "general note", + } + + +def test_composite_search_routes_to_explicit_target_cube(): + general = FakeCubeView( + cube_id="general", + search_result={"text_mem": [{"memory": "g"}]}, + ) + product = FakeCubeView( + cube_id="product", + search_result={"text_mem": [{"memory": "p"}]}, + ) + composite = CompositeCubeView( + cube_views=[general, product], + logger=logging.getLogger("test.composite"), + ) + + result = composite.search_memories(SimpleNamespace(info={"target_cube_id": "product"})) + + assert result["text_mem"] == [{"memory": "p", "cube_id": "product"}] + assert general.search_calls == 0 + assert product.search_calls == 1 def test_composite_add_continues_after_partial_failure(caplog): @@ -157,19 +185,24 @@ def test_composite_feedback_continues_after_partial_failure(caplog): @pytest.mark.parametrize("operation", ["add", "search", "feedback"]) def test_composite_raises_memcube_error_when_all_cubes_fail(operation): + causes = [ValueError("first failure"), ValueError("second failure")] composite = CompositeCubeView( cube_views=[ - FakeCubeView(cube_id="first", error=ValueError("first failure")), - FakeCubeView(cube_id="second", error=ValueError("second failure")), + FakeCubeView(cube_id="first", error=causes[0]), + FakeCubeView(cube_id="second", error=causes[1]), ], logger=logging.getLogger("test.composite"), ) request = SimpleNamespace(info={}) - with pytest.raises(MemCubeError, match=f"{operation} failed for all 2 selected cubes"): + with pytest.raises( + MemCubeError, match=f"{operation} failed for all 2 selected cubes" + ) as exc_info: if operation == "add": composite.add_memories(request) elif operation == "search": composite.search_memories(request) else: composite.feedback_memories(request) + + assert exc_info.value.causes == causes From 18546ea82bf81d73335f9fea90280344849bc3ef Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 5 Aug 2026 15:53:35 +0800 Subject: [PATCH 5/6] fix(memcube): preserve search result ownership --- src/memos/exceptions.py | 5 +++- src/memos/multi_mem_cube/composite_cube.py | 8 +++--- tests/multi_mem_cube/test_composite_cube.py | 30 ++++++++++++--------- 3 files changed, 27 insertions(+), 16 deletions(-) diff --git a/src/memos/exceptions.py b/src/memos/exceptions.py index 28b83c3df..d98aba739 100644 --- a/src/memos/exceptions.py +++ b/src/memos/exceptions.py @@ -15,7 +15,10 @@ class ConfigurationError(MemOSError): ... class MemoryError(MemOSError): ... -class MemCubeError(MemOSError): ... +class MemCubeError(MemOSError): + def __init__(self, message: str, causes: list[Exception] | None = None) -> None: + super().__init__(message) + self.causes = [] if causes is None else causes class VectorDBError(MemOSError): ... diff --git a/src/memos/multi_mem_cube/composite_cube.py b/src/memos/multi_mem_cube/composite_cube.py index a2f5f1da7..2c9530ac5 100644 --- a/src/memos/multi_mem_cube/composite_cube.py +++ b/src/memos/multi_mem_cube/composite_cube.py @@ -75,8 +75,7 @@ def _handle_failures( f"Composite cube {operation} failed for all {attempted_count} selected cubes: " f"{failed_cube_ids}" ) - error = MemCubeError(message) - error.causes = [exc for _, exc in failures] + error = MemCubeError(message, causes=[exc for _, exc in failures]) raise error from failures[0][1] def add_memories(self, add_req: APIADDRequest) -> list[dict[str, Any]]: @@ -162,10 +161,13 @@ def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: ) for key in memory_keys: memories = cube_result.get(key, []) + memories_with_provenance = [] for memory in memories: if isinstance(memory, dict): + memory = memory.copy() memory.setdefault("cube_id", view.cube_id) - merged_results[key].extend(memories) + memories_with_provenance.append(memory) + merged_results[key].extend(memories_with_provenance) note = cube_result.get("pref_note") if note: if merged_results["pref_note"]: diff --git a/tests/multi_mem_cube/test_composite_cube.py b/tests/multi_mem_cube/test_composite_cube.py index 604f0aa44..1870dbf2a 100644 --- a/tests/multi_mem_cube/test_composite_cube.py +++ b/tests/multi_mem_cube/test_composite_cube.py @@ -1,4 +1,3 @@ -import copy import logging from dataclasses import dataclass, field @@ -37,7 +36,7 @@ def search_memories(self, _search_req): self.search_calls += 1 if self.error: raise self.error - return copy.deepcopy(self.search_result) + return self.search_result def test_add_handler_routes_to_explicit_target_cube(monkeypatch): @@ -61,11 +60,12 @@ def test_add_handler_routes_to_explicit_target_cube(monkeypatch): composite = handler._build_cube_view(request) calls: list[str] = [] - def add_memories(view, _request): - calls.append(view.cube_id) - return [{"memory": view.cube_id}] - - monkeypatch.setattr(type(composite.cube_views[0]), "add_memories", add_memories) + for view in composite.cube_views: + monkeypatch.setattr( + view, + "add_memories", + lambda _request, cube_id=view.cube_id: (calls.append(cube_id) or [{"memory": cube_id}]), + ) result = composite.add_memories(request) @@ -89,9 +89,10 @@ def test_composite_falls_back_to_fanout_without_route_match(): def test_composite_search_adds_missing_cube_provenance(): + original_memory = {"memory": "g"} general = FakeCubeView( cube_id="general", - search_result={"text_mem": [{"memory": "g"}], "pref_note": "general note"}, + search_result={"text_mem": [original_memory], "pref_note": "general note"}, ) product = FakeCubeView( cube_id="product", @@ -107,10 +108,7 @@ def test_composite_search_adds_missing_cube_provenance(): by_memory = {item["memory"]: item for item in result["text_mem"]} assert by_memory["g"]["cube_id"] == "general" assert by_memory["p"]["cube_id"] == "existing" - assert general.search_result == { - "text_mem": [{"memory": "g"}], - "pref_note": "general note", - } + assert original_memory == {"memory": "g"} def test_composite_search_routes_to_explicit_target_cube(): @@ -206,3 +204,11 @@ def test_composite_raises_memcube_error_when_all_cubes_fail(operation): composite.feedback_memories(request) assert exc_info.value.causes == causes + + +def test_memcube_error_exposes_causes_in_constructor(): + causes = [ValueError("first"), RuntimeError("second")] + + error = MemCubeError("all failed", causes=causes) + + assert error.causes == causes From fcc2855e50da21c5d9c7b33ebdf5965319b6ef0a Mon Sep 17 00:00:00 2001 From: RerankerGuo <121015044+RerankerGuo@users.noreply.github.com> Date: Wed, 12 Aug 2026 10:54:23 +0800 Subject: [PATCH 6/6] fix(memcube): address remaining review findings Avoid rebinding search result loop variables, use descriptive dependency mocks in the real-handler regression, and compare all-failure causes by type and message rather than exception identity. Test: .venv/bin/python -m pytest tests/multi_mem_cube/test_composite_cube.py tests/test_add_stage_logging.py::TestCompositeCubeAdd -q\nTest: .venv/bin/python -m pytest tests/multi_mem_cube -q\nTest: .venv/bin/ruff check src/memos/exceptions.py src/memos/multi_mem_cube/composite_cube.py tests/multi_mem_cube/test_composite_cube.py --- src/memos/multi_mem_cube/composite_cube.py | 7 ++++--- tests/multi_mem_cube/test_composite_cube.py | 13 ++++++++----- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/src/memos/multi_mem_cube/composite_cube.py b/src/memos/multi_mem_cube/composite_cube.py index 2c9530ac5..e02ea5f3a 100644 --- a/src/memos/multi_mem_cube/composite_cube.py +++ b/src/memos/multi_mem_cube/composite_cube.py @@ -163,10 +163,11 @@ def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: memories = cube_result.get(key, []) memories_with_provenance = [] for memory in memories: + result_memory = memory if isinstance(memory, dict): - memory = memory.copy() - memory.setdefault("cube_id", view.cube_id) - memories_with_provenance.append(memory) + result_memory = memory.copy() + result_memory.setdefault("cube_id", view.cube_id) + memories_with_provenance.append(result_memory) merged_results[key].extend(memories_with_provenance) note = cube_result.get("pref_note") if note: diff --git a/tests/multi_mem_cube/test_composite_cube.py b/tests/multi_mem_cube/test_composite_cube.py index 1870dbf2a..0a8136166 100644 --- a/tests/multi_mem_cube/test_composite_cube.py +++ b/tests/multi_mem_cube/test_composite_cube.py @@ -3,6 +3,7 @@ from dataclasses import dataclass, field from types import SimpleNamespace from typing import Any +from unittest.mock import MagicMock import pytest @@ -46,10 +47,10 @@ def test_add_handler_routes_to_explicit_target_cube(monkeypatch): handler = AddHandler( HandlerDependencies( - naive_mem_cube=object(), - mem_reader=object(), - mem_scheduler=object(), - feedback_server=object(), + naive_mem_cube=MagicMock(), + mem_reader=MagicMock(), + mem_scheduler=MagicMock(), + feedback_server=MagicMock(), ) ) request = APIADDRequest( @@ -203,7 +204,9 @@ def test_composite_raises_memcube_error_when_all_cubes_fail(operation): else: composite.feedback_memories(request) - assert exc_info.value.causes == causes + assert [(type(cause), str(cause)) for cause in exc_info.value.causes] == [ + (type(cause), str(cause)) for cause in causes + ] def test_memcube_error_exposes_causes_in_constructor():