Merge branch 'dev-20260309-v2.0.9' of github.com:MemTensor/MemOS into dev-20260309-v2.0.9

Author: CarltonXiang

src/memos/api/handlers/memory_handler.py

@@ -320,7 +320,10 @@ def handle_delete_memories(delete_mem_req: DeleteMemoryRequest, naive_mem_cube:
     Now unified to delete from text_mem only (includes preferences).
     """
     logger.info(
-        f"[Delete memory request] writable_cube_ids: {delete_mem_req.writable_cube_ids}, memory_ids: {delete_mem_req.memory_ids}"
+        "[Delete memory request] writable_cube_ids: %s, memory_ids: %s, auto_cleanup_working: %s",
+        delete_mem_req.writable_cube_ids,
+        delete_mem_req.memory_ids,
+        getattr(delete_mem_req, "auto_cleanup_working", False),
     )
     # Validate that only one of memory_ids, file_ids, or filter is provided
     provided_params = [
@@ -335,6 +338,31 @@ def handle_delete_memories(delete_mem_req: DeleteMemoryRequest, naive_mem_cube:
         )
 
     try:
+        working_ids_to_delete: set[str] = set()
+        # When deleting by explicit memory_ids and auto_cleanup_working is enabled,
+        # collect related WorkingMemory ids from working_binding
+        if delete_mem_req.memory_ids is not None and getattr(
+            delete_mem_req, "auto_cleanup_working", False
+        ):
+            try:
+                memories = naive_mem_cube.text_mem.get_by_ids(memory_ids=delete_mem_req.memory_ids)
+            except Exception as e:
+                logger.warning("Failed to fetch memories before delete for working cleanup: %s", e)
+                memories = []
+
+            if memories:
+                import re
+
+                pattern = re.compile(r"\[working_binding:([0-9a-fA-F-]{36})\]")
+                for mem in memories:
+                    metadata = mem.get("metadata") or {}
+                    bg = metadata.get("background") or ""
+                    if not isinstance(bg, str):
+                        continue
+                    match = pattern.search(bg)
+                    if match:
+                        working_ids_to_delete.add(match.group(1))
+
         if delete_mem_req.memory_ids is not None:
             # Unified deletion from text_mem (includes preferences)
             naive_mem_cube.text_mem.delete_by_memory_ids(delete_mem_req.memory_ids)
@@ -344,6 +372,17 @@ def handle_delete_memories(delete_mem_req: DeleteMemoryRequest, naive_mem_cube:
             )
         elif delete_mem_req.filter is not None:
             naive_mem_cube.text_mem.delete_by_filter(filter=delete_mem_req.filter)
+
+        # After main deletion, optionally clean up related WorkingMemory nodes.
+        if working_ids_to_delete:
+            try:
+                logger.info(
+                    "Auto-cleanup WorkingMemory nodes after delete, count=%d",
+                    len(working_ids_to_delete),
+                )
+                naive_mem_cube.text_mem.delete_by_memory_ids(list(working_ids_to_delete))
+            except Exception as e:
+                logger.warning("Failed to auto-cleanup WorkingMemory nodes: %s, Pass", e)
     except Exception as e:
         logger.error(f"Failed to delete memories: {e}", exc_info=True)
         return DeleteMemoryResponse(

src/memos/api/product_models.py

@@ -858,6 +858,13 @@ class DeleteMemoryRequest(BaseRequest):
     memory_ids: list[str] | None = Field(None, description="Memory IDs")
     file_ids: list[str] | None = Field(None, description="File IDs")
     filter: dict[str, Any] | None = Field(None, description="Filter for the memory")
+    auto_cleanup_working: bool | None = Field(
+        False,
+        description=(
+            "(Internal) Whether to automatically delete related WorkingMemory nodes "
+            "based on working_binding metadata when deleting by memory_ids."
+        ),
+    )
 
 
 class SuggestionRequest(BaseRequest):

src/memos/graph_dbs/polardb.py

@@ -254,8 +254,13 @@ def _get_connection(self):
             if not self._semaphore.acquire(timeout=timeout):
                 logger.warning(f"Timeout waiting for connection slot ({timeout}s)")
                 raise RuntimeError(
-                    f"Connection pool busy: could not acquire a slot within {timeout}s (all connections in use)."
+                    f"Connection pool busy: acquire a slot within {timeout}s (all connections in use)."
                 )
+        logger.info(
+            "Connection pool usage: %s/%s",
+            self.connection_pool.maxconn - self._semaphore._value,
+            self.connection_pool.maxconn,
+        )
         conn = None
         broken = False
 
@@ -264,7 +269,7 @@ def _get_connection(self):
             logger.debug(f"Acquired connection {id(conn)} from pool")
             conn.autocommit = True
             with conn.cursor() as cur:
-                cur.execute("SELECT 1")
+                cur.execute(f'SET search_path = {self.db_name}_graph, ag_catalog, "$user", public;')
             yield conn
         except Exception as e:
             broken = True
@@ -1777,6 +1782,7 @@ def search_by_fulltext(
                 )
         where_clause_cte = f"WHERE {' AND '.join(where_with_q)}" if where_with_q else ""
         query = f"""
+            /*+ Set(max_parallel_workers_per_gather 0) */
             WITH q AS (SELECT to_tsquery('{tsquery_config}', %s) AS fq)
             SELECT {select_cols}
             FROM "{self.db_name}_graph"."Memory" m

src/memos/mem_reader/multi_modal_struct.py

@@ -819,7 +819,7 @@ def _process_one_item(
                     if result:
                         fine_memory_items.extend(result)
                 except Exception as e:
-                    logger.error(f"[MultiModalFine] worker error: {e}")
+                    logger.error(f"[MultiModalFine] worker error: {e} {traceback.format_exc()}")
 
         # related preceding and following rawfilememories
         fine_memory_items = self._relate_preceding_following_rawfile_memories(fine_memory_items)

src/memos/mem_reader/read_multi_modal/file_content_parser.py

@@ -367,7 +367,7 @@ def create_source(
     ) -> SourceMessage:
         """Create SourceMessage from file content part."""
         if isinstance(message, dict):
-            file_info = message.get("file", {})
+            file_info = message.get("file", {}) or {}
             source_dict = {
                 "type": "file",
                 "doc_path": file_info.get("filename") or file_info.get("file_id", ""),
@@ -470,7 +470,7 @@ def parse_fast(
         file_data = file_info.get("file_data", "")
         file_id = file_info.get("file_id", "")
         filename = file_info.get("filename", "")
-        file_url_flag = False
+        file_url_flag = bool(file_info)
         # Build content string based on available information
         content_parts = []
 
@@ -651,6 +651,9 @@ def parse_fine(
         file_id = file_info.get("file_id", "")
         filename = file_info.get("filename", "")
 
+        # Whether to keep full file_info in sources
+        file_url_flag = bool(file_info)
+
         # Extract custom_tags from kwargs (for LLM extraction)
         custom_tags = kwargs.get("custom_tags")
 
@@ -683,6 +686,7 @@ def parse_fine(
                     url_str = file_data[1:] if file_data.startswith("@") else file_data
 
                     if url_str.startswith(("http://", "https://")):
+                        file_url_flag = True
                         parsed_text, temp_file_path, is_markdown = self._handle_url(
                             url_str, filename
                         )
@@ -793,6 +797,7 @@ def _make_memory_item(
                 chunk_index=chunk_idx,
                 chunk_total=total_chunks,
                 chunk_content=chunk_content,
+                file_url_flag=file_url_flag,
             )
             return TextualMemoryItem(
                 memory=value,

src/memos/mem_reader/read_multi_modal/image_parser.py

@@ -51,15 +51,23 @@ def create_source(
             if isinstance(image_url, dict):
                 url = image_url.get("url", "")
                 detail = image_url.get("detail", "auto")
+                image_info = image_url
+                return SourceMessage(
+                    type="image",
+                    content=url,
+                    url=url,
+                    detail=detail,
+                    image_info=image_info,
+                )
             else:
                 url = str(image_url)
                 detail = "auto"
-            return SourceMessage(
-                type="image",
-                content=url,
-                url=url,
-                detail=detail,
-            )
+                return SourceMessage(
+                    type="image",
+                    content=url,
+                    url=url,
+                    detail=detail,
+                )
         return SourceMessage(type="image", content=str(message))
 
     def rebuild_from_source(
@@ -74,11 +82,16 @@ def rebuild_from_source(
             or (source.content or "").replace("[image_url]: ", "")
         )
         detail = getattr(source, "detail", "auto")
+        image_id = ""
+        image_info = source.image_info
+        if image_info and isinstance(image_info, dict):
+            image_id = image_info.get("image_id")
         return {
             "type": "image_url",
             "image_url": {
                 "url": url,
                 "detail": detail,
+                "image_id": str(image_id),
             },
         }
 

src/memos/mem_reader/read_multi_modal/multi_modal_parser.py

@@ -4,6 +4,8 @@
 in both fast and fine modes.
 """
 
+import traceback
+
 from typing import Any
 
 from memos.embedders.base import BaseEmbedder
@@ -248,7 +250,10 @@ def process_transfer(
         try:
             message = parser.rebuild_from_source(source)
         except Exception as e:
-            logger.error(f"[MultiModalParser] Error rebuilding message from source: {e}")
+            logger.error(
+                f"[MultiModalParser] Error rebuilding message from "
+                f"source: {e} {traceback.format_exc()}"
+            )
             return []
 
         # Parse in fine mode (pass context_items and custom_tags to parse_fine)

src/memos/mem_reader/read_multi_modal/user_parser.py

@@ -114,6 +114,7 @@ def create_source(
                             chat_time=chat_time,
                             message_id=message_id,
                             image_path=image_info.get("url"),
+                            image_info=image_info,
                         )
                         source.lang = overall_lang
                         sources.append(source)

src/memos/mem_reader/read_multi_modal/utils.py

@@ -45,6 +45,10 @@
 )
 
 
+KEYS_DROP_LABEL = r"(text|type|image_url|imageurl|url|file|file_id|image_id|file_data)"
+ID_KEYS_DROP_VALUE = r"(file_id|image_id)"
+
+
 def parse_json_result(response_text: str) -> dict:
     """
     Parse JSON result from LLM response.
@@ -356,13 +360,25 @@ def detect_lang(text):
         cleaned_text = re.sub(r"\[[\d\-:\s]+\]", "", cleaned_text)
         # remove URLs to prevent the dilution of Chinese characters
         cleaned_text = re.sub(r'https?://[^\s<>"{}|\\^`\[\]]+', "", cleaned_text)
-        # remove MessageType schema keywords (multimodal JSON noise)
+        # remove common id-like tokens (uuid-ish / file_id / image_id /
+        # my_id_01 etc.)
+        # uuid
+        cleaned_text = re.sub(
+            r"\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b",
+            " ",
+            cleaned_text,
+            flags=re.IGNORECASE,
+        )
+        # key:value where key ends with _id or is id, and value is quoted or bare token
+        cleaned_text = re.sub(
+            r'(?i)\b[a-z_]*id\b\s*[:=]\s*(".*?"|\'.*?\'|[a-z0-9_\-]+)', " ", cleaned_text
+        )
         cleaned_text = re.sub(
-            r"\b(text|type|image_url|imageurl|url)\b", "", cleaned_text, flags=re.IGNORECASE
+            r'(?i)\b[a-z_]*_id\b\s*[:=]\s*(".*?"|\'.*?\'|[a-z0-9_\-]+)', " ", cleaned_text
         )
         # remove schema keywords like text / type / image_url / url
         cleaned_text = re.sub(
-            r"\b(text|type|image_url|imageurl|url|file|file_id)\b",
+            r"\b(text|type|image_url|imageurl|url|file|file_id|image_id|file_data)\b",
             "",
             cleaned_text,
             flags=re.IGNORECASE,

src/memos/memories/textual/item.py

@@ -42,6 +42,7 @@ class SourceMessage(BaseModel):
     content: str | None = None
     doc_path: str | None = None
     file_info: dict | None = None
+    image_info: dict | None = None
     model_config = ConfigDict(extra="allow")