merge dev

Author: yuan.wang

examples/mem_reader/multimodal_struct_reader.py

@@ -426,7 +426,7 @@ def get_embedder_config() -> dict[str, Any]:
     def get_reader_config() -> dict[str, Any]:
         """Get reader configuration."""
         return {
-            "backend": os.getenv("MEM_READER_BACKEND", "simple_struct"),
+            "backend": os.getenv("MEM_READER_BACKEND", "multimodal_struct"),
             "config": {
                 "chunk_type": os.getenv("MEM_READER_CHAT_CHUNK_TYPE", "default"),
                 "chunk_length": int(os.getenv("MEM_READER_CHAT_CHUNK_TOKEN_SIZE", 1600)),

src/memos/api/config.py

@@ -41,6 +41,7 @@
 from memos.memories.textual.simple_preference import SimplePreferenceTextMemory
 from memos.memories.textual.simple_tree import SimpleTreeTextMemory
 from memos.memories.textual.tree_text_memory.organize.manager import MemoryManager
+from memos.memories.textual.tree_text_memory.retrieve.retrieve_utils import FastTokenizer
 
 
 if TYPE_CHECKING:
@@ -196,6 +197,7 @@ def init_server() -> dict[str, Any]:
 
     logger.debug("Memory manager initialized")
 
+    tokenizer = FastTokenizer()
     # Initialize text memory
     text_mem = SimpleTreeTextMemory(
         llm=llm,
@@ -206,6 +208,7 @@ def init_server() -> dict[str, Any]:
         memory_manager=memory_manager,
         config=default_cube_config.text_mem.config,
         internet_retriever=internet_retriever,
+        tokenizer=tokenizer,
     )
 
     logger.debug("Text memory initialized")

src/memos/api/handlers/component_init.py

@@ -388,6 +388,12 @@ class APISearchRequest(BaseRequest):
         description="(Internal) Operation definitions for multi-cube read permissions.",
     )
 
+    # ==== Source for  plugin ====
+    source: str | None = Field(
+        None,
+        description="Source of the search query [plugin will router diff search]",
+    )
+
     @model_validator(mode="after")
     def _convert_deprecated_fields(self) -> "APISearchRequest":
         """
@@ -469,7 +475,7 @@ class APIADDRequest(BaseRequest):
         ),
     )
 
-    info: dict[str, str] | None = Field(
+    info: dict[str, Any] | None = Field(
         None,
         description=(
             "Additional metadata for the add request. "

src/memos/api/product_models.py

@@ -1441,17 +1441,24 @@ def build_filter_condition(condition_dict: dict, param_counter: list) -> tuple[s
                                     f"{node_alias}.{key} {cypher_op} ${param_name}"
                                 )
                         elif op == "contains":
-                            # Handle contains operator (for array fields like tags, sources)
-                            param_name = f"filter_{key}_{op}_{param_counter[0]}"
-                            param_counter[0] += 1
-                            params[param_name] = op_value
-
-                            # For array fields, check if element is in array
-                            if key in ("tags", "sources"):
-                                condition_parts.append(f"${param_name} IN {node_alias}.{key}")
-                            else:
-                                # For non-array fields, contains might not be applicable, but we'll treat it as IN for consistency
-                                condition_parts.append(f"${param_name} IN {node_alias}.{key}")
+                            # Handle contains operator (for array fields)
+                            # Only supports array format: {"field": {"contains": ["value1", "value2"]}}
+                            # Single string values are not supported, use array format instead: {"field": {"contains": ["value"]}}
+                            if not isinstance(op_value, list):
+                                raise ValueError(
+                                    f"contains operator only supports array format. "
+                                    f"Use {{'{key}': {{'contains': ['{op_value}']}}}} instead of {{'{key}': {{'contains': '{op_value}'}}}}"
+                                )
+                            # Handle array of values: generate AND conditions for each value (all must be present)
+                            and_conditions = []
+                            for item in op_value:
+                                param_name = f"filter_{key}_{op}_{param_counter[0]}"
+                                param_counter[0] += 1
+                                params[param_name] = item
+                                # For array fields, check if element is in array
+                                and_conditions.append(f"${param_name} IN {node_alias}.{key}")
+                            if and_conditions:
+                                condition_parts.append(f"({' AND '.join(and_conditions)})")
                         elif op == "like":
                             # Handle like operator (for fuzzy matching, similar to SQL LIKE '%value%')
                             # Neo4j uses CONTAINS for string matching
@@ -1523,6 +1530,7 @@ def _parse_node(self, node_data: dict[str, Any]) -> dict[str, Any]:
 
     def delete_node_by_prams(
         self,
+        writable_cube_ids: list[str],
         memory_ids: list[str] | None = None,
         file_ids: list[str] | None = None,
         filter: dict | None = None,
@@ -1531,56 +1539,90 @@ def delete_node_by_prams(
         Delete nodes by memory_ids, file_ids, or filter.
 
         Args:
+            writable_cube_ids (list[str]): List of cube IDs (user_name) to filter nodes. Required parameter.
             memory_ids (list[str], optional): List of memory node IDs to delete.
             file_ids (list[str], optional): List of file node IDs to delete.
             filter (dict, optional): Filter dictionary to query matching nodes for deletion.
 
         Returns:
             int: Number of nodes deleted.
         """
-        # Collect all node IDs to delete
-        ids_to_delete = set()
+        logger.info(
+            f"[delete_node_by_prams] memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}, writable_cube_ids: {writable_cube_ids}"
+        )
+        print(
+            f"[delete_node_by_prams] memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}, writable_cube_ids: {writable_cube_ids}"
+        )
 
-        # Add memory_ids if provided
+        # Validate writable_cube_ids
+        if not writable_cube_ids or len(writable_cube_ids) == 0:
+            raise ValueError("writable_cube_ids is required and cannot be empty")
+
+        # Build WHERE conditions separately for memory_ids and file_ids
+        where_clauses = []
+        params = {}
+
+        # Build user_name condition from writable_cube_ids (OR relationship - match any cube_id)
+        user_name_conditions = []
+        for idx, cube_id in enumerate(writable_cube_ids):
+            param_name = f"cube_id_{idx}"
+            user_name_conditions.append(f"n.user_name = ${param_name}")
+            params[param_name] = cube_id
+
+        # Handle memory_ids: query n.id
         if memory_ids and len(memory_ids) > 0:
-            ids_to_delete.update(memory_ids)
+            where_clauses.append("n.id IN $memory_ids")
+            params["memory_ids"] = memory_ids
 
-        # Add file_ids if provided (treating them as node IDs)
+        # Handle file_ids: query n.file_ids field
+        # All file_ids must be present in the array field (AND relationship)
         if file_ids and len(file_ids) > 0:
-            ids_to_delete.update(file_ids)
+            file_id_and_conditions = []
+            for idx, file_id in enumerate(file_ids):
+                param_name = f"file_id_{idx}"
+                params[param_name] = file_id
+                # Check if this file_id is in the file_ids array field
+                file_id_and_conditions.append(f"${param_name} IN n.file_ids")
+            if file_id_and_conditions:
+                # Use AND to require all file_ids to be present
+                where_clauses.append(f"({' AND '.join(file_id_and_conditions)})")
 
         # Query nodes by filter if provided
+        filter_ids = []
         if filter:
             # Use get_by_metadata with empty filters list and filter
             filter_ids = self.get_by_metadata(
                 filters=[],
                 user_name=None,
                 filter=filter,
-                knowledgebase_ids=None,
-                user_name_flag=False,
+                knowledgebase_ids=writable_cube_ids,
             )
-            ids_to_delete.update(filter_ids)
 
-        # If no IDs to delete, return 0
-        if not ids_to_delete:
-            logger.warning("[delete_node_by_prams] No nodes to delete")
+        # If filter returned IDs, add condition for them
+        if filter_ids:
+            where_clauses.append("n.id IN $filter_ids")
+            params["filter_ids"] = filter_ids
+
+        # If no conditions (except user_name), return 0
+        if not where_clauses:
+            logger.warning(
+                "[delete_node_by_prams] No nodes to delete (no memory_ids, file_ids, or filter provided)"
+            )
             return 0
 
-        # Convert to list for easier handling
-        ids_list = list(ids_to_delete)
-        logger.info(f"[delete_node_by_prams] Deleting {len(ids_list)} nodes: {ids_list}")
+        # Build WHERE clause
+        # First, combine memory_ids, file_ids, and filter conditions with OR (any condition can match)
+        data_conditions = " OR ".join([f"({clause})" for clause in where_clauses])
 
-        # Build WHERE condition for collected IDs (query n.id)
-        ids_where = "n.id IN $ids_to_delete"
-        params = {"ids_to_delete": ids_list}
+        # 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})"
 
-        # Calculate total count for logging
-        total_count = len(ids_list)
         logger.info(
             f"[delete_node_by_prams] Deleting nodes - memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}"
         )
         print(
-            f"[delete_node_by_prams] Deleting {total_count} nodes - memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}"
+            f"[delete_node_by_prams] Deleting nodes - memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}"
         )
 
         # First count matching nodes to get accurate count
@@ -1592,16 +1634,17 @@ def delete_node_by_prams(
         delete_query = f"MATCH (n:Memory) WHERE {ids_where} DETACH DELETE n"
         logger.info(f"[delete_node_by_prams] delete_query: {delete_query}")
         print(f"[delete_node_by_prams] delete_query: {delete_query}")
+        print(f"[delete_node_by_prams] params: {params}")
 
         deleted_count = 0
         try:
             with self.driver.session(database=self.db_name) as session:
                 # Count nodes before deletion
                 count_result = session.run(count_query, **params)
                 count_record = count_result.single()
-                expected_count = total_count
+                expected_count = 0
                 if count_record:
-                    expected_count = count_record["node_count"] or total_count
+                    expected_count = count_record["node_count"] or 0
 
                 # Delete nodes
                 session.run(delete_query, **params)