Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
112 changes: 81 additions & 31 deletions src/memos/api/handlers/search_handler.py
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,7 @@
from memos.api.handlers.base_handler import BaseHandler, HandlerDependencies
from memos.api.handlers.formatters_handler import rerank_knowledge_mem
from memos.api.product_models import APISearchRequest, SearchResponse
from memos.context.context import get_current_trace_id
from memos.dream.contextualization import CONTEXT_MEMORY_TYPE
from memos.log import get_logger, summarize_search_request, summarize_search_results
from memos.memories.textual.tree_text_memory.retrieve.retrieve_utils import (
Expand All @@ -23,6 +24,7 @@
from memos.multi_mem_cube.composite_cube import CompositeCubeView
from memos.multi_mem_cube.single_cube import SingleCubeView
from memos.multi_mem_cube.views import MemCubeView
from memos.plugins.hook_context import HookContext, build_hook_context
from memos.plugins.hook_defs import H
from memos.plugins.hooks import hookable, trigger_hook

Expand Down Expand Up @@ -65,8 +67,14 @@ def __init__(self, dependencies: HandlerDependencies):
"naive_mem_cube", "mem_scheduler", "searcher", "deepsearch_agent"
)

@hookable("search")
def handle_search_memories(self, search_req: APISearchRequest) -> SearchResponse:
@hookable(
"search",
context_builder=lambda handler, request: handler._build_search_hook_context(request),
)
def handle_search_memories(
self,
search_req: APISearchRequest,
) -> SearchResponse:
"""
Main handler for search memories endpoint.

Expand Down Expand Up @@ -96,44 +104,75 @@ def handle_search_memories(self, search_req: APISearchRequest) -> SearchResponse
results = cube_view.search_memories(search_req_local)
hooked_results = trigger_hook(
H.SEARCH_MEMORY_RESULTS,
hook_context=self._build_search_hook_context(search_req_local),
handler=self,
search_req=search_req_local,
results=results,
)
if hooked_results is not None:
results = hooked_results
if not search_req_local.relativity:
search_req_local.relativity = 0
self.logger.info(f"[SearchHandler] Relativity filter: {search_req_local.relativity}")
results = self._apply_relativity_threshold(results, search_req_local.relativity)

if search_req_local.dedup == "sim":
results = self._dedup_text_memories(results, search_req.top_k)
self._strip_embeddings(results)
elif search_req_local.dedup == "mmr":
pref_top_k = getattr(search_req_local, "pref_top_k", 6)
results = self._mmr_dedup_text_memories(results, search_req.top_k, pref_top_k)
self._strip_embeddings(results)

text_mem = results["text_mem"]
results["text_mem"] = rerank_knowledge_mem(
self.reranker,
query=search_req.query,
text_mem=text_mem,
top_k=search_req_local.top_k,
file_mem_proportion=0.5,
)
hooked_results = trigger_hook(
H.SEARCH_RESULTS_AFTER_RERANK,
handler=self,
search_req=search_req_local,
results=results,
)
if hooked_results is not None:
results = hooked_results
try:
if not search_req_local.relativity:
search_req_local.relativity = 0
self.logger.info(f"[SearchHandler] Relativity filter: {search_req_local.relativity}")
results = self._apply_relativity_threshold(results, search_req_local.relativity)
hooked_results = trigger_hook(
H.SEARCH_RESULTS_AFTER_THRESHOLD,
hook_context=self._build_search_hook_context(search_req_local),
handler=self,
search_req=search_req_local,
results=results,
)
if hooked_results is not None:
results = hooked_results

if search_req_local.dedup == "sim":
results = self._dedup_text_memories(results, search_req.top_k)
self._strip_embeddings(results)
elif search_req_local.dedup == "mmr":
pref_top_k = getattr(search_req_local, "pref_top_k", 6)
results = self._mmr_dedup_text_memories(results, search_req.top_k, pref_top_k)
self._strip_embeddings(results)
hooked_results = trigger_hook(
H.SEARCH_RESULTS_AFTER_DEDUP,
hook_context=self._build_search_hook_context(search_req_local),
handler=self,
search_req=search_req_local,
results=results,
)
if hooked_results is not None:
results = hooked_results

text_mem = results["text_mem"]
results["text_mem"] = rerank_knowledge_mem(
self.reranker,
query=search_req.query,
text_mem=text_mem,
top_k=search_req_local.top_k,
file_mem_proportion=0.5,
)
hooked_results = trigger_hook(
H.SEARCH_RESULTS_AFTER_RERANK,
hook_context=self._build_search_hook_context(search_req_local),
handler=self,
search_req=search_req_local,
results=results,
)
if hooked_results is not None:
results = hooked_results
except Exception as error:
trigger_hook(
H.SEARCH_POST_PROCESS_FAILED,
hook_context=self._build_search_hook_context(search_req_local),
handler=self,
search_req=search_req_local,
error=error,
)
raise

hooked_results = trigger_hook(
H.SEARCH_CONTEXT_RENDER,
hook_context=self._build_search_hook_context(search_req_local),
handler=self,
search_req=search_req_local,
results=results,
Expand Down Expand Up @@ -1036,6 +1075,17 @@ def _resolve_cube_ids(self, search_req: APISearchRequest) -> list[str]:

return [search_req.user_id]

def _build_search_hook_context(self, search_req: APISearchRequest) -> HookContext:
mode = search_req.mode.value if hasattr(search_req.mode, "value") else str(search_req.mode)
return build_hook_context(
source="api.search",
trace_id=get_current_trace_id(),
user_id=search_req.user_id,
session_id=search_req.session_id or "default_session",
cube_ids=self._resolve_cube_ids(search_req),
attributes={"mode": mode},
)

def _build_cube_view(self, search_req: APISearchRequest, searcher=None) -> MemCubeView:
cube_ids = self._resolve_cube_ids(search_req)
searcher_to_use = searcher if searcher is not None else self.searcher
Expand Down
113 changes: 86 additions & 27 deletions src/memos/mem_reader/simple_struct.py
Original file line number Diff line number Diff line change
Expand Up @@ -13,10 +13,13 @@
from memos.chunkers import ChunkerFactory
from memos.configs.llm import LLMConfigFactory
from memos.configs.mem_reader import SimpleStructMemReaderConfig
from memos.context.context import ContextThreadPoolExecutor
from memos.context.context import ContextThreadPoolExecutor, get_current_trace_id
from memos.embedders.factory import EmbedderFactory
from memos.llms.factory import LLMFactory
from memos.mem_reader.base import BaseMemReader
from memos.plugins.hook_context import HookContext, build_hook_context
from memos.plugins.hook_defs import H
from memos.plugins.hooks import trigger_hook


if TYPE_CHECKING:
Expand Down Expand Up @@ -476,6 +479,33 @@ def _process_transfer_chat_data(

return chat_read_nodes

def _build_extract_hook_data(
self,
scene_data: SceneDataInput,
type: str,
info: dict[str, Any],
mode: str,
user_name: str | None,
kwargs: dict[str, Any],
) -> tuple[dict[str, Any], HookContext]:
hook_input = {
"mem_reader": self,
"scene_data": scene_data,
"type": type,
"info": info,
"mode": mode,
"user_name": user_name,
"kwargs": kwargs,
}
return hook_input, build_hook_context(
trace_id=get_current_trace_id(),
user_id=info.get("user_id") if isinstance(info, dict) else None,
session_id=info.get("session_id") if isinstance(info, dict) else None,
cube_ids=[user_name] if user_name else None,
source="mem_reader.extract",
attributes={"mode": mode, "type": type},
)

def get_memory(
self,
scene_data: SceneDataInput,
Expand Down Expand Up @@ -509,28 +539,57 @@ def get_memory(
Raises:
ValueError: If scene_data is empty or if info dictionary is missing required fields
"""
if not scene_data:
raise ValueError("scene_data is empty")

# Validate info dictionary format
if not isinstance(info, dict):
raise ValueError("info must be a dictionary")

required_fields = {"user_id", "session_id"}
missing_fields = required_fields - set(info.keys())
if missing_fields:
raise ValueError(f"info dictionary is missing required fields: {missing_fields}")

if not all(isinstance(info[field], str) for field in required_fields):
raise ValueError("user_id and session_id must be strings")

# Backward compatibility, after coercing scene_data, we only tackle
# with standard scene_data type: MessagesType
standard_scene_data = coerce_scene_data(scene_data, type)
return self._read_memory(
standard_scene_data, type, info, mode, user_name=user_name, **kwargs
# Build Hook business arguments and correlation context.
hook_input, hook_context = self._build_extract_hook_data(
scene_data,
type,
info,
mode,
user_name,
kwargs,
)

try:
if not scene_data:
raise ValueError("scene_data is empty")

# Validate info dictionary format
if not isinstance(info, dict):
raise ValueError("info must be a dictionary")

required_fields = {"user_id", "session_id"}
missing_fields = required_fields - set(info.keys())
if missing_fields:
raise ValueError(f"info dictionary is missing required fields: {missing_fields}")

if not all(isinstance(info[field], str) for field in required_fields):
raise ValueError("user_id and session_id must be strings")

# Backward compatibility, after coercing scene_data, we only tackle
# with standard scene_data type: MessagesType
standard_scene_data = coerce_scene_data(scene_data, type)
result = self._read_memory(
standard_scene_data, type, info, mode, user_name=user_name, **kwargs
)
except Exception as error:
trigger_hook(
H.MEM_READER_EXTRACT_FAILED,
hook_context=hook_context,
**hook_input,
error=error,
)
raise

hook_result = trigger_hook(
H.MEM_READER_EXTRACT_AFTER,
hook_context=hook_context,
**hook_input,
result=result,
)
if hook_result is not None:
result = hook_result
return result

def rewrite_memories(
self, messages: list[dict], memory_list: list[TextualMemoryItem], user_only: bool = True
) -> list[TextualMemoryItem]:
Expand Down Expand Up @@ -756,7 +815,7 @@ def fine_transfer_simple_mem(
if not input_memories:
return []

memory_list = []
memory_list = [[] for _ in input_memories]

if type == "chat":
processing_func = self._process_transfer_chat_data
Expand All @@ -767,15 +826,15 @@ def fine_transfer_simple_mem(

# Process Q&A pairs concurrently with context propagation
with ContextThreadPoolExecutor() as executor:
futures = [
executor.submit(processing_func, scene_data_info, custom_tags, **kwargs)
for scene_data_info in input_memories
]
futures = {
executor.submit(processing_func, scene_data_info, custom_tags, **kwargs): index
for index, scene_data_info in enumerate(input_memories)
}
for future in concurrent.futures.as_completed(futures):
try:
res_memory = future.result()
if res_memory is not None:
memory_list.append(res_memory)
memory_list[futures[future]] = res_memory
except Exception as e:
logger.error(f"Task failed with exception: {e}")
logger.error(traceback.format_exc())
Expand Down
24 changes: 23 additions & 1 deletion src/memos/mem_scheduler/task_schedule_modules/base_handler.py
Original file line number Diff line number Diff line change
@@ -1,9 +1,12 @@
from __future__ import annotations

from abc import abstractmethod
from typing import TYPE_CHECKING
from typing import TYPE_CHECKING, Any

from memos.log import get_logger
from memos.mem_scheduler.task_schedule_modules.operation_observer import (
SchedulerOperationObserver,
)
from memos.mem_scheduler.utils.misc_utils import group_messages_by_user_and_mem_cube


Expand Down Expand Up @@ -34,6 +37,25 @@ def validate_and_log_messages(self, messages: list[ScheduleMessageItem], label:
def handle_exception(self, e: Exception, message: str = "Error processing messages") -> None:
logger.error(f"{message}: {e}", exc_info=True)

def observe_operation(
self,
operation_name: str,
*,
operation: str,
operation_context: dict[str, Any],
operation_input: dict[str, Any],
capture_failure: bool = False,
) -> SchedulerOperationObserver:
"""Expose a scheduler operation through the standard plugin Hook contract."""
source = f"scheduler.{self.expected_task_label}.{operation_name}"
return SchedulerOperationObserver(
source=source,
operation=operation,
operation_context=operation_context,
operation_input=operation_input,
capture_failure=capture_failure,
)

def process_grouped_messages(
self,
messages: list[ScheduleMessageItem],
Expand Down
Loading