MemoryOS 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

memos/memories/textual/tree_text_memory/retrieve/searcher.py

@@ -1,19 +1,20 @@
-import concurrent.futures
 import json
+import traceback
 
 from datetime import datetime
 
+from memos.context.context import ContextThreadPoolExecutor
 from memos.embedders.factory import OllamaEmbedder
 from memos.graph_dbs.factory import Neo4jGraphDB
 from memos.llms.factory import AzureLLM, OllamaLLM, OpenAILLM
 from memos.log import get_logger
 from memos.memories.textual.item import SearchedTreeNodeTextualMemoryMetadata, TextualMemoryItem
+from memos.reranker.base import BaseReranker
 from memos.utils import timed
 
 from .internet_retriever_factory import InternetRetrieverFactory
 from .reasoner import MemoryReasoner
 from .recall import GraphMemoryRetriever
-from .reranker import MemoryReranker
 from .task_goal_parser import TaskGoalParser
 
 
@@ -26,22 +27,33 @@ class Searcher:
         dispatcher_llm: OpenAILLM | OllamaLLM | AzureLLM,
         graph_store: Neo4jGraphDB,
         embedder: OllamaEmbedder,
+        reranker: BaseReranker,
         internet_retriever: InternetRetrieverFactory | None = None,
+        moscube: bool = False,
     ):
         self.graph_store = graph_store
         self.embedder = embedder
 
         self.task_goal_parser = TaskGoalParser(dispatcher_llm)
         self.graph_retriever = GraphMemoryRetriever(self.graph_store, self.embedder)
-        self.reranker = MemoryReranker(dispatcher_llm, self.embedder)
+        self.reranker = reranker
         self.reasoner = MemoryReasoner(dispatcher_llm)
 
         # Create internet retriever from config if provided
         self.internet_retriever = internet_retriever
+        self.moscube = moscube
+
+        self._usage_executor = ContextThreadPoolExecutor(max_workers=4, thread_name_prefix="usage")
 
     @timed
     def search(
-        self, query: str, top_k: int, info=None, mode="fast", memory_type="All"
+        self,
+        query: str,
+        top_k: int,
+        info=None,
+        mode="fast",
+        memory_type="All",
+        search_filter: dict | None = None,
     ) -> list[TextualMemoryItem]:
         """
         Search for memories based on a query.
@@ -56,6 +68,7 @@ class Searcher:
             - 'fine': Uses a more detailed search process, invoking large models for higher precision, but slower performance.
             memory_type (str): Type restriction for search.
             ['All', 'WorkingMemory', 'LongTermMemory', 'UserMemory']
+            search_filter (dict, optional): Optional metadata filters for search results.
         Returns:
             list[TextualMemoryItem]: List of matching memories.
         """
@@ -71,19 +84,27 @@ class Searcher:
         else:
             logger.debug(f"[SEARCH] Received info dict: {info}")
 
-        parsed_goal, query_embedding, context, query = self._parse_task(query, info, mode)
+        parsed_goal, query_embedding, context, query = self._parse_task(
+            query, info, mode, search_filter=search_filter
+        )
         results = self._retrieve_paths(
-            query, parsed_goal, query_embedding, info, top_k, mode, memory_type
+            query, parsed_goal, query_embedding, info, top_k, mode, memory_type, search_filter
         )
         deduped = self._deduplicate_results(results)
         final_results = self._sort_and_trim(deduped, top_k)
         self._update_usage_history(final_results, info)
 
         logger.info(f"[SEARCH] Done. Total {len(final_results)} results.")
+        res_results = ""
+        for _num_i, result in enumerate(final_results):
+            res_results += "\n" + (
+                result.id + "|" + result.metadata.memory_type + "|" + result.memory
+            )
+        logger.info(f"[SEARCH] Results. {res_results}")
         return final_results
 
     @timed
-    def _parse_task(self, query, info, mode, top_k=5):
+    def _parse_task(self, query, info, mode, top_k=5, search_filter: dict | None = None):
         """Parse user query, do embedding search and create context"""
         context = []
         query_embedding = None
@@ -96,14 +117,30 @@ class Searcher:
             # retrieve related nodes by embedding
             related_nodes = [
                 self.graph_store.get_node(n["id"])
-                for n in self.graph_store.search_by_embedding(query_embedding, top_k=top_k)
+                for n in self.graph_store.search_by_embedding(
+                    query_embedding, top_k=top_k, search_filter=search_filter
+                )
             ]
-            context = list({node["memory"] for node in related_nodes})
+            memories = []
+            for node in related_nodes:
+                try:
+                    m = (
+                        node.get("memory")
+                        if isinstance(node, dict)
+                        else (getattr(node, "memory", None))
+                    )
+                    if isinstance(m, str) and m:
+                        memories.append(m)
+                except Exception:
+                    logger.error(f"[SEARCH] Error during search: {traceback.format_exc()}")
+                    continue
+            context = list(dict.fromkeys(memories))
 
             # optional: supplement context with internet knowledge
-            if self.internet_retriever:
+            """if self.internet_retriever:
                 extra = self.internet_retriever.retrieve_from_internet(query=query, top_k=3)
                 context.extend(item.memory.partition("\nContent: ")[-1] for item in extra)
+            """
 
         # parse goal using LLM
         parsed_goal = self.task_goal_parser.parse(
@@ -121,10 +158,20 @@ class Searcher:
         return parsed_goal, query_embedding, context, query
 
     @timed
-    def _retrieve_paths(self, query, parsed_goal, query_embedding, info, top_k, mode, memory_type):
+    def _retrieve_paths(
+        self,
+        query,
+        parsed_goal,
+        query_embedding,
+        info,
+        top_k,
+        mode,
+        memory_type,
+        search_filter: dict | None = None,
+    ):
         """Run A/B/C retrieval paths in parallel"""
         tasks = []
-        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+        with ContextThreadPoolExecutor(max_workers=3) as executor:
             tasks.append(
                 executor.submit(
                     self._retrieve_from_working_memory,
@@ -133,6 +180,7 @@ class Searcher:
                     query_embedding,
                     top_k,
                     memory_type,
+                    search_filter,
                 )
             )
             tasks.append(
@@ -143,6 +191,7 @@ class Searcher:
                     query_embedding,
                     top_k,
                     memory_type,
+                    search_filter,
                 )
             )
             tasks.append(
@@ -157,6 +206,17 @@ class Searcher:
                     memory_type,
                 )
             )
+            if self.moscube:
+                tasks.append(
+                    executor.submit(
+                        self._retrieve_from_memcubes,
+                        query,
+                        parsed_goal,
+                        query_embedding,
+                        top_k,
+                        "memos_cube01",
+                    )
+                )
 
             results = []
             for t in tasks:
@@ -168,14 +228,24 @@ class Searcher:
     # --- Path A
     @timed
     def _retrieve_from_working_memory(
-        self, query, parsed_goal, query_embedding, top_k, memory_type
+        self,
+        query,
+        parsed_goal,
+        query_embedding,
+        top_k,
+        memory_type,
+        search_filter: dict | None = None,
     ):
         """Retrieve and rerank from WorkingMemory"""
         if memory_type not in ["All", "WorkingMemory"]:
             logger.info(f"[PATH-A] '{query}'Skipped (memory_type does not match)")
             return []
         items = self.graph_retriever.retrieve(
-            query=query, parsed_goal=parsed_goal, top_k=top_k, memory_scope="WorkingMemory"
+            query=query,
+            parsed_goal=parsed_goal,
+            top_k=top_k,
+            memory_scope="WorkingMemory",
+            search_filter=search_filter,
         )
         return self.reranker.rerank(
             query=query,
@@ -183,36 +253,79 @@ class Searcher:
             graph_results=items,
             top_k=top_k,
             parsed_goal=parsed_goal,
+            search_filter=search_filter,
         )
 
     # --- Path B
     @timed
     def _retrieve_from_long_term_and_user(
-        self, query, parsed_goal, query_embedding, top_k, memory_type
+        self,
+        query,
+        parsed_goal,
+        query_embedding,
+        top_k,
+        memory_type,
+        search_filter: dict | None = None,
     ):
         """Retrieve and rerank from LongTermMemory and UserMemory"""
         results = []
-        if memory_type in ["All", "LongTermMemory"]:
-            results += self.graph_retriever.retrieve(
-                query=query,
-                parsed_goal=parsed_goal,
-                query_embedding=query_embedding,
-                top_k=top_k * 2,
-                memory_scope="LongTermMemory",
-            )
-        if memory_type in ["All", "UserMemory"]:
-            results += self.graph_retriever.retrieve(
-                query=query,
-                parsed_goal=parsed_goal,
-                query_embedding=query_embedding,
-                top_k=top_k * 2,
-                memory_scope="UserMemory",
-            )
+        tasks = []
+
+        with ContextThreadPoolExecutor(max_workers=2) as executor:
+            if memory_type in ["All", "LongTermMemory"]:
+                tasks.append(
+                    executor.submit(
+                        self.graph_retriever.retrieve,
+                        query=query,
+                        parsed_goal=parsed_goal,
+                        query_embedding=query_embedding,
+                        top_k=top_k * 2,
+                        memory_scope="LongTermMemory",
+                        search_filter=search_filter,
+                    )
+                )
+            if memory_type in ["All", "UserMemory"]:
+                tasks.append(
+                    executor.submit(
+                        self.graph_retriever.retrieve,
+                        query=query,
+                        parsed_goal=parsed_goal,
+                        query_embedding=query_embedding,
+                        top_k=top_k * 2,
+                        memory_scope="UserMemory",
+                        search_filter=search_filter,
+                    )
+                )
+
+            # Collect results from all tasks
+            for task in tasks:
+                results.extend(task.result())
+
         return self.reranker.rerank(
             query=query,
             query_embedding=query_embedding[0],
             graph_results=results,
+            top_k=top_k,
+            parsed_goal=parsed_goal,
+            search_filter=search_filter,
+        )
+
+    @timed
+    def _retrieve_from_memcubes(
+        self, query, parsed_goal, query_embedding, top_k, cube_name="memos_cube01"
+    ):
+        """Retrieve and rerank from LongTermMemory and UserMemory"""
+        results = self.graph_retriever.retrieve_from_cube(
+            query_embedding=query_embedding,
             top_k=top_k * 2,
+            memory_scope="LongTermMemory",
+            cube_name=cube_name,
+        )
+        return self.reranker.rerank(
+            query=query,
+            query_embedding=query_embedding[0],
+            graph_results=results,
+            top_k=top_k,
             parsed_goal=parsed_goal,
         )
 
@@ -256,8 +369,7 @@ class Searcher:
         final_items = []
         for item, score in sorted_results:
             meta_data = item.metadata.model_dump()
-            if "relativity" not in meta_data:
-                meta_data["relativity"] = score
+            meta_data["relativity"] = score
             final_items.append(
                 TextualMemoryItem(
                     id=item.id,
@@ -271,14 +383,30 @@ class Searcher:
     def _update_usage_history(self, items, info):
         """Update usage history in graph DB"""
         now_time = datetime.now().isoformat()
-        info.pop("chat_history", None)
-        # `info` should be a serializable dict or string
-        usage_record = json.dumps({"time": now_time, "info": info})
-        for item in items:
-            if (
-                hasattr(item, "id")
-                and hasattr(item, "metadata")
-                and hasattr(item.metadata, "usage")
-            ):
-                item.metadata.usage.append(usage_record)
-                self.graph_store.update_node(item.id, {"usage": item.metadata.usage})
+        info_copy = dict(info or {})
+        info_copy.pop("chat_history", None)
+        usage_record = json.dumps({"time": now_time, "info": info_copy})
+        payload = []
+        for it in items:
+            try:
+                item_id = getattr(it, "id", None)
+                md = getattr(it, "metadata", None)
+                if md is None:
+                    continue
+                if not hasattr(md, "usage") or md.usage is None:
+                    md.usage = []
+                md.usage.append(usage_record)
+                if item_id:
+                    payload.append((item_id, list(md.usage)))
+            except Exception:
+                logger.exception("[USAGE] snapshot item failed")
+
+        if payload:
+            self._usage_executor.submit(self._update_usage_history_worker, payload, usage_record)
+
+    def _update_usage_history_worker(self, payload, usage_record: str):
+        try:
+            for item_id, usage_list in payload:
+                self.graph_store.update_node(item_id, {"usage": usage_list})
+        except Exception:
+            logger.exception("[USAGE] update usage failed")

memos/memories/textual/tree_text_memory/retrieve/utils.py

@@ -8,18 +8,20 @@ You are a task parsing expert. Given a user task instruction, optional former co
 5. Need for internet search: If the user's task instruction only involves objective facts or can be completed without introducing external knowledge, set "internet_search" to False. Otherwise, set it to True.
 6. Memories: Provide 2–5 short semantic expansions or rephrasings of the rephrased/original user task instruction. These are used for improved embedding search coverage. Each should be clear, concise, and meaningful for retrieval.
 
-Task description:
-\"\"\"$task\"\"\"
-
 Former conversation (if any):
 \"\"\"
 $conversation
 \"\"\"
 
+Task description(User Question):
+\"\"\"$task\"\"\"
+
 Context (if any):
 \"\"\"$context\"\"\"
 
-Return strictly in this JSON format:
+Return strictly in this JSON format, note that the
+keys/tags/rephrased_instruction/memories should use the same language as the
+input query:
 {
   "keys": [...],
   "tags": [...],

memos/memories/textual/tree_text_memory/retrieve/xinyusearch.py

@@ -3,15 +3,16 @@
 import json
 import uuid
 
-from concurrent.futures import ThreadPoolExecutor, as_completed
+from concurrent.futures import as_completed
 from datetime import datetime
 
 import requests
 
+from memos.context.context import ContextThreadPoolExecutor
 from memos.embedders.factory import OllamaEmbedder
 from memos.log import get_logger
 from memos.mem_reader.base import BaseMemReader
-from memos.memories.textual.item import TextualMemoryItem
+from memos.memories.textual.item import SourceMessage, TextualMemoryItem
 
 
 logger = get_logger(__name__)
@@ -150,7 +151,7 @@ class XinyuSearchRetriever:
         # Convert to TextualMemoryItem format
         memory_items: list[TextualMemoryItem] = []
 
-        with ThreadPoolExecutor(max_workers=8) as executor:
+        with ContextThreadPoolExecutor(max_workers=8) as executor:
             futures = [
                 executor.submit(self._process_result, result, query, parsed_goal, info)
                 for result in search_results
@@ -332,7 +333,7 @@ class XinyuSearchRetriever:
             )
             read_item_i.metadata.source = "web"
             read_item_i.metadata.memory_type = "OuterMemory"
-            read_item_i.metadata.sources = [url] if url else []
+            read_item_i.metadata.sources = [SourceMessage(type="web", url=url)] if url else []
             read_item_i.metadata.visibility = "public"
 
             memory_items.append(read_item_i)

memos/memos_tools/notification_utils.py

@@ -2,6 +2,7 @@
 Notification utilities for MemOS product.
 """
 
+import asyncio
 import logging
 
 from collections.abc import Callable
@@ -51,6 +52,51 @@ def send_online_bot_notification(
         logger.warning(f"Failed to send online bot notification: {e}")
 
 
+async def send_online_bot_notification_async(
+    online_bot: Callable | None,
+    header_name: str,
+    sub_title_name: str,
+    title_color: str,
+    other_data1: dict[str, Any],
+    other_data2: dict[str, Any],
+    emoji: dict[str, str],
+) -> None:
+    """
+    Send notification via online_bot asynchronously if available.
+
+    Args:
+        online_bot: The online_bot function or None
+        header_name: Header name for the report
+        sub_title_name: Subtitle for the report
+        title_color: Title color
+        other_data1: First data dict
+        other_data2: Second data dict
+        emoji: Emoji configuration dict
+    """
+    if online_bot is None:
+        return
+
+    try:
+        # Run the potentially blocking notification in a thread pool
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(
+            None,
+            lambda: online_bot(
+                header_name=header_name,
+                sub_title_name=sub_title_name,
+                title_color=title_color,
+                other_data1=other_data1,
+                other_data2=other_data2,
+                emoji=emoji,
+            ),
+        )
+
+        logger.info(f"Online bot notification sent successfully (async): {header_name}")
+
+    except Exception as e:
+        logger.warning(f"Failed to send online bot notification (async): {e}")
+
+
 def send_error_bot_notification(
     error_bot: Callable | None,
     err: str,

memos/memos_tools/singleton.py

@@ -0,0 +1,174 @@
+"""
+Singleton decorator module for caching factory instances to avoid excessive memory usage
+from repeated initialization.
+"""
+
+import hashlib
+import json
+
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, TypeVar
+from weakref import WeakValueDictionary
+
+
+T = TypeVar("T")
+
+
+class FactorySingleton:
+    """Factory singleton manager that caches instances based on configuration parameters"""
+
+    def __init__(self):
+        # Use weak reference dictionary for automatic cleanup when instances are no longer referenced
+        self._instances: dict[str, WeakValueDictionary] = {}
+
+    def _generate_cache_key(self, config: Any, *args, **kwargs) -> str:
+        """Generate cache key based on configuration only (ignoring other parameters)"""
+
+        # Handle configuration objects - only use the config parameter
+        if hasattr(config, "model_dump"):  # Pydantic model
+            config_data = config.model_dump()
+        elif hasattr(config, "dict"):  # Legacy Pydantic model
+            config_data = config.dict()
+        elif isinstance(config, dict):
+            config_data = config
+        else:
+            # For other types, try to convert to string
+            config_data = str(config)
+
+        # Filter out time-related fields that shouldn't affect caching
+        filtered_config = self._filter_temporal_fields(config_data)
+
+        # Generate hash key based only on config
+        try:
+            cache_str = json.dumps(filtered_config, sort_keys=True, ensure_ascii=False, default=str)
+        except (TypeError, ValueError):
+            # If JSON serialization fails, convert the entire config to string
+            cache_str = str(filtered_config)
+
+        return hashlib.md5(cache_str.encode("utf-8")).hexdigest()
+
+    def _filter_temporal_fields(self, config_data: Any) -> Any:
+        """Filter out temporal fields that shouldn't affect instance caching"""
+        if isinstance(config_data, dict):
+            filtered = {}
+            for key, value in config_data.items():
+                # Skip common temporal field names
+                if key.lower() in {
+                    "created_at",
+                    "updated_at",
+                    "timestamp",
+                    "time",
+                    "date",
+                    "created_time",
+                    "updated_time",
+                    "last_modified",
+                    "modified_at",
+                    "start_time",
+                    "end_time",
+                    "execution_time",
+                    "run_time",
+                }:
+                    continue
+                # Recursively filter nested dictionaries
+                filtered[key] = self._filter_temporal_fields(value)
+            return filtered
+        elif isinstance(config_data, list):
+            # Recursively filter lists
+            return [self._filter_temporal_fields(item) for item in config_data]
+        else:
+            # For primitive types, return as-is
+            return config_data
+
+    def get_or_create(self, factory_class: type, cache_key: str, creator_func: Callable) -> Any:
+        """Get or create instance"""
+        class_name = factory_class.__name__
+
+        if class_name not in self._instances:
+            self._instances[class_name] = WeakValueDictionary()
+
+        class_cache = self._instances[class_name]
+
+        if cache_key in class_cache:
+            return class_cache[cache_key]
+
+        # Create new instance
+        instance = creator_func()
+        class_cache[cache_key] = instance
+        return instance
+
+    def clear_cache(self, factory_class: type | None = None):
+        """Clear cache"""
+        if factory_class:
+            class_name = factory_class.__name__
+            if class_name in self._instances:
+                self._instances[class_name].clear()
+        else:
+            for cache in self._instances.values():
+                cache.clear()
+
+
+# Global singleton manager
+_factory_singleton = FactorySingleton()
+
+
+def singleton_factory(factory_class: type | str | None = None):
+    """
+    Factory singleton decorator
+
+    Usage:
+    @singleton_factory()
+    def from_config(cls, config):
+        return SomeClass(config)
+
+    Or specify factory class:
+    @singleton_factory(EmbedderFactory)
+    def from_config(cls, config):
+        return SomeClass(config)
+    """
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> T:
+            # Determine factory class and config parameter
+            target_factory_class = factory_class
+            config = None
+
+            # Simple logic: check if first parameter is a class or config
+            if args:
+                if hasattr(args[0], "__name__") and hasattr(args[0], "__module__"):
+                    # First parameter is a class (cls), so this is a @classmethod
+                    if target_factory_class is None:
+                        target_factory_class = args[0]
+                    config = args[1] if len(args) > 1 else None
+                else:
+                    # First parameter is config, so this is a @staticmethod
+                    if target_factory_class is None:
+                        raise ValueError(
+                            "Factory class must be explicitly specified for static methods"
+                        )
+                    if isinstance(target_factory_class, str):
+                        # Convert string to a mock class for caching purposes
+                        class MockFactoryClass:
+                            __name__ = target_factory_class
+
+                        target_factory_class = MockFactoryClass
+                    config = args[0]
+
+            if config is None:
+                # If no configuration parameter, call original function directly
+                return func(*args, **kwargs)
+
+            # Generate cache key based only on config
+            cache_key = _factory_singleton._generate_cache_key(config)
+
+            # Function to create instance
+            def creator():
+                return func(*args, **kwargs)
+
+            # Get or create instance
+            return _factory_singleton.get_or_create(target_factory_class, cache_key, creator)
+
+        return wrapper
+
+    return decorator