MemoryOS 0.2.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

memos/mem_scheduler/general_modules/scheduler_logger.py

@@ -0,0 +1,261 @@
+from collections.abc import Callable
+
+from memos.log import get_logger
+from memos.mem_cube.general import GeneralMemCube
+from memos.mem_scheduler.general_modules.base import BaseSchedulerModule
+from memos.mem_scheduler.schemas.general_schemas import (
+    ACTIVATION_MEMORY_TYPE,
+    ADD_LABEL,
+    LONG_TERM_MEMORY_TYPE,
+    NOT_INITIALIZED,
+    PARAMETER_MEMORY_TYPE,
+    QUERY_LABEL,
+    TEXT_MEMORY_TYPE,
+    USER_INPUT_TYPE,
+    WORKING_MEMORY_TYPE,
+)
+from memos.mem_scheduler.schemas.message_schemas import (
+    ScheduleLogForWebItem,
+    ScheduleMessageItem,
+)
+from memos.mem_scheduler.utils.filter_utils import (
+    transform_name_to_key,
+)
+from memos.mem_scheduler.utils.misc_utils import log_exceptions
+from memos.memories.textual.tree import TextualMemoryItem, TreeTextMemory
+
+
+logger = get_logger(__name__)
+
+
+class SchedulerLoggerModule(BaseSchedulerModule):
+    def __init__(self):
+        """
+        Initialize RabbitMQ connection settings.
+        """
+        super().__init__()
+
+    @log_exceptions(logger=logger)
+    def create_autofilled_log_item(
+        self,
+        log_content: str,
+        label: str,
+        from_memory_type: str,
+        to_memory_type: str,
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+    ) -> ScheduleLogForWebItem:
+        text_mem_base: TreeTextMemory = mem_cube.text_mem
+        current_memory_sizes = text_mem_base.get_current_memory_size()
+        current_memory_sizes = {
+            "long_term_memory_size": current_memory_sizes.get("LongTermMemory", 0),
+            "user_memory_size": current_memory_sizes.get("UserMemory", 0),
+            "working_memory_size": current_memory_sizes.get("WorkingMemory", 0),
+            "transformed_act_memory_size": NOT_INITIALIZED,
+            "parameter_memory_size": NOT_INITIALIZED,
+        }
+        memory_capacities = {
+            "long_term_memory_capacity": text_mem_base.memory_manager.memory_size["LongTermMemory"],
+            "user_memory_capacity": text_mem_base.memory_manager.memory_size["UserMemory"],
+            "working_memory_capacity": text_mem_base.memory_manager.memory_size["WorkingMemory"],
+            "transformed_act_memory_capacity": NOT_INITIALIZED,
+            "parameter_memory_capacity": NOT_INITIALIZED,
+        }
+
+        if hasattr(self, "monitor"):
+            if (
+                user_id in self.monitor.activation_memory_monitors
+                and mem_cube_id in self.monitor.activation_memory_monitors[user_id]
+            ):
+                activation_monitor = self.monitor.activation_memory_monitors[user_id][mem_cube_id]
+                transformed_act_memory_size = len(activation_monitor.memories)
+                logger.info(
+                    f'activation_memory_monitors currently has "{transformed_act_memory_size}" transformed memory size'
+                )
+            else:
+                transformed_act_memory_size = 0
+                logger.info(
+                    f'activation_memory_monitors is not initialized for user "{user_id}" and mem_cube "{mem_cube_id}'
+                )
+            current_memory_sizes["transformed_act_memory_size"] = transformed_act_memory_size
+            current_memory_sizes["parameter_memory_size"] = 1
+
+            memory_capacities["transformed_act_memory_capacity"] = (
+                self.monitor.activation_mem_monitor_capacity
+            )
+            memory_capacities["parameter_memory_capacity"] = 1
+
+        log_message = ScheduleLogForWebItem(
+            user_id=user_id,
+            mem_cube_id=mem_cube_id,
+            label=label,
+            from_memory_type=from_memory_type,
+            to_memory_type=to_memory_type,
+            log_content=log_content,
+            current_memory_sizes=current_memory_sizes,
+            memory_capacities=memory_capacities,
+        )
+        return log_message
+
+    @log_exceptions(logger=logger)
+    def log_working_memory_replacement(
+        self,
+        original_memory: list[TextualMemoryItem],
+        new_memory: list[TextualMemoryItem],
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+        log_func_callback: Callable[[list[ScheduleLogForWebItem]], None],
+    ):
+        """Log changes when working memory is replaced."""
+        memory_type_map = {
+            transform_name_to_key(name=m.memory): m.metadata.memory_type
+            for m in original_memory + new_memory
+        }
+
+        original_text_memories = [m.memory for m in original_memory]
+        new_text_memories = [m.memory for m in new_memory]
+
+        # Convert to sets for efficient difference operations
+        original_set = set(original_text_memories)
+        new_set = set(new_text_memories)
+
+        # Identify changes
+        added_memories = list(new_set - original_set)  # Present in new but not original
+
+        # recording messages
+        for memory in added_memories:
+            normalized_mem = transform_name_to_key(name=memory)
+            if normalized_mem not in memory_type_map:
+                logger.error(f"Memory text not found in type mapping: {memory[:50]}...")
+            # Get the memory type from the map, default to LONG_TERM_MEMORY_TYPE if not found
+            mem_type = memory_type_map.get(normalized_mem, LONG_TERM_MEMORY_TYPE)
+
+            if mem_type == WORKING_MEMORY_TYPE:
+                logger.warning(f"Memory already in working memory: {memory[:50]}...")
+                continue
+
+            log_message = self.create_autofilled_log_item(
+                log_content=memory,
+                label=QUERY_LABEL,
+                from_memory_type=mem_type,
+                to_memory_type=WORKING_MEMORY_TYPE,
+                user_id=user_id,
+                mem_cube_id=mem_cube_id,
+                mem_cube=mem_cube,
+            )
+            log_func_callback([log_message])
+            logger.info(
+                f"{len(added_memories)} {LONG_TERM_MEMORY_TYPE} memorie(s) "
+                f"transformed to {WORKING_MEMORY_TYPE} memories."
+            )
+
+    @log_exceptions(logger=logger)
+    def log_activation_memory_update(
+        self,
+        original_text_memories: list[str],
+        new_text_memories: list[str],
+        label: str,
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+        log_func_callback: Callable[[list[ScheduleLogForWebItem]], None],
+    ):
+        """Log changes when activation memory is updated."""
+        original_set = set(original_text_memories)
+        new_set = set(new_text_memories)
+
+        # Identify changes
+        added_memories = list(new_set - original_set)  # Present in new but not original
+
+        # recording messages
+        for mem in added_memories:
+            log_message_a = self.create_autofilled_log_item(
+                log_content=mem,
+                label=label,
+                from_memory_type=TEXT_MEMORY_TYPE,
+                to_memory_type=ACTIVATION_MEMORY_TYPE,
+                user_id=user_id,
+                mem_cube_id=mem_cube_id,
+                mem_cube=mem_cube,
+            )
+            logger.info(
+                f"{len(added_memories)} {TEXT_MEMORY_TYPE} memorie(s) "
+                f"transformed to {ACTIVATION_MEMORY_TYPE} memories."
+            )
+
+            log_message_b = self.create_autofilled_log_item(
+                log_content=mem,
+                label=label,
+                from_memory_type=ACTIVATION_MEMORY_TYPE,
+                to_memory_type=PARAMETER_MEMORY_TYPE,
+                user_id=user_id,
+                mem_cube_id=mem_cube_id,
+                mem_cube=mem_cube,
+            )
+            logger.info(
+                f"{len(added_memories)} {ACTIVATION_MEMORY_TYPE} memorie(s) "
+                f"transformed to {PARAMETER_MEMORY_TYPE} memories."
+            )
+
+            log_func_callback([log_message_a, log_message_b])
+
+    @log_exceptions(logger=logger)
+    def log_adding_memory(
+        self,
+        memory: str,
+        memory_type: str,
+        user_id: str,
+        mem_cube_id: str,
+        mem_cube: GeneralMemCube,
+        log_func_callback: Callable[[list[ScheduleLogForWebItem]], None],
+    ):
+        """Log changes when working memory is replaced."""
+        log_message = self.create_autofilled_log_item(
+            log_content=memory,
+            label=ADD_LABEL,
+            from_memory_type=USER_INPUT_TYPE,
+            to_memory_type=memory_type,
+            user_id=user_id,
+            mem_cube_id=mem_cube_id,
+            mem_cube=mem_cube,
+        )
+        log_func_callback([log_message])
+        logger.info(
+            f"{USER_INPUT_TYPE} memory for user {user_id} "
+            f"converted to {memory_type} memory in mem_cube {mem_cube_id}: {memory}"
+        )
+
+    @log_exceptions(logger=logger)
+    def validate_schedule_message(self, message: ScheduleMessageItem, label: str):
+        """Validate if the message matches the expected label.
+
+        Args:
+            message: Incoming message item to validate.
+            label: Expected message label (e.g., QUERY_LABEL/ANSWER_LABEL).
+
+        Returns:
+            bool: True if validation passed, False otherwise.
+        """
+        if message.label != label:
+            logger.error(f"Handler validation failed: expected={label}, actual={message.label}")
+            return False
+        return True
+
+    @log_exceptions(logger=logger)
+    def validate_schedule_messages(self, messages: list[ScheduleMessageItem], label: str):
+        """Validate if all messages match the expected label.
+
+        Args:
+            messages: List of message items to validate.
+            label: Expected message label (e.g., QUERY_LABEL/ANSWER_LABEL).
+
+        Returns:
+            bool: True if all messages passed validation, False if any failed.
+        """
+        for message in messages:
+            if not self.validate_schedule_message(message, label):
+                logger.error("Message batch contains invalid labels, aborting processing")
+                return False
+        return True

memos/mem_scheduler/general_scheduler.py

@@ -4,12 +4,18 @@ from memos.configs.mem_scheduler import GeneralSchedulerConfig
 from memos.log import get_logger
 from memos.mem_cube.general import GeneralMemCube
 from memos.mem_scheduler.base_scheduler import BaseScheduler
-from memos.mem_scheduler.modules.schemas import (
+from memos.mem_scheduler.schemas.general_schemas import (
     ADD_LABEL,
     ANSWER_LABEL,
+    DEFAULT_MAX_QUERY_KEY_WORDS,
     QUERY_LABEL,
-    ScheduleMessageItem,
+    WORKING_MEMORY_TYPE,
+    MemCubeID,
+    UserID,
 )
+from memos.mem_scheduler.schemas.message_schemas import ScheduleMessageItem
+from memos.mem_scheduler.schemas.monitor_schemas import QueryMonitorItem
+from memos.mem_scheduler.utils.filter_utils import is_all_chinese, is_all_english
 from memos.memories.textual.tree import TextualMemoryItem, TreeTextMemory
 
 
@@ -29,6 +35,78 @@ class GeneralScheduler(BaseScheduler):
         }
         self.dispatcher.register_handlers(handlers)
 
+    # for evaluation
+    def search_for_eval(
+        self, query: str, user_id: UserID | str, top_k: int, scheduler_flag: bool = True
+    ) -> (list[str], bool):
+        self.monitor.register_query_monitor_if_not_exists(
+            user_id=user_id, mem_cube_id=self.current_mem_cube_id
+        )
+
+        query_keywords = self.monitor.extract_query_keywords(query=query)
+        logger.info(f'Extract keywords "{query_keywords}" from query "{query}"')
+
+        item = QueryMonitorItem(
+            query_text=query,
+            keywords=query_keywords,
+            max_keywords=DEFAULT_MAX_QUERY_KEY_WORDS,
+        )
+        query_monitor = self.monitor.query_monitors[user_id][self.current_mem_cube_id]
+        query_monitor.put(item=item)
+        logger.debug(f"Queries in monitor are {query_monitor.get_queries_with_timesort()}.")
+
+        queries = [query]
+
+        # recall
+        mem_cube = self.current_mem_cube
+        text_mem_base = mem_cube.text_mem
+
+        cur_working_memory: list[TextualMemoryItem] = text_mem_base.get_working_memory()
+        text_working_memory: list[str] = [w_m.memory for w_m in cur_working_memory]
+        intent_result = self.monitor.detect_intent(
+            q_list=queries, text_working_memory=text_working_memory
+        )
+
+        if not scheduler_flag:
+            return text_working_memory, intent_result["trigger_retrieval"]
+        else:
+            if intent_result["trigger_retrieval"]:
+                missing_evidences = intent_result["missing_evidences"]
+                num_evidence = len(missing_evidences)
+                k_per_evidence = max(1, top_k // max(1, num_evidence))
+                new_candidates = []
+                for item in missing_evidences:
+                    logger.info(f"missing_evidences: {item}")
+                    results: list[TextualMemoryItem] = self.retriever.search(
+                        query=item,
+                        mem_cube=mem_cube,
+                        top_k=k_per_evidence,
+                        method=self.search_method,
+                    )
+                    logger.info(
+                        f"search results for {missing_evidences}: {[one.memory for one in results]}"
+                    )
+                    new_candidates.extend(results)
+                print(
+                    f"missing_evidences: {missing_evidences} and get {len(new_candidates)} new candidate memories."
+                )
+            else:
+                new_candidates = []
+                print(f"intent_result: {intent_result}. not triggered")
+
+            # rerank
+            new_order_working_memory = self.replace_working_memory(
+                user_id=user_id,
+                mem_cube_id=self.current_mem_cube_id,
+                mem_cube=self.current_mem_cube,
+                original_memory=cur_working_memory,
+                new_memory=new_candidates,
+            )
+            new_order_working_memory = new_order_working_memory[:top_k]
+            logger.info(f"size of new_order_working_memory: {len(new_order_working_memory)}")
+
+            return [m.memory for m in new_order_working_memory], intent_result["trigger_retrieval"]
+
     def _query_message_consumer(self, messages: list[ScheduleMessageItem]) -> None:
         """
         Process and handle query trigger messages from the queue.
@@ -36,12 +114,12 @@ class GeneralScheduler(BaseScheduler):
         Args:
             messages: List of query messages to process
         """
-        logger.debug(f"Messages {messages} assigned to {QUERY_LABEL} handler.")
+        logger.info(f"Messages {messages} assigned to {QUERY_LABEL} handler.")
 
         # Process the query in a session turn
         grouped_messages = self.dispatcher.group_messages_by_user_and_cube(messages=messages)
 
-        self._validate_messages(messages=messages, label=QUERY_LABEL)
+        self.validate_schedule_messages(messages=messages, label=QUERY_LABEL)
 
         for user_id in grouped_messages:
             for mem_cube_id in grouped_messages[user_id]:
@@ -49,16 +127,88 @@ class GeneralScheduler(BaseScheduler):
                 if len(messages) == 0:
                     return
 
+                mem_cube = messages[0].mem_cube
+
                 # for status update
                 self._set_current_context_from_message(msg=messages[0])
 
-                self.process_session_turn(
-                    queries=[msg.content for msg in messages],
+                # update query monitors
+                for msg in messages:
+                    self.monitor.register_query_monitor_if_not_exists(
+                        user_id=user_id, mem_cube_id=mem_cube_id
+                    )
+
+                    query = msg.content
+                    query_keywords = self.monitor.extract_query_keywords(query=query)
+                    logger.info(f'Extract keywords "{query_keywords}" from query "{query}"')
+
+                    if len(query_keywords) == 0:
+                        stripped_query = query.strip()
+                        # Determine measurement method based on language
+                        if is_all_english(stripped_query):
+                            words = stripped_query.split()  # Word count for English
+                        elif is_all_chinese(stripped_query):
+                            words = stripped_query  # Character count for Chinese
+                        else:
+                            logger.debug(
+                                f"Mixed-language memory, using character count: {stripped_query[:50]}..."
+                            )
+                            words = stripped_query  # Default to character count
+
+                        query_keywords = list(set(words[:20]))
+                        logger.error(
+                            f"Keyword extraction failed for query. Using fallback keywords: {query_keywords[:10]}... (truncated)"
+                        )
+
+                    item = QueryMonitorItem(
+                        query_text=query,
+                        keywords=query_keywords,
+                        max_keywords=DEFAULT_MAX_QUERY_KEY_WORDS,
+                    )
+
+                    self.monitor.query_monitors[user_id][mem_cube_id].put(item=item)
+                logger.debug(
+                    f"Queries in monitor are "
+                    f"{self.monitor.query_monitors[user_id][mem_cube_id].get_queries_with_timesort()}."
+                )
+
+                queries = [msg.content for msg in messages]
+
+                # recall
+                cur_working_memory, new_candidates = self.process_session_turn(
+                    queries=queries,
                     user_id=user_id,
                     mem_cube_id=mem_cube_id,
-                    mem_cube=messages[0].mem_cube,
+                    mem_cube=mem_cube,
                     top_k=self.top_k,
                 )
+                logger.info(
+                    f"Processed {queries} and get {len(new_candidates)} new candidate memories."
+                )
+
+                # rerank
+                new_order_working_memory = self.replace_working_memory(
+                    user_id=user_id,
+                    mem_cube_id=mem_cube_id,
+                    mem_cube=mem_cube,
+                    original_memory=cur_working_memory,
+                    new_memory=new_candidates,
+                )
+                logger.info(f"size of new_order_working_memory: {len(new_order_working_memory)}")
+
+                # update activation memories
+                logger.info(
+                    f"Activation memory update {'enabled' if self.enable_activation_memory else 'disabled'} "
+                    f"(interval: {self.monitor.act_mem_update_interval}s)"
+                )
+                if self.enable_activation_memory:
+                    self.update_activation_memory_periodically(
+                        interval_seconds=self.monitor.act_mem_update_interval,
+                        label=QUERY_LABEL,
+                        user_id=user_id,
+                        mem_cube_id=mem_cube_id,
+                        mem_cube=messages[0].mem_cube,
+                    )
 
     def _answer_message_consumer(self, messages: list[ScheduleMessageItem]) -> None:
         """
@@ -67,11 +217,11 @@ class GeneralScheduler(BaseScheduler):
         Args:
           messages: List of answer messages to process
         """
-        logger.debug(f"Messages {messages} assigned to {ANSWER_LABEL} handler.")
+        logger.info(f"Messages {messages} assigned to {ANSWER_LABEL} handler.")
         # Process the query in a session turn
         grouped_messages = self.dispatcher.group_messages_by_user_and_cube(messages=messages)
 
-        self._validate_messages(messages=messages, label=ANSWER_LABEL)
+        self.validate_schedule_messages(messages=messages, label=ANSWER_LABEL)
 
         for user_id in grouped_messages:
             for mem_cube_id in grouped_messages[user_id]:
@@ -82,105 +232,118 @@ class GeneralScheduler(BaseScheduler):
                 # for status update
                 self._set_current_context_from_message(msg=messages[0])
 
-                # update acivation memories
-                if self.enable_act_memory_update:
-                    self.update_activation_memory_periodically(
-                        interval_seconds=self.monitor.act_mem_update_interval,
-                        label=ANSWER_LABEL,
-                        user_id=user_id,
-                        mem_cube_id=mem_cube_id,
-                        mem_cube=messages[0].mem_cube,
-                    )
-
     def _add_message_consumer(self, messages: list[ScheduleMessageItem]) -> None:
-        logger.debug(f"Messages {messages} assigned to {ADD_LABEL} handler.")
+        logger.info(f"Messages {messages} assigned to {ADD_LABEL} handler.")
         # Process the query in a session turn
         grouped_messages = self.dispatcher.group_messages_by_user_and_cube(messages=messages)
 
-        self._validate_messages(messages=messages, label=ADD_LABEL)
+        self.validate_schedule_messages(messages=messages, label=ADD_LABEL)
+        try:
+            for user_id in grouped_messages:
+                for mem_cube_id in grouped_messages[user_id]:
+                    messages = grouped_messages[user_id][mem_cube_id]
+                    if len(messages) == 0:
+                        return
 
-        for user_id in grouped_messages:
-            for mem_cube_id in grouped_messages[user_id]:
-                messages = grouped_messages[user_id][mem_cube_id]
-                if len(messages) == 0:
-                    return
+                    # for status update
+                    self._set_current_context_from_message(msg=messages[0])
 
-                # for status update
-                self._set_current_context_from_message(msg=messages[0])
+                    # submit logs
+                    for msg in messages:
+                        try:
+                            userinput_memory_ids = json.loads(msg.content)
+                        except Exception as e:
+                            logger.error(f"Error: {e}. Content: {msg.content}", exc_info=True)
+                            userinput_memory_ids = []
 
-                # submit logs
-                for msg in messages:
-                    user_inputs = json.loads(msg.content)
-                    self.log_adding_user_inputs(
-                        user_inputs=user_inputs,
-                        user_id=msg.user_id,
-                        mem_cube_id=msg.mem_cube_id,
-                        mem_cube=msg.mem_cube,
-                    )
+                        mem_cube = msg.mem_cube
+                        for memory_id in userinput_memory_ids:
+                            mem_item: TextualMemoryItem = mem_cube.text_mem.get(memory_id=memory_id)
+                            mem_type = mem_item.metadata.memory_type
+                            mem_content = mem_item.memory
 
-                # update acivation memories
-                if self.enable_act_memory_update:
-                    self.update_activation_memory_periodically(
-                        interval_seconds=self.monitor.act_mem_update_interval,
-                        label=ADD_LABEL,
-                        user_id=user_id,
-                        mem_cube_id=mem_cube_id,
-                        mem_cube=messages[0].mem_cube,
-                    )
+                            if mem_type == WORKING_MEMORY_TYPE:
+                                continue
+
+                            self.log_adding_memory(
+                                memory=mem_content,
+                                memory_type=mem_type,
+                                user_id=msg.user_id,
+                                mem_cube_id=msg.mem_cube_id,
+                                mem_cube=msg.mem_cube,
+                                log_func_callback=self._submit_web_logs,
+                            )
+
+        except Exception as e:
+            logger.error(f"Error: {e}", exc_info=True)
 
     def process_session_turn(
         self,
         queries: str | list[str],
-        user_id: str,
-        mem_cube_id: str,
+        user_id: UserID | str,
+        mem_cube_id: MemCubeID | str,
         mem_cube: GeneralMemCube,
         top_k: int = 10,
-        query_history: list[str] | None = None,
-    ) -> None:
+    ) -> tuple[list[TextualMemoryItem], list[TextualMemoryItem]] | None:
         """
         Process a dialog turn:
         - If q_list reaches window size, trigger retrieval;
         - Immediately switch to the new memory if retrieval is triggered.
         """
-        if isinstance(queries, str):
-            queries = [queries]
-
-        if query_history is None:
-            query_history = queries
-        else:
-            query_history.extend(queries)
 
         text_mem_base = mem_cube.text_mem
         if not isinstance(text_mem_base, TreeTextMemory):
             logger.error("Not implemented!", exc_info=True)
             return
 
-        working_memory: list[TextualMemoryItem] = text_mem_base.get_working_memory()
-        text_working_memory: list[str] = [w_m.memory for w_m in working_memory]
+        logger.info(f"Processing {len(queries)} queries.")
+
+        cur_working_memory: list[TextualMemoryItem] = text_mem_base.get_working_memory()
+        text_working_memory: list[str] = [w_m.memory for w_m in cur_working_memory]
         intent_result = self.monitor.detect_intent(
-            q_list=query_history, text_working_memory=text_working_memory
+            q_list=queries, text_working_memory=text_working_memory
         )
 
-        if intent_result["trigger_retrieval"]:
-            missing_evidences = intent_result["missing_evidences"]
-            num_evidence = len(missing_evidences)
-            k_per_evidence = max(1, top_k // max(1, num_evidence))
-            new_candidates = []
-            for item in missing_evidences:
-                logger.debug(f"missing_evidences: {item}")
-                results = self.retriever.search(
-                    query=item, mem_cube=mem_cube, top_k=k_per_evidence, method=self.search_method
-                )
-                logger.debug(f"search results for {missing_evidences}: {results}")
-                new_candidates.extend(results)
+        time_trigger_flag = False
+        if self.monitor.timed_trigger(
+            last_time=self.monitor.last_query_consume_time,
+            interval_seconds=self.monitor.query_trigger_interval,
+        ):
+            time_trigger_flag = True
 
-            new_order_working_memory = self.retriever.replace_working_memory(
-                queries=queries,
-                user_id=user_id,
-                mem_cube_id=mem_cube_id,
+        if (not intent_result["trigger_retrieval"]) and (not time_trigger_flag):
+            logger.info(f"Query schedule not triggered. Intent_result: {intent_result}")
+            return
+        elif (not intent_result["trigger_retrieval"]) and time_trigger_flag:
+            logger.info("Query schedule is forced to trigger due to time ticker")
+            intent_result["trigger_retrieval"] = True
+            intent_result["missing_evidences"] = queries
+        else:
+            logger.info(
+                f'Query schedule triggered for user "{user_id}" and mem_cube "{mem_cube_id}".'
+                f" Missing evidences: {intent_result['missing_evidences']}"
+            )
+
+        missing_evidences = intent_result["missing_evidences"]
+        num_evidence = len(missing_evidences)
+        k_per_evidence = max(1, top_k // max(1, num_evidence))
+        new_candidates = []
+        for item in missing_evidences:
+            logger.info(f"missing_evidences: {item}")
+            info = {
+                "user_id": user_id,
+                "session_id": "",
+            }
+
+            results: list[TextualMemoryItem] = self.retriever.search(
+                query=item,
                 mem_cube=mem_cube,
-                original_memory=working_memory,
-                new_memory=new_candidates,
-                top_k=top_k,
+                top_k=k_per_evidence,
+                method=self.search_method,
+                info=info,
+            )
+            logger.info(
+                f"search results for {missing_evidences}: {[one.memory for one in results]}"
             )
-            logger.debug(f"size of new_order_working_memory: {len(new_order_working_memory)}")
+            new_candidates.extend(results)
+        return cur_working_memory, new_candidates