Merge remote-tracking branch 'upstream/dev' into dev

Author: tangg555

src/memos/api/handlers/component_init.py

@@ -247,7 +247,7 @@ def init_server() -> dict[str, Any]:
             config_factory=pref_retriever_config,
             llm_provider=llm,
             embedder=embedder,
-            reranker=reranker,
+            reranker=feedback_reranker,
             vector_db=vector_db,
         )
         if os.getenv("ENABLE_PREFERENCE_MEMORY", "false") == "true"
@@ -262,7 +262,7 @@ def init_server() -> dict[str, Any]:
             extractor_llm=llm,
             vector_db=vector_db,
             embedder=embedder,
-            reranker=reranker,
+            reranker=feedback_reranker,
             extractor=pref_extractor,
             adder=pref_adder,
             retriever=pref_retriever,

src/memos/graph_dbs/polardb.py

@@ -4792,35 +4792,35 @@ def delete_node_by_prams(
         # Build user_name condition from writable_cube_ids (OR relationship - match any cube_id)
         user_name_conditions = []
         for cube_id in writable_cube_ids:
-            # Escape single quotes in cube IDs
-            escaped_cube_id = str(cube_id).replace("'", "\\'")
-            user_name_conditions.append(f"n.user_name = '{escaped_cube_id}'")
+            # Use agtype_access_operator with VARIADIC ARRAY format for consistency
+            user_name_conditions.append(
+                f"agtype_access_operator(VARIADIC ARRAY[properties, '\"user_name\"'::agtype]) = '\"{cube_id}\"'::agtype"
+            )
 
         # Build WHERE conditions separately for memory_ids and file_ids
         where_conditions = []
 
-        # Handle memory_ids: query n.id
+        # Handle memory_ids: query properties.id
         if memory_ids and len(memory_ids) > 0:
             memory_id_conditions = []
             for node_id in memory_ids:
-                # Escape single quotes in node IDs
-                escaped_id = str(node_id).replace("'", "\\'")
-                memory_id_conditions.append(f"'{escaped_id}'")
+                memory_id_conditions.append(
+                    f"ag_catalog.agtype_access_operator(properties, '\"id\"'::agtype) = '\"{node_id}\"'::agtype"
+                )
             if memory_id_conditions:
-                where_conditions.append(f"n.id IN [{', '.join(memory_id_conditions)}]")
+                where_conditions.append(f"({' OR '.join(memory_id_conditions)})")
 
-        # Handle file_ids: query n.file_ids field
-        # All file_ids must be present in the array field (AND relationship)
+        # Check if any file_id is in the file_ids array field (OR relationship)
         if file_ids and len(file_ids) > 0:
-            file_id_and_conditions = []
+            file_id_conditions = []
             for file_id in file_ids:
-                # Escape single quotes in file IDs
-                escaped_id = str(file_id).replace("'", "\\'")
-                # Check if this file_id is in the file_ids array field
-                file_id_and_conditions.append(f"'{escaped_id}' IN n.file_ids")
-            if file_id_and_conditions:
-                # Use AND to require all file_ids to be present
-                where_conditions.append(f"({' OR '.join(file_id_and_conditions)})")
+                # Format: agtype_in_operator(agtype_access_operator(VARIADIC ARRAY[properties, '"file_ids"'::agtype]), '"file_id"'::agtype)
+                file_id_conditions.append(
+                    f"agtype_in_operator(agtype_access_operator(VARIADIC ARRAY[properties, '\"file_ids\"'::agtype]), '\"{file_id}\"'::agtype)"
+                )
+            if file_id_conditions:
+                # Use OR to match any file_id in the array
+                where_conditions.append(f"({' OR '.join(file_id_conditions)})")
 
         # Query nodes by filter if provided
         filter_ids = set()
@@ -4846,11 +4846,11 @@ def delete_node_by_prams(
         if filter_ids:
             filter_id_conditions = []
             for node_id in filter_ids:
-                # Escape single quotes in node IDs
-                escaped_id = str(node_id).replace("'", "\\'")
-                filter_id_conditions.append(f"'{escaped_id}'")
+                filter_id_conditions.append(
+                    f"ag_catalog.agtype_access_operator(properties, '\"id\"'::agtype) = '\"{node_id}\"'::agtype"
+                )
             if filter_id_conditions:
-                where_conditions.append(f"n.id IN [{', '.join(filter_id_conditions)}]")
+                where_conditions.append(f"({' OR '.join(filter_id_conditions)})")
 
         # If no conditions (except user_name), return 0
         if not where_conditions:
@@ -4865,26 +4865,21 @@ def delete_node_by_prams(
 
         # Then, combine with user_name condition using AND (must match user_name AND one of the data conditions)
         user_name_where = " OR ".join(user_name_conditions)
-        ids_where = f"{user_name_where} AND ({data_conditions})"
+        where_clause = f"({user_name_where}) AND ({data_conditions})"
 
-        # Use Cypher DELETE query
+        # Use SQL DELETE query for better performance
         # First count matching nodes to get accurate count
         count_query = f"""
-                SELECT * FROM cypher('{self.db_name}_graph', $$
-                MATCH (n:Memory)
-                WHERE {ids_where}
-                RETURN count(n) AS node_count
-                $$) AS (node_count agtype)
+                SELECT COUNT(*)
+                FROM "{self.db_name}_graph"."Memory"
+                WHERE {where_clause}
             """
         logger.info(f"[delete_node_by_prams] count_query: {count_query}")
 
         # Then delete nodes
         delete_query = f"""
-                SELECT * FROM cypher('{self.db_name}_graph', $$
-                MATCH (n:Memory)
-                WHERE {ids_where}
-                DETACH DELETE n
-                $$) AS (result agtype)
+                DELETE FROM "{self.db_name}_graph"."Memory"
+                WHERE {where_clause}
             """
 
         logger.info(
@@ -4899,20 +4894,20 @@ def delete_node_by_prams(
             with conn.cursor() as cursor:
                 # Count nodes before deletion
                 cursor.execute(count_query)
-                count_results = cursor.fetchall()
-                expected_count = 0
-                if count_results and len(count_results) > 0:
-                    count_str = str(count_results[0][0])
-                    count_str = count_str.strip('"').strip("'")
-                    expected_count = int(count_str) if count_str.isdigit() else 0
+                count_result = cursor.fetchone()
+                expected_count = count_result[0] if count_result else 0
+
+                logger.info(
+                    f"[delete_node_by_prams] Found {expected_count} nodes matching the criteria"
+                )
 
                 # Delete nodes
                 cursor.execute(delete_query)
-                # Use the count from before deletion as the actual deleted count
-                deleted_count = expected_count
+                # Use rowcount to get actual deleted count
+                deleted_count = cursor.rowcount
                 elapsed_time = time.time() - batch_start_time
                 logger.info(
-                    f"[delete_node_by_prams] execute_values completed successfully in {elapsed_time:.2f}s"
+                    f"[delete_node_by_prams] Deletion completed successfully in {elapsed_time:.2f}s, deleted {deleted_count} nodes"
                 )
         except Exception as e:
             logger.error(f"[delete_node_by_prams] Failed to delete nodes: {e}", exc_info=True)

src/memos/mem_reader/multi_modal_struct.py

@@ -8,8 +8,9 @@
 from memos.configs.mem_reader import MultiModalStructMemReaderConfig
 from memos.context.context import ContextThreadPoolExecutor
 from memos.mem_reader.read_multi_modal import MultiModalParser, detect_lang
+from memos.mem_reader.read_multi_modal.base import _derive_key
 from memos.mem_reader.simple_struct import PROMPT_DICT, SimpleStructMemReader
-from memos.memories.textual.item import TextualMemoryItem
+from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata
 from memos.templates.tool_mem_prompts import TOOL_TRAJECTORY_PROMPT_EN, TOOL_TRAJECTORY_PROMPT_ZH
 from memos.types import MessagesType
 from memos.utils import timed
@@ -184,6 +185,33 @@ def _concat_multi_modal_memories(
             if window:
                 windows.append(window)
 
+        # Batch compute embeddings for all windows
+        if windows:
+            # Collect all valid windows that need embedding
+            valid_windows = [w for w in windows if w and w.memory]
+
+            if valid_windows:
+                # Collect all texts that need embedding
+                texts_to_embed = [w.memory for w in valid_windows]
+
+                # Batch compute all embeddings at once
+                try:
+                    embeddings = self.embedder.embed(texts_to_embed)
+                    # Fill embeddings back into memory items
+                    for window, embedding in zip(valid_windows, embeddings, strict=True):
+                        window.metadata.embedding = embedding
+                except Exception as e:
+                    logger.error(f"[MultiModalStruct] Error batch computing embeddings: {e}")
+                    # Fallback: compute embeddings individually
+                    for window in valid_windows:
+                        if window.memory:
+                            try:
+                                window.metadata.embedding = self.embedder.embed([window.memory])[0]
+                            except Exception as e2:
+                                logger.error(
+                                    f"[MultiModalStruct] Error computing embedding for item: {e2}"
+                                )
+
         return windows
 
     def _build_window_from_items(
@@ -247,17 +275,35 @@ def _build_window_from_items(
             # If no text content, return None
             return None
 
-        # Create aggregated memory item (similar to _build_fast_node in simple_struct)
+        # Create aggregated memory item without embedding (will be computed in batch later)
         extra_kwargs: dict[str, Any] = {}
         if aggregated_file_ids:
             extra_kwargs["file_ids"] = aggregated_file_ids
-        aggregated_item = self._make_memory_item(
-            value=merged_text,
-            info=info,
-            memory_type=memory_type,
-            tags=["mode:fast"],
-            sources=all_sources,
-            **extra_kwargs,
+
+        # Extract info fields
+        info_ = info.copy()
+        user_id = info_.pop("user_id", "")
+        session_id = info_.pop("session_id", "")
+
+        # Create memory item without embedding (set to None, will be filled in batch)
+        aggregated_item = TextualMemoryItem(
+            memory=merged_text,
+            metadata=TreeNodeTextualMemoryMetadata(
+                user_id=user_id,
+                session_id=session_id,
+                memory_type=memory_type,
+                status="activated",
+                tags=["mode:fast"],
+                key=_derive_key(merged_text),
+                embedding=None,  # Will be computed in batch
+                usage=[],
+                sources=all_sources,
+                background="",
+                confidence=0.99,
+                type="fact",
+                info=info_,
+                **extra_kwargs,
+            ),
         )
 
         return aggregated_item
@@ -282,22 +328,23 @@ def _get_llm_response(
         Returns:
             LLM response dictionary
         """
-        # Try to extract actual text content from sources for better language detection
-        text_for_lang_detection = mem_str
+        # Determine language: prioritize lang from sources (set in fast mode),
+        # fallback to detecting from mem_str if sources don't have lang
+        lang = None
+
+        # First, try to get lang from sources (fast mode already set this)
         if sources:
-            source_texts = []
             for source in sources:
-                if hasattr(source, "content") and source.content:
-                    source_texts.append(source.content)
-                elif isinstance(source, dict) and source.get("content"):
-                    source_texts.append(source.get("content"))
-
-            # If we have text content from sources, use it for language detection
-            if source_texts:
-                text_for_lang_detection = " ".join(source_texts)
-
-        # Use the extracted text for language detection
-        lang = detect_lang(text_for_lang_detection)
+                if hasattr(source, "lang") and source.lang:
+                    lang = source.lang
+                    break
+                elif isinstance(source, dict) and source.get("lang"):
+                    lang = source.get("lang")
+                    break
+
+        # Fallback: detect language from mem_str if no lang from sources
+        if lang is None:
+            lang = detect_lang(mem_str)
 
         # Select prompt template based on prompt_type
         if prompt_type == "doc":
@@ -574,8 +621,13 @@ def _process_multi_modal_data(
             for fast_item in fast_memory_items:
                 sources = fast_item.metadata.sources
                 for source in sources:
+                    lang = getattr(source, "lang", "en")
                     items = self.multi_modal_parser.process_transfer(
-                        source, context_items=[fast_item], custom_tags=custom_tags, info=info
+                        source,
+                        context_items=[fast_item],
+                        custom_tags=custom_tags,
+                        info=info,
+                        lang=lang,
                     )
                     fine_memory_items.extend(items)
             return fine_memory_items
@@ -616,8 +668,9 @@ def _process_transfer_multi_modal_data(
 
         # Part B: get fine multimodal items
         for source in sources:
+            lang = getattr(source, "lang", "en")
             items = self.multi_modal_parser.process_transfer(
-                source, context_items=[raw_node], info=info, custom_tags=custom_tags
+                source, context_items=[raw_node], info=info, custom_tags=custom_tags, lang=lang
             )
             fine_memory_items.extend(items)
         return fine_memory_items