MemoryOS 2.0.3__py3-none-any.whl

memos/configs/internet_retriever.py

@@ -0,0 +1,100 @@
+"""Configuration classes for internet retrievers."""
+
+from typing import Any, ClassVar
+
+from pydantic import Field, field_validator, model_validator
+
+from memos.configs.base import BaseConfig
+from memos.exceptions import ConfigurationError
+from memos.mem_reader.factory import MemReaderConfigFactory
+
+
+class BaseInternetRetrieverConfig(BaseConfig):
+    """Base configuration class for internet retrievers."""
+
+    api_key: str = Field(..., description="API key for the search service")
+    search_engine_id: str | None = Field(
+        None, description="Search engine ID (required for Google Custom Search)"
+    )
+
+
+class GoogleCustomSearchConfig(BaseInternetRetrieverConfig):
+    """Configuration class for Google Custom Search API."""
+
+    search_engine_id: str = Field(..., description="Google Custom Search Engine ID (cx parameter)")
+    max_results: int = Field(default=20, description="Maximum number of results to retrieve")
+    num_per_request: int = Field(
+        default=10, description="Number of results per API request (max 10 for Google)"
+    )
+
+
+class BingSearchConfig(BaseInternetRetrieverConfig):
+    """Configuration class for Bing Search API."""
+
+    endpoint: str = Field(
+        default="https://api.bing.microsoft.com/v7.0/search", description="Bing Search API endpoint"
+    )
+    max_results: int = Field(default=20, description="Maximum number of results to retrieve")
+    num_per_request: int = Field(default=10, description="Number of results per API request")
+
+
+class XinyuSearchConfig(BaseInternetRetrieverConfig):
+    """Configuration class for Xinyu Search API."""
+
+    search_engine_id: str | None = Field(
+        None, description="Not used for Xinyu Search (kept for compatibility)"
+    )
+    max_results: int = Field(default=20, description="Maximum number of results to retrieve")
+    num_per_request: int = Field(
+        default=10, description="Number of results per API request (not used for Xinyu)"
+    )
+    reader: MemReaderConfigFactory = Field(
+        ...,
+        default_factory=MemReaderConfigFactory,
+        description="Reader configuration",
+    )
+
+
+class BochaSearchConfig(BaseInternetRetrieverConfig):
+    """Configuration class for Bocha Search API."""
+
+    max_results: int = Field(default=20, description="Maximum number of results to retrieve")
+    num_per_request: int = Field(default=10, description="Number of results per API request")
+    reader: MemReaderConfigFactory = Field(
+        ...,
+        default_factory=MemReaderConfigFactory,
+        description="Reader configuration",
+    )
+
+
+class InternetRetrieverConfigFactory(BaseConfig):
+    """Factory class for creating internet retriever configurations."""
+
+    backend: str | None = Field(
+        None, description="Backend for internet retriever (google, bing, etc.)"
+    )
+    config: dict[str, Any] | None = Field(
+        None, description="Configuration for the internet retriever backend"
+    )
+
+    backend_to_class: ClassVar[dict[str, Any]] = {
+        "google": GoogleCustomSearchConfig,
+        "bing": BingSearchConfig,
+        "xinyu": XinyuSearchConfig,
+        "bocha": BochaSearchConfig,
+    }
+
+    @field_validator("backend")
+    @classmethod
+    def validate_backend(cls, backend: str | None) -> str | None:
+        """Validate the backend field."""
+        if backend is not None and backend not in cls.backend_to_class:
+            raise ConfigurationError(f"Invalid internet retriever backend: {backend}")
+        return backend
+
+    @model_validator(mode="after")
+    def create_config(self) -> "InternetRetrieverConfigFactory":
+        if self.backend is not None:
+            config_class = self.backend_to_class[self.backend]
+            self.config = config_class(**self.config)
+        return self

memos/configs/llm.py

@@ -0,0 +1,151 @@
+from typing import Any, ClassVar
+
+from pydantic import Field, field_validator, model_validator
+
+from memos.configs.base import BaseConfig
+
+
+class BaseLLMConfig(BaseConfig):
+    """Base configuration class for LLMs."""
+
+    model_name_or_path: str = Field(..., description="Model name or path")
+    temperature: float = Field(default=0.7, description="Temperature for sampling")
+    max_tokens: int = Field(default=8192, description="Maximum number of tokens to generate")
+    top_p: float = Field(default=0.95, description="Top-p sampling parameter")
+    top_k: int = Field(default=50, description="Top-k sampling parameter")
+    remove_think_prefix: bool = Field(
+        default=False,
+        description="Remove content within think tags from the generated text",
+    )
+    default_headers: dict[str, Any] | None = Field(
+        default=None, description="Default headers for LLM requests"
+    )
+
+
+class OpenAILLMConfig(BaseLLMConfig):
+    api_key: str = Field(..., description="API key for OpenAI")
+    api_base: str = Field(
+        default="https://api.openai.com/v1", description="Base URL for OpenAI API"
+    )
+    extra_body: Any = Field(default=None, description="extra body")
+
+
+class OpenAIResponsesLLMConfig(BaseLLMConfig):
+    api_key: str = Field(..., description="API key for OpenAI")
+    api_base: str = Field(
+        default="https://api.openai.com/v1", description="Base URL for OpenAI responses API"
+    )
+    extra_body: Any = Field(default=None, description="extra body")
+    enable_thinking: bool = Field(
+        default=False,
+        description="Enable reasoning outputs from vLLM",
+    )
+
+
+class QwenLLMConfig(BaseLLMConfig):
+    api_key: str = Field(..., description="API key for DashScope (Qwen)")
+    api_base: str = Field(
+        default="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+        description="Base URL for Qwen OpenAI-compatible API",
+    )
+    extra_body: Any = Field(default=None, description="extra body")
+
+
+class DeepSeekLLMConfig(BaseLLMConfig):
+    api_key: str = Field(..., description="API key for DeepSeek")
+    api_base: str = Field(
+        default="https://api.deepseek.com",
+        description="Base URL for DeepSeek OpenAI-compatible API",
+    )
+    extra_body: Any = Field(default=None, description="Extra options for API")
+
+
+class AzureLLMConfig(BaseLLMConfig):
+    base_url: str = Field(
+        default="https://api.openai.azure.com/",
+        description="Base URL for Azure OpenAI API",
+    )
+    api_version: str = Field(
+        default="2024-03-01-preview",
+        description="API version for Azure OpenAI",
+    )
+    api_key: str = Field(..., description="API key for Azure OpenAI")
+
+
+class AzureResponsesLLMConfig(BaseLLMConfig):
+    base_url: str = Field(
+        default="https://api.openai.azure.com/",
+        description="Base URL for Azure OpenAI API",
+    )
+    api_version: str = Field(
+        default="2024-03-01-preview",
+        description="API version for Azure OpenAI",
+    )
+    api_key: str = Field(..., description="API key for Azure OpenAI")
+
+
+class OllamaLLMConfig(BaseLLMConfig):
+    api_base: str = Field(
+        default="http://localhost:11434",
+        description="Base URL for Ollama API",
+    )
+    enable_thinking: bool = Field(
+        default=False,
+        description="Enable reasoning outputs from Ollama",
+    )
+
+
+class HFLLMConfig(BaseLLMConfig):
+    do_sample: bool = Field(
+        default=False,
+        description="Whether to use sampling (if False, always greedy/argmax decoding)",
+    )
+    add_generation_prompt: bool = Field(
+        default=True,
+        description="Apply generation template for the conversation",
+    )
+
+
+class VLLMLLMConfig(BaseLLMConfig):
+    api_key: str = Field(default="", description="API key for vLLM (optional for local server)")
+    api_base: str = Field(
+        default="http://localhost:8088/v1",
+        description="Base URL for vLLM API",
+    )
+    enable_thinking: bool = Field(
+        default=False,
+        description="Enable reasoning outputs from vLLM",
+    )
+
+
+class LLMConfigFactory(BaseConfig):
+    """Factory class for creating LLM configurations."""
+
+    backend: str = Field(..., description="Backend for LLM")
+    config: dict[str, Any] = Field(..., description="Configuration for the LLM backend")
+
+    backend_to_class: ClassVar[dict[str, Any]] = {
+        "openai": OpenAILLMConfig,
+        "ollama": OllamaLLMConfig,
+        "azure": AzureLLMConfig,
+        "huggingface": HFLLMConfig,
+        "vllm": VLLMLLMConfig,
+        "huggingface_singleton": HFLLMConfig,  # Add singleton support
+        "qwen": QwenLLMConfig,
+        "deepseek": DeepSeekLLMConfig,
+        "openai_new": OpenAIResponsesLLMConfig,
+    }
+
+    @field_validator("backend")
+    @classmethod
+    def validate_backend(cls, backend: str) -> str:
+        """Validate the backend field."""
+        if backend not in cls.backend_to_class:
+            raise ValueError(f"Invalid backend: {backend}")
+        return backend
+
+    @model_validator(mode="after")
+    def create_config(self) -> "LLMConfigFactory":
+        config_class = self.backend_to_class[self.backend]
+        self.config = config_class(**self.config)
+        return self

memos/configs/mem_agent.py

@@ -0,0 +1,54 @@
+from typing import Any, ClassVar
+
+from pydantic import Field, field_validator, model_validator
+
+from memos.configs.base import BaseConfig
+
+
+class BaseAgentConfig(BaseConfig):
+    """Base configuration class for agents."""
+
+    agent_name: str = Field(..., description="Name of the agent")
+    description: str | None = Field(default=None, description="Description of the agent")
+
+
+class SimpleAgentConfig(BaseAgentConfig):
+    """Simple agent configuration class."""
+
+    max_iterations: int = Field(
+        default=10, description="Maximum number of iterations for the agent"
+    )
+    timeout: int = Field(default=30, description="Timeout in seconds for agent execution")
+
+
+class DeepSearchAgentConfig(BaseAgentConfig):
+    """Deep search agent configuration class."""
+
+    max_iterations: int = Field(default=3, description="Maximum number of iterations for the agent")
+    timeout: int = Field(default=30, description="Timeout in seconds for agent execution")
+
+
+class MemAgentConfigFactory(BaseConfig):
+    """Factory class for creating agent configurations."""
+
+    backend: str = Field(..., description="Backend for agent")
+    config: dict[str, Any] = Field(..., description="Configuration for the agent backend")
+
+    backend_to_class: ClassVar[dict[str, Any]] = {
+        "simple": SimpleAgentConfig,
+        "deep_search": DeepSearchAgentConfig,
+    }
+
+    @field_validator("backend")
+    @classmethod
+    def validate_backend(cls, backend: str) -> str:
+        """Validate the backend field."""
+        if backend not in cls.backend_to_class:
+            raise ValueError(f"Invalid backend: {backend}")
+        return backend
+
+    @model_validator(mode="after")
+    def create_config(self) -> "MemAgentConfigFactory":
+        config_class = self.backend_to_class[self.backend]
+        self.config = config_class(**self.config)
+        return self

memos/configs/mem_chat.py

@@ -0,0 +1,81 @@
+import uuid
+
+from datetime import datetime
+from typing import Any, ClassVar
+
+from pydantic import Field, field_validator, model_validator
+
+from memos.configs.base import BaseConfig
+from memos.configs.llm import LLMConfigFactory
+
+
+class BaseMemChatConfig(BaseConfig):
+    """Base configuration class for MemChat."""
+
+    user_id: str = Field(..., description="User ID for the MemChat")
+    session_id: str = Field(
+        default_factory=lambda: str(uuid.uuid4()), description="Session ID for the MemChat"
+    )
+    created_at: datetime = Field(
+        default_factory=datetime.now,
+        description="Creation timestamp for the MemChat",
+    )
+    config_filename: str = Field(
+        default="config.json",
+        description="Filename for storing the MemChat configuration",
+    )
+
+
+class SimpleMemChatConfig(BaseMemChatConfig):
+    """Simple MemChat configuration class."""
+
+    chat_llm: LLMConfigFactory = Field(
+        ...,
+        default_factory=LLMConfigFactory,
+        description="LLM configuration for the MemChat",
+    )
+    max_turns_window: int = Field(
+        default=15,
+        description="Maximum number of turns to keep in the conversation history",
+    )
+    top_k: int = Field(
+        default=5,
+        description="Maximum number of memories to retrieve for each query",
+    )
+    enable_textual_memory: bool = Field(
+        default=False,
+        description="Enable textual memory for the MemChat",
+    )
+    enable_activation_memory: bool = Field(
+        default=False,
+        description="Enable activation memory for the MemChat",
+    )
+    enable_parametric_memory: bool = Field(
+        default=False,
+        description="Enable parametric memory for the MemChat",
+    )
+
+
+class MemChatConfigFactory(BaseConfig):
+    """Factory class for creating MemChat configurations."""
+
+    backend: str = Field(..., description="Backend for MemChat")
+    config: dict[str, Any] = Field(..., description="Configuration for the MemChat backend")
+
+    backend_to_class: ClassVar[dict[str, Any]] = {
+        "simple": SimpleMemChatConfig,
+    }
+
+    @field_validator("backend")
+    @classmethod
+    def validate_backend(cls, backend: str) -> str:
+        """Validate the backend field."""
+        if backend not in cls.backend_to_class:
+            raise ValueError(f"Invalid backend: {backend}")
+        return backend
+
+    @model_validator(mode="after")
+    def create_config(self) -> "MemChatConfigFactory":
+        config_class = self.backend_to_class[self.backend]
+        self.config = config_class(**self.config)
+        return self

memos/configs/mem_cube.py

@@ -0,0 +1,105 @@
+import uuid
+
+from pydantic import Field, field_validator
+
+from memos.configs.base import BaseConfig
+from memos.configs.memory import (
+    MemoryConfigFactory,
+)
+from memos.exceptions import ConfigurationError
+from memos.log import get_logger
+
+
+logger = get_logger(__name__)
+
+
+class BaseMemCubeConfig(BaseConfig):
+    """Base configuration class for MemCube."""
+
+    model_schema: str = Field(
+        "NOT_SET",
+        description="Schema for configuration. This value will be automatically set.",
+        exclude=False,
+    )
+
+    config_filename: str = Field(
+        "config.json",
+        description="Filename for storing MemCube configuration",
+    )
+
+
+class GeneralMemCubeConfig(BaseMemCubeConfig):
+    """General MemCube memory configuration class."""
+
+    user_id: str = Field(
+        "default_user",
+        description="User ID for the MemCube. This is used to distinguish between different users' memories.",
+    )
+    cube_id: str = Field(
+        str(uuid.uuid4()),
+        description="Cube ID for the MemCube. This is used to distinguish between different MemCubes.",
+    )
+    text_mem: MemoryConfigFactory = Field(
+        ...,
+        default_factory=MemoryConfigFactory,
+        description="Configuration for the textual memory",
+    )
+    act_mem: MemoryConfigFactory = Field(
+        ...,
+        default_factory=MemoryConfigFactory,
+        description="Configuration for the activation memory",
+    )
+    para_mem: MemoryConfigFactory = Field(
+        ...,
+        default_factory=MemoryConfigFactory,
+        description="Configuration for the parametric memory",
+    )
+    pref_mem: MemoryConfigFactory = Field(
+        ...,
+        default_factory=MemoryConfigFactory,
+        description="Configuration for the preference memory",
+    )
+
+    @field_validator("text_mem")
+    @classmethod
+    def validate_text_mem(cls, text_mem: MemoryConfigFactory) -> MemoryConfigFactory:
+        """Validate the text_mem field."""
+        allowed_backends = ["naive_text", "general_text", "tree_text", "uninitialized"]
+        if text_mem.backend not in allowed_backends:
+            raise ConfigurationError(
+                f"GeneralMemCubeConfig requires text_mem backend to be one of {allowed_backends}, got '{text_mem.backend}'"
+            )
+        return text_mem
+
+    @field_validator("act_mem")
+    @classmethod
+    def validate_act_mem(cls, act_mem: MemoryConfigFactory) -> MemoryConfigFactory:
+        """Validate the act_mem field."""
+        allowed_backends = ["kv_cache", "vllm_kv_cache", "uninitialized"]
+        if act_mem.backend not in allowed_backends:
+            raise ConfigurationError(
+                f"GeneralMemCubeConfig requires act_mem backend to be one of {allowed_backends}, got '{act_mem.backend}'"
+            )
+        return act_mem
+
+    @field_validator("para_mem")
+    @classmethod
+    def validate_para_mem(cls, para_mem: MemoryConfigFactory) -> MemoryConfigFactory:
+        """Validate the para_mem field."""
+        allowed_backends = ["lora", "uninitialized"]
+        if para_mem.backend not in allowed_backends:
+            raise ConfigurationError(
+                f"GeneralMemCubeConfig requires para_mem backend to be one of {allowed_backends}, got '{para_mem.backend}'"
+            )
+        return para_mem
+
+    @field_validator("pref_mem")
+    @classmethod
+    def validate_pref_mem(cls, pref_mem: MemoryConfigFactory) -> MemoryConfigFactory:
+        """Validate the pref_mem field."""
+        allowed_backends = ["pref_text", "uninitialized"]
+        if pref_mem.backend not in allowed_backends:
+            raise ConfigurationError(
+                f"GeneralMemCubeConfig requires pref_mem backend to be one of {allowed_backends}, got '{pref_mem.backend}'"
+            )
+        return pref_mem

memos/configs/mem_os.py

@@ -0,0 +1,83 @@
+import uuid
+
+from typing import Any
+
+from pydantic import Field, model_validator
+
+from memos.configs.base import BaseConfig
+from memos.configs.llm import LLMConfigFactory
+from memos.configs.mem_reader import MemReaderConfigFactory
+from memos.configs.mem_scheduler import SchedulerConfigFactory
+from memos.configs.mem_user import UserManagerConfigFactory
+
+
+class MOSConfig(BaseConfig):
+    user_id: str = Field(
+        default="root",
+        description="User ID for the MOS. This is used to distinguish between different users' memories.",
+    )
+    session_id: str = Field(
+        default=str(uuid.uuid4()),
+        description="Session ID for the MOS. This is used to distinguish between different dialogue",
+    )
+    chat_model: LLMConfigFactory = Field(
+        ...,
+        default_factory=LLMConfigFactory,
+        description="LLM configuration for the chat model in the MOS",
+    )
+    mem_reader: MemReaderConfigFactory = Field(
+        ...,
+        default_factory=MemReaderConfigFactory,
+        description="MemReader configuration for the MOS",
+    )
+    mem_scheduler: SchedulerConfigFactory | None = Field(
+        default=None,
+        description="Memory scheduler configuration for managing memory operations",
+    )
+    user_manager: UserManagerConfigFactory = Field(
+        default_factory=lambda: UserManagerConfigFactory(backend="sqlite", config={}),
+        description="User manager configuration for database operations",
+    )
+    max_turns_window: int = Field(
+        default=15,
+        description="Maximum number of turns to keep in the conversation history",
+    )
+    top_k: int = Field(
+        default=5,
+        description="Maximum number of memories to retrieve for each query",
+    )
+    enable_textual_memory: bool = Field(
+        default=True,
+        description="Enable textual memory for the MemChat",
+    )
+    enable_activation_memory: bool = Field(
+        default=False,
+        description="Enable activation memory for the MemChat",
+    )
+    enable_parametric_memory: bool = Field(
+        default=False,
+        description="Enable parametric memory for the MemChat",
+    )
+    enable_preference_memory: bool = Field(
+        default=False,
+        description="Enable preference memory for the MemChat",
+    )
+    enable_mem_scheduler: bool = Field(
+        default=False,
+        description="Enable memory scheduler for automated memory management",
+    )
+    PRO_MODE: bool = Field(
+        default=False,
+        description="Enable PRO mode for complex query decomposition",
+    )
+
+
+class MemOSConfigFactory(BaseConfig):
+    """Factory class for creating Memos configurations."""
+
+    config: dict[str, Any] = Field(..., description="Configuration for the MemOS backend")
+
+    @model_validator(mode="after")
+    def create_config(self) -> "MemOSConfigFactory":
+        self.config = MOSConfig(**self.config)
+        return self

memos/configs/mem_reader.py

@@ -0,0 +1,91 @@
+from datetime import datetime
+from typing import Any, ClassVar
+
+from pydantic import ConfigDict, Field, field_validator, model_validator
+
+from memos.configs.base import BaseConfig
+from memos.configs.chunker import ChunkerConfigFactory
+from memos.configs.embedder import EmbedderConfigFactory
+from memos.configs.llm import LLMConfigFactory
+
+
+class BaseMemReaderConfig(BaseConfig):
+    """Base configuration class for MemReader."""
+
+    created_at: datetime = Field(
+        default_factory=datetime.now, description="Creation timestamp for the MemReader"
+    )
+
+    @field_validator("created_at", mode="before")
+    @classmethod
+    def parse_datetime(cls, value):
+        """Parse datetime from string if needed."""
+        if isinstance(value, str):
+            return datetime.fromisoformat(value.replace("Z", "+00:00"))
+        return value
+
+    llm: LLMConfigFactory = Field(..., description="LLM configuration for the MemReader")
+    embedder: EmbedderConfigFactory = Field(
+        ..., description="Embedder configuration for the MemReader"
+    )
+    chunker: ChunkerConfigFactory = Field(
+        ..., description="Chunker configuration for the MemReader"
+    )
+    remove_prompt_example: bool = Field(
+        default=False,
+        description="whether remove example in memory extraction prompt to save token",
+    )
+
+    chat_chunker: dict[str, Any] = Field(
+        default=None, description="Configuration for the MemReader chat chunk strategy"
+    )
+
+
+class SimpleStructMemReaderConfig(BaseMemReaderConfig):
+    """SimpleStruct MemReader configuration class."""
+
+    # Allow passing additional fields without raising validation errors
+    model_config = ConfigDict(extra="allow", strict=True)
+
+
+class MultiModalStructMemReaderConfig(BaseMemReaderConfig):
+    """MultiModalStruct MemReader configuration class."""
+
+    direct_markdown_hostnames: list[str] | None = Field(
+        default=None,
+        description="List of hostnames that should return markdown directly without parsing. "
+        "If None, reads from FILE_PARSER_DIRECT_MARKDOWN_HOSTNAMES environment variable.",
+    )
+
+
+class StrategyStructMemReaderConfig(BaseMemReaderConfig):
+    """StrategyStruct MemReader configuration class."""
+
+    model_config = ConfigDict(extra="allow", strict=True)
+
+
+class MemReaderConfigFactory(BaseConfig):
+    """Factory class for creating MemReader configurations."""
+
+    backend: str = Field(..., description="Backend for MemReader")
+    config: dict[str, Any] = Field(..., description="Configuration for the MemReader backend")
+
+    backend_to_class: ClassVar[dict[str, Any]] = {
+        "simple_struct": SimpleStructMemReaderConfig,
+        "multimodal_struct": MultiModalStructMemReaderConfig,
+        "strategy_struct": StrategyStructMemReaderConfig,
+    }
+
+    @field_validator("backend")
+    @classmethod
+    def validate_backend(cls, backend: str) -> str:
+        """Validate the backend field."""
+        if backend not in cls.backend_to_class:
+            raise ValueError(f"Invalid backend: {backend}")
+        return backend
+
+    @model_validator(mode="after")
+    def create_config(self) -> "MemReaderConfigFactory":
+        config_class = self.backend_to_class[self.backend]
+        self.config = config_class(**self.config)
+        return self