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

memos/memos_tools/lockfree_dict.py

@@ -0,0 +1,120 @@
+"""
+Lock-free dictionary implementation using copy-on-write strategy.
+This provides better performance but uses more memory.
+"""
+
+import threading
+
+from collections.abc import ItemsView, Iterator, KeysView, ValuesView
+from typing import Generic, TypeVar
+
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class CopyOnWriteDict(Generic[K, V]):
+    """
+    A lock-free dictionary using copy-on-write strategy.
+
+    Reads are completely lock-free and very fast.
+    Writes create a new copy of the dictionary.
+    Uses more memory but provides excellent read performance.
+    """
+
+    def __init__(self, initial_dict: dict[K, V] | None = None):
+        """Initialize with optional initial dictionary."""
+        self._dict = initial_dict.copy() if initial_dict else {}
+        self._write_lock = threading.Lock()  # Only for writes
+
+    def __getitem__(self, key: K) -> V:
+        """Get item by key - completely lock-free."""
+        return self._dict[key]
+
+    def __setitem__(self, key: K, value: V) -> None:
+        """Set item by key - uses copy-on-write."""
+        with self._write_lock:
+            # Create a new dictionary with the update
+            new_dict = self._dict.copy()
+            new_dict[key] = value
+            # Atomic replacement
+            self._dict = new_dict
+
+    def __delitem__(self, key: K) -> None:
+        """Delete item by key - uses copy-on-write."""
+        with self._write_lock:
+            new_dict = self._dict.copy()
+            del new_dict[key]
+            self._dict = new_dict
+
+    def __contains__(self, key: K) -> bool:
+        """Check if key exists - completely lock-free."""
+        return key in self._dict
+
+    def __len__(self) -> int:
+        """Get length - completely lock-free."""
+        return len(self._dict)
+
+    def __bool__(self) -> bool:
+        """Check if not empty - completely lock-free."""
+        return bool(self._dict)
+
+    def __iter__(self) -> Iterator[K]:
+        """Iterate over keys - completely lock-free."""
+        return iter(self._dict.keys())
+
+    def get(self, key: K, default: V | None = None) -> V:
+        """Get with default - completely lock-free."""
+        return self._dict.get(key, default)
+
+    def keys(self) -> KeysView[K]:
+        """Get keys - completely lock-free."""
+        return self._dict.keys()
+
+    def values(self) -> ValuesView[V]:
+        """Get values - completely lock-free."""
+        return self._dict.values()
+
+    def items(self) -> ItemsView[K, V]:
+        """Get items - completely lock-free."""
+        return self._dict.items()
+
+    def copy(self) -> dict[K, V]:
+        """Create a copy - completely lock-free."""
+        return self._dict.copy()
+
+    def update(self, *args, **kwargs) -> None:
+        """Update dictionary - uses copy-on-write."""
+        with self._write_lock:
+            new_dict = self._dict.copy()
+            new_dict.update(*args, **kwargs)
+            self._dict = new_dict
+
+    def clear(self) -> None:
+        """Clear all items."""
+        with self._write_lock:
+            self._dict = {}
+
+    def pop(self, key: K, *args) -> V:
+        """Pop item by key."""
+        with self._write_lock:
+            new_dict = self._dict.copy()
+            result = new_dict.pop(key, *args)
+            self._dict = new_dict
+            return result
+
+    def setdefault(self, key: K, default: V | None = None) -> V:
+        """Set default value for key if not exists."""
+        # Fast path for existing keys
+        if key in self._dict:
+            return self._dict[key]
+
+        with self._write_lock:
+            # Double-check after acquiring lock
+            if key in self._dict:
+                return self._dict[key]
+
+            new_dict = self._dict.copy()
+            result = new_dict.setdefault(key, default)
+            self._dict = new_dict
+            return result

memos/memos_tools/notification_service.py

@@ -0,0 +1,44 @@
+"""
+Simple online_bot integration utility.
+"""
+
+import logging
+
+from collections.abc import Callable
+
+
+logger = logging.getLogger(__name__)
+
+
+def get_online_bot_function() -> Callable | None:
+    """
+    Get online_bot function if available, otherwise return None.
+
+    Returns:
+        online_bot function if available, None otherwise
+    """
+    try:
+        from memos.memos_tools.dinding_report_bot import online_bot
+
+        logger.info("online_bot function loaded successfully")
+        return online_bot
+    except ImportError as e:
+        logger.warning(f"Failed to import online_bot: {e}, returning None")
+        return None
+
+
+def get_error_bot_function() -> Callable | None:
+    """
+    Get error_bot function if available, otherwise return None.
+
+    Returns:
+        error_bot function if available, None otherwise
+    """
+    try:
+        from memos.memos_tools.dinding_report_bot import error_bot
+
+        logger.info("error_bot function loaded successfully")
+        return error_bot
+    except ImportError as e:
+        logger.warning(f"Failed to import error_bot: {e}, returning None")
+        return None

memos/memos_tools/notification_utils.py

@@ -0,0 +1,96 @@
+"""
+Notification utilities for MemOS product.
+"""
+
+import logging
+
+from collections.abc import Callable
+from typing import Any
+
+
+logger = logging.getLogger(__name__)
+
+
+def send_online_bot_notification(
+    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 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:
+        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: {header_name}")
+
+    except Exception as e:
+        logger.warning(f"Failed to send online bot notification: {e}")
+
+
+def send_error_bot_notification(
+    error_bot: Callable | None,
+    err: str,
+    title: str = "MemOS Error",
+    level: str = "P2",
+    user_ids: list | None = None,
+) -> None:
+    """
+    Send error alert if error_bot is available.
+
+    Args:
+        error_bot: The error_bot function or None
+        err: Error message
+        title: Alert title
+        level: Alert level (P0, P1, P2)
+        user_ids: List of user IDs to notify
+    """
+    if error_bot is None:
+        return
+
+    try:
+        error_bot(
+            err=err,
+            title=title,
+            level=level,
+            user_ids=user_ids or [],
+        )
+        logger.info(f"Error alert sent successfully: {title}")
+    except Exception as e:
+        logger.warning(f"Failed to send error alert: {e}")
+
+
+# Keep backward compatibility
+def send_error_alert(
+    error_bot: Callable | None,
+    error_message: str,
+    title: str = "MemOS Error",
+    level: str = "P2",
+) -> None:
+    """
+    Send error alert if error_bot is available (backward compatibility).
+    """
+    send_error_bot_notification(error_bot, error_message, title, level)

memos/memos_tools/thread_safe_dict.py

@@ -0,0 +1,288 @@
+"""
+Thread-safe dictionary wrapper for concurrent access with optimized read-write locks.
+"""
+
+import threading
+
+from collections.abc import ItemsView, Iterator, KeysView, ValuesView
+from typing import Generic, TypeVar
+
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+class ReadWriteLock:
+    """A simple read-write lock implementation. use for product-server scenario"""
+
+    def __init__(self):
+        self._read_ready = threading.Condition(threading.RLock())
+        self._readers = 0
+
+    def acquire_read(self):
+        """Acquire a read lock. Multiple readers can hold the lock simultaneously."""
+        self._read_ready.acquire()
+        try:
+            self._readers += 1
+        finally:
+            self._read_ready.release()
+
+    def release_read(self):
+        """Release a read lock."""
+        self._read_ready.acquire()
+        try:
+            self._readers -= 1
+            if self._readers == 0:
+                self._read_ready.notify_all()
+        finally:
+            self._read_ready.release()
+
+    def acquire_write(self):
+        """Acquire a write lock. Only one writer can hold the lock."""
+        self._read_ready.acquire()
+        while self._readers > 0:
+            self._read_ready.wait()
+
+    def release_write(self):
+        """Release a write lock."""
+        self._read_ready.release()
+
+
+class ThreadSafeDict(Generic[K, V]):
+    """
+    A thread-safe dictionary wrapper with optimized read-write locks.
+
+    This class allows multiple concurrent readers while ensuring exclusive access for writers.
+    Read operations (get, contains, iteration) can happen concurrently.
+    Write operations (set, delete, update) are exclusive.
+    """
+
+    def __init__(self, initial_dict: dict[K, V] | None = None):
+        """
+        Initialize the thread-safe dictionary.
+
+        Args:
+            initial_dict: Optional initial dictionary to copy from
+        """
+        self._dict: dict[K, V] = initial_dict.copy() if initial_dict else {}
+        self._lock = ReadWriteLock()
+
+    def __getitem__(self, key: K) -> V:
+        """Get item by key."""
+        self._lock.acquire_read()
+        try:
+            return self._dict[key]
+        finally:
+            self._lock.release_read()
+
+    def __setitem__(self, key: K, value: V) -> None:
+        """Set item by key."""
+        self._lock.acquire_write()
+        try:
+            self._dict[key] = value
+        finally:
+            self._lock.release_write()
+
+    def __delitem__(self, key: K) -> None:
+        """Delete item by key."""
+        self._lock.acquire_write()
+        try:
+            del self._dict[key]
+        finally:
+            self._lock.release_write()
+
+    def __contains__(self, key: K) -> bool:
+        """Check if key exists in dictionary."""
+        self._lock.acquire_read()
+        try:
+            return key in self._dict
+        finally:
+            self._lock.release_read()
+
+    def __len__(self) -> int:
+        """Get length of dictionary."""
+        self._lock.acquire_read()
+        try:
+            return len(self._dict)
+        finally:
+            self._lock.release_read()
+
+    def __bool__(self) -> bool:
+        """Check if dictionary is not empty."""
+        self._lock.acquire_read()
+        try:
+            return bool(self._dict)
+        finally:
+            self._lock.release_read()
+
+    def __iter__(self) -> Iterator[K]:
+        """Iterate over keys. Returns a snapshot to avoid iteration issues."""
+        self._lock.acquire_read()
+        try:
+            # Return a snapshot of keys to avoid iteration issues
+            return iter(list(self._dict.keys()))
+        finally:
+            self._lock.release_read()
+
+    def get(self, key: K, default: V | None = None) -> V:
+        """Get item by key with optional default."""
+        self._lock.acquire_read()
+        try:
+            return self._dict.get(key, default)
+        finally:
+            self._lock.release_read()
+
+    def pop(self, key: K, *args) -> V:
+        """Pop item by key."""
+        self._lock.acquire_write()
+        try:
+            return self._dict.pop(key, *args)
+        finally:
+            self._lock.release_write()
+
+    def update(self, *args, **kwargs) -> None:
+        """Update dictionary."""
+        self._lock.acquire_write()
+        try:
+            self._dict.update(*args, **kwargs)
+        finally:
+            self._lock.release_write()
+
+    def clear(self) -> None:
+        """Clear all items."""
+        self._lock.acquire_write()
+        try:
+            self._dict.clear()
+        finally:
+            self._lock.release_write()
+
+    def keys(self) -> KeysView[K]:
+        """Get dictionary keys view (snapshot)."""
+        self._lock.acquire_read()
+        try:
+            return list(self._dict.keys())
+        finally:
+            self._lock.release_read()
+
+    def values(self) -> ValuesView[V]:
+        """Get dictionary values view (snapshot)."""
+        self._lock.acquire_read()
+        try:
+            return list(self._dict.values())
+        finally:
+            self._lock.release_read()
+
+    def items(self) -> ItemsView[K, V]:
+        """Get dictionary items view (snapshot)."""
+        self._lock.acquire_read()
+        try:
+            return list(self._dict.items())
+        finally:
+            self._lock.release_read()
+
+    def copy(self) -> dict[K, V]:
+        """Create a copy of the dictionary."""
+        self._lock.acquire_read()
+        try:
+            return self._dict.copy()
+        finally:
+            self._lock.release_read()
+
+    def setdefault(self, key: K, default: V | None = None) -> V:
+        """Set default value for key if not exists."""
+        self._lock.acquire_write()
+        try:
+            return self._dict.setdefault(key, default)
+        finally:
+            self._lock.release_write()
+
+    def __repr__(self) -> str:
+        """String representation."""
+        self._lock.acquire_read()
+        try:
+            return f"ThreadSafeDict({self._dict})"
+        finally:
+            self._lock.release_read()
+
+    def __str__(self) -> str:
+        """String representation."""
+        self._lock.acquire_read()
+        try:
+            return str(self._dict)
+        finally:
+            self._lock.release_read()
+
+
+class SimpleThreadSafeDict(Generic[K, V]):
+    """
+    Simple thread-safe dictionary with exclusive locks for all operations.
+    Use this if you prefer simplicity over performance.
+    """
+
+    def __init__(self, initial_dict: dict[K, V] | None = None):
+        self._dict: dict[K, V] = initial_dict.copy() if initial_dict else {}
+        self._lock = threading.RLock()
+
+    def __getitem__(self, key: K) -> V:
+        with self._lock:
+            return self._dict[key]
+
+    def __setitem__(self, key: K, value: V) -> None:
+        with self._lock:
+            self._dict[key] = value
+
+    def __delitem__(self, key: K) -> None:
+        with self._lock:
+            del self._dict[key]
+
+    def __contains__(self, key: K) -> bool:
+        with self._lock:
+            return key in self._dict
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._dict)
+
+    def __bool__(self) -> bool:
+        with self._lock:
+            return bool(self._dict)
+
+    def __iter__(self) -> Iterator[K]:
+        with self._lock:
+            return iter(list(self._dict.keys()))
+
+    def get(self, key: K, default: V | None = None) -> V:
+        with self._lock:
+            return self._dict.get(key, default)
+
+    def pop(self, key: K, *args) -> V:
+        with self._lock:
+            return self._dict.pop(key, *args)
+
+    def update(self, *args, **kwargs) -> None:
+        with self._lock:
+            self._dict.update(*args, **kwargs)
+
+    def clear(self) -> None:
+        with self._lock:
+            self._dict.clear()
+
+    def keys(self):
+        with self._lock:
+            return list(self._dict.keys())
+
+    def values(self):
+        with self._lock:
+            return list(self._dict.values())
+
+    def items(self):
+        with self._lock:
+            return list(self._dict.items())
+
+    def copy(self) -> dict[K, V]:
+        with self._lock:
+            return self._dict.copy()
+
+    def setdefault(self, key: K, default: V | None = None) -> V:
+        with self._lock:
+            return self._dict.setdefault(key, default)

memos/settings.py

@@ -1,7 +1,9 @@
+import os
+
 from pathlib import Path
 
 
-MEMOS_DIR = Path.cwd() / ".memos"
+MEMOS_DIR = Path(os.getenv("MEMOS_BASE_PATH", Path.cwd())) / ".memos"
 DEBUG = False
 
 # "memos" or "memos.submodules" ... to filter logs from specific packages

memos/templates/mem_reader_prompts.py

@@ -2,6 +2,8 @@ SIMPLE_STRUCT_MEM_READER_PROMPT = """You are a memory extraction expert.
 Your task is to extract memories from the perspective of user, based on a conversation between user and assistant. This means identifying what user would plausibly remember — including their own experiences, thoughts, plans, or relevant statements and actions made by others (such as assistant) that impacted or were acknowledged by user.
 Please perform:
 1. Identify information that reflects user's experiences, beliefs, concerns, decisions, plans, or reactions — including meaningful input from assistant that user acknowledged or responded to.
+If the message is from the user, extract user-relevant memories; if it is from the assistant, only extract factual memories that the user acknowledged or responded to.
+
 2. Resolve all time, person, and event references clearly:
    - Convert relative time expressions (e.g., “yesterday,” “next Friday”) into absolute dates using the message timestamp if possible.
    - Clearly distinguish between event time and message time.
@@ -16,6 +18,7 @@ For example, write "The user felt exhausted..." instead of "I felt exhausted..."
    - Include all key experiences, thoughts, emotional responses, and plans — even if they seem minor.
    - Prioritize completeness and fidelity over conciseness.
    - Do not generalize or skip details that could be personally meaningful to user.
+5. Please avoid any content that violates national laws and regulations or involves politically sensitive information in the memories you extract.
 
 Return a single valid JSON object with the following structure:
 
@@ -150,7 +153,7 @@ Output:
   "summary": "Tom is currently focused on managing a new project with a tight schedule. After a team meeting on June 25, 2025, he realized the original deadline of December 15 might not be feasible due to backend delays. Concerned about insufficient testing time, he welcomed Jerry’s suggestion of proposing an extension. Tom plans to raise the idea of shifting the deadline to January 5, 2026 in the next morning’s meeting. His actions reflect both stress about timelines and a proactive, team-oriented problem-solving approach."
 }
 
-Another Example in Chinese (注意: 你的输出必须和输入的user语言一致)：
+Another Example in Chinese (注意: 当user的语言为中文时，你就需要也输出中文)：
 {
   "memory list": [
     {