MemoryOS 2.0.12__tar.gz → 2.0.14__tar.gz

{memoryos-2.0.12 → memoryos-2.0.14}/PKG-INFO

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

{memoryos-2.0.12 → memoryos-2.0.14}/pyproject.toml

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

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/__init__.py

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

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/api/config.py

@@ -369,6 +369,26 @@ class APIConfig:
 
         return {"backend": "openai", "config": config}
 
+    @staticmethod
+    def get_qwen_llm_config() -> dict[str, Any] | None:
+        if not os.getenv("QWEN_API_KEY"):
+            return None
+        return {
+            "backend": "qwen",
+            "config": {
+                "model_name_or_path": os.getenv("QWEN_MODEL", "qwen-flash"),
+                "temperature": float(os.getenv("QWEN_TEMPERATURE", "0.8")),
+                "max_tokens": int(os.getenv("QWEN_MAX_TOKENS", "8000")),
+                "top_p": float(os.getenv("QWEN_TOP_P", "0.9")),
+                "top_k": int(os.getenv("QWEN_TOP_K", "50")),
+                "remove_think_prefix": os.getenv("QWEN_REMOVE_THINK_PREFIX", "true").lower()
+                == "true",
+                "api_key": os.getenv("QWEN_API_KEY", ""),
+                "api_base": os.getenv("QWEN_API_BASE", ""),
+                "model_schema": os.getenv("QWEN_MODEL_SCHEMA", "memos.configs.llm.QwenLLMConfig"),
+            },
+        }
+
     @staticmethod
     def get_memreader_general_llm_config() -> dict[str, Any]:
         """Get general LLM configuration for non-chat/doc tasks.
@@ -639,6 +659,7 @@ class APIConfig:
 
         return config
 
+    @staticmethod
     def get_internet_config() -> dict[str, Any]:
         """Get internet retriever configuration.
 
@@ -705,8 +726,9 @@ class APIConfig:
 
     @staticmethod
     def get_nli_config() -> dict[str, Any]:
-        """Get NLI model configuration."""
+        """Get relation-judge configuration for memory-version candidate matching."""
         return {
+            "provider": os.getenv("MEM_VERSION_RELATION_JUDGE_PROVIDER", "llm"),
             "base_url": os.getenv("NLI_MODEL_BASE_URL", "http://localhost:32532"),
         }
 
@@ -872,7 +894,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", "200")
+                    os.getenv("MOS_SCHEDULER_THREAD_POOL_MAX_WORKERS", "50")
                 ),
                 "consume_interval_seconds": float(
                     os.getenv("MOS_SCHEDULER_CONSUME_INTERVAL_SECONDS", "0.01")
@@ -952,6 +974,7 @@ class APIConfig:
                 "backend": reader_config["backend"],
                 "config": {
                     "llm": APIConfig.get_memreader_config(),
+                    "qwen_llm": APIConfig.get_qwen_llm_config(),
                     # General LLM for non-chat/doc tasks (hallucination filter, rewrite, merge, etc.)
                     "general_llm": APIConfig.get_memreader_general_llm_config(),
                     # Image parser LLM (requires vision model)
@@ -986,6 +1009,7 @@ class APIConfig:
                             "SKILLS_LOCAL_DIR", "/tmp/upload_skill_memory/"
                         ),
                     },
+                    "memory_version_switch": os.getenv("MEM_READER_MEM_VERSION_SWITCH", "off"),
                 },
             },
             "enable_textual_memory": True,

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/api/handlers/add_handler.py

@@ -15,6 +15,7 @@ from memos.memories.textual.item import (
 from memos.multi_mem_cube.composite_cube import CompositeCubeView
 from memos.multi_mem_cube.single_cube import SingleCubeView
 from memos.multi_mem_cube.views import MemCubeView
+from memos.plugins.hooks import hookable
 from memos.types import MessageList
 
 
@@ -37,6 +38,7 @@ class AddHandler(BaseHandler):
             "naive_mem_cube", "mem_reader", "mem_scheduler", "feedback_server"
         )
 
+    @hookable("add")
     def handle_add_memories(self, add_req: APIADDRequest) -> MemoryResponse:
         """
         Main handler for add memories endpoint.

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/api/handlers/component_init.py

@@ -32,14 +32,14 @@ from memos.mem_reader.factory import MemReaderFactory
 from memos.mem_scheduler.orm_modules.base_model import BaseDBManager
 from memos.mem_scheduler.scheduler_factory import SchedulerFactory
 from memos.memories.textual.simple_tree import SimpleTreeTextMemory
-from memos.memories.textual.tree_text_memory.organize.history_manager import MemoryHistoryManager
 from memos.memories.textual.tree_text_memory.organize.manager import MemoryManager
 from memos.memories.textual.tree_text_memory.retrieve.retrieve_utils import FastTokenizer
+from memos.plugins.component_bootstrap import build_plugin_context
+from memos.plugins.manager import plugin_manager
 
 
 if TYPE_CHECKING:
     from memos.memories.textual.tree import TreeTextMemory
-from memos.extras.nli_model.client import NLIClient
 from memos.mem_agent.deepsearch_agent import DeepSearchMemAgent
 from memos.memories.textual.tree_text_memory.retrieve.internet_retriever_factory import (
     InternetRetrieverFactory,
@@ -122,6 +122,12 @@ def init_server() -> dict[str, Any]:
         existing code that uses the components.
     """
     logger.info("Initializing MemOS server components...")
+    logger.info(
+        "[INIT_SERVER] env_MEMSCHEDULER_STREAM_KEY_PREFIX=%s, env_MEMSCHEDULER_REDIS_STREAM_KEY_PREFIX=%s, env_POLAR_DB_DB_NAME=%s",
+        os.getenv("MEMSCHEDULER_STREAM_KEY_PREFIX"),
+        os.getenv("MEMSCHEDULER_REDIS_STREAM_KEY_PREFIX"),
+        os.getenv("POLAR_DB_DB_NAME"),
+    )
 
     # Initialize Redis client first as it is a core dependency for features like scheduler status tracking
     if os.getenv("MEMSCHEDULER_USE_REDIS_QUEUE", "False").lower() == "true":
@@ -169,10 +175,25 @@ def init_server() -> dict[str, Any]:
         else None
     )
     embedder = EmbedderFactory.from_config(embedder_config)
-    nli_client = NLIClient(base_url=nli_client_config["base_url"])
-    memory_history_manager = MemoryHistoryManager(nli_client=nli_client, graph_db=graph_db)
+
+    plugin_context = build_plugin_context(
+        graph_db=graph_db,
+        embedder=embedder,
+        default_cube_config=default_cube_config,
+        nli_client_config=nli_client_config,
+        mem_reader_config=mem_reader_config,
+        reranker_config=reranker_config,
+        feedback_reranker_config=feedback_reranker_config,
+        internet_retriever_config=internet_retriever_config,
+    )
+    plugin_manager.discover()
+    plugin_manager.init_components(plugin_context)
+
     # Pass graph_db to mem_reader for recall operations (deduplication, conflict detection)
-    mem_reader = MemReaderFactory.from_config(mem_reader_config, graph_db=graph_db)
+    mem_reader = MemReaderFactory.from_config(
+        mem_reader_config,
+        graph_db=graph_db,
+    )
     reranker = RerankerFactory.from_config(reranker_config)
     feedback_reranker = RerankerFactory.from_config(feedback_reranker_config)
     internet_retriever = InternetRetrieverFactory.from_config(
@@ -303,6 +324,4 @@ def init_server() -> dict[str, Any]:
         "feedback_server": feedback_server,
         "redis_client": redis_client,
         "deepsearch_agent": deepsearch_agent,
-        "nli_client": nli_client,
-        "memory_history_manager": memory_history_manager,
     }

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/api/handlers/formatters_handler.py

@@ -141,6 +141,7 @@ def separate_knowledge_and_conversation_mem(memories: list[dict[str, Any]]):
         sources = item.get("metadata", {}).get("sources", [])
         if (
             item["metadata"]["memory_type"] != "RawFileMemory"
+            and sources
             and len(sources) > 0
             and "type" in sources[0]
             and sources[0]["type"] == "file"

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/api/server_api.py

@@ -9,13 +9,21 @@ from starlette.staticfiles import StaticFiles
 from memos.api.exceptions import APIExceptionHandler
 from memos.api.middleware.request_context import RequestContextMiddleware
 from memos.api.routers.server_router import router as server_router
+from memos.plugins.manager import plugin_manager
 
 
 load_dotenv()
 
+plugin_manager.discover()
+
 # Configure logging
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
+logger.info(
+    "[SERVER_API] load_dotenv completed. env_MEMSCHEDULER_STREAM_KEY_PREFIX=%s, env_MEMSCHEDULER_REDIS_STREAM_KEY_PREFIX=%s",
+    os.getenv("MEMSCHEDULER_STREAM_KEY_PREFIX"),
+    os.getenv("MEMSCHEDULER_REDIS_STREAM_KEY_PREFIX"),
+)
 
 app = FastAPI(
     title="MemOS Server REST APIs",
@@ -49,6 +57,8 @@ app.exception_handler(HTTPException)(APIExceptionHandler.http_error_handler)
 # Fallback for unknown errors
 app.exception_handler(Exception)(APIExceptionHandler.global_exception_handler)
 
+plugin_manager.init_app(app)
+
 
 if __name__ == "__main__":
     import argparse

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/chunkers/sentence_chunker.py

@@ -53,4 +53,5 @@ class SentenceChunker(BaseChunker):
             chunks.append(chunk)
 
         logger.debug(f"Generated {len(chunks)} chunks from input text")
+
         return chunks

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/configs/mem_reader.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Literal
 
 from pydantic import ConfigDict, Field, field_validator, model_validator
 
@@ -76,6 +76,13 @@ class MultiModalStructMemReaderConfig(BaseMemReaderConfig):
         default=None,
         description="Skills directory for the MemReader",
     )
+    memory_version_switch: Literal["on", "off"] = Field(
+        default="off",
+        description="Turn on memory version or off",
+    )
+
+    # Allow passing additional fields without raising validation errors
+    model_config = ConfigDict(extra="allow", strict=True)
 
 
 class StrategyStructMemReaderConfig(BaseMemReaderConfig):

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/graph_dbs/polardb.py

@@ -899,13 +899,7 @@ class PolarDBGraphDB(BaseGraphDB):
                     logger.info(
                         f" polardb [get_node] get_node completed time in {elapsed_time:.2f}s"
                     )
-                    return self._parse_node(
-                        {
-                            "id": id,
-                            "memory": properties.get("memory", ""),
-                            **properties,
-                        }
-                    )
+                    return self._parse_node(properties)
                 return None
 
         except Exception as e:
@@ -976,15 +970,7 @@ class PolarDBGraphDB(BaseGraphDB):
                         properties["embedding"] = embedding
                     except (json.JSONDecodeError, TypeError):
                         logger.warning(f"Failed to parse embedding for node {node_id}")
-                nodes.append(
-                    self._parse_node(
-                        {
-                            "id": properties.get("id", node_id),
-                            "memory": properties.get("memory", ""),
-                            "metadata": properties,
-                        }
-                    )
-                )
+                nodes.append(self._parse_node(properties))
             return nodes
 
     @timed
@@ -1534,7 +1520,7 @@ class PolarDBGraphDB(BaseGraphDB):
         user_name_conditions = self._build_user_name_and_kb_ids_conditions_sql(
             user_name=user_name,
             knowledgebase_ids=knowledgebase_ids,
-            default_user_name=self.config.user_name,
+            default_user_name=self._get_config_value("user_name"),
         )
 
         # Add OR condition if we have any user_name conditions
@@ -1633,7 +1619,7 @@ class PolarDBGraphDB(BaseGraphDB):
         user_name_conditions = self._build_user_name_and_kb_ids_conditions_sql(
             user_name=user_name,
             knowledgebase_ids=knowledgebase_ids,
-            default_user_name=self.config.user_name,
+            default_user_name=self._get_config_value("user_name"),
         )
 
         # Add OR condition if we have any user_name conditions
@@ -1751,7 +1737,7 @@ class PolarDBGraphDB(BaseGraphDB):
         user_name_conditions = self._build_user_name_and_kb_ids_conditions_sql(
             user_name=user_name,
             knowledgebase_ids=knowledgebase_ids,
-            default_user_name=self.config.user_name,
+            default_user_name=self._get_config_value("user_name"),
         )
 
         if user_name_conditions:
@@ -1873,7 +1859,7 @@ class PolarDBGraphDB(BaseGraphDB):
         user_name_conditions = self._build_user_name_and_kb_ids_conditions_sql(
             user_name=user_name,
             knowledgebase_ids=knowledgebase_ids,
-            default_user_name=self.config.user_name,
+            default_user_name=self._get_config_value("user_name"),
         )
 
         if user_name_conditions:

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/mem_feedback/feedback.py

@@ -33,6 +33,8 @@ from memos.memories.textual.tree_text_memory.organize.manager import (
     extract_working_binding_ids,
 )
 from memos.memories.textual.tree_text_memory.retrieve.retrieve_utils import StopwordManager
+from memos.plugins.hook_defs import H
+from memos.plugins.hooks import trigger_single_hook
 
 
 if TYPE_CHECKING:
@@ -245,6 +247,7 @@ class MemFeedback(BaseMemFeedback):
             datetime.now().isoformat()
         )
         to_add_memory.metadata.background = new_memory_item.metadata.background
+        to_add_memory.metadata.sources = new_memory_item.metadata.sources
 
         added_ids = self._retry_db_operation(
             lambda: self.memory_manager.add([to_add_memory], user_name=user_name, use_batch=False)
@@ -288,33 +291,43 @@ class MemFeedback(BaseMemFeedback):
             new_memory_item.memory = operation["text"]
             new_memory_item.metadata.embedding = self._batch_embed([operation["text"]])[0]
 
-        if memory_type == "WorkingMemory":
-            fields = {
-                "memory": new_memory_item.memory,
-                "key": new_memory_item.metadata.key,
-                "tags": new_memory_item.metadata.tags,
-                "embedding": new_memory_item.metadata.embedding,
-                "background": new_memory_item.metadata.background,
-                "covered_history": old_memory_item.id,
-            }
-            self.graph_store.update_node(old_memory_item.id, fields=fields, user_name=user_name)
-            item_id = old_memory_item.id
-        else:
-            done = self._single_add_operation(
-                old_memory_item, new_memory_item, user_id, user_name, async_mode
+        if getattr(self.mem_reader, "memory_version_switch", "off") != "on":
+            if memory_type == "WorkingMemory":
+                fields = {
+                    "memory": new_memory_item.memory,
+                    "key": new_memory_item.metadata.key,
+                    "tags": new_memory_item.metadata.tags,
+                    "embedding": new_memory_item.metadata.embedding,
+                    "background": new_memory_item.metadata.background,
+                    "covered_history": old_memory_item.id,
+                }
+                self.graph_store.update_node(old_memory_item.id, fields=fields, user_name=user_name)
+                item_id = old_memory_item.id
+            else:
+                done = self._single_add_operation(
+                    old_memory_item, new_memory_item, user_id, user_name, async_mode
+                )
+                item_id = done.get("id")
+                self.graph_store.update_node(
+                    item_id, {"covered_history": old_memory_item.id}, user_name=user_name
+                )
+                self.graph_store.update_node(
+                    old_memory_item.id, {"status": "archived"}, user_name=user_name
+                )
+
+            logger.info(
+                f"[Memory Feedback UPDATE] New Add:{item_id} | Set archived:{old_memory_item.id} | memory_type: {memory_type}"
             )
-            item_id = done.get("id")
-            self.graph_store.update_node(
-                item_id, {"covered_history": old_memory_item.id}, user_name=user_name
+        else:
+            item_id = self._single_update_operation_with_versions(
+                old_memory_item=old_memory_item,
+                new_memory_item=new_memory_item,
+                user_name=user_name,
             )
-            self.graph_store.update_node(
-                old_memory_item.id, {"status": "archived"}, user_name=user_name
+            logger.info(
+                f"[Memory Feedback UPDATE] Updated:{item_id} | history appended | memory_type: {old_memory_item.metadata.memory_type}"
             )
 
-        logger.info(
-            f"[Memory Feedback UPDATE] New Add:{item_id} | Set archived:{old_memory_item.id} | memory_type: {memory_type}"
-        )
-
         return {
             "id": item_id,
             "text": new_memory_item.memory,
@@ -323,6 +336,78 @@ class MemFeedback(BaseMemFeedback):
             "origin_memory": old_memory_item.memory,
         }
 
+    def _single_update_operation_with_versions(
+        self,
+        old_memory_item: TextualMemoryItem,
+        new_memory_item: TextualMemoryItem,
+        user_name: str,
+    ) -> str:
+        try:
+            updated_item, archived_item, archived_metadata, updated_fields = trigger_single_hook(
+                H.MEMORY_VERSION_APPLY_FEEDBACK_UPDATE,
+                old_item=old_memory_item,
+                new_item=new_memory_item,
+                user_name=user_name,
+            )
+        except Exception as e:
+            logger.warning(
+                "[Memory Feedback UPDATE] history fallback for %s: %s", old_memory_item.id, e
+            )
+            updated_item = old_memory_item.model_copy(deep=True)
+            updated_item.memory = new_memory_item.memory
+            updated_item.metadata.key = new_memory_item.metadata.key
+            updated_item.metadata.tags = new_memory_item.metadata.tags
+            updated_item.metadata.background = new_memory_item.metadata.background
+            if getattr(new_memory_item.metadata, "sources", None) is not None:
+                current_sources = list(updated_item.metadata.sources or [])
+                updated_item.metadata.sources = (
+                    list(new_memory_item.metadata.sources or []) + current_sources
+                )
+            if getattr(new_memory_item.metadata, "embedding", None) is not None:
+                updated_item.metadata.embedding = new_memory_item.metadata.embedding
+            if updated_item.metadata.memory_type == "PreferenceMemory":
+                updated_item.metadata.preference = updated_item.memory
+            updated_fields = {
+                "memory": updated_item.memory,
+                "key": updated_item.metadata.key,
+                "tags": updated_item.metadata.tags,
+                "embedding": updated_item.metadata.embedding,
+                "background": updated_item.metadata.background,
+                "sources": [
+                    source.model_dump(exclude_none=True)
+                    if hasattr(source, "model_dump")
+                    else source
+                    for source in (updated_item.metadata.sources or [])
+                ],
+                "covered_history": old_memory_item.id,
+            }
+            archived_item = None
+            archived_metadata = None
+
+        if archived_item and archived_metadata:
+            try:
+                self.graph_store.add_node(
+                    id=archived_item.id,
+                    memory=archived_item.memory,
+                    metadata=archived_metadata,
+                    user_name=user_name,
+                )
+            except Exception as e:
+                logger.warning(
+                    "[Memory Feedback UPDATE] archive add failed for %s: %s",
+                    old_memory_item.id,
+                    e,
+                )
+        self._retry_db_operation(
+            lambda: self.graph_store.update_node(
+                id=updated_item.id,
+                fields=updated_fields,
+                user_name=user_name,
+            )
+        )
+        self._del_working_binding(user_name, [old_memory_item])
+        return updated_item.id
+
     def _del_working_binding(self, user_name, mem_items: list[TextualMemoryItem]) -> set[str]:
         """Delete working memory bindings"""
         bindings_to_delete = extract_working_binding_ids(mem_items)
@@ -331,9 +416,7 @@ class MemFeedback(BaseMemFeedback):
             f"[Memory Feedback UPDATE] Extracted {len(bindings_to_delete)} working_binding ids to cleanup: {list(bindings_to_delete)}"
         )
 
-        delete_ids = []
-        if bindings_to_delete:
-            delete_ids = list({bindings_to_delete})
+        delete_ids = list(bindings_to_delete)
 
         for mid in delete_ids:
             try:
@@ -346,6 +429,7 @@ class MemFeedback(BaseMemFeedback):
                 logger.warning(
                     f"[0107 Feedback Core:_del_working_binding] TreeTextMemory.delete_hard: failed to delete {mid}: {e}"
                 )
+        return bindings_to_delete
 
     def semantics_feedback(
         self,
@@ -476,9 +560,22 @@ class MemFeedback(BaseMemFeedback):
                         f"[0107 Feedback Core: semantics_feedback] Operation failed for {original_op}: {e}",
                         exc_info=True,
                     )
-        if update_results:
-            updated_ids = [item["archived_id"] for item in update_results]
-            self._del_working_binding(updated_ids, user_name)
+        if update_results and getattr(self.mem_reader, "memory_version_switch", "off") != "on":
+            archived_ids = [item["archived_id"] for item in update_results]
+            archived_items = []
+            for aid in archived_ids:
+                try:
+                    node = self.graph_store.get_node(aid, user_name=user_name)
+                    if node:
+                        archived_items.append(TextualMemoryItem(**node))
+                except Exception as e:
+                    logger.warning(
+                        "[Memory Feedback] Failed to fetch archived item %s for working_binding cleanup: %s",
+                        aid,
+                        e,
+                    )
+            if archived_items:
+                self._del_working_binding(user_name, archived_items)
 
         return {"record": {"add": add_results, "update": update_results}}
 
@@ -1066,7 +1163,14 @@ class MemFeedback(BaseMemFeedback):
                         tags=tags,
                         key=key,
                         embedding=embedding,
-                        sources=[{"type": "chat"}],
+                        sources=[
+                            {
+                                "type": "feedback",
+                                "role": "user",
+                                "chat_time": feedback_time,
+                                "content": feedback_content,
+                            }
+                        ],
                         background=background,
                         type="fine",
                         info=info,

{memoryos-2.0.12 → memoryos-2.0.14}/src/memos/mem_os/utils/format_utils.py

@@ -1399,5 +1399,18 @@ def clean_json_response(response: str) -> str:
 
     Returns:
         str: Clean JSON string without markdown formatting
+
+    Raises:
+        ValueError: If ``response`` is None. This is almost always an upstream
+            failure (LLM call returned None instead of raising) and surfacing
+            it here is much easier to diagnose than the implicit
+            ``AttributeError: 'NoneType' object has no attribute 'replace'``
+            that would otherwise be thrown.
     """
+    if response is None:
+        raise ValueError(
+            "clean_json_response received None — upstream LLM call likely "
+            "failed silently (check timed_with_status / generate() error "
+            "handling)."
+        )
     return response.replace("```json", "").replace("```", "").strip()