MemoryOS 2.0.2__tar.gz → 2.0.3__tar.gz

{memoryos-2.0.2 → memoryos-2.0.3}/PKG-INFO

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

{memoryos-2.0.2 → memoryos-2.0.3}/pyproject.toml

@@ -4,7 +4,7 @@
 ##############################################################################
 
 name = "MemoryOS"
-version = "2.0.2"
+version = "2.0.3"
 description = "Intelligence Begins with Memory"
 license = {text = "Apache-2.0"}
 readme = "README.md"

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/__init__.py

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

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/api/config.py

@@ -23,7 +23,7 @@ if TYPE_CHECKING:
 
 
 # Load environment variables
-load_dotenv()
+load_dotenv(override=True)
 
 logger = logging.getLogger(__name__)
 
@@ -410,6 +410,8 @@ class APIConfig:
                     "url": os.getenv("MOS_RERANKER_URL", "localhost:8000/v1/rerank"),
                     "model": os.getenv("MOS_FEEDBACK_RERANKER_MODEL", "bge-reranker-v2-m3"),
                     "timeout": 10,
+                    "max_query_tokens": int(os.getenv("MOS_RERANKER_MAX_TOKENS", 8000)),
+                    "concate_len": int(os.getenv("MOS_RERANKER_CONCAT_LEN", 1000)),
                     "headers_extra": json.loads(os.getenv("MOS_RERANKER_HEADERS_EXTRA", "{}")),
                     "rerank_source": os.getenv("MOS_RERANK_SOURCE"),
                     "reranker_strategy": os.getenv("MOS_RERANKER_STRATEGY", "single_turn"),

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/api/handlers/component_init.py

@@ -133,19 +133,22 @@ def init_server() -> dict[str, Any]:
     logger.info("Initializing MemOS server components...")
 
     # Initialize Redis client first as it is a core dependency for features like scheduler status tracking
-    try:
-        from memos.mem_scheduler.orm_modules.api_redis_model import APIRedisDBManager
-
-        redis_client = APIRedisDBManager.load_redis_engine_from_env()
-        if redis_client:
-            logger.info("Redis client initialized successfully.")
-        else:
-            logger.error(
-                "Failed to initialize Redis client. Check REDIS_HOST etc. in environment variables."
-            )
-    except Exception as e:
-        logger.error(f"Failed to initialize Redis client: {e}", exc_info=True)
-        redis_client = None  # Ensure redis_client exists even on failure
+    if os.getenv("MEMSCHEDULER_USE_REDIS_QUEUE", "False").lower() == "true":
+        try:
+            from memos.mem_scheduler.orm_modules.api_redis_model import APIRedisDBManager
+
+            redis_client = APIRedisDBManager.load_redis_engine_from_env()
+            if redis_client:
+                logger.info("Redis client initialized successfully.")
+            else:
+                logger.error(
+                    "Failed to initialize Redis client. Check REDIS_HOST etc. in environment variables."
+                )
+        except Exception as e:
+            logger.error(f"Failed to initialize Redis client: {e}", exc_info=True)
+            redis_client = None  # Ensure redis_client exists even on failure
+    else:
+        redis_client = None
 
     # Get default cube configuration
     default_cube_config = APIConfig.get_default_cube_config()

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/api/handlers/config_builders.py

@@ -89,7 +89,7 @@ def build_chat_llm_config() -> list[dict[str, Any]]:
     Returns:
         Validated chat LLM configuration dictionary
     """
-    configs = json.loads(os.getenv("CHAT_MODEL_LIST"))
+    configs = json.loads(os.getenv("CHAT_MODEL_LIST", "[]"))
     return [
         {
             "config_class": LLMConfigFactory.model_validate(

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/api/handlers/formatters_handler.py

@@ -144,7 +144,7 @@ def separate_knowledge_and_conversation_mem(memories: list[dict[str, Any]]):
     knowledge_mem = []
     conversation_mem = []
     for item in memories:
-        sources = item["metadata"]["sources"]
+        sources = item.get("metadata", {}).get("sources", [])
         if (
             len(sources) > 0
             and "type" in sources[0]
@@ -199,7 +199,7 @@ def rerank_knowledge_mem(
         item["metadata"]["sources"] = []
 
     for item in conversation_mem:
-        item["metadata"]["sources"] = []
+        item.setdefault("metadata", {})["sources"] = []
 
     # deduplicate: remove items with duplicate memory content
     original_count = len(reranked_knowledge_mem)

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/api/mcp_serve.py

@@ -61,6 +61,19 @@ def load_default_config(user_id="default_user"):
         "SCHEDULER_TOP_N": "scheduler_top_n",
     }
 
+    # Fields that should always be kept as strings (not converted to numbers)
+    string_only_fields = {
+        "openai_api_key",
+        "openai_api_base",
+        "neo4j_uri",
+        "neo4j_user",
+        "neo4j_password",
+        "neo4j_db_name",
+        "text_mem_type",
+        "model_name",
+        "embedder_model",
+    }
+
     kwargs = {"user_id": user_id}
     for env_key, param_key in env_mapping.items():
         val = os.getenv(env_key)
@@ -74,6 +87,9 @@ def load_default_config(user_id="default_user"):
             # Handle boolean conversions
             if val.lower() in ("true", "false"):
                 kwargs[param_key] = val.lower() == "true"
+            # Keep certain fields as strings
+            elif param_key in string_only_fields:
+                kwargs[param_key] = val
             else:
                 # Try numeric conversions (int first, then float)
                 try:
@@ -93,6 +109,10 @@ def load_default_config(user_id="default_user"):
     openai_api_base = kwargs.pop("openai_api_base", "https://api.openai.com/v1")
     text_mem_type = kwargs.pop("text_mem_type", "tree_text")
 
+    # Ensure embedder_model has a default value if not set
+    if "embedder_model" not in kwargs:
+        kwargs["embedder_model"] = os.getenv("EMBEDDER_MODEL", "nomic-embed-text:latest")
+
     config, cube = get_default(
         openai_api_key=openai_api_key,
         openai_api_base=openai_api_base,
@@ -110,6 +130,21 @@ class MOSMCPStdioServer:
         self.mos_core.register_mem_cube(cube)
         self._setup_tools()
 
+
+class MOSMCPServer:
+    """MCP Server that accepts an existing MOS instance."""
+
+    def __init__(self, mos_instance: MOS | None = None):
+        self.mcp = FastMCP("MOS Memory System")
+        if mos_instance is None:
+            # Fall back to creating from default config
+            config, cube = load_default_config()
+            self.mos_core = MOS(config=config)
+            self.mos_core.register_mem_cube(cube)
+        else:
+            self.mos_core = mos_instance
+        self._setup_tools()
+
     def _setup_tools(self):
         """Setup MCP tools"""
 
@@ -133,7 +168,10 @@ class MOSMCPStdioServer:
                 response = self.mos_core.chat(query, user_id)
                 return response
             except Exception as e:
-                return f"Chat error: {e!s}"
+                import traceback
+
+                error_details = traceback.format_exc()
+                return f"Chat error: {e!s}\nTraceback:\n{error_details}"
 
         @self.mcp.tool()
         async def create_user(
@@ -261,7 +299,10 @@ class MOSMCPStdioServer:
                 result = self.mos_core.search(query, user_id, cube_ids)
                 return result
             except Exception as e:
-                return {"error": str(e)}
+                import traceback
+
+                error_details = traceback.format_exc()
+                return {"error": str(e), "traceback": error_details}
 
         @self.mcp.tool()
         async def add_memory(
@@ -527,23 +568,24 @@ class MOSMCPStdioServer:
             except Exception as e:
                 return f"Error controlling memory scheduler: {e!s}"
 
-    def run(self, transport: str = "stdio", **kwargs):
-        """Run MCP server with specified transport"""
-        if transport == "stdio":
-            # Run stdio mode (default for local usage)
-            self.mcp.run(transport="stdio")
-        elif transport == "http":
-            # Run HTTP mode
-            host = kwargs.get("host", "localhost")
-            port = kwargs.get("port", 8000)
-            asyncio.run(self.mcp.run_http_async(host=host, port=port))
-        elif transport == "sse":
-            # Run SSE mode (deprecated but still supported)
-            host = kwargs.get("host", "localhost")
-            port = kwargs.get("port", 8000)
-            self.mcp.run(transport="sse", host=host, port=port)
-        else:
-            raise ValueError(f"Unsupported transport: {transport}")
+
+def _run_mcp(self, transport: str = "stdio", **kwargs):
+    if transport == "stdio":
+        self.mcp.run(transport="stdio")
+    elif transport == "http":
+        host = kwargs.get("host", "localhost")
+        port = kwargs.get("port", 8000)
+        asyncio.run(self.mcp.run_http_async(host=host, port=port))
+    elif transport == "sse":
+        host = kwargs.get("host", "localhost")
+        port = kwargs.get("port", 8000)
+        self.mcp.run(transport="sse", host=host, port=port)
+    else:
+        raise ValueError(f"Unsupported transport: {transport}")
+
+
+MOSMCPStdioServer.run = _run_mcp
+MOSMCPServer.run = _run_mcp
 
 
 # Usage example

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/api/start_api.py

@@ -20,7 +20,7 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(
 logger = logging.getLogger(__name__)
 
 # Load environment variables
-load_dotenv()
+load_dotenv(override=True)
 
 T = TypeVar("T")
 

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/cli.py

@@ -13,7 +13,7 @@ from io import BytesIO
 
 def export_openapi(output: str) -> bool:
     """Export OpenAPI schema to JSON file."""
-    from memos.api.start_api import app
+    from memos.api.server_api import app
 
     # Create directory if it doesn't exist
     if os.path.dirname(output):

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/graph_dbs/neo4j.py

@@ -209,6 +209,10 @@ class Neo4jGraphDB(BaseGraphDB):
         # Flatten info fields to top level (for Neo4j flat structure)
         metadata = _flatten_info_fields(metadata)
 
+        # Initialize delete_time and delete_record_id fields
+        metadata.setdefault("delete_time", "")
+        metadata.setdefault("delete_record_id", "")
+
         # Merge node and set metadata
         created_at = metadata.pop("created_at")
         updated_at = metadata.pop("updated_at")
@@ -251,6 +255,7 @@ class Neo4jGraphDB(BaseGraphDB):
                 - metadata: dict[str, Any] - Node metadata
             user_name: Optional user name (will use config default if not provided)
         """
+        logger.info("neo4j [add_nodes_batch] staring")
         if not nodes:
             logger.warning("[add_nodes_batch] Empty nodes list, skipping")
             return
@@ -280,6 +285,10 @@ class Neo4jGraphDB(BaseGraphDB):
                 # Flatten info fields to top level (for Neo4j flat structure)
                 metadata = _flatten_info_fields(metadata)
 
+                # Initialize delete_time and delete_record_id fields
+                metadata.setdefault("delete_time", "")
+                metadata.setdefault("delete_record_id", "")
+
                 # Merge node and set metadata
                 created_at = metadata.pop("created_at")
                 updated_at = metadata.pop("updated_at")
@@ -1705,7 +1714,7 @@ class Neo4jGraphDB(BaseGraphDB):
         node.pop("user_name", None)
 
         # serialization
-        if node["sources"]:
+        if node.get("sources"):
             for idx in range(len(node["sources"])):
                 if not (
                     isinstance(node["sources"][idx], str)

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/graph_dbs/neo4j_community.py

@@ -56,6 +56,10 @@ class Neo4jCommunityGraphDB(Neo4jGraphDB):
         # Safely process metadata
         metadata = _prepare_node_metadata(metadata)
 
+        # Initialize delete_time and delete_record_id fields
+        metadata.setdefault("delete_time", "")
+        metadata.setdefault("delete_record_id", "")
+
         # serialization
         if metadata["sources"]:
             for idx in range(len(metadata["sources"])):
@@ -105,6 +109,7 @@ class Neo4jCommunityGraphDB(Neo4jGraphDB):
             )
 
     def add_nodes_batch(self, nodes: list[dict[str, Any]], user_name: str | None = None) -> None:
+        print("neo4j_community add_nodes_batch:")
         if not nodes:
             logger.warning("[add_nodes_batch] Empty nodes list, skipping")
             return
@@ -130,6 +135,10 @@ class Neo4jCommunityGraphDB(Neo4jGraphDB):
                 metadata = _prepare_node_metadata(metadata)
                 metadata = _flatten_info_fields(metadata)
 
+                # Initialize delete_time and delete_record_id fields
+                metadata.setdefault("delete_time", "")
+                metadata.setdefault("delete_record_id", "")
+
                 embedding = metadata.pop("embedding", None)
                 if embedding is None:
                     raise ValueError(f"Missing 'embedding' in metadata for node {node_id}")

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/graph_dbs/polardb.py

@@ -835,6 +835,11 @@ class PolarDBGraphDB(BaseGraphDB):
     def add_edge(
         self, source_id: str, target_id: str, type: str, user_name: str | None = None
     ) -> None:
+        logger.info(
+            f"polardb [add_edge] source_id: {source_id}, target_id: {target_id}, type: {type},user_name:{user_name}"
+        )
+
+        start_time = time.time()
         if not source_id or not target_id:
             logger.warning(f"Edge '{source_id}' and '{target_id}' are both None")
             raise ValueError("[add_edge] source_id and target_id must be provided")
@@ -864,13 +869,16 @@ class PolarDBGraphDB(BaseGraphDB):
                   AND end_id   = ag_catalog._make_graph_id('{self.db_name}_graph'::name, 'Memory'::name, '{target_id}'::text::cstring)
             );
         """
-
+        logger.info(f"polardb [add_edge] query: {query}, properties: {json.dumps(properties)}")
         conn = None
         try:
             conn = self._get_connection()
             with conn.cursor() as cursor:
                 cursor.execute(query, (source_id, target_id, type, json.dumps(properties)))
                 logger.info(f"Edge created: {source_id} -[{type}]-> {target_id}")
+
+                elapsed_time = time.time() - start_time
+                logger.info(f" polardb [add_edge] insert completed time in {elapsed_time:.2f}s")
         except Exception as e:
             logger.error(f"Failed to insert edge: {e}", exc_info=True)
             raise
@@ -1033,7 +1041,10 @@ class PolarDBGraphDB(BaseGraphDB):
         Returns:
             dict: Node properties as key-value pairs, or None if not found.
         """
-
+        logger.info(
+            f"polardb [get_node] id: {id}, include_embedding: {include_embedding}, user_name: {user_name}"
+        )
+        start_time = time.time()
         select_fields = "id, properties, embedding" if include_embedding else "id, properties"
 
         query = f"""
@@ -1048,6 +1059,7 @@ class PolarDBGraphDB(BaseGraphDB):
             query += "\nAND ag_catalog.agtype_access_operator(properties, '\"user_name\"'::agtype) = %s::agtype"
             params.append(self.format_param_value(user_name))
 
+        logger.info(f"polardb [get_node] query: {query},params: {params}")
         conn = None
         try:
             conn = self._get_connection()
@@ -1084,6 +1096,10 @@ class PolarDBGraphDB(BaseGraphDB):
                         except (json.JSONDecodeError, TypeError):
                             logger.warning(f"Failed to parse embedding for node {id}")
 
+                    elapsed_time = time.time() - start_time
+                    logger.info(
+                        f" polardb [get_node] get_node completed time in {elapsed_time:.2f}s"
+                    )
                     return self._parse_node(
                         {
                             "id": id,
@@ -1879,7 +1895,7 @@ class PolarDBGraphDB(BaseGraphDB):
         filter: dict | None = None,
         knowledgebase_ids: list[str] | None = None,
         tsvector_field: str = "properties_tsvector_zh",
-        tsquery_config: str = "jiebaqry",
+        tsquery_config: str = "jiebacfg",
         **kwargs,
     ) -> list[dict]:
         """
@@ -1902,7 +1918,11 @@ class PolarDBGraphDB(BaseGraphDB):
         Returns:
             list[dict]: result list containing id and score
         """
+        logger.info(
+            f"[search_by_fulltext] query_words: {query_words},top_k:{top_k},scope:{scope},status:{status},threshold:{threshold},search_filter:{search_filter},user_name:{user_name},knowledgebase_ids:{knowledgebase_ids},filter:{filter}"
+        )
         # Build WHERE clause dynamically, same as search_by_embedding
+        start_time = time.time()
         where_clauses = []
 
         if scope:
@@ -1924,6 +1944,7 @@ class PolarDBGraphDB(BaseGraphDB):
             knowledgebase_ids=knowledgebase_ids,
             default_user_name=self.config.user_name,
         )
+        logger.info(f"[search_by_fulltext] user_name_conditions: {user_name_conditions}")
 
         # Add OR condition if we have any user_name conditions
         if user_name_conditions:
@@ -1946,6 +1967,8 @@ class PolarDBGraphDB(BaseGraphDB):
 
         # Build filter conditions using common method
         filter_conditions = self._build_filter_conditions_sql(filter)
+        logger.info(f"[search_by_fulltext] filter_conditions: {filter_conditions}")
+
         where_clauses.extend(filter_conditions)
         # Add fulltext search condition
         # Convert query_text to OR query format: "word1 | word2 | word3"
@@ -1955,6 +1978,8 @@ class PolarDBGraphDB(BaseGraphDB):
 
         where_clause = f"WHERE {' AND '.join(where_clauses)}" if where_clauses else ""
 
+        logger.info(f"[search_by_fulltext] where_clause: {where_clause}")
+
         # Build fulltext search query
         query = f"""
             SELECT
@@ -1986,7 +2011,10 @@ class PolarDBGraphDB(BaseGraphDB):
                     # Apply threshold filter if specified
                     if threshold is None or score_val >= threshold:
                         output.append({"id": id_val, "score": score_val})
-
+                elapsed_time = time.time() - start_time
+                logger.info(
+                    f" polardb [search_by_fulltext] query completed time in {elapsed_time:.2f}s"
+                )
                 return output[:top_k]
         finally:
             self._return_connection(conn)
@@ -3394,6 +3422,8 @@ class PolarDBGraphDB(BaseGraphDB):
             "memory": memory,
             "created_at": created_at,
             "updated_at": updated_at,
+            "delete_time": "",
+            "delete_record_id": "",
             **metadata,
         }
 
@@ -3535,6 +3565,8 @@ class PolarDBGraphDB(BaseGraphDB):
                     "memory": memory,
                     "created_at": created_at,
                     "updated_at": updated_at,
+                    "delete_time": "",
+                    "delete_record_id": "",
                     **metadata,
                 }
 
@@ -4281,7 +4313,7 @@ class PolarDBGraphDB(BaseGraphDB):
         user_name_conditions = []
         effective_user_name = user_name if user_name else default_user_name
 
-        if effective_user_name:
+        if effective_user_name and default_user_name != "xxx":
             user_name_conditions.append(
                 f"ag_catalog.agtype_access_operator(properties, '\"user_name\"'::agtype) = '\"{effective_user_name}\"'::agtype"
             )

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/llms/hf.py

@@ -51,7 +51,7 @@ class HFLLM(BaseLLM):
                 self.config.model_name_or_path, torch_dtype="auto", device_map="auto"
             )
         self.tokenizer = AutoTokenizer.from_pretrained(
-            self.config.model_name_or_path, use_fast=True
+            self.config.model_name_or_path, use_fast=True, force_download=True
         )
 
         # Logits processors for sampling

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/mem_feedback/feedback.py

@@ -96,6 +96,7 @@ class MemFeedback(BaseMemFeedback):
         self.searcher: Searcher = None
         self.reranker = None
         self.pref_mem: SimplePreferenceTextMemory = None
+        self.pref_feedback: bool = False
         self.DB_IDX_READY = False
 
     @require_python_package(
@@ -630,11 +631,14 @@ class MemFeedback(BaseMemFeedback):
         )
         retrieved_mems = [item[0] for item in retrieved_mems if float(item[1]) > 0.01]
 
-        pref_info = {}
-        if "user_id" in info:
-            pref_info = {"user_id": info["user_id"]}
-        retrieved_prefs = self.pref_mem.search(query, top_k, pref_info)
-        return retrieved_mems + retrieved_prefs
+        if self.pref_feedback:
+            pref_info = {}
+            if "user_id" in info:
+                pref_info = {"user_id": info["user_id"]}
+            retrieved_prefs = self.pref_mem.search(query, top_k, pref_info)
+            return retrieved_mems + retrieved_prefs
+        else:
+            return retrieved_mems
 
     def _vec_query(self, new_memories_embedding: list[float], user_name=None):
         """Vector retrieval query"""

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/mem_feedback/simple_feedback.py

@@ -25,6 +25,7 @@ class SimpleMemFeedback(MemFeedback):
         searcher: Searcher,
         reranker: BaseReranker,
         pref_mem: SimplePreferenceTextMemory,
+        pref_feedback: bool = False,
     ):
         self.llm = llm
         self.embedder = embedder
@@ -36,3 +37,4 @@ class SimpleMemFeedback(MemFeedback):
         self.pref_mem = pref_mem
         self.reranker = reranker
         self.DB_IDX_READY = False
+        self.pref_feedback = pref_feedback

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/mem_reader/read_multi_modal/image_parser.py

@@ -151,6 +151,17 @@ class ImageParser(BaseMessageParser):
             IMAGE_ANALYSIS_PROMPT_ZH if lang == "zh" else IMAGE_ANALYSIS_PROMPT_EN
         )
 
+        # Add context if available
+        context_text = ""
+        if context_items:
+            for item in context_items:
+                if hasattr(item, "memory") and item.memory:
+                    context_text += f"{item.memory}\n"
+        context_text = context_text.strip()
+
+        # Inject context into prompt when possible
+        image_analysis_prompt = image_analysis_prompt.replace("{context}", context_text)
+
         # Build messages with image content
         messages = [
             {
@@ -168,21 +179,6 @@ class ImageParser(BaseMessageParser):
             }
         ]
 
-        # Add context if available
-        if context_items:
-            context_text = ""
-            for item in context_items:
-                if hasattr(item, "memory") and item.memory:
-                    context_text += f"{item.memory}\n"
-            if context_text:
-                messages.insert(
-                    0,
-                    {
-                        "role": "system",
-                        "content": f"Context from previous conversation:\n{context_text}",
-                    },
-                )
-
         try:
             # Call LLM with vision model
             response_text = self.llm.generate(messages)
@@ -192,6 +188,9 @@ class ImageParser(BaseMessageParser):
 
             # Parse JSON response
             response_json = self._parse_json_result(response_text)
+            if not response_json:
+                logger.warning(f"[ImageParser] Fail to parse response from LLM: {response_text}")
+                return []
 
             # Extract memory items from response
             memory_items = []
@@ -323,8 +322,7 @@ class ImageParser(BaseMessageParser):
                     return json.loads(s)
                 except json.JSONDecodeError:
                     pass
-            logger.error(f"[ImageParser] Failed to parse JSON: {e}\nResponse: {response_text}")
-            return {}
+            logger.warning(f"[ImageParser] Failed to parse JSON: {e}\nResponse: {response_text}")
 
     def _create_memory_item(
         self,

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/mem_reader/read_multi_modal/utils.py

@@ -97,7 +97,7 @@ def parse_json_result(response_text: str) -> dict:
                 return json.loads(s)
             except json.JSONDecodeError:
                 pass
-        logger.error(f"[JSONParse] Failed to decode JSON: {e}\nRaw: {response_text}")
+        logger.warning(f"[JSONParse] Failed to decode JSON: {e}\nRaw: {response_text}")
         return {}
 
 

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/mem_reader/simple_struct.py

@@ -224,6 +224,22 @@ class SimpleStructMemReader(BaseMemReader, ABC):
             ),
         )
 
+    def _safe_generate(self, messages: list[dict]) -> str | None:
+        try:
+            return self.llm.generate(messages)
+        except Exception:
+            logger.exception("[LLM] Generation failed")
+            return None
+
+    def _safe_parse(self, text: str | None) -> dict | None:
+        if not text:
+            return None
+        try:
+            return parse_json_result(text)
+        except Exception:
+            logger.warning("[LLM] JSON parse failed")
+            return None
+
     def _get_llm_response(self, mem_str: str, custom_tags: list[str] | None) -> dict:
         lang = detect_lang(mem_str)
         template = PROMPT_DICT["chat"][lang]
@@ -240,13 +256,13 @@ class SimpleStructMemReader(BaseMemReader, ABC):
         if self.config.remove_prompt_example:
             prompt = prompt.replace(examples, "")
         messages = [{"role": "user", "content": prompt}]
-        try:
-            response_text = self.llm.generate(messages)
-            response_json = parse_json_result(response_text)
-        except Exception as e:
-            logger.error(f"[LLM] Exception during chat generation: {e}")
-            response_json = {
-                "memory list": [
+
+        response_text = self._safe_generate(messages)
+        response_json = self._safe_parse(response_text)
+
+        if not response_json:
+            return {
+                "memory_list": [
                     {
                         "key": mem_str[:10],
                         "memory_type": "UserMemory",
@@ -256,6 +272,7 @@ class SimpleStructMemReader(BaseMemReader, ABC):
                 ],
                 "summary": mem_str,
             }
+
         return response_json
 
     def _iter_chat_windows(self, scene_data_info, max_tokens=None, overlap=200):

{memoryos-2.0.2 → memoryos-2.0.3}/src/memos/mem_reader/utils.py

@@ -70,7 +70,7 @@ def parse_json_result(response_text: str) -> dict:
         if "Invalid \\escape" in str(e):
             s = s.replace("\\", "\\\\")
             return json.loads(s)
-        logger.error(
+        logger.warning(
             f"[JSONParse] Failed to decode JSON: {e}\nTail: Raw {response_text} \
             json: {s}"
         )