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

memos/configs/mem_scheduler.py

@@ -6,12 +6,12 @@ from typing import Any, ClassVar
 from pydantic import ConfigDict, Field, field_validator, model_validator
 
 from memos.configs.base import BaseConfig
-from memos.mem_scheduler.modules.schemas import (
+from memos.mem_scheduler.general_modules.misc import DictConversionMixin
+from memos.mem_scheduler.schemas.general_schemas import (
     BASE_DIR,
     DEFAULT_ACT_MEM_DUMP_PATH,
     DEFAULT_CONSUME_INTERVAL_SECONDS,
     DEFAULT_THREAD__POOL_MAX_WORKERS,
-    DictConversionMixin,
 )
 
 
@@ -21,7 +21,6 @@ class BaseSchedulerConfig(BaseConfig):
     top_k: int = Field(
         default=10, description="Number of top candidates to consider in initial retrieval"
     )
-    top_n: int = Field(default=5, description="Number of final results to return after processing")
     enable_parallel_dispatch: bool = Field(
         default=True, description="Whether to enable parallel message processing using thread pool"
     )
@@ -44,19 +43,26 @@ class BaseSchedulerConfig(BaseConfig):
 
 
 class GeneralSchedulerConfig(BaseSchedulerConfig):
+    model_config = ConfigDict(extra="ignore", strict=True)
     act_mem_update_interval: int | None = Field(
         default=300, description="Interval in seconds for updating activation memory"
     )
     context_window_size: int | None = Field(
-        default=5, description="Size of the context window for conversation history"
+        default=10, description="Size of the context window for conversation history"
     )
     act_mem_dump_path: str | None = Field(
         default=DEFAULT_ACT_MEM_DUMP_PATH,  # Replace with DEFAULT_ACT_MEM_DUMP_PATH
         description="File path for dumping activation memory",
     )
-    enable_act_memory_update: bool = Field(
+    enable_activation_memory: bool = Field(
         default=False, description="Whether to enable automatic activation memory updates"
     )
+    working_mem_monitor_capacity: int = Field(
+        default=30, description="Capacity of the working memory monitor"
+    )
+    activation_mem_monitor_capacity: int = Field(
+        default=20, description="Capacity of the activation memory monitor"
+    )
 
 
 class SchedulerConfigFactory(BaseConfig):
@@ -105,7 +111,20 @@ class RabbitMQConfig(
 
 
 class GraphDBAuthConfig(BaseConfig):
-    uri: str = Field(default="localhost", description="URI for graph database access")
+    uri: str = Field(
+        default="bolt://localhost:7687",
+        description="URI for graph database access (e.g., bolt://host:port)",
+    )
+    user: str = Field(default="neo4j", description="Username for graph database authentication")
+    password: str = Field(
+        default="",
+        description="Password for graph database authentication",
+        min_length=8,  # 建议密码最小长度
+    )
+    db_name: str = Field(default="neo4j", description="Database name to connect to")
+    auto_create: bool = Field(
+        default=True, description="Whether to automatically create the database if it doesn't exist"
+    )
 
 
 class OpenAIConfig(BaseConfig):
@@ -123,29 +142,46 @@ class AuthConfig(BaseConfig, DictConversionMixin):
     )
 
     @classmethod
-    def from_local_yaml(cls, config_path: str | None = None) -> "AuthConfig":
+    def from_local_config(cls, config_path: str | Path | None = None) -> "AuthConfig":
         """
-        Load configuration from YAML file
+        Load configuration from either a YAML or JSON file based on file extension.
+
+        Automatically detects file type (YAML or JSON) from the file extension
+        and uses the appropriate parser. If no path is provided, uses the default
+        configuration path (YAML) or its JSON counterpart.
 
         Args:
-            config_path: Path to YAML configuration file
+            config_path: Optional path to configuration file.
+                         If not provided, uses default configuration path.
 
         Returns:
-            AuthConfig instance
+            AuthConfig instance populated with data from the configuration file.
 
         Raises:
-            FileNotFoundError: If config file doesn't exist
-            ValueError: If YAML parsing or validation fails
+            FileNotFoundError: If the specified or default configuration file does not exist.
+            ValueError: If file extension is not .yaml/.yml or .json, or if parsing fails.
         """
-
+        # Determine config path
         if config_path is None:
             config_path = cls.default_config_path
 
-        # Check file exists
-        if not Path(config_path).exists():
-            raise FileNotFoundError(f"Config file not found: {config_path}")
-
-        return cls.from_yaml_file(yaml_path=config_path)
+        # Validate file existence
+        config_path_obj = Path(config_path)
+        if not config_path_obj.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+        # Get file extension and determine parser
+        file_ext = config_path_obj.suffix.lower()
+
+        if file_ext in (".yaml", ".yml"):
+            return cls.from_yaml_file(yaml_path=str(config_path_obj))
+        elif file_ext == ".json":
+            return cls.from_json_file(json_path=str(config_path_obj))
+        else:
+            raise ValueError(
+                f"Unsupported file format: {file_ext}. "
+                "Please use YAML (.yaml, .yml) or JSON (.json) files."
+            )
 
     def set_openai_config_to_environment(self):
         # Set environment variables

memos/configs/mem_user.py

@@ -0,0 +1,58 @@
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from memos.configs.base import BaseConfig
+
+
+class BaseUserManagerConfig(BaseConfig):
+    """Base configuration class for user managers."""
+
+    user_id: str = Field(default="root", description="Default user ID for initialization")
+
+
+class SQLiteUserManagerConfig(BaseUserManagerConfig):
+    """SQLite user manager configuration."""
+
+    db_path: str | None = Field(
+        default=None,
+        description="Path to SQLite database file. If None, uses default path in MEMOS_DIR",
+    )
+
+
+class MySQLUserManagerConfig(BaseUserManagerConfig):
+    """MySQL user manager configuration."""
+
+    host: str = Field(default="localhost", description="MySQL server host")
+    port: int = Field(default=3306, description="MySQL server port")
+    username: str = Field(default="root", description="MySQL username")
+    password: str = Field(default="", description="MySQL password")
+    database: str = Field(default="memos_users", description="MySQL database name")
+    charset: str = Field(default="utf8mb4", description="MySQL charset")
+
+
+class UserManagerConfigFactory(BaseModel):
+    """Factory for user manager configurations."""
+
+    backend: str = Field(default="sqlite", description="Backend for user manager")
+    config: dict[str, Any] = Field(
+        default_factory=dict, description="Configuration for the user manager backend"
+    )
+
+    backend_to_class: ClassVar[dict[str, Any]] = {
+        "sqlite": SQLiteUserManagerConfig,
+        "mysql": MySQLUserManagerConfig,
+    }
+
+    @field_validator("backend")
+    @classmethod
+    def validate_backend(cls, backend: str) -> str:
+        if backend not in cls.backend_to_class:
+            raise ValueError(f"Unsupported user manager backend: {backend}")
+        return backend
+
+    @model_validator(mode="after")
+    def instantiate_config(self):
+        config_class = self.backend_to_class[self.backend]
+        self.config = config_class(**self.config)
+        return self

memos/graph_dbs/base.py

@@ -70,15 +70,27 @@ class BaseGraphDB(ABC):
 
     # Graph Query & Reasoning
     @abstractmethod
-    def get_node(self, id: str) -> dict[str, Any] | None:
+    def get_node(self, id: str, include_embedding: bool = False) -> dict[str, Any] | None:
         """
         Retrieve the metadata and content of a node.
         Args:
             id: Node identifier.
+            include_embedding: with/without embedding
         Returns:
             Dictionary of node fields, or None if not found.
         """
 
+    @abstractmethod
+    def get_nodes(self, id: str, include_embedding: bool = False) -> dict[str, Any] | None:
+        """
+        Retrieve the metadata and memory of a list of nodes.
+        Args:
+            ids: List of Node identifier.
+            include_embedding: with/without embedding
+        Returns:
+        list[dict]: Parsed node records containing 'id', 'memory', and 'metadata'.
+        """
+
     @abstractmethod
     def get_neighbors(
         self, id: str, type: str, direction: Literal["in", "out", "both"] = "out"
@@ -146,7 +158,7 @@ class BaseGraphDB(ABC):
         """
 
     @abstractmethod
-    def get_by_metadata(self, filters: dict[str, Any]) -> list[str]:
+    def get_by_metadata(self, filters: list[dict[str, Any]]) -> list[str]:
         """
         Retrieve node IDs that match given metadata filters.
 
@@ -162,6 +174,16 @@ class BaseGraphDB(ABC):
             - Can be used for faceted recall or prefiltering before embedding rerank.
         """
 
+    @abstractmethod
+    def get_structure_optimization_candidates(
+        self, scope: str, include_embedding: bool = False
+    ) -> list[dict]:
+        """
+        Find nodes that are likely candidates for structure optimization:
+        - Isolated nodes, nodes with empty background, or nodes with exactly one child.
+        - Plus: the child of any parent node that has exactly one child.
+        """
+
     # Structure Maintenance
     @abstractmethod
     def deduplicate_nodes(self) -> None:
@@ -197,7 +219,7 @@ class BaseGraphDB(ABC):
         """
 
     @abstractmethod
-    def export_graph(self) -> dict[str, Any]:
+    def export_graph(self, include_embedding: bool = False) -> dict[str, Any]:
         """
         Export the entire graph as a serializable dictionary.
 
@@ -213,3 +235,16 @@ class BaseGraphDB(ABC):
         Args:
             data: A dictionary containing all nodes and edges to be loaded.
         """
+
+    @abstractmethod
+    def get_all_memory_items(self, scope: str, include_embedding: bool = False) -> list[dict]:
+        """
+        Retrieve all memory items of a specific memory_type.
+
+        Args:
+            scope (str): Must be one of 'WorkingMemory', 'LongTermMemory', or 'UserMemory'.
+            include_embedding: with/without embedding
+
+        Returns:
+            list[dict]: Full list of memory items under this scope.
+        """

memos/graph_dbs/factory.py

@@ -2,6 +2,7 @@ from typing import Any, ClassVar
 
 from memos.configs.graph_db import GraphDBConfigFactory
 from memos.graph_dbs.base import BaseGraphDB
+from memos.graph_dbs.nebular import NebulaGraphDB
 from memos.graph_dbs.neo4j import Neo4jGraphDB
 from memos.graph_dbs.neo4j_community import Neo4jCommunityGraphDB
 
@@ -12,6 +13,7 @@ class GraphStoreFactory(BaseGraphDB):
     backend_to_class: ClassVar[dict[str, Any]] = {
         "neo4j": Neo4jGraphDB,
         "neo4j-community": Neo4jCommunityGraphDB,
+        "nebular": NebulaGraphDB,
     }
 
     @classmethod