MemoryOS 2.0.2__tar.gz → 2.0.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MemoryOS
-Version: 2.0.2
+Version: 2.0.4
 Summary: Intelligence Begins with Memory
 License: Apache-2.0
 License-File: LICENSE
@@ -25,7 +25,10 @@ Provides-Extra: mem-reader
 Provides-Extra: mem-scheduler
 Provides-Extra: mem-user
 Provides-Extra: pref-mem
+Provides-Extra: skill-mem
 Provides-Extra: tree-mem
+Requires-Dist: alibabacloud-oss-v2 (>=1.2.2,<1.2.3) ; extra == "all"
+Requires-Dist: alibabacloud-oss-v2 (>=1.2.2,<1.2.3) ; extra == "skill-mem"
 Requires-Dist: cachetools (>=6.0.0) ; extra == "all"
 Requires-Dist: chonkie (>=1.0.7,<2.0.0) ; extra == "all"
 Requires-Dist: chonkie (>=1.0.7,<2.0.0) ; extra == "mem-reader"
@@ -42,7 +45,7 @@ Requires-Dist: markitdown[docx,pdf,pptx,xls,xlsx] (>=0.1.1,<0.2.0) ; extra == "m
 Requires-Dist: neo4j (>=5.28.1,<6.0.0) ; extra == "all"
 Requires-Dist: neo4j (>=5.28.1,<6.0.0) ; extra == "tree-mem"
 Requires-Dist: nltk (>=3.9.1,<4.0.0) ; extra == "all"
-Requires-Dist: ollama (>=0.4.8,<0.5.0)
+Requires-Dist: ollama (>=0.5.0,<0.5.1)
 Requires-Dist: openai (>=1.77.0,<2.0.0)
 Requires-Dist: pika (>=1.3.2,<2.0.0) ; extra == "all"
 Requires-Dist: pika (>=1.3.2,<2.0.0) ; extra == "mem-scheduler"

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

@@ -4,7 +4,7 @@
 ##############################################################################
 
 name = "MemoryOS"
-version = "2.0.2"
+version = "2.0.4"
 description = "Intelligence Begins with Memory"
 license = {text = "Apache-2.0"}
 readme = "README.md"
@@ -37,7 +37,7 @@ classifiers = [
 ]
 dependencies = [
     "openai (>=1.77.0,<2.0.0)",
-    "ollama (>=0.4.8,<0.5.0)",
+    "ollama (>=0.5.0,<0.5.1)",
     "transformers (>=4.51.3,<5.0.0)",
     "tenacity (>=9.1.2,<10.0.0)",  # Error handling and retrying library
     "fastapi[all] (>=0.115.12,<0.116.0)",  # Web framework for building APIs
@@ -97,6 +97,11 @@ pref-mem = [
     "datasketch (>=1.6.5,<2.0.0)",  # MinHash library
 ]
 
+# SkillMemory
+skill-mem = [
+    "alibabacloud-oss-v2 (>=1.2.2,<1.2.3)",
+]
+
 # All optional dependencies
 # Allow users to install with `pip install MemoryOS[all]`
 all = [
@@ -123,6 +128,7 @@ all = [
     "volcengine-python-sdk (>=4.0.4,<5.0.0)",
     "nltk (>=3.9.1,<4.0.0)",
     "rake-nltk (>=1.0.6,<1.1.0)",
+    "alibabacloud-oss-v2 (>=1.2.2,<1.2.3)",
 
     # Uncategorized dependencies
 ]

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

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

{memoryos-2.0.2 → memoryos-2.0.4}/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"),
@@ -438,6 +440,18 @@ class APIConfig:
                     "model_name_or_path": os.getenv("MOS_EMBEDDER_MODEL", "text-embedding-3-large"),
                     "headers_extra": json.loads(os.getenv("MOS_EMBEDDER_HEADERS_EXTRA", "{}")),
                     "base_url": os.getenv("MOS_EMBEDDER_API_BASE", "http://openai.com"),
+                    "backup_client": os.getenv("MOS_EMBEDDER_BACKUP_CLIENT", "false").lower()
+                    == "true",
+                    "backup_base_url": os.getenv(
+                        "MOS_EMBEDDER_BACKUP_API_BASE", "http://openai.com"
+                    ),
+                    "backup_api_key": os.getenv("MOS_EMBEDDER_BACKUP_API_KEY", "sk-xxxx"),
+                    "backup_headers_extra": json.loads(
+                        os.getenv("MOS_EMBEDDER_BACKUP_HEADERS_EXTRA", "{}")
+                    ),
+                    "backup_model_name_or_path": os.getenv(
+                        "MOS_EMBEDDER_BACKUP_MODEL", "text-embedding-3-large"
+                    ),
                 },
             }
         else:  # ollama
@@ -465,6 +479,35 @@ class APIConfig:
         }
 
     @staticmethod
+    def get_oss_config() -> dict[str, Any] | None:
+        """Get OSS configuration and validate connection."""
+
+        config = {
+            "endpoint": os.getenv("OSS_ENDPOINT", "http://oss-cn-shanghai.aliyuncs.com"),
+            "access_key_id": os.getenv("OSS_ACCESS_KEY_ID", ""),
+            "access_key_secret": os.getenv("OSS_ACCESS_KEY_SECRET", ""),
+            "region": os.getenv("OSS_REGION", ""),
+            "bucket_name": os.getenv("OSS_BUCKET_NAME", ""),
+        }
+
+        # Validate that all required fields have values
+        required_fields = [
+            "endpoint",
+            "access_key_id",
+            "access_key_secret",
+            "region",
+            "bucket_name",
+        ]
+        missing_fields = [field for field in required_fields if not config.get(field)]
+
+        if missing_fields:
+            logger.warning(
+                f"OSS configuration incomplete. Missing fields: {', '.join(missing_fields)}"
+            )
+            return None
+
+        return config
+
     def get_internet_config() -> dict[str, Any]:
         """Get embedder configuration."""
         reader_config = APIConfig.get_reader_config()
@@ -507,6 +550,13 @@ class APIConfig:
             },
         }
 
+    @staticmethod
+    def get_nli_config() -> dict[str, Any]:
+        """Get NLI model configuration."""
+        return {
+            "base_url": os.getenv("NLI_MODEL_BASE_URL", "http://localhost:32532"),
+        }
+
     @staticmethod
     def get_neo4j_community_config(user_id: str | None = None) -> dict[str, Any]:
         """Get Neo4j community configuration."""
@@ -744,6 +794,11 @@ class APIConfig:
                         ).split(",")
                         if h.strip()
                     ],
+                    "oss_config": APIConfig.get_oss_config(),
+                    "skills_dir_config": {
+                        "skills_oss_dir": os.getenv("SKILLS_OSS_DIR", "skill_memory/"),
+                        "skills_local_dir": os.getenv("SKILLS_LOCAL_DIR", "/tmp/skill_memory/"),
+                    },
                 },
             },
             "enable_textual_memory": True,

{memoryos-2.0.2 → memoryos-2.0.4}/src/memos/api/handlers/chat_handler.py

@@ -110,6 +110,7 @@ class ChatHandler(BaseHandler):
         Raises:
             HTTPException: If chat fails
         """
+        self.logger.info(f"[ChatHandler] Chat Req is: {chat_req}")
         try:
             # Resolve readable cube IDs (for search)
             readable_cube_ids = chat_req.readable_cube_ids or [chat_req.user_id]
@@ -241,6 +242,7 @@ class ChatHandler(BaseHandler):
         Raises:
             HTTPException: If stream initialization fails
         """
+        self.logger.info(f"[ChatHandler] Chat Req is: {chat_req}")
         try:
 
             def generate_chat_response() -> Generator[str, None, None]:
@@ -422,6 +424,7 @@ class ChatHandler(BaseHandler):
         Raises:
             HTTPException: If stream initialization fails
         """
+        self.logger.info(f"[ChatHandler] Chat Req is: {chat_req}")
         try:
 
             def generate_chat_response() -> Generator[str, None, None]:
@@ -585,6 +588,8 @@ class ChatHandler(BaseHandler):
                     # get internet reference
                     internet_reference = self._get_internet_reference(
                         search_response.data.get("text_mem")[0]["memories"]
+                        if search_response.data.get("text_mem")
+                        else []
                     )
                     yield f"data: {json.dumps({'type': 'reference', 'data': reference}, ensure_ascii=False)}\n\n"
 

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

@@ -18,6 +18,7 @@ from memos.api.handlers.config_builders import (
     build_internet_retriever_config,
     build_llm_config,
     build_mem_reader_config,
+    build_nli_client_config,
     build_pref_adder_config,
     build_pref_extractor_config,
     build_pref_retriever_config,
@@ -48,6 +49,7 @@ from memos.memories.textual.tree_text_memory.retrieve.retrieve_utils import Fast
 
 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,
@@ -133,19 +135,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()
@@ -158,6 +163,7 @@ def init_server() -> dict[str, Any]:
     llm_config = build_llm_config()
     chat_llm_config = build_chat_llm_config()
     embedder_config = build_embedder_config()
+    nli_client_config = build_nli_client_config()
     mem_reader_config = build_mem_reader_config()
     reranker_config = build_reranker_config()
     feedback_reranker_config = build_feedback_reranker_config()
@@ -183,6 +189,7 @@ def init_server() -> dict[str, Any]:
         else None
     )
     embedder = EmbedderFactory.from_config(embedder_config)
+    nli_client = NLIClient(base_url=nli_client_config["base_url"])
     # Pass graph_db to mem_reader for recall operations (deduplication, conflict detection)
     mem_reader = MemReaderFactory.from_config(mem_reader_config, graph_db=graph_db)
     reranker = RerankerFactory.from_config(reranker_config)
@@ -304,6 +311,9 @@ def init_server() -> dict[str, Any]:
     )
     logger.debug("Searcher created")
 
+    # Set searcher to mem_reader
+    mem_reader.set_searcher(searcher)
+
     # Initialize feedback server
     feedback_server = SimpleMemFeedback(
         llm=llm,
@@ -382,4 +392,5 @@ def init_server() -> dict[str, Any]:
         "feedback_server": feedback_server,
         "redis_client": redis_client,
         "deepsearch_agent": deepsearch_agent,
+        "nli_client": nli_client,
     }

{memoryos-2.0.2 → memoryos-2.0.4}/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(
@@ -188,3 +188,13 @@ def build_pref_retriever_config() -> dict[str, Any]:
         Validated retriever configuration dictionary
     """
     return RetrieverConfigFactory.model_validate({"backend": "naive", "config": {}})
+
+
+def build_nli_client_config() -> dict[str, Any]:
+    """
+    Build NLI client configuration.
+
+    Returns:
+        NLI client configuration dictionary
+    """
+    return APIConfig.get_nli_config()

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

@@ -112,13 +112,17 @@ def post_process_textual_mem(
     fact_mem = [
         mem
         for mem in text_formatted_mem
-        if mem["metadata"]["memory_type"] not in ["ToolSchemaMemory", "ToolTrajectoryMemory"]
+        if mem["metadata"]["memory_type"]
+        in ["WorkingMemory", "LongTermMemory", "UserMemory", "OuterMemory"]
     ]
     tool_mem = [
         mem
         for mem in text_formatted_mem
         if mem["metadata"]["memory_type"] in ["ToolSchemaMemory", "ToolTrajectoryMemory"]
     ]
+    skill_mem = [
+        mem for mem in text_formatted_mem if mem["metadata"]["memory_type"] == "SkillMemory"
+    ]
 
     memories_result["text_mem"].append(
         {
@@ -134,6 +138,13 @@ def post_process_textual_mem(
             "total_nodes": len(tool_mem),
         }
     )
+    memories_result["skill_mem"].append(
+        {
+            "cube_id": mem_cube_id,
+            "memories": skill_mem,
+            "total_nodes": len(skill_mem),
+        }
+    )
     return memories_result
 
 
@@ -144,7 +155,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 +210,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.4}/src/memos/api/handlers/memory_handler.py

@@ -210,10 +210,45 @@ def handle_get_memory(memory_id: str, naive_mem_cube: NaiveMemCube) -> GetMemory
     )
 
 
+def handle_get_memory_by_ids(
+    memory_ids: list[str], naive_mem_cube: NaiveMemCube
+) -> GetMemoryResponse:
+    """
+    Handler for getting multiple memories by their IDs.
+
+    Retrieves multiple memories and formats them as a list of dictionaries.
+    """
+    try:
+        memories = naive_mem_cube.text_mem.get_by_ids(memory_ids=memory_ids)
+    except Exception:
+        memories = []
+
+    # Ensure memories is not None
+    if memories is None:
+        memories = []
+
+    if naive_mem_cube.pref_mem is not None:
+        collection_names = ["explicit_preference", "implicit_preference"]
+        for collection_name in collection_names:
+            try:
+                result = naive_mem_cube.pref_mem.get_by_ids_with_collection_name(
+                    collection_name, memory_ids
+                )
+                if result is not None:
+                    result = [format_memory_item(item, save_sources=False) for item in result]
+                    memories.extend(result)
+            except Exception:
+                continue
+
+    return GetMemoryResponse(
+        message="Memories retrieved successfully", code=200, data={"memories": memories}
+    )
+
+
 def handle_get_memories(
     get_mem_req: GetMemoryRequest, naive_mem_cube: NaiveMemCube
 ) -> GetMemoryResponse:
-    results: dict[str, Any] = {"text_mem": [], "pref_mem": [], "tool_mem": []}
+    results: dict[str, Any] = {"text_mem": [], "pref_mem": [], "tool_mem": [], "skill_mem": []}
     memories = naive_mem_cube.text_mem.get_all(
         user_name=get_mem_req.mem_cube_id,
         user_id=get_mem_req.user_id,
@@ -226,6 +261,8 @@ def handle_get_memories(
 
     if not get_mem_req.include_tool_memory:
         results["tool_mem"] = []
+    if not get_mem_req.include_skill_memory:
+        results["skill_mem"] = []
 
     preferences: list[TextualMemoryItem] = []
 
@@ -270,6 +307,7 @@ def handle_get_memories(
         "text_mem": results.get("text_mem", []),
         "pref_mem": results.get("pref_mem", []),
         "tool_mem": results.get("tool_mem", []),
+        "skill_mem": results.get("skill_mem", []),
     }
 
     return GetMemoryResponse(message="Memories retrieved successfully", data=filtered_results)