From 1a517115561e91cc7cb214e38afe899b3b7fc1d0 Mon Sep 17 00:00:00 2001 From: One Date: Thu, 5 Nov 2026 17:14:38 +0800 Subject: [PATCH] fix(retrieval): write relativity in place instead of full rebuild The textual branch of _sort_and_trim rebuilt every selected item (model_dump + two-level pydantic construction, including re-validating the full embedding list and sources) only to set metadata.relativity to the final score. When the metadata type already declares the relativity field (vector/fulltext recall results), write the score in place with the same float() coercion pydantic validation would have applied. Items whose metadata lacks the field (e.g. graph/bm25 results) still go through the rebuild for the type upgrade, preserving behavior. --- .../tree_text_memory/retrieve/searcher.py | 35 +++-- tests/memories/textual/test_tree_searcher.py | 135 +++++++++++++++++- 2 files changed, 160 insertions(+), 10 deletions(-) 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..b7db6fe7b 100644 --- a/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py +++ b/src/memos/memories/textual/tree_text_memory/retrieve/searcher.py @@ -1165,7 +1165,14 @@ def _sort_and_trim( include_preference_memory=False, pref_mem_top_k=6, ): - """Sort results by score and trim to top_k""" + """Sort results by score and trim to top_k. + + Note: + Takes ownership of ``results``: selected textual items have their + ``metadata.relativity`` overwritten in place when the metadata type + already declares the field; other metadata types are rebuilt into + ``SearchedTreeNodeTextualMemoryMetadata`` as before. + """ final_items = [] if search_tool_memory: tool_schema_results = [ @@ -1266,15 +1273,25 @@ def _sort_and_trim( for item, score in sorted_results: if plugin and round(score, 2) == 0.00: continue - meta_data = item.metadata.model_dump() - meta_data["relativity"] = score - final_items.append( - TextualMemoryItem( - id=item.id, - memory=item.memory, - metadata=SearchedTreeNodeTextualMemoryMetadata(**meta_data), + metadata = item.metadata + if isinstance(metadata, SearchedTreeNodeTextualMemoryMetadata): + # The field already exists on this metadata type: write the + # score in place, applying the same float() coercion the + # rebuild path below would apply through pydantic validation. + metadata.relativity = float(score) + final_items.append(item) + else: + # Type upgrade (e.g. graph/bm25 results without relativity): + # rebuild into the searched metadata type as before. + meta_data = metadata.model_dump() + meta_data["relativity"] = score + final_items.append( + TextualMemoryItem( + id=item.id, + memory=item.memory, + metadata=SearchedTreeNodeTextualMemoryMetadata(**meta_data), + ) ) - ) return final_items @timed diff --git a/tests/memories/textual/test_tree_searcher.py b/tests/memories/textual/test_tree_searcher.py index fe40cbb7d..31e96ce06 100644 --- a/tests/memories/textual/test_tree_searcher.py +++ b/tests/memories/textual/test_tree_searcher.py @@ -2,9 +2,14 @@ from unittest.mock import MagicMock +import numpy as np import pytest -from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata +from memos.memories.textual.item import ( + SearchedTreeNodeTextualMemoryMetadata, + TextualMemoryItem, + TreeNodeTextualMemoryMetadata, +) from memos.memories.textual.tree_text_memory.retrieve.searcher import Searcher from memos.reranker.base import BaseReranker @@ -168,3 +173,131 @@ def test_deduplicate_rawfile_results_uses_knowledge_summary_ids(mock_searcher): assert result == [raw_file] mock_searcher.graph_store.get_edges.assert_not_called() + + +def make_searched_item(content: str, score: float, relativity: float = 0.5): + """Build a Searched-type candidate as produced by vector/fulltext recall.""" + return ( + TextualMemoryItem( + id=str(uuid.uuid4()), + memory=content, + metadata=SearchedTreeNodeTextualMemoryMetadata( + memory_type="LongTermMemory", + embedding=[0.1] * 5, + usage=[], + sources=[{"type": "chat", "role": "user", "content": "context"}], + relativity=relativity, + ), + ), + score, + ) + + +def rebuild_like_before(item: TextualMemoryItem, score: float) -> TextualMemoryItem: + """Reference implementation of the pre-optimization dump-and-rebuild behavior.""" + meta_data = item.metadata.model_dump() + meta_data["relativity"] = score + return TextualMemoryItem( + id=item.id, + memory=item.memory, + metadata=SearchedTreeNodeTextualMemoryMetadata(**meta_data), + ) + + +def test_sort_and_trim_hot_path_in_place_equivalence(mock_searcher): + """Searched-type items are reused in place and match the old rebuild output.""" + inputs = [ + make_searched_item("m-high", 0.9), + make_searched_item("m-mid", 0.8), + make_searched_item("m-low", 0.7), + ] + input_items = {item.id: item for item, _ in inputs} + + result = mock_searcher._sort_and_trim(inputs, top_k=2) + + assert [item.memory for item in result] == ["m-high", "m-mid"] + for item, score in zip(result, [0.9, 0.8], strict=True): + # Selected items are the very same objects, relativity overwritten in place. + assert item is input_items[item.id] + assert item.metadata.relativity == score + assert isinstance(item.metadata.relativity, float) + # Output is exactly what the old dump-and-rebuild path produced. + assert item.to_dict() == rebuild_like_before(input_items[item.id], score).to_dict() + + +def test_sort_and_trim_cold_path_type_upgrade(mock_searcher): + """Non-Searched metadata (e.g. graph/bm25 results) is still rebuilt.""" + original = make_item("graph-mem", 0.8) + + result = mock_searcher._sort_and_trim([original], top_k=2) + + assert len(result) == 1 + rebuilt = result[0] + assert rebuilt is not original[0] # cold path produces a new item + assert isinstance(rebuilt.metadata, SearchedTreeNodeTextualMemoryMetadata) + assert rebuilt.metadata.relativity == 0.8 + assert rebuilt.to_dict() == rebuild_like_before(original[0], 0.8).to_dict() + + +def test_sort_and_trim_mixed_types(mock_searcher): + """Mixed Searched/TreeNode candidates all come back as Searched with final scores.""" + inputs = [ + make_searched_item("hot-1", 0.6), + make_item("cold-1", 0.95), + make_searched_item("hot-2", 0.7), + ] + + result = mock_searcher._sort_and_trim(inputs, top_k=3) + + assert [item.memory for item in result] == ["cold-1", "hot-2", "hot-1"] + assert all(isinstance(item.metadata, SearchedTreeNodeTextualMemoryMetadata) for item in result) + assert [item.metadata.relativity for item in result] == [0.95, 0.7, 0.6] + + +def test_sort_and_trim_beyond_top_k_untouched(mock_searcher): + """Candidates trimmed away keep the relativity injected at recall time.""" + inputs = [ + make_searched_item("keep", 0.9), + make_searched_item("drop-1", 0.5), + make_searched_item("drop-2", 0.4), + ] + + result = mock_searcher._sort_and_trim(inputs, top_k=1) + + assert [item.memory for item in result] == ["keep"] + for item, _ in inputs[1:]: + assert item.metadata.relativity == 0.5 + + +def test_sort_and_trim_plugin_filters_zero_scores(mock_searcher): + """plugin=True drops candidates whose score rounds to 0.00 without writing.""" + inputs = [make_searched_item("near-zero", 0.001, relativity=0.42)] + + result = mock_searcher._sort_and_trim(inputs, top_k=5, plugin=True) + + assert result == [] + assert inputs[0][0].metadata.relativity == 0.42 + + +def test_sort_and_trim_reuses_input_list_safely(mock_searcher): + """Calling _sort_and_trim twice on the same candidates is idempotent.""" + inputs = [ + make_searched_item("m-1", 0.9), + make_item("m-2", 0.8), + ] + + first = mock_searcher._sort_and_trim(list(inputs), top_k=2) + second = mock_searcher._sort_and_trim(list(inputs), top_k=2) + + assert [item.to_dict() for item in first] == [item.to_dict() for item in second] + assert [item.metadata.relativity for item in first] == [0.9, 0.8] + + +def test_sort_and_trim_coerces_numpy_score(mock_searcher): + """The in-place write applies the same float() coercion pydantic validation did.""" + item, _score = make_searched_item("np-mem", 0.0) + + result = mock_searcher._sort_and_trim([(item, np.float64(0.9))], top_k=1) + + assert isinstance(result[0].metadata.relativity, float) + assert result[0].metadata.relativity == 0.9