Hotfix/task id loss

src/memos/api/handlers/add_handler.py

@@ -45,7 +45,9 @@ def handle_add_memories(self, add_req: APIADDRequest) -> MemoryResponse:
         Returns:
             MemoryResponse with added memory information
         """
-        self.logger.info(f"[AddHandler] Add Req is: {add_req}")
+        self.logger.info(
+            f"[DIAGNOSTIC] server_router -> add_handler.handle_add_memories called (Modified at 2025-11-29 18:46). Full request: {add_req.model_dump_json(indent=2)}"
+        )
 
         if add_req.info:
             exclude_fields = list_all_fields()

src/memos/api/routers/product_router.py

@@ -188,6 +188,7 @@ def get_all_memories(memory_req: GetMemoryPlaygroundRequest):
 @router.post("/add", summary="add a new memory", response_model=SimpleResponse)
 def create_memory(memory_req: MemoryCreateRequest):
     """Create a new memory for a specific user."""
+    logger.info("DIAGNOSTIC: /product/add endpoint called. This confirms the new code is deployed.")
     # Initialize status_tracker outside try block to avoid NameError in except blocks
     status_tracker = None
 

src/memos/mem_os/core.py

@@ -788,6 +788,9 @@ def process_textual_memory():
                                 timestamp=datetime.utcnow(),
                                 task_id=task_id,
                             )
+                            logger.info(
+                                f"[DIAGNOSTIC] core.add: Submitting message to scheduler: {message_item.model_dump_json(indent=2)}"
+                            )
                             self.mem_scheduler.memos_message_queue.submit_messages(
                                 messages=[message_item]
                             )

src/memos/mem_scheduler/base_scheduler.py

@@ -594,6 +594,11 @@ def _submit_web_logs(
         Args:
             messages: Single log message or list of log messages
         """
+        messages_list = [messages] if isinstance(messages, ScheduleLogForWebItem) else messages
+        for message in messages_list:
+            logger.info(
+                f"[DIAGNOSTIC] base_scheduler._submit_web_logs called. Message to publish: {message.model_dump_json(indent=2)}"
+            )
         if self.rabbitmq_config is None:
             return
 

src/memos/mem_scheduler/general_modules/scheduler_logger.py

@@ -113,9 +113,10 @@ def create_event_log(
         metadata: list[dict],
         memory_len: int,
         memcube_name: str | None = None,
+        log_content: str | None = None,
     ) -> ScheduleLogForWebItem:
         item = self.create_autofilled_log_item(
-            log_content="",
+            log_content=log_content or "",
             label=label,
             from_memory_type=from_memory_type,
             to_memory_type=to_memory_type,

src/memos/mem_scheduler/general_scheduler.py

@@ -367,16 +367,19 @@ def _add_message_consumer(self, messages: list[ScheduleMessageItem]) -> None:
                             if kb_log_content:
                                 event = self.create_event_log(
                                     label="knowledgeBaseUpdate",
+                                    # 1. 移除 log_content 参数
+                                    # 2. 补充 memory_type
                                     from_memory_type=USER_INPUT_TYPE,
                                     to_memory_type=LONG_TERM_MEMORY_TYPE,
                                     user_id=msg.user_id,
                                     mem_cube_id=msg.mem_cube_id,
                                     mem_cube=self.current_mem_cube,
                                     memcube_log_content=kb_log_content,
-                                    metadata=None,  # Per design doc for KB logs
+                                    metadata=None,
                                     memory_len=len(kb_log_content),
                                     memcube_name=self._map_memcube_name(msg.mem_cube_id),
                                 )
+                                # 3. 后置赋值 log_content
                                 event.log_content = (
                                     f"Knowledge Base Memory Update: {len(kb_log_content)} changes."
                                 )
@@ -474,6 +477,9 @@ def _add_message_consumer(self, messages: list[ScheduleMessageItem]) -> None:
             logger.error(f"Error: {e}", exc_info=True)
 
     def _mem_read_message_consumer(self, messages: list[ScheduleMessageItem]) -> None:
+        logger.info(
+            f"[DIAGNOSTIC] general_scheduler._mem_read_message_consumer called. Received messages: {[msg.model_dump_json(indent=2) for msg in messages]}"
+        )
         logger.info(f"Messages {messages} assigned to {MEM_READ_LABEL} handler.")
 
         def process_message(message: ScheduleMessageItem):
@@ -538,6 +544,9 @@ def _process_memories_with_reader(
         task_id: str | None = None,
         info: dict | None = None,
     ) -> None:
+        logger.info(
+            f"[DIAGNOSTIC] general_scheduler._process_memories_with_reader called. mem_ids: {mem_ids}, user_id: {user_id}, mem_cube_id: {mem_cube_id}, task_id: {task_id}"
+        )
         """
         Process memories using mem_reader for enhanced memory processing.
 
@@ -635,6 +644,9 @@ def _process_memories_with_reader(
                                 }
                             )
                         if kb_log_content:
+                            logger.info(
+                                f"[DIAGNOSTIC] general_scheduler._process_memories_with_reader: Creating event log for KB update. Label: knowledgeBaseUpdate, user_id: {user_id}, mem_cube_id: {mem_cube_id}, task_id: {task_id}. KB content: {json.dumps(kb_log_content, indent=2)}"
+                            )
                             event = self.create_event_log(
                                 label="knowledgeBaseUpdate",
                                 from_memory_type=USER_INPUT_TYPE,

src/memos/mem_scheduler/schemas/message_schemas.py

@@ -84,6 +84,7 @@ def to_dict(self) -> dict:
             "content": self.content,
             "timestamp": self.timestamp.isoformat(),
             "user_name": self.user_name,
+            "task_id": self.task_id if self.task_id is not None else "",
         }
 
     @classmethod
@@ -97,6 +98,7 @@ def from_dict(cls, data: dict) -> "ScheduleMessageItem":
             content=data["content"],
             timestamp=datetime.fromisoformat(data["timestamp"]),
             user_name=data.get("user_name"),
+            task_id=data.get("task_id"),
         )
 
 

src/memos/mem_scheduler/task_schedule_modules/redis_queue.py

@@ -35,7 +35,8 @@ class SchedulerRedisQueue(RedisSchedulerModule):
     def __init__(
         self,
         stream_key_prefix: str = os.getenv(
-            "MEMSCHEDULER_REDIS_STREAM_KEY_PREFIX", "scheduler:messages:stream"
+            "MEMSCHEDULER_REDIS_STREAM_KEY_PREFIX",
+            "scheduler:messages:stream:v2",
         ),
         consumer_group: str = "scheduler_group",
         consumer_name: str | None = "scheduler_consumer",
@@ -78,6 +79,11 @@ def __init__(
         # Task tracking for mem_scheduler_wait compatibility
         self._unfinished_tasks = 0
 
+        logger.info(
+            f"[REDIS_QUEUE] Initialized with stream_prefix='{self.stream_key_prefix}', "
+            f"consumer_group='{self.consumer_group}', consumer_name='{self.consumer_name}'"
+        )
+
         # Auto-initialize Redis connection
         if self.auto_initialize_redis():
             self._is_connected = True

src/memos/mem_scheduler/webservice_modules/rabbitmq_service.py

@@ -1,4 +1,5 @@
 import json
+import os
 import ssl
 import threading
 import time
@@ -270,15 +271,36 @@ def rabbitmq_publish_message(self, message: dict):
         """
         import pika
 
+        exchange_name = self.rabbitmq_exchange_name
+        routing_key = self.rabbit_queue_name
+
+        if message.get("label") == "knowledgeBaseUpdate":
+            kb_specific_exchange_name = os.getenv("MEMSCHEDULER_RABBITMQ_EXCHANGE_NAME")
+
+            if kb_specific_exchange_name:
+                exchange_name = kb_specific_exchange_name
+
+            routing_key = ""  # User specified empty routing key for KB updates
+
+            logger.info(
+                f"[DIAGNOSTIC] Publishing KB Update message. "
+                f"ENV_EXCHANGE_NAME_USED: {kb_specific_exchange_name is not None}. "
+                f"Current configured Exchange: {exchange_name}, Routing Key: '{routing_key}'."
+            )
+            logger.info(f"  - Message Content: {json.dumps(message, indent=2)}")
+
         with self._rabbitmq_lock:
             if not self.is_rabbitmq_connected():
                 logger.error("Cannot publish - no active connection")
                 return False
 
+            logger.info(
+                f"[DIAGNOSTIC] rabbitmq_service.rabbitmq_publish_message: Attempting to publish message. Exchange: {exchange_name}, Routing Key: {routing_key}, Message Content: {json.dumps(message, indent=2)}"
+            )
             try:
                 self.rabbitmq_channel.basic_publish(
-                    exchange=self.rabbitmq_exchange_name,
-                    routing_key=self.rabbit_queue_name,
+                    exchange=exchange_name,
+                    routing_key=routing_key,
                     body=json.dumps(message),
                     properties=pika.BasicProperties(
                         delivery_mode=2,  # Persistent

src/memos/multi_mem_cube/single_cube.py

@@ -55,6 +55,10 @@ def add_memories(self, add_req: APIADDRequest) -> list[dict[str, Any]]:
         This is basically your current handle_add_memories logic,
         but scoped to a single cube_id.
         """
+        sync_mode = add_req.async_mode or self._get_sync_mode()
+        self.logger.info(
+            f"[DIAGNOSTIC] single_cube.add_memories called for cube_id: {self.cube_id}. sync_mode: {sync_mode}. Request: {add_req.model_dump_json(indent=2)}"
+        )
         user_context = UserContext(
             user_id=add_req.user_id,
             mem_cube_id=self.cube_id,