From 1ee1727575e811b28e349c942b7c982b228a16aa Mon Sep 17 00:00:00 2001 From: One Date: Mon, 9 Nov 2026 20:47:58 +0800 Subject: [PATCH 1/3] fix(retrieval): defer candidate construction until after ranking Recall previously constructed a fully validated TextualMemoryItem for every recalled candidate, including the ones later discarded by ranking and trimming. Vector and fulltext recall now wrap candidate node dicts in a validation-free view (DeferredTextualMemoryItem), and real items are built only for survivors, via the same from_dict validation as before. - The view exposes passthrough attributes (id, memory, metadata field lookups), so merge / rerank / dedup decisions are unchanged. - _sort_and_trim materializes survivors in every branch loop; the full_recall exit materializes everything for callers that treat results as fully constructed items. - retrieve_from_cube materializes eagerly: it mutates metadata in place and must keep returning real items. --- src/memos/memories/textual/item.py | 99 ++++++- .../tree_text_memory/retrieve/recall.py | 31 ++- .../tree_text_memory/retrieve/searcher.py | 36 ++- .../textual/test_deferred_candidate.py | 255 ++++++++++++++++++ tests/memories/textual/test_tree_retriever.py | 13 +- 5 files changed, 417 insertions(+), 17 deletions(-) create mode 100644 tests/memories/textual/test_deferred_candidate.py diff --git a/src/memos/memories/textual/item.py b/src/memos/memories/textual/item.py index a874ac77b..06a56904e 100644 --- a/src/memos/memories/textual/item.py +++ b/src/memos/memories/textual/item.py @@ -5,7 +5,7 @@ import uuid from datetime import datetime -from typing import Any, Literal +from typing import Any, ClassVar, Literal from pydantic import BaseModel, ConfigDict, Field, field_validator @@ -392,3 +392,100 @@ def list_all_fields() -> list[str]: meta_all = sorted(set().union(*[set(m.model_fields.keys()) for m in meta_models])) return top + meta_all + + +class _DeferredMetadata: + """Read-only passthrough view over a raw candidate metadata dict. + + Field lookups first hit the raw dict; keys missing from the dict fall + back to the pydantic model field defaults, so pre-materialization + readers observe the same values a built item would expose (e.g. + ``memory_type`` -> ``"WorkingMemory"``, ``usage`` -> ``[]``). Unknown + names raise ``AttributeError`` so ``hasattr``/``getattr`` keep their + usual semantics. ``mode="before"`` validators are NOT replicated — + consumers that need validated objects (e.g. reranker strategies + reading ``sources``) must operate on materialized items. + """ + + __slots__ = ("_metadata",) + + # Class-level cache of {field name: pydantic default} for the metadata + # models _coerce_metadata can produce from raw node dicts. Searched (a + # superset of the TreeNode/Textual fields) is listed LAST so it wins any + # field-name conflict with Preference — e.g. created_at keeps the + # TreeNode default_factory instead of Preference's None, matching what + # a recall node would actually build. + _FIELD_DEFAULTS: ClassVar[dict[str, Any] | None] = None + + def __init__(self, metadata: dict): + self._metadata = metadata + + @classmethod + def _field_defaults(cls) -> dict[str, Any]: + if cls._FIELD_DEFAULTS is None: + cls._FIELD_DEFAULTS = { + name: field.get_default(call_default_factory=True) + for model in ( + PreferenceTextualMemoryMetadata, + SearchedTreeNodeTextualMemoryMetadata, + ) + for name, field in model.model_fields.items() + } + return cls._FIELD_DEFAULTS + + def __getattr__(self, name: str): + if name.startswith("__"): + raise AttributeError(name) + try: + return self._metadata[name] + except KeyError: + defaults = self._field_defaults() + if name not in defaults: + raise AttributeError(name) from None + default = defaults[name] + # Copy mutable defaults so callers cannot corrupt the shared cache. + if isinstance(default, (list, dict, set)): + return default.copy() + return default + + +class DeferredTextualMemoryItem: + """Validation-free view over a raw candidate node dict. + + Recall paths wrap candidate node dicts in this view instead of eagerly + constructing a ``TextualMemoryItem``, so full pydantic validation runs + only for candidates that survive ranking and trimming (via ``build``) + rather than for every recalled candidate. + + Contract (read-only): exposes ``id``, ``memory`` and ``metadata`` field + lookups, with metadata falling back to pydantic field defaults for + known fields and raising ``AttributeError`` for unknown ones. Raw node + values are passed through unchanged apart from those defaults — + ``mode="before"`` validators are not applied. The view is immutable: + consumers that mutate items or rely on validated objects (reranker + strategies, ``model_dump``) must call ``build()`` first. + """ + + __slots__ = ("_node",) + + def __init__(self, node: dict): + self._node = node + + @property + def id(self) -> str: + return self._node.get("id") + + @property + def memory(self) -> str: + return self._node.get("memory") + + @property + def metadata(self) -> _DeferredMetadata: + return _DeferredMetadata(self._node.get("metadata") or {}) + + def build(self) -> TextualMemoryItem: + """Materialize the deferred candidate with full validation.""" + return TextualMemoryItem.from_dict(self._node) + + +RetrievableMemoryItem = TextualMemoryItem | DeferredTextualMemoryItem diff --git a/src/memos/memories/textual/tree_text_memory/retrieve/recall.py b/src/memos/memories/textual/tree_text_memory/retrieve/recall.py index c3939358f..84dbbf890 100644 --- a/src/memos/memories/textual/tree_text_memory/retrieve/recall.py +++ b/src/memos/memories/textual/tree_text_memory/retrieve/recall.py @@ -5,7 +5,11 @@ from memos.embedders.factory import OllamaEmbedder from memos.graph_dbs.neo4j import Neo4jGraphDB from memos.log import get_logger -from memos.memories.textual.item import TextualMemoryItem +from memos.memories.textual.item import ( + DeferredTextualMemoryItem, + RetrievableMemoryItem, + TextualMemoryItem, +) from memos.memories.textual.tree_text_memory.retrieve.bm25_util import EnhancedBM25 from memos.memories.textual.tree_text_memory.retrieve.retrieval_mid_structs import ParsedTaskGoal @@ -90,7 +94,7 @@ def retrieve( user_name: str | None = None, id_filter: dict | None = None, use_fast_graph: bool = False, - ) -> list[TextualMemoryItem]: + ) -> list[RetrievableMemoryItem]: """ Perform hybrid memory retrieval: - Run graph-based lookup from dispatch plan. @@ -209,9 +213,14 @@ def retrieve_from_cube( if memory_scope not in ["WorkingMemory", "LongTermMemory", "UserMemory"]: raise ValueError(f"Unsupported memory scope: {memory_scope}") - graph_results = self._vector_recall( - query_embedding, memory_scope, top_k, cube_name=cube_name, user_name=user_name - ) + # Materialize deferred candidates first: this path mutates metadata + # in place below and must hand out real items. + graph_results = [ + item.build() if isinstance(item, DeferredTextualMemoryItem) else item + for item in self._vector_recall( + query_embedding, memory_scope, top_k, cube_name=cube_name, user_name=user_name + ) + ] for result_i in graph_results: result_i.metadata.memory_type = "OuterMemory" @@ -227,7 +236,7 @@ def retrieve_from_mixed( query_embedding: list[list[float]] | None = None, search_filter: dict | None = None, user_name: str | None = None, - ) -> list[TextualMemoryItem]: + ) -> list[RetrievableMemoryItem]: """Retrieve from mixed and memory""" vector_results = self._vector_recall( query_embedding or [], @@ -378,7 +387,7 @@ def _vector_recall( search_filter: dict | None = None, search_priority: dict | None = None, user_name: str | None = None, - ) -> list[TextualMemoryItem]: + ) -> list[RetrievableMemoryItem]: """ Perform vector-based similarity retrieval using query embedding. # TODO: tackle with post-filter and pre-filter(5.18+) better. @@ -513,7 +522,9 @@ def search_path_b(): node["metadata"]["relativity"] = id_to_hit.get(rid, {}).get("score", 0.0) ordered_nodes.append(node) - return [TextualMemoryItem.from_dict(n) for n in ordered_nodes] + # Deferred candidates: full pydantic validation runs later, only for + # items that survive ranking and trimming (searcher._sort_and_trim). + return [DeferredTextualMemoryItem(n) for n in ordered_nodes] @staticmethod def _memory_item_from_vector_hit(hit: dict) -> TextualMemoryItem: @@ -656,4 +667,6 @@ def _fulltext_recall( node["metadata"]["relativity"] = id_to_score.get(rid, 0.0) ordered_nodes.append(node) - return [TextualMemoryItem.from_dict(n) for n in ordered_nodes] + # Deferred candidates: full pydantic validation runs later, only for + # items that survive ranking and trimming (searcher._sort_and_trim). + return [DeferredTextualMemoryItem(n) for n in ordered_nodes] diff --git a/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py b/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py index b44d28218..c57f72e04 100644 --- a/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py +++ b/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py @@ -8,7 +8,12 @@ from memos.graph_dbs.factory import Neo4jGraphDB from memos.llms.factory import AzureLLM, OllamaLLM, OpenAILLM from memos.log import get_logger, summarize_textual_memories -from memos.memories.textual.item import SearchedTreeNodeTextualMemoryMetadata, TextualMemoryItem +from memos.memories.textual.item import ( + DeferredTextualMemoryItem, + RetrievableMemoryItem, + SearchedTreeNodeTextualMemoryMetadata, + TextualMemoryItem, +) from memos.memories.textual.tree_text_memory.retrieve.bm25_util import EnhancedBM25 from memos.memories.textual.tree_text_memory.retrieve.retrieve_utils import ( FastTokenizer, @@ -33,6 +38,15 @@ logger = get_logger(__name__) + + +def _materialize_candidate(item: RetrievableMemoryItem) -> TextualMemoryItem: + """Build deferred candidates into fully validated items; pass items through.""" + if isinstance(item, DeferredTextualMemoryItem): + return item.build() + return item + + KEYWORD_EXTRACT_TOP_K = 3 KEYWORD_ALLOW_POS = ("n", "nr", "nrt", "ns", "nt", "nz", "vn", "v", "t", "eng", "m") COT_DICT = { @@ -80,12 +94,17 @@ def _maybe_rerank( enabled: bool, *, query: str, - graph_results: list[TextualMemoryItem], + graph_results: list[RetrievableMemoryItem], top_k: int, **kwargs, ) -> list[tuple[TextualMemoryItem, float]]: + # Reranker strategies enrich and mutate items (e.g. single_turn + # reassigns ``item.memory``), and deferred views are read-only, so + # materialize before reranking. The disabled path materializes too, + # so Searcher.retrieve() never returns deferred views to callers. if not enabled or self.reranker is None: - return [(item, 0.0) for item in graph_results[:top_k]] + return [(_materialize_candidate(item), 0.0) for item in graph_results[:top_k]] + graph_results = [_materialize_candidate(item) for item in graph_results] return self.reranker.rerank( query=query, graph_results=graph_results, @@ -154,7 +173,7 @@ def retrieve( def post_retrieve( self, - retrieved_results: list[tuple[TextualMemoryItem, float]], + retrieved_results: list[tuple[RetrievableMemoryItem, float]], top_k: int, user_name: str | None = None, info=None, @@ -258,7 +277,9 @@ def search( full_recall = kwargs.get("full_recall", False) if full_recall: - return retrieved_results + # full_recall callers receive untrimmed results and may treat them + # as fully constructed items; materialize deferred candidates here. + return [(_materialize_candidate(item), score) for item, score in retrieved_results] final_results = self.post_retrieve( retrieved_results=retrieved_results, @@ -1179,6 +1200,7 @@ def _sort_and_trim( for item, score in sorted_tool_schema_results: if plugin and round(score, 2) == 0.00: continue + item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( @@ -1199,6 +1221,7 @@ def _sort_and_trim( for item, score in sorted_tool_trajectory_results: if plugin and round(score, 2) == 0.00: continue + item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( @@ -1221,6 +1244,7 @@ def _sort_and_trim( for item, score in sorted_skill_results: if plugin and round(score, 2) == 0.00: continue + item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( @@ -1243,6 +1267,7 @@ def _sort_and_trim( for item, score in sorted_pref_results: if plugin and round(score, 2) == 0.00: continue + item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( @@ -1266,6 +1291,7 @@ def _sort_and_trim( for item, score in sorted_results: if plugin and round(score, 2) == 0.00: continue + item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( diff --git a/tests/memories/textual/test_deferred_candidate.py b/tests/memories/textual/test_deferred_candidate.py new file mode 100644 index 000000000..c1ab4ca3c --- /dev/null +++ b/tests/memories/textual/test_deferred_candidate.py @@ -0,0 +1,255 @@ +"""Tests for deferred candidate construction in the recall pipeline. + +Covers the ``DeferredTextualMemoryItem`` view: attribute passthrough, +``build()`` equivalence against eager construction, and pipeline-level +equivalence for rerank / dedup / sort-and-trim when candidates are deferred. +""" + +import copy +import uuid + +import pytest + +from unittest.mock import patch + +from memos.memories.textual.item import ( + DeferredTextualMemoryItem, + SearchedTreeNodeTextualMemoryMetadata, + TextualMemoryItem, +) +from memos.memories.textual.tree_text_memory.retrieve.searcher import ( + Searcher, + _materialize_candidate, +) +from memos.reranker.cosine_local import CosineLocalReranker + + +def make_node(i, with_embedding=True, with_relativity=True, memory_type="LongTermMemory"): + md = { + "memory_type": memory_type, + "background": "fact", + "timestamp": 1735689600.0, + "created_at": "2026-01-15T10:30:00", + "updated_at": "2026-01-15T10:30:00", + "confidence": 0.9, + "usage": ["u1"], + "sources": [ + { + "conversation_id": str(uuid.uuid4()), + "content": f"source content {i}", + "timestamp": "2026-01-15T10:30:00", + "role": "user", + } + ], + } + if with_embedding: + md["embedding"] = [float(i), 1.0, 2.0, 3.0] + if with_relativity: + md["relativity"] = 0.5 + return { + "id": str(uuid.uuid4()), + "memory": f"memory content {i}", + "metadata": md, + } + + +def test_view_attribute_passthrough(): + node = make_node(1) + view = DeferredTextualMemoryItem(node) + assert view.id == node["id"] + assert view.memory == node["memory"] + assert view.metadata.embedding == node["metadata"]["embedding"] + assert view.metadata.background == "fact" + assert view.metadata.memory_type == "LongTermMemory" + with pytest.raises(AttributeError): + view.metadata.nonexistent + + +def test_view_unknown_field_hasattr_getattr_semantics(): + view = DeferredTextualMemoryItem(make_node(1)) + assert not hasattr(view.metadata, "no_such_field") + assert getattr(view.metadata, "no_such_field", "fallback") == "fallback" + + +def test_view_known_field_defaults_match_built_item(): + node = make_node(3) + node["metadata"] = { + k: v for k, v in node["metadata"].items() + if k not in ("memory_type", "usage", "file_ids", "knowledge_summary_ids") + } + view = DeferredTextualMemoryItem(node) + built = TextualMemoryItem.from_dict(node) + assert view.metadata.memory_type == built.metadata.memory_type == "WorkingMemory" + assert view.metadata.usage == built.metadata.usage == [] + assert view.metadata.file_ids == built.metadata.file_ids == [] + assert view.metadata.knowledge_summary_ids == built.metadata.knowledge_summary_ids == [] + + +def test_view_defaults_are_not_shared_mutable_state(): + view = DeferredTextualMemoryItem({"id": "x", "memory": "m", "metadata": {}}) + view.metadata.usage.append("corrupted") + fresh = DeferredTextualMemoryItem({"id": "y", "memory": "m", "metadata": {}}) + assert fresh.metadata.usage == [] + + +def test_view_missing_metadata(): + view = DeferredTextualMemoryItem({"id": "x", "memory": "m"}) + assert view.id == "x" + assert view.memory == "m" + # Missing keys fall back to the pydantic field defaults, matching what a + # built item would expose for the same node dict. + assert view.metadata.memory_type == "WorkingMemory" + with pytest.raises(AttributeError): + view.metadata.no_such_field + + +def test_view_id_matches_real_item_id(): + node = make_node(2) + assert DeferredTextualMemoryItem(node).id == TextualMemoryItem.from_dict(node).id + + +def test_build_equivalence(): + nodes = [make_node(i) for i in range(5)] + nodes.append(make_node(9, with_embedding=False, with_relativity=False)) + nodes.append(make_node(11, memory_type="UserMemory")) + for node in nodes: + assert ( + DeferredTextualMemoryItem(node).build().to_dict() + == TextualMemoryItem.from_dict(node).to_dict() + ) + + +def test_materialize_helper(): + node = make_node(3) + view = DeferredTextualMemoryItem(node) + item = TextualMemoryItem.from_dict(node) + assert _materialize_candidate(view).to_dict() == item.to_dict() + assert _materialize_candidate(item) is item + + +def test_rerank_equivalence_views_vs_items(): + nodes = [make_node(i, with_embedding=(i % 3 != 0)) for i in range(8)] + items = [TextualMemoryItem.from_dict(n) for n in nodes] + views = [DeferredTextualMemoryItem(n) for n in nodes] + query_embedding = [0.5, 1.0, 2.0, 3.0] + reranker = CosineLocalReranker() + + out_items = reranker.rerank( + query="q", graph_results=items, top_k=5, query_embedding=query_embedding + ) + out_views = reranker.rerank( + query="q", graph_results=views, top_k=5, query_embedding=query_embedding + ) + + assert len(out_items) == len(out_views) + for (item_a, score_a), (item_b, score_b) in zip(out_items, out_views, strict=True): + assert score_a == score_b + assert item_a.memory == item_b.memory + + +def test_maybe_rerank_materializes_before_rerank(): + """Reranker strategies mutate items (e.g. single_turn reassigns memory).""" + + class MutatingReranker: + def rerank(self, query, graph_results, top_k, **kwargs): + out = [] + for i, item in enumerate(graph_results[:top_k]): + item.memory = f"{item.memory} enriched" # would fail on a view + out.append((item, 1.0 - i * 0.1)) + return out + + searcher = Searcher.__new__(Searcher) + searcher.reranker = MutatingReranker() + result = searcher._maybe_rerank( + True, query="q", graph_results=[DeferredTextualMemoryItem(make_node(4))], top_k=5 + ) + assert len(result) == 1 + assert isinstance(result[0][0], TextualMemoryItem) + assert result[0][0].memory == "memory content 4 enriched" + + +def test_maybe_rerank_disabled_path_materializes(): + """Searcher.retrieve() must never hand deferred views to its callers.""" + searcher = Searcher.__new__(Searcher) + searcher.reranker = None + result = searcher._maybe_rerank( + False, query="q", graph_results=[DeferredTextualMemoryItem(make_node(6))], top_k=5 + ) + assert len(result) == 1 + assert isinstance(result[0][0], TextualMemoryItem) + assert result[0][1] == 0.0 + + +def test_sort_and_trim_defaults_missing_memory_type(): + """A node without memory_type is WorkingMemory by default and must + survive the textual branch filter instead of being silently dropped.""" + node = make_node(7) + node["metadata"] = {k: v for k, v in node["metadata"].items() if k != "memory_type"} + searcher = Searcher.__new__(Searcher) + out = searcher._sort_and_trim([(DeferredTextualMemoryItem(node), 0.8)], 4) + assert len(out) == 1 + assert out[0].metadata.memory_type == "WorkingMemory" + + +def test_deduplicate_results_mixed(): + searcher = Searcher.__new__(Searcher) + nodes = [make_node(i) for i in range(4)] + items = [TextualMemoryItem.from_dict(n) for n in nodes] + results = [ + (DeferredTextualMemoryItem(nodes[0]), 0.1), + (items[0], 0.9), + (items[1], 0.5), + (DeferredTextualMemoryItem(nodes[1]), 0.4), + ] + deduped = searcher._deduplicate_results(results) + assert len(deduped) == 2 + assert deduped[0][1] == 0.9 + assert deduped[0][0].memory == items[0].memory + + +def test_sort_and_trim_equivalence(): + nodes = [make_node(i) for i in range(10)] + items = [TextualMemoryItem.from_dict(n) for n in nodes] + scores = [0.9 - i * 0.05 for i in range(10)] + results_items = list(zip(items, scores, strict=True)) + results_mixed = [ + (DeferredTextualMemoryItem(nodes[i]) if i % 2 == 0 else items[i], scores[i]) + for i in range(10) + ] + + searcher = Searcher.__new__(Searcher) + out_items = searcher._sort_and_trim(results_items, 4) + out_mixed = searcher._sort_and_trim(results_mixed, 4) + + assert [it.to_dict() for it in out_items] == [it.to_dict() for it in out_mixed] + for it in out_mixed: + assert isinstance(it, TextualMemoryItem) + assert isinstance(it.metadata, SearchedTreeNodeTextualMemoryMetadata) + + +def test_sort_and_trim_tool_branch_materializes(): + node = make_node(21, memory_type="ToolSchemaMemory") + view = DeferredTextualMemoryItem(node) + searcher = Searcher.__new__(Searcher) + out = searcher._sort_and_trim([(view, 0.7)], 6, search_tool_memory=True) + assert len(out) == 1 + assert isinstance(out[0], TextualMemoryItem) + assert out[0].metadata.memory_type == "ToolSchemaMemory" + + +def test_plugin_zero_score_skips_materialization(): + view = DeferredTextualMemoryItem(make_node(5)) + searcher = Searcher.__new__(Searcher) + with patch.object( + DeferredTextualMemoryItem, "build", side_effect=AssertionError("should not build") + ) as mock_build: + out = searcher._sort_and_trim([(view, 0.001)], 3, plugin=True) + assert out == [] + assert mock_build.call_count == 0 + + +def test_deepcopy_safety(): + view = DeferredTextualMemoryItem(make_node(7)) + copied = copy.deepcopy(view) + assert copied.memory == view.memory + assert copied.build().to_dict() == view.build().to_dict() diff --git a/tests/memories/textual/test_tree_retriever.py b/tests/memories/textual/test_tree_retriever.py index 39e22a063..893d2926a 100644 --- a/tests/memories/textual/test_tree_retriever.py +++ b/tests/memories/textual/test_tree_retriever.py @@ -4,7 +4,11 @@ import pytest -from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata +from memos.memories.textual.item import ( + DeferredTextualMemoryItem, + TextualMemoryItem, + TreeNodeTextualMemoryMetadata, +) from memos.memories.textual.tree_text_memory.retrieve.recall import GraphMemoryRetriever from memos.memories.textual.tree_text_memory.retrieve.retrieval_mid_structs import ParsedTaskGoal @@ -77,7 +81,12 @@ def test_vector_recall_combines_and_dedups(retriever, mock_graph_store): results = retriever._vector_recall(vec, "LongTermMemory", top_k=5) assert len(results) == 2 - assert all(isinstance(r, TextualMemoryItem) for r in results) + # Vector recall returns deferred candidates; they build into fully + # validated items with the same ids. + assert all(isinstance(r, DeferredTextualMemoryItem) for r in results) + built = [r.build() for r in results] + assert all(isinstance(b, TextualMemoryItem) for b in built) + assert {b.id for b in built} == {n1_id, n2_id} def test_vector_recall_uses_lightweight_hits_without_get_nodes( From 70d80aa25834d97eb564aeff7f03ffed17cdf52d Mon Sep 17 00:00:00 2001 From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com> Date: Wed, 18 Nov 2026 14:49:53 +0800 Subject: [PATCH 2/3] fix: keep deferred retrieval internal to plugin search --- src/memos/memories/textual/item.py | 99 +----- .../tree_text_memory/retrieve/recall.py | 50 ++- .../tree_text_memory/retrieve/searcher.py | 48 +-- .../textual/test_deferred_candidate.py | 304 ++++-------------- tests/memories/textual/test_tree_retriever.py | 13 +- 5 files changed, 92 insertions(+), 422 deletions(-) diff --git a/src/memos/memories/textual/item.py b/src/memos/memories/textual/item.py index 06a56904e..a874ac77b 100644 --- a/src/memos/memories/textual/item.py +++ b/src/memos/memories/textual/item.py @@ -5,7 +5,7 @@ import uuid from datetime import datetime -from typing import Any, ClassVar, Literal +from typing import Any, Literal from pydantic import BaseModel, ConfigDict, Field, field_validator @@ -392,100 +392,3 @@ def list_all_fields() -> list[str]: meta_all = sorted(set().union(*[set(m.model_fields.keys()) for m in meta_models])) return top + meta_all - - -class _DeferredMetadata: - """Read-only passthrough view over a raw candidate metadata dict. - - Field lookups first hit the raw dict; keys missing from the dict fall - back to the pydantic model field defaults, so pre-materialization - readers observe the same values a built item would expose (e.g. - ``memory_type`` -> ``"WorkingMemory"``, ``usage`` -> ``[]``). Unknown - names raise ``AttributeError`` so ``hasattr``/``getattr`` keep their - usual semantics. ``mode="before"`` validators are NOT replicated — - consumers that need validated objects (e.g. reranker strategies - reading ``sources``) must operate on materialized items. - """ - - __slots__ = ("_metadata",) - - # Class-level cache of {field name: pydantic default} for the metadata - # models _coerce_metadata can produce from raw node dicts. Searched (a - # superset of the TreeNode/Textual fields) is listed LAST so it wins any - # field-name conflict with Preference — e.g. created_at keeps the - # TreeNode default_factory instead of Preference's None, matching what - # a recall node would actually build. - _FIELD_DEFAULTS: ClassVar[dict[str, Any] | None] = None - - def __init__(self, metadata: dict): - self._metadata = metadata - - @classmethod - def _field_defaults(cls) -> dict[str, Any]: - if cls._FIELD_DEFAULTS is None: - cls._FIELD_DEFAULTS = { - name: field.get_default(call_default_factory=True) - for model in ( - PreferenceTextualMemoryMetadata, - SearchedTreeNodeTextualMemoryMetadata, - ) - for name, field in model.model_fields.items() - } - return cls._FIELD_DEFAULTS - - def __getattr__(self, name: str): - if name.startswith("__"): - raise AttributeError(name) - try: - return self._metadata[name] - except KeyError: - defaults = self._field_defaults() - if name not in defaults: - raise AttributeError(name) from None - default = defaults[name] - # Copy mutable defaults so callers cannot corrupt the shared cache. - if isinstance(default, (list, dict, set)): - return default.copy() - return default - - -class DeferredTextualMemoryItem: - """Validation-free view over a raw candidate node dict. - - Recall paths wrap candidate node dicts in this view instead of eagerly - constructing a ``TextualMemoryItem``, so full pydantic validation runs - only for candidates that survive ranking and trimming (via ``build``) - rather than for every recalled candidate. - - Contract (read-only): exposes ``id``, ``memory`` and ``metadata`` field - lookups, with metadata falling back to pydantic field defaults for - known fields and raising ``AttributeError`` for unknown ones. Raw node - values are passed through unchanged apart from those defaults — - ``mode="before"`` validators are not applied. The view is immutable: - consumers that mutate items or rely on validated objects (reranker - strategies, ``model_dump``) must call ``build()`` first. - """ - - __slots__ = ("_node",) - - def __init__(self, node: dict): - self._node = node - - @property - def id(self) -> str: - return self._node.get("id") - - @property - def memory(self) -> str: - return self._node.get("memory") - - @property - def metadata(self) -> _DeferredMetadata: - return _DeferredMetadata(self._node.get("metadata") or {}) - - def build(self) -> TextualMemoryItem: - """Materialize the deferred candidate with full validation.""" - return TextualMemoryItem.from_dict(self._node) - - -RetrievableMemoryItem = TextualMemoryItem | DeferredTextualMemoryItem diff --git a/src/memos/memories/textual/tree_text_memory/retrieve/recall.py b/src/memos/memories/textual/tree_text_memory/retrieve/recall.py index 84dbbf890..e66ba24fb 100644 --- a/src/memos/memories/textual/tree_text_memory/retrieve/recall.py +++ b/src/memos/memories/textual/tree_text_memory/retrieve/recall.py @@ -5,11 +5,7 @@ from memos.embedders.factory import OllamaEmbedder from memos.graph_dbs.neo4j import Neo4jGraphDB from memos.log import get_logger -from memos.memories.textual.item import ( - DeferredTextualMemoryItem, - RetrievableMemoryItem, - TextualMemoryItem, -) +from memos.memories.textual.item import TextualMemoryItem from memos.memories.textual.tree_text_memory.retrieve.bm25_util import EnhancedBM25 from memos.memories.textual.tree_text_memory.retrieve.retrieval_mid_structs import ParsedTaskGoal @@ -94,7 +90,7 @@ def retrieve( user_name: str | None = None, id_filter: dict | None = None, use_fast_graph: bool = False, - ) -> list[RetrievableMemoryItem]: + ) -> list[TextualMemoryItem]: """ Perform hybrid memory retrieval: - Run graph-based lookup from dispatch plan. @@ -213,14 +209,9 @@ def retrieve_from_cube( if memory_scope not in ["WorkingMemory", "LongTermMemory", "UserMemory"]: raise ValueError(f"Unsupported memory scope: {memory_scope}") - # Materialize deferred candidates first: this path mutates metadata - # in place below and must hand out real items. - graph_results = [ - item.build() if isinstance(item, DeferredTextualMemoryItem) else item - for item in self._vector_recall( - query_embedding, memory_scope, top_k, cube_name=cube_name, user_name=user_name - ) - ] + graph_results = self._vector_recall( + query_embedding, memory_scope, top_k, cube_name=cube_name, user_name=user_name + ) for result_i in graph_results: result_i.metadata.memory_type = "OuterMemory" @@ -236,7 +227,7 @@ def retrieve_from_mixed( query_embedding: list[list[float]] | None = None, search_filter: dict | None = None, user_name: str | None = None, - ) -> list[RetrievableMemoryItem]: + ) -> list[TextualMemoryItem]: """Retrieve from mixed and memory""" vector_results = self._vector_recall( query_embedding or [], @@ -376,7 +367,12 @@ def process_node(node): final_nodes = [result for result in temp_results if result is not None] return final_nodes - def _vector_recall( + def _vector_recall(self, *args, **kwargs) -> list[TextualMemoryItem]: + return [ + TextualMemoryItem.from_dict(node) for node in self._vector_recall_nodes(*args, **kwargs) + ] + + def _vector_recall_nodes( self, query_embedding: list[list[float]], memory_scope: str, @@ -387,7 +383,7 @@ def _vector_recall( search_filter: dict | None = None, search_priority: dict | None = None, user_name: str | None = None, - ) -> list[RetrievableMemoryItem]: + ) -> list[dict]: """ Perform vector-based similarity retrieval using query embedding. # TODO: tackle with post-filter and pre-filter(5.18+) better. @@ -486,7 +482,7 @@ def search_path_b(): hit.get("memory") is not None and hit.get("memory_type") is not None for hit in lightweight_hits ): - return [self._memory_item_from_vector_hit(hit) for hit in lightweight_hits] + return [self._node_from_vector_hit(hit) for hit in lightweight_hits] logger.warning( "Lightweight vector search returned incomplete fields; falling back to get_nodes" ) @@ -522,25 +518,17 @@ def search_path_b(): node["metadata"]["relativity"] = id_to_hit.get(rid, {}).get("score", 0.0) ordered_nodes.append(node) - # Deferred candidates: full pydantic validation runs later, only for - # items that survive ranking and trimming (searcher._sort_and_trim). - return [DeferredTextualMemoryItem(n) for n in ordered_nodes] + return ordered_nodes @staticmethod - def _memory_item_from_vector_hit(hit: dict) -> TextualMemoryItem: + def _node_from_vector_hit(hit: dict) -> dict: metadata = { key: value for key, value in hit.items() if key not in {"id", "memory", "score"} and value is not None } metadata["relativity"] = hit.get("score", 0.0) - return TextualMemoryItem.from_dict( - { - "id": hit["id"], - "memory": hit["memory"], - "metadata": metadata, - } - ) + return {"id": hit["id"], "memory": hit["memory"], "metadata": metadata} def _bm25_recall( self, @@ -667,6 +655,4 @@ def _fulltext_recall( node["metadata"]["relativity"] = id_to_score.get(rid, 0.0) ordered_nodes.append(node) - # Deferred candidates: full pydantic validation runs later, only for - # items that survive ranking and trimming (searcher._sort_and_trim). - return [DeferredTextualMemoryItem(n) for n in ordered_nodes] + return [TextualMemoryItem.from_dict(n) for n in ordered_nodes] diff --git a/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py b/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py index c57f72e04..0563d6c7a 100644 --- a/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py +++ b/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py @@ -8,12 +8,7 @@ from memos.graph_dbs.factory import Neo4jGraphDB from memos.llms.factory import AzureLLM, OllamaLLM, OpenAILLM from memos.log import get_logger, summarize_textual_memories -from memos.memories.textual.item import ( - DeferredTextualMemoryItem, - RetrievableMemoryItem, - SearchedTreeNodeTextualMemoryMetadata, - TextualMemoryItem, -) +from memos.memories.textual.item import SearchedTreeNodeTextualMemoryMetadata, TextualMemoryItem from memos.memories.textual.tree_text_memory.retrieve.bm25_util import EnhancedBM25 from memos.memories.textual.tree_text_memory.retrieve.retrieve_utils import ( FastTokenizer, @@ -38,15 +33,6 @@ logger = get_logger(__name__) - - -def _materialize_candidate(item: RetrievableMemoryItem) -> TextualMemoryItem: - """Build deferred candidates into fully validated items; pass items through.""" - if isinstance(item, DeferredTextualMemoryItem): - return item.build() - return item - - KEYWORD_EXTRACT_TOP_K = 3 KEYWORD_ALLOW_POS = ("n", "nr", "nrt", "ns", "nt", "nz", "vn", "v", "t", "eng", "m") COT_DICT = { @@ -94,17 +80,12 @@ def _maybe_rerank( enabled: bool, *, query: str, - graph_results: list[RetrievableMemoryItem], + graph_results: list[TextualMemoryItem], top_k: int, **kwargs, ) -> list[tuple[TextualMemoryItem, float]]: - # Reranker strategies enrich and mutate items (e.g. single_turn - # reassigns ``item.memory``), and deferred views are read-only, so - # materialize before reranking. The disabled path materializes too, - # so Searcher.retrieve() never returns deferred views to callers. if not enabled or self.reranker is None: - return [(_materialize_candidate(item), 0.0) for item in graph_results[:top_k]] - graph_results = [_materialize_candidate(item) for item in graph_results] + return [(item, 0.0) for item in graph_results[:top_k]] return self.reranker.rerank( query=query, graph_results=graph_results, @@ -173,7 +154,7 @@ def retrieve( def post_retrieve( self, - retrieved_results: list[tuple[RetrievableMemoryItem, float]], + retrieved_results: list[tuple[TextualMemoryItem, float]], top_k: int, user_name: str | None = None, info=None, @@ -277,9 +258,7 @@ def search( full_recall = kwargs.get("full_recall", False) if full_recall: - # full_recall callers receive untrimmed results and may treat them - # as fully constructed items; materialize deferred candidates here. - return [(_materialize_candidate(item), score) for item, score in retrieved_results] + return retrieved_results final_results = self.post_retrieve( retrieved_results=retrieved_results, @@ -1134,15 +1113,15 @@ def _retrieve_simple( logger.info(f"[SIMPLESEARCH] Query words: {query_words}") query_embeddings = self.embedder.embed(query_words) - items = self.graph_retriever.retrieve_from_mixed( + candidate_nodes = self.graph_retriever._vector_recall_nodes( top_k=top_k * 2, memory_scope=None, query_embedding=query_embeddings, search_filter=search_filter, user_name=user_name, ) - logger.info(f"[SIMPLESEARCH] Items count: {len(items)}") - documents = [getattr(item, "memory", "") for item in items] + logger.info(f"[SIMPLESEARCH] Items count: {len(candidate_nodes)}") + documents = [node["memory"] for node in candidate_nodes] if not documents: return [] documents_embeddings = self.embedder.embed(documents) @@ -1151,11 +1130,13 @@ def _retrieve_simple( return [] similarity_matrix = cosine_similarity_matrix(documents_embeddings) selected_indices, _ = find_best_unrelated_subgroup(documents, similarity_matrix) - selected_items = [items[i] for i in selected_indices] + rerank = bool(kwargs.get("rerank", True)) + if not rerank or self.reranker is None: + selected_indices = selected_indices[:top_k] + selected_items = [TextualMemoryItem.from_dict(candidate_nodes[i]) for i in selected_indices] logger.info( f"[SIMPLESEARCH] after unrelated subgroup selection items count: {len(selected_items)}" ) - rerank = bool(kwargs.get("rerank", True)) return self._maybe_rerank( rerank, query=query, @@ -1200,7 +1181,6 @@ def _sort_and_trim( for item, score in sorted_tool_schema_results: if plugin and round(score, 2) == 0.00: continue - item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( @@ -1221,7 +1201,6 @@ def _sort_and_trim( for item, score in sorted_tool_trajectory_results: if plugin and round(score, 2) == 0.00: continue - item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( @@ -1244,7 +1223,6 @@ def _sort_and_trim( for item, score in sorted_skill_results: if plugin and round(score, 2) == 0.00: continue - item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( @@ -1267,7 +1245,6 @@ def _sort_and_trim( for item, score in sorted_pref_results: if plugin and round(score, 2) == 0.00: continue - item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( @@ -1291,7 +1268,6 @@ def _sort_and_trim( for item, score in sorted_results: if plugin and round(score, 2) == 0.00: continue - item = _materialize_candidate(item) meta_data = item.metadata.model_dump() meta_data["relativity"] = score final_items.append( diff --git a/tests/memories/textual/test_deferred_candidate.py b/tests/memories/textual/test_deferred_candidate.py index c1ab4ca3c..381cda113 100644 --- a/tests/memories/textual/test_deferred_candidate.py +++ b/tests/memories/textual/test_deferred_candidate.py @@ -1,255 +1,69 @@ -"""Tests for deferred candidate construction in the recall pipeline. - -Covers the ``DeferredTextualMemoryItem`` view: attribute passthrough, -``build()`` equivalence against eager construction, and pipeline-level -equivalence for rerank / dedup / sort-and-trim when candidates are deferred. -""" - -import copy import uuid -import pytest - -from unittest.mock import patch - -from memos.memories.textual.item import ( - DeferredTextualMemoryItem, - SearchedTreeNodeTextualMemoryMetadata, - TextualMemoryItem, -) -from memos.memories.textual.tree_text_memory.retrieve.searcher import ( - Searcher, - _materialize_candidate, -) -from memos.reranker.cosine_local import CosineLocalReranker - - -def make_node(i, with_embedding=True, with_relativity=True, memory_type="LongTermMemory"): - md = { - "memory_type": memory_type, - "background": "fact", - "timestamp": 1735689600.0, - "created_at": "2026-01-15T10:30:00", - "updated_at": "2026-01-15T10:30:00", - "confidence": 0.9, - "usage": ["u1"], - "sources": [ - { - "conversation_id": str(uuid.uuid4()), - "content": f"source content {i}", - "timestamp": "2026-01-15T10:30:00", - "role": "user", - } - ], - } - if with_embedding: - md["embedding"] = [float(i), 1.0, 2.0, 3.0] - if with_relativity: - md["relativity"] = 0.5 - return { - "id": str(uuid.uuid4()), - "memory": f"memory content {i}", - "metadata": md, - } - - -def test_view_attribute_passthrough(): - node = make_node(1) - view = DeferredTextualMemoryItem(node) - assert view.id == node["id"] - assert view.memory == node["memory"] - assert view.metadata.embedding == node["metadata"]["embedding"] - assert view.metadata.background == "fact" - assert view.metadata.memory_type == "LongTermMemory" - with pytest.raises(AttributeError): - view.metadata.nonexistent - - -def test_view_unknown_field_hasattr_getattr_semantics(): - view = DeferredTextualMemoryItem(make_node(1)) - assert not hasattr(view.metadata, "no_such_field") - assert getattr(view.metadata, "no_such_field", "fallback") == "fallback" - - -def test_view_known_field_defaults_match_built_item(): - node = make_node(3) - node["metadata"] = { - k: v for k, v in node["metadata"].items() - if k not in ("memory_type", "usage", "file_ids", "knowledge_summary_ids") - } - view = DeferredTextualMemoryItem(node) - built = TextualMemoryItem.from_dict(node) - assert view.metadata.memory_type == built.metadata.memory_type == "WorkingMemory" - assert view.metadata.usage == built.metadata.usage == [] - assert view.metadata.file_ids == built.metadata.file_ids == [] - assert view.metadata.knowledge_summary_ids == built.metadata.knowledge_summary_ids == [] - - -def test_view_defaults_are_not_shared_mutable_state(): - view = DeferredTextualMemoryItem({"id": "x", "memory": "m", "metadata": {}}) - view.metadata.usage.append("corrupted") - fresh = DeferredTextualMemoryItem({"id": "y", "memory": "m", "metadata": {}}) - assert fresh.metadata.usage == [] - - -def test_view_missing_metadata(): - view = DeferredTextualMemoryItem({"id": "x", "memory": "m"}) - assert view.id == "x" - assert view.memory == "m" - # Missing keys fall back to the pydantic field defaults, matching what a - # built item would expose for the same node dict. - assert view.metadata.memory_type == "WorkingMemory" - with pytest.raises(AttributeError): - view.metadata.no_such_field - - -def test_view_id_matches_real_item_id(): - node = make_node(2) - assert DeferredTextualMemoryItem(node).id == TextualMemoryItem.from_dict(node).id - - -def test_build_equivalence(): - nodes = [make_node(i) for i in range(5)] - nodes.append(make_node(9, with_embedding=False, with_relativity=False)) - nodes.append(make_node(11, memory_type="UserMemory")) - for node in nodes: - assert ( - DeferredTextualMemoryItem(node).build().to_dict() - == TextualMemoryItem.from_dict(node).to_dict() - ) - - -def test_materialize_helper(): - node = make_node(3) - view = DeferredTextualMemoryItem(node) - item = TextualMemoryItem.from_dict(node) - assert _materialize_candidate(view).to_dict() == item.to_dict() - assert _materialize_candidate(item) is item - - -def test_rerank_equivalence_views_vs_items(): - nodes = [make_node(i, with_embedding=(i % 3 != 0)) for i in range(8)] - items = [TextualMemoryItem.from_dict(n) for n in nodes] - views = [DeferredTextualMemoryItem(n) for n in nodes] - query_embedding = [0.5, 1.0, 2.0, 3.0] - reranker = CosineLocalReranker() - - out_items = reranker.rerank( - query="q", graph_results=items, top_k=5, query_embedding=query_embedding - ) - out_views = reranker.rerank( - query="q", graph_results=views, top_k=5, query_embedding=query_embedding - ) - - assert len(out_items) == len(out_views) - for (item_a, score_a), (item_b, score_b) in zip(out_items, out_views, strict=True): - assert score_a == score_b - assert item_a.memory == item_b.memory - - -def test_maybe_rerank_materializes_before_rerank(): - """Reranker strategies mutate items (e.g. single_turn reassigns memory).""" - - class MutatingReranker: - def rerank(self, query, graph_results, top_k, **kwargs): - out = [] - for i, item in enumerate(graph_results[:top_k]): - item.memory = f"{item.memory} enriched" # would fail on a view - out.append((item, 1.0 - i * 0.1)) - return out - - searcher = Searcher.__new__(Searcher) - searcher.reranker = MutatingReranker() - result = searcher._maybe_rerank( - True, query="q", graph_results=[DeferredTextualMemoryItem(make_node(4))], top_k=5 - ) - assert len(result) == 1 - assert isinstance(result[0][0], TextualMemoryItem) - assert result[0][0].memory == "memory content 4 enriched" - - -def test_maybe_rerank_disabled_path_materializes(): - """Searcher.retrieve() must never hand deferred views to its callers.""" - searcher = Searcher.__new__(Searcher) - searcher.reranker = None - result = searcher._maybe_rerank( - False, query="q", graph_results=[DeferredTextualMemoryItem(make_node(6))], top_k=5 - ) - assert len(result) == 1 - assert isinstance(result[0][0], TextualMemoryItem) - assert result[0][1] == 0.0 - - -def test_sort_and_trim_defaults_missing_memory_type(): - """A node without memory_type is WorkingMemory by default and must - survive the textual branch filter instead of being silently dropped.""" - node = make_node(7) - node["metadata"] = {k: v for k, v in node["metadata"].items() if k != "memory_type"} - searcher = Searcher.__new__(Searcher) - out = searcher._sort_and_trim([(DeferredTextualMemoryItem(node), 0.8)], 4) - assert len(out) == 1 - assert out[0].metadata.memory_type == "WorkingMemory" +from unittest.mock import Mock, patch +import pytest -def test_deduplicate_results_mixed(): - searcher = Searcher.__new__(Searcher) - nodes = [make_node(i) for i in range(4)] - items = [TextualMemoryItem.from_dict(n) for n in nodes] - results = [ - (DeferredTextualMemoryItem(nodes[0]), 0.1), - (items[0], 0.9), - (items[1], 0.5), - (DeferredTextualMemoryItem(nodes[1]), 0.4), +from memos.memories.textual.item import TextualMemoryItem +from memos.memories.textual.tree_text_memory.retrieve.recall import GraphMemoryRetriever +from memos.memories.textual.tree_text_memory.retrieve.retrieval_mid_structs import ParsedTaskGoal +from memos.memories.textual.tree_text_memory.retrieve.searcher import Searcher + + +@pytest.fixture +def retriever(): + store = Mock() + store.get_nodes.return_value = [ + { + "id": str(uuid.uuid4()), + "memory": "first", + "metadata": {"metadata": {"memory_type": "SkillMemory"}}, + }, + {"id": str(uuid.uuid4()), "memory": "second", "metadata": {"memory_type": "UserMemory"}}, ] - deduped = searcher._deduplicate_results(results) - assert len(deduped) == 2 - assert deduped[0][1] == 0.9 - assert deduped[0][0].memory == items[0].memory - - -def test_sort_and_trim_equivalence(): - nodes = [make_node(i) for i in range(10)] - items = [TextualMemoryItem.from_dict(n) for n in nodes] - scores = [0.9 - i * 0.05 for i in range(10)] - results_items = list(zip(items, scores, strict=True)) - results_mixed = [ - (DeferredTextualMemoryItem(nodes[i]) if i % 2 == 0 else items[i], scores[i]) - for i in range(10) + store.search_by_embedding.return_value = [ + {"id": node["id"], "score": 1.0 - i / 10} + for i, node in enumerate(store.get_nodes.return_value) ] + return GraphMemoryRetriever(store, Mock()) + + +@pytest.mark.parametrize("mixed", [False, True]) +def test_public_recall_materializes_legacy_nested_metadata(retriever, mixed): + if mixed: + results = retriever.retrieve_from_mixed(top_k=2, query_embedding=[[0.1]]) + else: + results = retriever.retrieve( + "query", + ParsedTaskGoal(keys=[], tags=[]), + top_k=2, + memory_scope="SkillMemory", + query_embedding=[[0.1]], + ) - searcher = Searcher.__new__(Searcher) - out_items = searcher._sort_and_trim(results_items, 4) - out_mixed = searcher._sort_and_trim(results_mixed, 4) - - assert [it.to_dict() for it in out_items] == [it.to_dict() for it in out_mixed] - for it in out_mixed: - assert isinstance(it, TextualMemoryItem) - assert isinstance(it.metadata, SearchedTreeNodeTextualMemoryMetadata) - - -def test_sort_and_trim_tool_branch_materializes(): - node = make_node(21, memory_type="ToolSchemaMemory") - view = DeferredTextualMemoryItem(node) - searcher = Searcher.__new__(Searcher) - out = searcher._sort_and_trim([(view, 0.7)], 6, search_tool_memory=True) - assert len(out) == 1 - assert isinstance(out[0], TextualMemoryItem) - assert out[0].metadata.memory_type == "ToolSchemaMemory" + assert all(isinstance(item, TextualMemoryItem) for item in results) + assert [item.metadata.memory_type for item in results] == ["SkillMemory", "UserMemory"] -def test_plugin_zero_score_skips_materialization(): - view = DeferredTextualMemoryItem(make_node(5)) +def test_plugin_search_materializes_only_subgroup_survivors(retriever): searcher = Searcher.__new__(Searcher) - with patch.object( - DeferredTextualMemoryItem, "build", side_effect=AssertionError("should not build") - ) as mock_build: - out = searcher._sort_and_trim([(view, 0.001)], 3, plugin=True) - assert out == [] - assert mock_build.call_count == 0 - - -def test_deepcopy_safety(): - view = DeferredTextualMemoryItem(make_node(7)) - copied = copy.deepcopy(view) - assert copied.memory == view.memory - assert copied.build().to_dict() == view.build().to_dict() + searcher.graph_retriever = retriever + searcher.tokenizer = None + searcher.embedder = Mock() + searcher.embedder.embed.return_value = [[0.1], [0.2]] + searcher.reranker = Mock() + searcher.reranker.rerank.side_effect = lambda **kw: [(kw["graph_results"][0], 0.7)] + + with ( + patch.object(TextualMemoryItem, "from_dict", wraps=TextualMemoryItem.from_dict) as build, + patch( + "memos.memories.textual.tree_text_memory.retrieve.searcher.find_best_unrelated_subgroup", + return_value=([0], None), + ), + ): + [(result, score)] = searcher._retrieve_simple("sample", top_k=1) + + assert result.metadata.memory_type == "SkillMemory" + assert score == 0.7 + build.assert_called_once() + assert build.call_args.args[0]["memory"] == "first" diff --git a/tests/memories/textual/test_tree_retriever.py b/tests/memories/textual/test_tree_retriever.py index 893d2926a..39e22a063 100644 --- a/tests/memories/textual/test_tree_retriever.py +++ b/tests/memories/textual/test_tree_retriever.py @@ -4,11 +4,7 @@ import pytest -from memos.memories.textual.item import ( - DeferredTextualMemoryItem, - TextualMemoryItem, - TreeNodeTextualMemoryMetadata, -) +from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata from memos.memories.textual.tree_text_memory.retrieve.recall import GraphMemoryRetriever from memos.memories.textual.tree_text_memory.retrieve.retrieval_mid_structs import ParsedTaskGoal @@ -81,12 +77,7 @@ def test_vector_recall_combines_and_dedups(retriever, mock_graph_store): results = retriever._vector_recall(vec, "LongTermMemory", top_k=5) assert len(results) == 2 - # Vector recall returns deferred candidates; they build into fully - # validated items with the same ids. - assert all(isinstance(r, DeferredTextualMemoryItem) for r in results) - built = [r.build() for r in results] - assert all(isinstance(b, TextualMemoryItem) for b in built) - assert {b.id for b in built} == {n1_id, n2_id} + assert all(isinstance(r, TextualMemoryItem) for r in results) def test_vector_recall_uses_lightweight_hits_without_get_nodes( From 739104c9572a241ea452ac4dbea9e271b028b723 Mon Sep 17 00:00:00 2001 From: Wenqiang Wei <46308778+endxxxx@users.noreply.github.com> Date: Wed, 18 Nov 2026 15:03:15 +0800 Subject: [PATCH 3/3] test: exercise PolarDB identifiers through public recall --- tests/graph_dbs/test_search_return_fields.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/tests/graph_dbs/test_search_return_fields.py b/tests/graph_dbs/test_search_return_fields.py index a23374e5a..4918614a3 100644 --- a/tests/graph_dbs/test_search_return_fields.py +++ b/tests/graph_dbs/test_search_return_fields.py @@ -276,7 +276,7 @@ def test_polardb_declares_lightweight_vector_search_support(self, polardb_instan ], ) def test_lightweight_numeric_user_id_can_be_recalled( - self, polardb_instance, stored_user_id, expected_user_id + self, polardb_instance, stored_user_id, expected_user_id, monkeypatch ): from memos.memories.textual.tree_text_memory.retrieve.recall import GraphMemoryRetriever @@ -324,7 +324,14 @@ def fake_connection(): "is_fast", ], ) - memory = GraphMemoryRetriever._memory_item_from_vector_hit(hits[0]) + monkeypatch.setenv("MEMOS_POLARDB_LIGHTWEIGHT_SEARCH_ENABLED", "true") + graph_store = MagicMock(supports_lightweight_vector_search=True) + graph_store.search_by_embedding.return_value = hits + retriever = GraphMemoryRetriever(graph_store, MagicMock()) + [memory] = retriever.retrieve_from_mixed( + top_k=1, query_embedding=[[0.1] * 1024], user_name="knowledge-cube" + ) + graph_store.get_nodes.assert_not_called() assert memory.metadata.user_id == expected_user_id assert memory.metadata.tags == ["synthetic"] assert memory.metadata.info == {"test": True}