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 11c5245ba..e02ea5f3a 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 @@ -19,28 +20,93 @@ 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, 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 + operation raises ``MemCubeError``. """ 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 _route_views(self, request: Any) -> list[SingleCubeView]: + 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: + return routed + self.logger.warning( + "[CompositeCubeView] target cube %s not found; fallback to fan-out", + target_cube_id, + ) + + 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] partial failure operation=%s succeeded=%d failed=%d " + "failed_cubes=%s", + operation, + succeeded_count, + len(failures), + failed_cube_ids, + ) + return + + message = ( + f"Composite cube {operation} failed for all {attempted_count} selected cubes: " + f"{failed_cube_ids}" + ) + 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]]: all_results: list[dict[str, Any]] = [] - cube_count = len(self.cube_views) + 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(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, ) - 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]: @@ -54,25 +120,55 @@ 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): - 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", [])) + view = future_to_view[future] + 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", + "para_mem", + "pref_mem", + "tool_mem", + "skill_mem", + ) + for key in memory_keys: + memories = cube_result.get(key, []) + memories_with_provenance = [] + for memory in memories: + result_memory = memory + if isinstance(memory, dict): + 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: if merged_results["pref_note"]: @@ -80,14 +176,32 @@ def _search_single_cube(view: SingleCubeView) -> dict[str, Any]: else: merged_results["pref_note"] = note + self._handle_failures("search", len(target_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( + "[CompositeCubeView] route feedback to cube=%s", + view.cube_id, + ) + 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) - for view in self.cube_views: - self.logger.info(f"[CompositeCubeView] fan-out add to cube={view.cube_id}") - results = view.feedback_memories(feedback_req) - 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 new file mode 100644 index 000000000..0a8136166 --- /dev/null +++ b/tests/multi_mem_cube/test_composite_cube.py @@ -0,0 +1,217 @@ +import logging + +from dataclasses import dataclass, field +from types import SimpleNamespace +from typing import Any +from unittest.mock import MagicMock + +import pytest + +from memos.exceptions import MemCubeError +from memos.multi_mem_cube.composite_cube import CompositeCubeView + + +@dataclass +class FakeCubeView: + cube_id: str + 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 + search_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): + self.search_calls += 1 + if self.error: + raise self.error + return self.search_result + + +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 + + handler = AddHandler( + HandlerDependencies( + naive_mem_cube=MagicMock(), + mem_reader=MagicMock(), + mem_scheduler=MagicMock(), + feedback_server=MagicMock(), + ) + ) + request = APIADDRequest( + user_id="user", + writable_cube_ids=["general", "product"], + info={"target_cube_id": "product"}, + ) + composite = handler._build_cube_view(request) + calls: list[str] = [] + + 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) + + assert result == [{"memory": "product"}] + assert calls == ["product"] + + +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={"target_cube_id": "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(): + original_memory = {"memory": "g"} + general = FakeCubeView( + cube_id="general", + search_result={"text_mem": [original_memory], "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" + assert original_memory == {"memory": "g"} + + +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): + 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): + causes = [ValueError("first failure"), ValueError("second failure")] + composite = CompositeCubeView( + cube_views=[ + 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" + ) as exc_info: + if operation == "add": + composite.add_memories(request) + elif operation == "search": + composite.search_memories(request) + else: + composite.feedback_memories(request) + + 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(): + causes = [ValueError("first"), RuntimeError("second")] + + error = MemCubeError("all failed", causes=causes) + + assert error.causes == causes