Feat/skill memory

docker/requirements-full.txt

@@ -89,7 +89,7 @@ nvidia-cusparselt-cu12==0.6.3
 nvidia-nccl-cu12==2.26.2
 nvidia-nvjitlink-cu12==12.6.85
 nvidia-nvtx-cu12==12.6.77
-ollama==0.4.9
+ollama==0.5.0
 onnxruntime==1.22.1
 openai==1.97.0
 openapi-pydantic==0.5.1
@@ -184,3 +184,4 @@ py-key-value-aio==0.2.8
 py-key-value-shared==0.2.8
 PyJWT==2.10.1
 pytest==9.0.2
+alibabacloud-oss-v2==1.2.2

docker/requirements.txt

@@ -54,7 +54,7 @@ mdurl==0.1.2
 more-itertools==10.8.0
 neo4j==5.28.1
 numpy==2.3.4
-ollama==0.4.9
+ollama==0.5.0
 openai==1.109.1
 openapi-pydantic==0.5.1
 orjson==3.11.4
@@ -123,3 +123,4 @@ uvicorn==0.38.0
 uvloop==0.22.1; sys_platform != 'win32'
 watchfiles==1.1.1
 websockets==15.0.1
+alibabacloud-oss-v2==1.2.2

pyproject.toml

@@ -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
 ]

src/memos/api/handlers/component_init.py

@@ -307,6 +307,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,

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
 
 

src/memos/api/handlers/memory_handler.py

@@ -213,7 +213,7 @@ def handle_get_memory(memory_id: str, naive_mem_cube: NaiveMemCube) -> GetMemory
 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 +226,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 +272,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)

src/memos/api/product_models.py

@@ -358,6 +358,18 @@ class APISearchRequest(BaseRequest):
         description="Number of tool memories to retrieve (top-K). Default: 6.",
     )
 
+    include_skill_memory: bool = Field(
+        True,
+        description="Whether to retrieve skill memories along with general memories. "
+        "If enabled, the system will automatically recall skill memories "
+        "relevant to the query. Default: True.",
+    )
+    skill_mem_top_k: int = Field(
+        3,
+        ge=0,
+        description="Number of skill memories to retrieve (top-K). Default: 3.",
+    )
+
     # ==== Filter conditions ====
     # TODO: maybe add detailed description later
     filter: dict[str, Any] | None = Field(
@@ -393,7 +405,7 @@ class APISearchRequest(BaseRequest):
     # Internal field for search memory type
     search_memory_type: str = Field(
         "All",
-        description="Type of memory to search: All, WorkingMemory, LongTermMemory, UserMemory, OuterMemory, ToolSchemaMemory, ToolTrajectoryMemory",
+        description="Type of memory to search: All, WorkingMemory, LongTermMemory, UserMemory, OuterMemory, ToolSchemaMemory, ToolTrajectoryMemory, SkillMemory",
     )
 
     # ==== Context ====
@@ -772,7 +784,8 @@ class GetMemoryRequest(BaseRequest):
     mem_cube_id: str = Field(..., description="Cube ID")
     user_id: str | None = Field(None, description="User ID")
     include_preference: bool = Field(True, description="Whether to return preference memory")
-    include_tool_memory: bool = Field(False, description="Whether to return tool memory")
+    include_tool_memory: bool = Field(True, description="Whether to return tool memory")
+    include_skill_memory: bool = Field(True, description="Whether to return skill memory")
     filter: dict[str, Any] | None = Field(None, description="Filter for the memory")
     page: int | None = Field(
         None,

src/memos/mem_reader/base.py

@@ -7,6 +7,7 @@
 
 if TYPE_CHECKING:
     from memos.graph_dbs.base import BaseGraphDB
+    from memos.memories.textual.tree_text_memory.retrieve.searcher import Searcher
 
 
 class BaseMemReader(ABC):
@@ -33,6 +34,12 @@ def set_graph_db(self, graph_db: "BaseGraphDB | None") -> None:
             graph_db: The graph database instance, or None to disable recall operations.
         """
 
+    @abstractmethod
+    def set_searcher(self, searcher: "Searcher | None") -> None:
+        """
+        Set the searcher instance for recall operations.
+        """
+
     @abstractmethod
     def get_memory(
         self, scene_data: list, type: str, info: dict[str, Any], mode: str = "fast"

src/memos/mem_reader/factory.py

@@ -10,6 +10,7 @@
 
 if TYPE_CHECKING:
     from memos.graph_dbs.base import BaseGraphDB
+    from memos.memories.textual.tree_text_memory.retrieve.searcher import Searcher
 
 
 class MemReaderFactory(BaseMemReader):
@@ -27,6 +28,7 @@ def from_config(
         cls,
         config_factory: MemReaderConfigFactory,
         graph_db: Optional["BaseGraphDB | None"] = None,
+        searcher: Optional["Searcher | None"] = None,
     ) -> BaseMemReader:
         """
         Create a MemReader instance from configuration.
@@ -50,4 +52,7 @@ def from_config(
         if graph_db is not None:
             reader.set_graph_db(graph_db)
 
+        if searcher is not None:
+            reader.set_searcher(searcher)
+
         return reader

src/memos/mem_reader/multi_modal_struct.py

@@ -10,6 +10,7 @@
 from memos.context.context import ContextThreadPoolExecutor
 from memos.mem_reader.read_multi_modal import MultiModalParser, detect_lang
 from memos.mem_reader.read_multi_modal.base import _derive_key
+from memos.mem_reader.read_skill_memory.process_skill_memory import process_skill_memory_fine
 from memos.mem_reader.simple_struct import PROMPT_DICT, SimpleStructMemReader
 from memos.mem_reader.utils import parse_json_result
 from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata
@@ -819,13 +820,25 @@ def _process_multi_modal_data(
                 future_tool = executor.submit(
                     self._process_tool_trajectory_fine, fast_memory_items, info, **kwargs
                 )
+                future_skill = executor.submit(
+                    process_skill_memory_fine,
+                    fast_memory_items=fast_memory_items,
+                    info=info,
+                    searcher=self.searcher,
+                    graph_db=self.graph_db,
+                    llm=self.llm,
+                    embedder=self.embedder,
+                    **kwargs,
+                )
 
                 # Collect results
                 fine_memory_items_string_parser = future_string.result()
                 fine_memory_items_tool_trajectory_parser = future_tool.result()
+                fine_memory_items_skill_memory_parser = future_skill.result()
 
             fine_memory_items.extend(fine_memory_items_string_parser)
             fine_memory_items.extend(fine_memory_items_tool_trajectory_parser)
+            fine_memory_items.extend(fine_memory_items_skill_memory_parser)
 
             # Part B: get fine multimodal items
             for fast_item in fast_memory_items:
@@ -844,50 +857,62 @@ def _process_multi_modal_data(
 
     @timed
     def _process_transfer_multi_modal_data(
-        self, raw_node: TextualMemoryItem, custom_tags: list[str] | None = None, **kwargs
+        self, raw_nodes: list[TextualMemoryItem], custom_tags: list[str] | None = None, **kwargs
     ) -> list[TextualMemoryItem]:
         """
         Process transfer for multimodal data.
 
         Each source is processed independently by its corresponding parser,
         which knows how to rebuild the original message and parse it in fine mode.
         """
-        sources = raw_node.metadata.sources or []
-        if not sources:
-            logger.warning("[MultiModalStruct] No sources found in raw_node")
+        if not raw_nodes:
+            logger.warning("[MultiModalStruct] No raw nodes found.")
             return []
 
-        # Extract info from raw_node (same as simple_struct.py)
+        # Extract info from raw_nodes (same as simple_struct.py)
         info = {
-            "user_id": raw_node.metadata.user_id,
-            "session_id": raw_node.metadata.session_id,
-            **(raw_node.metadata.info or {}),
+            "user_id": raw_nodes[0].metadata.user_id,
+            "session_id": raw_nodes[0].metadata.session_id,
+            **(raw_nodes[0].metadata.info or {}),
         }
 
         fine_memory_items = []
         # Part A: call llm in parallel using thread pool
         with ContextThreadPoolExecutor(max_workers=2) as executor:
             future_string = executor.submit(
-                self._process_string_fine, [raw_node], info, custom_tags, **kwargs
+                self._process_string_fine, raw_nodes, info, custom_tags, **kwargs
             )
             future_tool = executor.submit(
-                self._process_tool_trajectory_fine, [raw_node], info, **kwargs
+                self._process_tool_trajectory_fine, raw_nodes, info, **kwargs
+            )
+            future_skill = executor.submit(
+                process_skill_memory_fine,
+                raw_nodes,
+                info,
+                searcher=self.searcher,
+                llm=self.llm,
+                embedder=self.embedder,
+                graph_db=self.graph_db,
+                **kwargs,
             )
 
             # Collect results
             fine_memory_items_string_parser = future_string.result()
             fine_memory_items_tool_trajectory_parser = future_tool.result()
-
+            fine_memory_items_skill_memory_parser = future_skill.result()
         fine_memory_items.extend(fine_memory_items_string_parser)
         fine_memory_items.extend(fine_memory_items_tool_trajectory_parser)
+        fine_memory_items.extend(fine_memory_items_skill_memory_parser)
 
         # Part B: get fine multimodal items
-        for source in sources:
-            lang = getattr(source, "lang", "en")
-            items = self.multi_modal_parser.process_transfer(
-                source, context_items=[raw_node], info=info, custom_tags=custom_tags, lang=lang
-            )
-            fine_memory_items.extend(items)
+        for raw_node in raw_nodes:
+            sources = raw_node.metadata.sources
+            for source in sources:
+                lang = getattr(source, "lang", "en")
+                items = self.multi_modal_parser.process_transfer(
+                    source, context_items=[raw_node], info=info, custom_tags=custom_tags, lang=lang
+                )
+                fine_memory_items.extend(items)
         return fine_memory_items
 
     def get_scene_data_info(self, scene_data: list, type: str) -> list[list[Any]]:
@@ -944,22 +969,7 @@ def fine_transfer_simple_mem(
         if not input_memories:
             return []
 
-        memory_list = []
-
         # Process Q&A pairs concurrently with context propagation
-        with ContextThreadPoolExecutor() as executor:
-            futures = [
-                executor.submit(
-                    self._process_transfer_multi_modal_data, scene_data_info, custom_tags, **kwargs
-                )
-                for scene_data_info in input_memories
-            ]
-            for future in concurrent.futures.as_completed(futures):
-                try:
-                    res_memory = future.result()
-                    if res_memory is not None:
-                        memory_list.append(res_memory)
-                except Exception as e:
-                    logger.error(f"Task failed with exception: {e}")
-                    logger.error(traceback.format_exc())
-        return memory_list
+        memory_list = self._process_transfer_multi_modal_data(input_memories, custom_tags, **kwargs)
+
+        return [memory_list]