MemoryOS 2.0.9__tar.gz → 2.0.10__tar.gz

{memoryos-2.0.9 → memoryos-2.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MemoryOS
-Version: 2.0.9
+Version: 2.0.10
 Summary: Intelligence Begins with Memory
 License: Apache-2.0
 License-File: LICENSE

{memoryos-2.0.9 → memoryos-2.0.10}/pyproject.toml

@@ -4,7 +4,7 @@
 ##############################################################################
 
 name = "MemoryOS"
-version = "2.0.9"
+version = "2.0.10"
 description = "Intelligence Begins with Memory"
 license = {text = "Apache-2.0"}
 readme = "README.md"
@@ -170,6 +170,8 @@ optional = true
 [tool.poetry.group.test.dependencies]
 pytest = "^8.3.5"
 pytest-asyncio = "^0.23.5"
+pytest-cov = "^6.1"
+pytest-html = "^4.2"
 ruff = "^0.11.8"
 
 [tool.poetry.group.eval]
@@ -208,6 +210,23 @@ filterwarnings = [
 ]
 
 
+[tool.coverage.run]
+source = ["src/memos"]
+branch = true
+
+[tool.coverage.report]
+show_missing = true
+skip_empty = true
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "if __name__ == .__main__.",
+]
+
+[tool.coverage.html]
+directory = "cov-report"
+
+
 [tool.ruff]
 ##############################################################################
 # Ruff is a fast Python linter and formatter.

{memoryos-2.0.9 → memoryos-2.0.10}/src/memos/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.0.9"
+__version__ = "2.0.10"
 
 from memos.configs.mem_cube import GeneralMemCubeConfig
 from memos.configs.mem_os import MOSConfig

{memoryos-2.0.9 → memoryos-2.0.10}/src/memos/api/config.py

@@ -321,23 +321,40 @@ class APIConfig:
 
     @staticmethod
     def get_memreader_config() -> dict[str, Any]:
-        """Get MemReader configuration for chat/doc extraction (fine-tuned 0.6B model)."""
-        return {
-            "backend": "openai",
-            "config": {
-                "model_name_or_path": os.getenv("MEMRADER_MODEL", "gpt-4o-mini"),
-                "temperature": 0.6,
-                "max_tokens": int(os.getenv("MEMRADER_MAX_TOKENS", "8000")),
-                "top_p": 0.95,
-                "top_k": 20,
-                "api_key": os.getenv("MEMRADER_API_KEY", "EMPTY"),
-                # Default to OpenAI base URL when env var is not provided to satisfy pydantic
-                # validation requirements during tests/import.
-                "api_base": os.getenv("MEMRADER_API_BASE", "https://api.openai.com/v1"),
-                "remove_think_prefix": True,
-            },
+        """Get MemReader configuration for chat/doc extraction (fine-tuned 0.6B model).
+
+        When MEMREADER_GENERAL_MODEL is configured (i.e. a separate stable LLM exists),
+        the backup client is automatically enabled so that primary failures (self-deployed
+        model) fall back to the general LLM.
+        """
+        config = {
+            "model_name_or_path": os.getenv("MEMRADER_MODEL", "gpt-4o-mini"),
+            "temperature": 0.6,
+            "max_tokens": int(os.getenv("MEMRADER_MAX_TOKENS", "8000")),
+            "top_p": 0.95,
+            "top_k": 20,
+            "api_key": os.getenv("MEMRADER_API_KEY", "EMPTY"),
+            # Default to OpenAI base URL when env var is not provided to satisfy pydantic
+            # validation requirements during tests/import.
+            "api_base": os.getenv("MEMRADER_API_BASE", "https://api.openai.com/v1"),
+            "remove_think_prefix": True,
         }
 
+        general_model = os.getenv("MEMREADER_GENERAL_MODEL")
+        enable_backup = os.getenv("MEMREADER_ENABLE_BACKUP", "false").lower() == "true"
+        if general_model and enable_backup:
+            config["backup_client"] = True
+            config["backup_model_name_or_path"] = general_model
+            config["backup_api_key"] = os.getenv(
+                "MEMREADER_GENERAL_API_KEY", os.getenv("OPENAI_API_KEY", "EMPTY")
+            )
+            config["backup_api_base"] = os.getenv(
+                "MEMREADER_GENERAL_API_BASE",
+                os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+            )
+
+        return {"backend": "openai", "config": config}
+
     @staticmethod
     def get_memreader_general_llm_config() -> dict[str, Any]:
         """Get general LLM configuration for non-chat/doc tasks.
@@ -837,7 +854,7 @@ class APIConfig:
                 ),
                 "context_window_size": int(os.getenv("MOS_SCHEDULER_CONTEXT_WINDOW_SIZE", "5")),
                 "thread_pool_max_workers": int(
-                    os.getenv("MOS_SCHEDULER_THREAD_POOL_MAX_WORKERS", "10000")
+                    os.getenv("MOS_SCHEDULER_THREAD_POOL_MAX_WORKERS", "200")
                 ),
                 "consume_interval_seconds": float(
                     os.getenv("MOS_SCHEDULER_CONSUME_INTERVAL_SECONDS", "0.01")
@@ -850,6 +867,8 @@ class APIConfig:
                     "MOS_SCHEDULER_ENABLE_ACTIVATION_MEMORY", "false"
                 ).lower()
                 == "true",
+                "use_redis_queue": os.getenv("MEMSCHEDULER_USE_REDIS_QUEUE", "False").lower()
+                == "true",
             },
         }
 

{memoryos-2.0.9 → memoryos-2.0.10}/src/memos/api/handlers/component_init.py

@@ -233,7 +233,7 @@ def init_server() -> dict[str, Any]:
     searcher: Searcher = tree_mem.get_searcher(
         manual_close_internet=os.getenv("ENABLE_INTERNET", "true").lower() == "false",
         moscube=False,
-        process_llm=mem_reader.llm,
+        process_llm=mem_reader.general_llm,
     )
     logger.debug("Searcher created")
 
@@ -255,12 +255,13 @@ def init_server() -> dict[str, Any]:
     # Initialize Scheduler
     scheduler_config_dict = APIConfig.get_scheduler_config()
     scheduler_config = SchedulerConfigFactory(
-        backend="optimized_scheduler", config=scheduler_config_dict
+        backend=scheduler_config_dict["backend"],
+        config=scheduler_config_dict["config"],
     )
     mem_scheduler: OptimizedScheduler = SchedulerFactory.from_config(scheduler_config)
     mem_scheduler.initialize_modules(
         chat_llm=llm,
-        process_llm=mem_reader.llm,
+        process_llm=mem_reader.general_llm,
         db_engine=BaseDBManager.create_default_sqlite_engine(),
         mem_reader=mem_reader,
         redis_client=redis_client,

{memoryos-2.0.9 → memoryos-2.0.10}/src/memos/configs/llm.py

@@ -28,6 +28,22 @@ class OpenAILLMConfig(BaseLLMConfig):
         default="https://api.openai.com/v1", description="Base URL for OpenAI API"
     )
     extra_body: Any = Field(default=None, description="extra body")
+    backup_client: bool = Field(
+        default=False,
+        description="Whether to enable backup client for fallback on primary failure",
+    )
+    backup_api_key: str | None = Field(
+        default=None, description="API key for backup OpenAI-compatible endpoint"
+    )
+    backup_api_base: str | None = Field(
+        default=None, description="Base URL for backup OpenAI-compatible endpoint"
+    )
+    backup_model_name_or_path: str | None = Field(
+        default=None, description="Model name for backup endpoint"
+    )
+    backup_headers: dict[str, Any] | None = Field(
+        default=None, description="Default headers for backup client requests"
+    )
 
 
 class OpenAIResponsesLLMConfig(BaseLLMConfig):
@@ -42,22 +58,18 @@ class OpenAIResponsesLLMConfig(BaseLLMConfig):
     )
 
 
-class QwenLLMConfig(BaseLLMConfig):
-    api_key: str = Field(..., description="API key for DashScope (Qwen)")
+class QwenLLMConfig(OpenAILLMConfig):
     api_base: str = Field(
         default="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
         description="Base URL for Qwen OpenAI-compatible API",
     )
-    extra_body: Any = Field(default=None, description="extra body")
 
 
-class DeepSeekLLMConfig(BaseLLMConfig):
-    api_key: str = Field(..., description="API key for DeepSeek")
+class DeepSeekLLMConfig(OpenAILLMConfig):
     api_base: str = Field(
         default="https://api.deepseek.com",
         description="Base URL for DeepSeek OpenAI-compatible API",
     )
-    extra_body: Any = Field(default=None, description="Extra options for API")
 
 
 class AzureLLMConfig(BaseLLMConfig):

{memoryos-2.0.9 → memoryos-2.0.10}/src/memos/configs/mem_scheduler.py

@@ -155,7 +155,10 @@ class SchedulerConfigFactory(BaseConfig):
     @model_validator(mode="after")
     def create_config(self) -> "SchedulerConfigFactory":
         config_class = self.backend_to_class[self.backend]
-        self.config = config_class(**self.config)
+        raw = self.config
+        if isinstance(raw, dict) and "config" in raw and "use_redis_queue" not in raw:
+            raw = raw["config"]
+        self.config = config_class(**raw)
         return self
 
 

{memoryos-2.0.9 → memoryos-2.0.10}/src/memos/graph_dbs/neo4j_community.py

@@ -721,6 +721,8 @@ class Neo4jCommunityGraphDB(Neo4jGraphDB):
         user_name: str | None = None,
         filter: dict | None = None,
         knowledgebase_ids: list[str] | None = None,
+        user_name_flag: bool = True,
+        status: str | None = None,
     ) -> list[str]:
         """
         Retrieve node IDs that match given metadata filters.
@@ -745,15 +747,20 @@ class Neo4jCommunityGraphDB(Neo4jGraphDB):
             - Can be used for faceted recall or prefiltering before embedding rerank.
         """
         logger.info(
-            f"[get_by_metadata] filters: {filters},user_name: {user_name},filter: {filter},knowledgebase_ids: {knowledgebase_ids}"
+            f"[get_by_metadata] filters: {filters},user_name: {user_name},filter: {filter},knowledgebase_ids: {knowledgebase_ids},status: {status}"
         )
         print(
-            f"[get_by_metadata] filters: {filters},user_name: {user_name},filter: {filter},knowledgebase_ids: {knowledgebase_ids}"
+            f"[get_by_metadata] filters: {filters},user_name: {user_name},filter: {filter},knowledgebase_ids: {knowledgebase_ids},status: {status}"
         )
         user_name = user_name if user_name else self.config.user_name
         where_clauses = []
         params = {}
 
+        # Add status filter if provided
+        if status:
+            where_clauses.append("n.status = $status")
+            params["status"] = status
+
         for i, f in enumerate(filters):
             field = f["field"]
             op = f.get("op", "=")

{memoryos-2.0.9 → memoryos-2.0.10}/src/memos/graph_dbs/polardb.py

@@ -432,14 +432,13 @@ class PolarDBGraphDB(BaseGraphDB):
     def remove_oldest_memory(
         self, memory_type: str, keep_latest: int, user_name: str | None = None
     ) -> None:
-        """
-        Remove all WorkingMemory nodes except the latest `keep_latest` entries.
-
-        Args:
-            memory_type (str): Memory type (e.g., 'WorkingMemory', 'LongTermMemory').
-            keep_latest (int): Number of latest WorkingMemory entries to keep.
-            user_name (str, optional): User name for filtering in non-multi-db mode
-        """
+        start_time = time.perf_counter()
+        logger.info(
+            "remove_oldest_memory by memory_type:%s,keep_latest: %s,user_name:%s",
+            memory_type,
+            keep_latest,
+            user_name,
+        )
         user_name = user_name if user_name else self._get_config_value("user_name")
 
         # Use actual OFFSET logic, consistent with nebular.py
@@ -456,6 +455,9 @@ class PolarDBGraphDB(BaseGraphDB):
             self.format_param_value(user_name),
             keep_latest,
         ]
+        logger.info(
+            f"remove_oldest_memory by select_query:{select_query},select_params:{select_params}"
+        )
         try:
             with self._get_connection() as conn, conn.cursor() as cursor:
                 # Execute query to get IDs to delete
@@ -482,6 +484,8 @@ class PolarDBGraphDB(BaseGraphDB):
                     f"keeping {keep_latest} latest for user {user_name}, "
                     f"removed ids: {ids_to_delete}"
                 )
+                elapsed = (time.perf_counter() - start_time) * 1000.0
+                logger.info("remove_oldest_memory internal took %.1f ms", elapsed)
         except Exception as e:
             logger.error(f"[remove_oldest_memory] Failed: {e}", exc_info=True)
             raise
@@ -1840,9 +1844,8 @@ class PolarDBGraphDB(BaseGraphDB):
         **kwargs,
     ) -> list[dict]:
         logger.info(
-            "search_by_embedding user_name:%s,filter: %s, knowledgebase_ids: %s,scope:%s,status:%s,search_filter:%s,filter:%s,knowledgebase_ids:%s,return_fields:%s",
+            "search_by_embedding by user_name:%s,knowledgebase_ids: %s,scope:%s,status:%s,search_filter:%s,filter:%s,knowledgebase_ids:%s,return_fields:%s",
             user_name,
-            filter,
             knowledgebase_ids,
             scope,
             status,
@@ -1895,20 +1898,21 @@ class PolarDBGraphDB(BaseGraphDB):
         where_clause = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
 
         query = f"""
+                    set hnsw.ef_search = 100;set hnsw.iterative_scan = relaxed_order;
                     WITH t AS (
                         SELECT id,
                                properties,
                                timeline,
                                ag_catalog.agtype_access_operator(properties, '"id"'::agtype) AS old_id,
-                               (1 - (embedding <=> %s::vector(1024))) AS scope
+                               (embedding <=> %s::vector(1024)) AS scope_distance
                         FROM "{self.db_name}_graph"."Memory"
                         {where_clause}
-                        ORDER BY scope DESC
+                        ORDER BY scope_distance ASC
                         LIMIT {top_k}
                     )
-                    SELECT *
+                    SELECT *,(1 - scope_distance) AS scope
                     FROM t
-                    WHERE scope > 0.1;
+                    WHERE scope_distance < 0.9;
                 """
         vector_str = convert_to_vector(vector)
         query = query.replace("%s::vector(1024)", f"'{vector_str}'::vector(1024)")
@@ -1953,7 +1957,7 @@ class PolarDBGraphDB(BaseGraphDB):
                     output.append(item)
             elapsed_time = (time.perf_counter() - start_time) * 1000.0
             logger.info(
-                "search_by_embedding query embedding completed time took %.1f ms", elapsed_time
+                "search_by_embedding query by embedding completed time took %.1f ms", elapsed_time
             )
             return output[:top_k]
 
@@ -1966,30 +1970,13 @@ class PolarDBGraphDB(BaseGraphDB):
         knowledgebase_ids: list | None = None,
         user_name_flag: bool = True,
     ) -> list[str]:
-        """
-        Retrieve node IDs that match given metadata filters.
-        Supports exact match.
-
-        Args:
-        filters: List of filter dicts like:
-            [
-                {"field": "key", "op": "in", "value": ["A", "B"]},
-                {"field": "confidence", "op": ">=", "value": 80},
-                {"field": "tags", "op": "contains", "value": "AI"},
-                ...
-            ]
-        user_name (str, optional): User name for filtering in non-multi-db mode
-
-        Returns:
-            list[str]: Node IDs whose metadata match the filter conditions. (AND logic).
-        """
+        start_time = time.perf_counter()
         logger.info(
             f" get_by_metadata user_name:{user_name},filter: {filter}, knowledgebase_ids: {knowledgebase_ids},filters:{filters}"
         )
 
         user_name = user_name if user_name else self._get_config_value("user_name")
 
-        # Build WHERE conditions for cypher query
         where_conditions = []
 
         for f in filters:
@@ -1997,18 +1984,13 @@ class PolarDBGraphDB(BaseGraphDB):
             op = f.get("op", "=")
             value = f["value"]
 
-            # Format value
             if isinstance(value, str):
-                # Escape single quotes using backslash when inside $$ dollar-quoted strings
-                # In $$ delimiters, Cypher string literals can use \' to escape single quotes
                 escaped_str = value.replace("'", "\\'")
                 escaped_value = f"'{escaped_str}'"
             elif isinstance(value, list):
-                # Handle list values - use double quotes for Cypher arrays
                 list_items = []
                 for v in value:
                     if isinstance(v, str):
-                        # Escape double quotes in string values for Cypher
                         escaped_str = v.replace('"', '\\"')
                         list_items.append(f'"{escaped_str}"')
                     else:
@@ -2016,7 +1998,6 @@ class PolarDBGraphDB(BaseGraphDB):
                 escaped_value = f"[{', '.join(list_items)}]"
             else:
                 escaped_value = f"'{value}'" if isinstance(value, str) else str(value)
-            # Build WHERE conditions
             if op == "=":
                 where_conditions.append(f"n.{field} = {escaped_value}")
             elif op == "in":
@@ -2045,22 +2026,19 @@ class PolarDBGraphDB(BaseGraphDB):
             knowledgebase_ids=knowledgebase_ids,
             default_user_name=self._get_config_value("user_name"),
         )
-        logger.info(f"[get_by_metadata] user_name_conditions: {user_name_conditions}")
+        logger.info(f"get_by_metadata user_name_conditions: {user_name_conditions}")
 
-        # Add user_name WHERE clause
         if user_name_conditions:
             if len(user_name_conditions) == 1:
                 where_conditions.append(user_name_conditions[0])
             else:
                 where_conditions.append(f"({' OR '.join(user_name_conditions)})")
 
-        # Build filter conditions using common method
         filter_where_clause = self._build_filter_conditions_cypher(filter)
-        logger.info(f"[get_by_metadata] filter_where_clause: {filter_where_clause}")
+        logger.info(f"get_by_metadata filter_where_clause: {filter_where_clause}")
 
         where_str = " AND ".join(where_conditions) + filter_where_clause
 
-        # Use cypher query
         cypher_query = f"""
                SELECT * FROM cypher('{self.db_name}_graph', $$
                MATCH (n:Memory)
@@ -2070,7 +2048,7 @@ class PolarDBGraphDB(BaseGraphDB):
            """
 
         ids = []
-        logger.info(f"[get_by_metadata] cypher_query: {cypher_query}")
+        logger.info(f"get_by_metadata cypher_query: {cypher_query}")
         try:
             with self._get_connection() as conn, conn.cursor() as cursor:
                 cursor.execute(cypher_query)
@@ -2078,7 +2056,8 @@ class PolarDBGraphDB(BaseGraphDB):
                 ids = [str(item[0]).strip('"') for item in results]
         except Exception as e:
             logger.warning(f"Failed to get metadata: {e}, query is {cypher_query}")
-
+        elapsed = (time.perf_counter() - start_time) * 1000.0
+        logger.info("get_by_metadata internal took %.1f ms", elapsed)
         return ids
 
     @timed
@@ -2165,25 +2144,19 @@ class PolarDBGraphDB(BaseGraphDB):
         params: dict[str, Any] | None = None,
         user_name: str | None = None,
     ) -> list[dict[str, Any]]:
-        """
-        Count nodes grouped by any fields.
-
-        Args:
-            group_fields (list[str]): Fields to group by, e.g., ["memory_type", "status"]
-            where_clause (str, optional): Extra WHERE condition. E.g.,
-            "WHERE n.status = 'activated'"
-            params (dict, optional): Parameters for WHERE clause.
-            user_name (str, optional): User name for filtering in non-multi-db mode
-
-        Returns:
-            list[dict]: e.g., [{ 'memory_type': 'WorkingMemory', 'status': 'active', 'count': 10 }, ...]
-        """
+        start_time = time.perf_counter()
+        logger.info(
+            "get_grouped_counts by group_fields:%s,where_clause: %s,params:%s,user_name:%s",
+            group_fields,
+            where_clause,
+            params,
+            user_name,
+        )
         if not group_fields:
             raise ValueError("group_fields cannot be empty")
 
         user_name = user_name if user_name else self._get_config_value("user_name")
 
-        # Build user clause
         user_clause = f"ag_catalog.agtype_access_operator(properties, '\"user_name\"'::agtype) = '\"{user_name}\"'::agtype"
         if where_clause:
             where_clause = where_clause.strip()
@@ -2194,44 +2167,43 @@ class PolarDBGraphDB(BaseGraphDB):
         else:
             where_clause = f"WHERE {user_clause}"
 
-        # Inline parameters if provided
         if params and isinstance(params, dict):
             for key, value in params.items():
-                # Handle different value types appropriately
                 if isinstance(value, str):
                     value = f"'{value}'"
                 where_clause = where_clause.replace(f"${key}", str(value))
 
-        # Handle user_name parameter in where_clause
         if "user_name = %s" in where_clause:
             where_clause = where_clause.replace(
                 "user_name = %s",
                 f"ag_catalog.agtype_access_operator(properties, '\"user_name\"'::agtype) = '\"{user_name}\"'::agtype",
             )
 
-        # Build return fields and group by fields
-        return_fields = []
-        group_by_fields = []
-
+        cte_select_list = []
+        aliases = []
         for field in group_fields:
             alias = field.replace(".", "_")
-            return_fields.append(
-                f"ag_catalog.agtype_access_operator(properties, '\"{field}\"'::agtype)::text AS {alias}"
-            )
-            group_by_fields.append(
-                f"ag_catalog.agtype_access_operator(properties, '\"{field}\"'::agtype)::text"
+            aliases.append(alias)
+            cte_select_list.append(
+                f"ag_catalog.agtype_access_operator(properties, '\"{field}\"'::agtype) AS {alias}"
             )
-
-        # Full SQL query construction
+        outer_select = ", ".join(f"{a}::text" for a in aliases)
+        outer_group_by = ", ".join(aliases)
         query = f"""
-            SELECT {", ".join(return_fields)}, COUNT(*) AS count
-            FROM "{self.db_name}_graph"."Memory"
-            {where_clause}
-            GROUP BY {", ".join(group_by_fields)}
+            WITH t AS (
+                SELECT {", ".join(cte_select_list)}
+                FROM "{self.db_name}_graph"."Memory"
+                {where_clause}
+                LIMIT 1000
+            )
+            SELECT {outer_select}, count(*) AS count
+            FROM t
+            GROUP BY {outer_group_by}
         """
+        logger.info(f"get_grouped_counts query:{query},params:{params}")
+
         try:
             with self._get_connection() as conn, conn.cursor() as cursor:
-                # Handle parameterized query
                 if params and isinstance(params, list):
                     cursor.execute(query, params)
                 else:
@@ -2250,6 +2222,8 @@ class PolarDBGraphDB(BaseGraphDB):
                     count_value = row[-1]  # Last column is count
                     output.append({**group_values, "count": int(count_value)})
 
+                elapsed = (time.perf_counter() - start_time) * 1000.0
+                logger.info("get_grouped_counts internal took %.1f ms", elapsed)
                 return output
 
         except Exception as e:
@@ -4667,6 +4641,36 @@ class PolarDBGraphDB(BaseGraphDB):
                                         condition_parts.append(
                                             f"ag_catalog.agtype_access_operator(properties, '\"{key}\"'::agtype)::text LIKE '%{op_value}%'"
                                         )
+                            elif op == "nolike":
+                                if key.startswith("info."):
+                                    info_field = key[5:]
+                                    if isinstance(op_value, str):
+                                        escaped_value = (
+                                            escape_sql_string(op_value)
+                                            .replace("%", "\\%")
+                                            .replace("_", "\\_")
+                                        )
+                                        condition_parts.append(
+                                            f"ag_catalog.agtype_access_operator(VARIADIC ARRAY[properties, '\"info\"'::ag_catalog.agtype, '\"{info_field}\"'::ag_catalog.agtype])::text NOT LIKE '%{escaped_value}%'"
+                                        )
+                                    else:
+                                        condition_parts.append(
+                                            f"ag_catalog.agtype_access_operator(VARIADIC ARRAY[properties, '\"info\"'::ag_catalog.agtype, '\"{info_field}\"'::ag_catalog.agtype])::text NOT LIKE '%{op_value}%'"
+                                        )
+                                else:
+                                    if isinstance(op_value, str):
+                                        escaped_value = (
+                                            escape_sql_string(op_value)
+                                            .replace("%", "\\%")
+                                            .replace("_", "\\_")
+                                        )
+                                        condition_parts.append(
+                                            f"ag_catalog.agtype_access_operator(properties, '\"{key}\"'::agtype)::text NOT LIKE '%{escaped_value}%'"
+                                        )
+                                    else:
+                                        condition_parts.append(
+                                            f"ag_catalog.agtype_access_operator(properties, '\"{key}\"'::agtype)::text NOT LIKE '%{op_value}%'"
+                                        )
                     # Check if key starts with "info." prefix (for simple equality)
                     elif key.startswith("info."):
                         # Extract the field name after "info."
@@ -4756,6 +4760,7 @@ class PolarDBGraphDB(BaseGraphDB):
             "project_id",
             "manager_user_id",
             "delete_time",
+            "related_id",
         }
 
         def process_condition(condition):

{memoryos-2.0.9 → memoryos-2.0.10}/src/memos/llms/ollama.py

@@ -88,7 +88,7 @@ class OllamaLLM(BaseLLM):
         )
         str_response = response.message.content
         if self.config.remove_think_prefix:
-            return remove_thinking_tags(str_response)
+            return remove_thinking_tags(str_response or "")
         else:
             return str_thinking + str_response