Merge branch 'feat/complete_multi_modal' of github.com:CaralHsi/MemOSRealPublic into feat/complete_multi_modal

Author: CaralHsi

src/memos/api/product_models.py

@@ -469,7 +469,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/graph_dbs/neo4j.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

src/memos/graph_dbs/polardb.py

@@ -3443,23 +3443,40 @@ def build_cypher_filter_condition(condition_dict: dict) -> str:
                                             condition_parts.append(f"n.{key} = {op_value}")
                             elif op == "contains":
                                 # 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}'}}}}"
+                                    )
                                 # Check if key starts with "info." prefix
                                 if key.startswith("info."):
                                     info_field = key[5:]  # Remove "info." prefix
-                                    if isinstance(op_value, str):
-                                        escaped_value = escape_cypher_string(op_value)
-                                        condition_parts.append(
-                                            f"'{escaped_value}' IN n.info.{info_field}"
-                                        )
-                                    else:
-                                        condition_parts.append(f"{op_value} IN n.info.{info_field}")
+                                    # Handle array of values: generate AND conditions for each value (all must be present)
+                                    and_conditions = []
+                                    for item in op_value:
+                                        if isinstance(item, str):
+                                            escaped_value = escape_cypher_string(item)
+                                            and_conditions.append(
+                                                f"'{escaped_value}' IN n.info.{info_field}"
+                                            )
+                                        else:
+                                            and_conditions.append(f"{item} IN n.info.{info_field}")
+                                    if and_conditions:
+                                        condition_parts.append(f"({' AND '.join(and_conditions)})")
                                 else:
                                     # Direct property access
-                                    if isinstance(op_value, str):
-                                        escaped_value = escape_cypher_string(op_value)
-                                        condition_parts.append(f"'{escaped_value}' IN n.{key}")
-                                    else:
-                                        condition_parts.append(f"{op_value} IN n.{key}")
+                                    # Handle array of values: generate AND conditions for each value (all must be present)
+                                    and_conditions = []
+                                    for item in op_value:
+                                        if isinstance(item, str):
+                                            escaped_value = escape_cypher_string(item)
+                                            and_conditions.append(f"'{escaped_value}' IN n.{key}")
+                                        else:
+                                            and_conditions.append(f"{item} IN n.{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%')
                                 # Check if key starts with "info." prefix
@@ -3668,29 +3685,46 @@ def build_filter_condition(condition_dict: dict) -> str:
                                             )
                             elif op == "contains":
                                 # Handle contains operator (for array fields) - use @> operator
+                                # 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}'}}}}"
+                                    )
                                 # Check if key starts with "info." prefix
                                 if key.startswith("info."):
                                     info_field = key[5:]  # Remove "info." prefix
-                                    if isinstance(op_value, str):
-                                        escaped_value = escape_sql_string(op_value)
-                                        condition_parts.append(
-                                            f"ag_catalog.agtype_access_operator(VARIADIC ARRAY[properties, '\"info\"'::ag_catalog.agtype, '\"{info_field}\"'::ag_catalog.agtype]) @> '\"{escaped_value}\"'::agtype"
-                                        )
-                                    else:
-                                        condition_parts.append(
-                                            f"ag_catalog.agtype_access_operator(VARIADIC ARRAY[properties, '\"info\"'::ag_catalog.agtype, '\"{info_field}\"'::ag_catalog.agtype]) @> {op_value}::agtype"
-                                        )
+                                    # Handle array of values: generate AND conditions for each value (all must be present)
+                                    and_conditions = []
+                                    for item in op_value:
+                                        if isinstance(item, str):
+                                            escaped_value = escape_sql_string(item)
+                                            and_conditions.append(
+                                                f"ag_catalog.agtype_access_operator(VARIADIC ARRAY[properties, '\"info\"'::ag_catalog.agtype, '\"{info_field}\"'::ag_catalog.agtype]) @> '\"{escaped_value}\"'::agtype"
+                                            )
+                                        else:
+                                            and_conditions.append(
+                                                f"ag_catalog.agtype_access_operator(VARIADIC ARRAY[properties, '\"info\"'::ag_catalog.agtype, '\"{info_field}\"'::ag_catalog.agtype]) @> {item}::agtype"
+                                            )
+                                    if and_conditions:
+                                        condition_parts.append(f"({' AND '.join(and_conditions)})")
                                 else:
                                     # Direct property access
-                                    if isinstance(op_value, str):
-                                        escaped_value = escape_sql_string(op_value)
-                                        condition_parts.append(
-                                            f"ag_catalog.agtype_access_operator(properties, '\"{key}\"'::agtype) @> '\"{escaped_value}\"'::agtype"
-                                        )
-                                    else:
-                                        condition_parts.append(
-                                            f"ag_catalog.agtype_access_operator(properties, '\"{key}\"'::agtype) @> {op_value}::agtype"
-                                        )
+                                    # Handle array of values: generate AND conditions for each value (all must be present)
+                                    and_conditions = []
+                                    for item in op_value:
+                                        if isinstance(item, str):
+                                            escaped_value = escape_sql_string(item)
+                                            and_conditions.append(
+                                                f"ag_catalog.agtype_access_operator(properties, '\"{key}\"'::agtype) @> '\"{escaped_value}\"'::agtype"
+                                            )
+                                        else:
+                                            and_conditions.append(
+                                                f"ag_catalog.agtype_access_operator(properties, '\"{key}\"'::agtype) @> {item}::agtype"
+                                            )
+                                    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%')
                                 # Check if key starts with "info." prefix

src/memos/mem_scheduler/optimized_scheduler.py

@@ -138,7 +138,8 @@ def mix_search_memories(
         target_session_id = search_req.session_id
         if not target_session_id:
             target_session_id = "default_session"
-        search_filter = {"session_id": search_req.session_id} if search_req.session_id else None
+        search_priority = {"session_id": search_req.session_id} if search_req.session_id else None
+        search_filter = search_req.filter
 
         # Rerank Memories - reranker expects TextualMemoryItem objects
 
@@ -155,6 +156,7 @@ def mix_search_memories(
             mode=SearchMode.FAST,
             manual_close_internet=not search_req.internet_search,
             search_filter=search_filter,
+            search_priority=search_priority,
             info=info,
         )
 
@@ -178,7 +180,7 @@ def mix_search_memories(
                 query=search_req.query,  # Use search_req.query instead of undefined query
                 graph_results=history_memories,  # Pass TextualMemoryItem objects directly
                 top_k=search_req.top_k,  # Use search_req.top_k instead of undefined top_k
-                search_filter=search_filter,
+                search_priority=search_priority,
             )
             logger.info(f"Reranked {len(sorted_history_memories)} history memories.")
             processed_hist_mem = self.searcher.post_retrieve(
@@ -234,6 +236,7 @@ def mix_search_memories(
                             mode=SearchMode.FAST,
                             memory_type="All",
                             search_filter=search_filter,
+                            search_priority=search_priority,
                             info=info,
                         )
                     else:

src/memos/memories/textual/prefer_text_memory/retrievers.py

@@ -17,7 +17,11 @@ def __init__(self, llm_provider=None, embedder=None, reranker=None, vector_db=No
 
     @abstractmethod
     def retrieve(
-        self, query: str, top_k: int, info: dict[str, Any] | None = None
+        self,
+        query: str,
+        top_k: int,
+        info: dict[str, Any] | None = None,
+        search_filter: dict[str, Any] | None = None,
     ) -> list[TextualMemoryItem]:
         """Retrieve memories from the retriever."""
 
@@ -76,14 +80,19 @@ def _original_text_reranker(
         return prefs_mem
 
     def retrieve(
-        self, query: str, top_k: int, info: dict[str, Any] | None = None
+        self,
+        query: str,
+        top_k: int,
+        info: dict[str, Any] | None = None,
+        search_filter: dict[str, Any] | None = None,
     ) -> list[TextualMemoryItem]:
         """Retrieve memories from the naive retriever."""
         # TODO: un-support rewrite query and session filter now
         if info:
             info = info.copy()  # Create a copy to avoid modifying the original
             info.pop("chat_history", None)
             info.pop("session_id", None)
+        search_filter = {"and": [info, search_filter]}
         query_embeddings = self.embedder.embed([query])  # Pass as list to get list of embeddings
         query_embedding = query_embeddings[0]  # Get the first (and only) embedding
 
@@ -96,15 +105,15 @@ def retrieve(
                 query,
                 "explicit_preference",
                 top_k * 2,
-                info,
+                search_filter,
             )
             future_implicit = executor.submit(
                 self.vector_db.search,
                 query_embedding,
                 query,
                 "implicit_preference",
                 top_k * 2,
-                info,
+                search_filter,
             )
 
             # Wait for all results

src/memos/memories/textual/preference.py

@@ -76,7 +76,9 @@ def get_memory(
         """
         return self.extractor.extract(messages, type, info)
 
-    def search(self, query: str, top_k: int, info=None, **kwargs) -> list[TextualMemoryItem]:
+    def search(
+        self, query: str, top_k: int, info=None, search_filter=None, **kwargs
+    ) -> list[TextualMemoryItem]:
         """Search for memories based on a query.
         Args:
             query (str): The query to search for.
@@ -85,7 +87,8 @@ def search(self, query: str, top_k: int, info=None, **kwargs) -> list[TextualMem
         Returns:
             list[TextualMemoryItem]: List of matching memories.
         """
-        return self.retriever.retrieve(query, top_k, info)
+        logger.info(f"search_filter for preference memory: {search_filter}")
+        return self.retriever.retrieve(query, top_k, info, search_filter)
 
     def load(self, dir: str) -> None:
         """Load memories from the specified directory.

src/memos/memories/textual/simple_preference.py

@@ -50,7 +50,9 @@ def get_memory(
         """
         return self.extractor.extract(messages, type, info)
 
-    def search(self, query: str, top_k: int, info=None, **kwargs) -> list[TextualMemoryItem]:
+    def search(
+        self, query: str, top_k: int, info=None, search_filter=None, **kwargs
+    ) -> list[TextualMemoryItem]:
         """Search for memories based on a query.
         Args:
             query (str): The query to search for.
@@ -59,7 +61,7 @@ def search(self, query: str, top_k: int, info=None, **kwargs) -> list[TextualMem
         Returns:
             list[TextualMemoryItem]: List of matching memories.
         """
-        return self.retriever.retrieve(query, top_k, info)
+        return self.retriever.retrieve(query, top_k, info, search_filter)
 
     def add(self, memories: list[TextualMemoryItem | dict[str, Any]]) -> list[str]:
         """Add memories.

src/memos/memories/textual/tree.py

@@ -162,6 +162,7 @@ def search(
         mode: str = "fast",
         memory_type: str = "All",
         manual_close_internet: bool = True,
+        search_priority: dict | None = None,
         search_filter: dict | None = None,
         user_name: str | None = None,
     ) -> list[TextualMemoryItem]:
@@ -209,7 +210,14 @@ def search(
                 manual_close_internet=manual_close_internet,
             )
         return searcher.search(
-            query, top_k, info, mode, memory_type, search_filter, user_name=user_name
+            query,
+            top_k,
+            info,
+            mode,
+            memory_type,
+            search_filter,
+            search_priority,
+            user_name=user_name,
         )
 
     def get_relevant_subgraph(