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..e66ba24fb 100644 --- a/src/memos/memories/textual/tree_text_memory/retrieve/recall.py +++ b/src/memos/memories/textual/tree_text_memory/retrieve/recall.py @@ -367,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, @@ -378,7 +383,7 @@ def _vector_recall( search_filter: dict | None = None, search_priority: dict | None = None, user_name: str | None = None, - ) -> list[TextualMemoryItem]: + ) -> list[dict]: """ Perform vector-based similarity retrieval using query embedding. # TODO: tackle with post-filter and pre-filter(5.18+) better. @@ -477,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" ) @@ -513,23 +518,17 @@ 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] + 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, 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..0563d6c7a 100644 --- a/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py +++ b/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py @@ -1113,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) @@ -1130,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, 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} diff --git a/tests/memories/textual/test_deferred_candidate.py b/tests/memories/textual/test_deferred_candidate.py new file mode 100644 index 000000000..381cda113 --- /dev/null +++ b/tests/memories/textual/test_deferred_candidate.py @@ -0,0 +1,69 @@ +import uuid + +from unittest.mock import Mock, patch + +import pytest + +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"}}, + ] + 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]], + ) + + assert all(isinstance(item, TextualMemoryItem) for item in results) + assert [item.metadata.memory_type for item in results] == ["SkillMemory", "UserMemory"] + + +def test_plugin_search_materializes_only_subgroup_survivors(retriever): + searcher = Searcher.__new__(Searcher) + 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"