gllm-memory-binary 0.2.0.post1__cp313-cp313-win_amd64.whl

gllm_memory/__init__.pyi

@@ -0,0 +1,8 @@
+from gllm_memory.builder.build_memory_client import build_memory_client as build_memory_client
+from gllm_memory.builder.memory_manager_builder import MemoryManagerConfig as MemoryManagerConfig
+from gllm_memory.clients.mem0.http.mem0_client import Mem0Client as Mem0Client
+from gllm_memory.clients.memory_client import BaseMemoryClient as BaseMemoryClient
+from gllm_memory.enums import MemoryProviderType as MemoryProviderType
+from gllm_memory.memory_manager import MemoryManager as MemoryManager
+
+__all__ = ['MemoryManager', 'MemoryManagerConfig', 'BaseMemoryClient', 'Mem0Client', 'MemoryProviderType', 'build_memory_client']

gllm_memory/backends/__init__.pyi

@@ -0,0 +1,5 @@
+from gllm_memory.backends.base import BaseMemoryBackendAdapter as BaseMemoryBackendAdapter
+from gllm_memory.backends.mem0 import Mem0BackendAdapter as Mem0BackendAdapter
+from gllm_memory.backends.resolver import build_configured_memory_client as build_configured_memory_client, resolve_config_backend_adapter as resolve_config_backend_adapter
+
+__all__ = ['BaseMemoryBackendAdapter', 'Mem0BackendAdapter', 'build_configured_memory_client', 'resolve_config_backend_adapter']

gllm_memory/backends/base.pyi

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from gllm_memory.builder.memory_manager_builder import MemoryManagerConfig as MemoryManagerConfig
+from gllm_memory.clients.memory_client import BaseMemoryClient as BaseMemoryClient
+from typing import Any
+
+class BaseMemoryBackendAdapter(ABC):
+    """Abstract adapter interface for one internal memory backend.
+
+    Attributes:
+        backend_key (str): Stable internal identifier for the backend implementation.
+    """
+    backend_key: str
+    @abstractmethod
+    def can_handle_config(self, config: dict[str, Any] | MemoryManagerConfig) -> bool:
+        """Determine whether this adapter can handle one config object or payload.
+
+        Args:
+            config (dict[str, Any] | MemoryManagerConfig): Memory configuration candidate.
+
+        Returns:
+            bool: ``True`` if this adapter can build a runtime for the given config.
+        """
+    @abstractmethod
+    def build_configured_client(self, *, config: dict[str, Any] | MemoryManagerConfig, instruction: str | None = None, timeout_sec: int = 30) -> BaseMemoryClient:
+        """Build one configured memory client for this backend.
+
+        Args:
+            config (dict[str, Any] | MemoryManagerConfig): Memory configuration candidate.
+            instruction (str | None, optional): Optional instruction override. Defaults to None.
+            timeout_sec (int, optional): Request timeout in seconds. Defaults to 30.
+
+        Returns:
+            BaseMemoryClient: Concrete client instance for the selected backend.
+        """

gllm_memory/backends/mem0/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_memory.backends.mem0.adapter import Mem0BackendAdapter as Mem0BackendAdapter
+
+__all__ = ['Mem0BackendAdapter']

gllm_memory/backends/mem0/adapter.pyi

@@ -0,0 +1,35 @@
+from _typeshed import Incomplete
+from gllm_memory.backends.base import BaseMemoryBackendAdapter as BaseMemoryBackendAdapter
+from gllm_memory.backends.mem0.config_compiler import PUBLIC_MEMORY_CONFIG_SECTIONS as PUBLIC_MEMORY_CONFIG_SECTIONS, compile_public_payload_to_mem0_config as compile_public_payload_to_mem0_config, looks_like_mem0_native_config as looks_like_mem0_native_config
+from gllm_memory.builder.memory_manager_builder import MemoryManagerConfig as MemoryManagerConfig, clone_memory_config_payload as clone_memory_config_payload
+from gllm_memory.clients.mem0.sdk.mem0_sdk_client import Mem0SDKClient as Mem0SDKClient
+from gllm_memory.clients.memory_client import BaseMemoryClient as BaseMemoryClient
+from gllm_memory.enums import MemoryProviderType as MemoryProviderType
+from typing import Any
+
+class Mem0BackendAdapter(BaseMemoryBackendAdapter):
+    """Backend adapter that compiles config payloads into Mem0 runtime clients."""
+    backend_key: Incomplete
+    def can_handle_config(self, config: dict[str, Any] | MemoryManagerConfig) -> bool:
+        """Determine whether this adapter can handle one config object or payload.
+
+        Args:
+            config (dict[str, Any] | MemoryManagerConfig): Memory configuration candidate.
+
+        Returns:
+            bool: ``True`` when the config is compatible with the Mem0 backend.
+        """
+    def build_configured_client(self, *, config: dict[str, Any] | MemoryManagerConfig, instruction: str | None = None, timeout_sec: int = 30) -> BaseMemoryClient:
+        """Build one Mem0 SDK client from the given config input.
+
+        Args:
+            config (dict[str, Any] | MemoryManagerConfig): Memory configuration candidate.
+            instruction (str | None, optional): Optional instruction override. Defaults to None.
+            timeout_sec (int, optional): Request timeout in seconds. Defaults to 30.
+
+        Returns:
+            BaseMemoryClient: Concrete ``Mem0SDKClient`` instance.
+
+        Raises:
+            ValueError: If the config is unsupported by this adapter.
+        """

gllm_memory/backends/mem0/config_compiler.pyi

@@ -0,0 +1,38 @@
+from _typeshed import Incomplete
+from gllm_memory.backends.mem0.defaults import DEFAULT_MEM0_BACKEND_OPTIONS as DEFAULT_MEM0_BACKEND_OPTIONS
+from gllm_memory.builder.memory_manager_builder import clone_memory_config_payload as clone_memory_config_payload
+from typing import Any
+
+VERSION_KEY: str
+VECTOR_STORE_KEY: str
+EMBEDDER_KEY: str
+LLM_KEY: str
+RERANKER_KEY: str
+PUBLIC_MEMORY_STORE_KEY: str
+PUBLIC_EMBEDDING_KEY: str
+HISTORY_DB_PATH_KEY: str
+GRAPH_STORE_KEY: str
+DISABLE_GRAPH_KEY: str
+BACKEND_DISABLE_GRAPH_KEY: str
+PUBLIC_MEMORY_CONFIG_SECTIONS: Incomplete
+MEM0_NATIVE_KEYS: Incomplete
+
+def looks_like_mem0_native_config(config: dict[str, Any]) -> bool:
+    """Determine whether one dict already looks like a Mem0-native SDK config.
+
+    Args:
+        config (dict[str, Any]): Candidate config dict.
+
+    Returns:
+        bool: ``True`` if the dict already contains Mem0-native root keys.
+    """
+def compile_public_payload_to_mem0_config(payload: dict[str, Any], backend_options: dict[str, Any] | None = None) -> dict[str, Any]:
+    """Compile public config payload into Mem0-native SDK config.
+
+    Args:
+        payload (dict[str, Any]): Public config payload.
+        backend_options (dict[str, Any] | None, optional): Internal backend options. Defaults to None.
+
+    Returns:
+        dict[str, Any]: Mem0-native config dict.
+    """

gllm_memory/backends/mem0/defaults.pyi

@@ -0,0 +1,21 @@
+from _typeshed import Incomplete
+from dataclasses import dataclass
+from typing import Any
+
+MEM0_VERSION_KEY: str
+MEM0_HISTORY_DB_PATH_KEY: str
+MEM0_BACKEND_DISABLE_GRAPH_KEY: str
+
+@dataclass(frozen=True, slots=True)
+class Mem0BackendDefaults:
+    """Default root options for Mem0 SDK-backed configured memory."""
+    version: str = ...
+    history_db_path: str = ...
+    disable_graph: bool = ...
+    def to_backend_options(self) -> dict[str, Any]:
+        """Return a new backend-options payload using Mem0 option names."""
+
+DEFAULT_MEM0_BACKEND_OPTIONS: Incomplete
+
+def build_default_mem0_backend_options() -> dict[str, Any]:
+    """Build a mutable backend-options dict for one ``MemoryManagerConfigBuilder``."""

gllm_memory/backends/resolver.pyi

@@ -0,0 +1,29 @@
+from gllm_memory.backends.base import BaseMemoryBackendAdapter as BaseMemoryBackendAdapter
+from gllm_memory.backends.mem0 import Mem0BackendAdapter as Mem0BackendAdapter
+from gllm_memory.builder.memory_manager_builder import MemoryManagerConfig as MemoryManagerConfig
+from gllm_memory.clients.memory_client import BaseMemoryClient as BaseMemoryClient
+from typing import Any
+
+def resolve_config_backend_adapter(config: dict[str, Any] | MemoryManagerConfig) -> BaseMemoryBackendAdapter:
+    """Resolve one backend adapter for the given config object or payload.
+
+    Args:
+        config (dict[str, Any] | MemoryManagerConfig): Memory configuration candidate.
+
+    Returns:
+        BaseMemoryBackendAdapter: Matching backend adapter.
+
+    Raises:
+        ValueError: If no registered backend adapter can handle the config.
+    """
+def build_configured_memory_client(*, config: dict[str, Any] | MemoryManagerConfig, instruction: str | None = None, timeout_sec: int = 30) -> BaseMemoryClient:
+    """Build one configured memory client using the resolved backend adapter.
+
+    Args:
+        config (dict[str, Any] | MemoryManagerConfig): Memory configuration candidate.
+        instruction (str | None, optional): Optional instruction override. Defaults to None.
+        timeout_sec (int, optional): Request timeout in seconds. Defaults to 30.
+
+    Returns:
+        BaseMemoryClient: Concrete client instance created by the selected adapter.
+    """

gllm_memory/builder/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_memory.builder.build_memory_client import build_from_env as build_from_env, build_memory_client as build_memory_client
+from gllm_memory.builder.memory_manager_builder import MemoryManagerConfig as MemoryManagerConfig, MemoryManagerConfigBuilder as MemoryManagerConfigBuilder
+
+__all__ = ['build_from_env', 'build_memory_client', 'MemoryManagerConfig', 'MemoryManagerConfigBuilder']

gllm_memory/builder/build_memory_client.pyi

@@ -0,0 +1,45 @@
+from gllm_memory.backends.resolver import build_configured_memory_client as build_configured_memory_client
+from gllm_memory.builder.memory_manager_builder import MemoryManagerConfig as MemoryManagerConfig
+from gllm_memory.clients.mem0.http.mem0_client import Mem0Client as Mem0Client
+from gllm_memory.clients.memory_client import BaseMemoryClient as BaseMemoryClient
+from gllm_memory.enums import MemoryProviderType as MemoryProviderType
+from typing import Any
+
+def build_memory_client(provider: str, **kwargs) -> BaseMemoryClient:
+    """Create a memory client for the specified provider.
+
+    Args:
+        provider (str): The name of the memory provider.
+        **kwargs: Additional keyword arguments passed to the client constructor.
+
+    Returns:
+        BaseMemoryClient: The created memory client instance.
+
+    Raises:
+        ValueError: If the provider is not supported.
+    """
+def build_from_env(api_key: str | None = None, instruction: str | None = None, host: str | None = None, config: dict[str, Any] | MemoryManagerConfig | None = None) -> BaseMemoryClient:
+    """Create a memory client from configuration.
+
+    Routes to the appropriate client based on what's provided:
+    1. If config provided -> resolve internal configured backend
+    2. Else if api_key or host provided -> Mem0Client (existing)
+    3. Else read from environment -> Mem0Client (existing)
+
+    Args:
+        api_key (str | None, optional): API key for authentication. If None, will be read
+            from MEM0_API_KEY environment variable. Defaults to None.
+        instruction (str | None, optional): Custom instructions for memory handling.
+            Defaults to None.
+        host (str | None, optional): Host for the memory client.
+            Defaults to None.
+        config (dict[str, Any] | MemoryManagerConfig | None, optional): Configured memory payload
+            or config object. If provided, resolves the configured backend path. Defaults to None.
+
+    Returns:
+        BaseMemoryClient: The created memory client instance.
+
+    Raises:
+        RuntimeError: If API key is not provided and MEM0_API_KEY environment variable is missing.
+        ValueError: If the provider specified in environment is not supported.
+    """

gllm_memory/builder/memory_manager_builder.pyi

@@ -0,0 +1,275 @@
+from _typeshed import Incomplete
+from dataclasses import dataclass
+from gllm_memory.enums import MemoryProviderType as MemoryProviderType
+from typing import Any
+
+@dataclass(frozen=True, slots=True)
+class _BuilderDefaults:
+    """Default values used by ``MemoryManagerConfigBuilder``."""
+    openai_embedder_model: str = ...
+    elasticsearch_auto_create_index: bool = ...
+    elasticsearch_use_ssl: bool = ...
+    elasticsearch_verify_certs: bool = ...
+
+@dataclass(frozen=True, slots=True)
+class _ConfigKeys:
+    """Internal keys used in builder and Mem0-compatible config payloads."""
+    memory_store: str = ...
+    embedding: str = ...
+    llm: str = ...
+    reranker: str = ...
+    @property
+    def required_sections(self) -> tuple[str, str, str]:
+        """Return config sections required before building."""
+
+@dataclass(frozen=True, slots=True)
+class _ProviderNames:
+    """Provider names handled specially by the builder."""
+    elasticsearch: str = ...
+    gllm_inference: str = ...
+    llm_reranker: str = ...
+    openai: str = ...
+
+logger: Incomplete
+
+class MemoryManagerConfig:
+    """Public configuration object for ``MemoryManager``.
+
+    Attributes:
+        instruction (str | None): Optional instruction carried with the config object.
+    """
+    instruction: Incomplete
+    def __init__(self, config: dict[str, Any], instruction: str | None = None, backend_key: str = ..., backend_options: dict[str, Any] | None = None) -> None:
+        """Initializes a new instance of the ``MemoryManagerConfig`` class.
+
+        Args:
+            config (dict[str, Any]): Underlying memory-engine config payload.
+            instruction (str | None, optional): Optional instruction stored with the config object.
+                Defaults to None.
+            backend_key (str, optional): Internal backend key selected by the library.
+                Defaults to ``MemoryProviderType.MEM0``.
+            backend_options (dict[str, Any] | None, optional): Internal backend-specific options.
+                Defaults to None.
+        """
+    @classmethod
+    def builder(cls) -> MemoryManagerConfigBuilder:
+        """Create a builder for ``MemoryManagerConfig``."""
+    def to_dict(self) -> dict[str, Any]:
+        """Return a safe copy of the underlying config payload."""
+    def get_backend_key(self) -> str:
+        """Return the internal backend key selected for this config object."""
+    def get_backend_options(self) -> dict[str, Any]:
+        """Return a safe copy of the internal backend-specific options."""
+
+class MemoryManagerConfigBuilder:
+    """Builder for ``MemoryManagerConfig``.
+
+    Attributes:
+        memory_store (_MemoryManagerStoreBuilder): Memory-store configuration helper.
+        embedding (_MemoryManagerEmbeddingBuilder): Embedding configuration helper.
+        llm (_MemoryManagerLLMBuilder): LLM registration helper.
+        reranker (_MemoryManagerRerankerBuilder): Optional reranker configuration helper.
+    """
+    memory_store: Incomplete
+    embedding: Incomplete
+    llm: Incomplete
+    reranker: Incomplete
+    def __init__(self) -> None:
+        """Initializes a new instance of the ``MemoryManagerConfigBuilder`` class."""
+    def instruction(self, instruction: str | None) -> MemoryManagerConfigBuilder:
+        """Set one optional instruction stored with the config object.
+
+        Args:
+            instruction (str | None): Instruction text. ``None`` clears the stored instruction.
+
+        Returns:
+            MemoryManagerConfigBuilder: The builder itself.
+        """
+    def conversation_store_path(self, conversation_store_path: str) -> MemoryManagerConfigBuilder:
+        """Set the path used for local conversation-state persistence.
+
+        Args:
+            conversation_store_path (str): Local conversation-store path.
+
+        Returns:
+            MemoryManagerConfigBuilder: The builder itself.
+
+        Raises:
+            ValueError: If the path is blank, contains traversal, or cannot be created.
+        """
+    def build_config(self) -> dict[str, Any]:
+        """Build validated memory-engine config.
+
+        Returns:
+            dict[str, Any]: Deep-copied config dictionary.
+
+        Raises:
+            ValueError: If required sections are missing.
+        """
+    def build(self) -> MemoryManagerConfig:
+        """Build one ``MemoryManagerConfig`` object from the assembled config.
+
+        Returns:
+            MemoryManagerConfig: Built config object.
+        """
+    def set_provider_config(self, section: str, provider: str, config: dict[str, Any]) -> MemoryManagerConfigBuilder:
+        """Set one provider section in the underlying config.
+
+        Used by nested builders (``memory_store``, ``embedding``, ``llm``) in this module.
+
+        Args:
+            section (str): Section name such as ``memory_store`` or ``embedding``.
+            provider (str): Provider identifier.
+            config (dict[str, Any]): Provider config payload.
+
+        Returns:
+            MemoryManagerConfigBuilder: The builder itself.
+        """
+
+class _MemoryManagerStoreBuilder:
+    """Memory-store builder for ``MemoryManagerConfigBuilder``."""
+    def __init__(self, root_builder: MemoryManagerConfigBuilder) -> None:
+        """Initializes a new instance of the ``_MemoryManagerStoreBuilder`` class.
+
+        Args:
+            root_builder (MemoryManagerConfigBuilder): Root builder.
+        """
+    def elasticsearch(self, *, host: str, port: int, collection_name: str, embedding_model_dims: int, user: str | None = None, password: str | None = None, auto_create_index: bool = ..., use_ssl: bool = ..., verify_certs: bool = ...) -> MemoryManagerConfigBuilder:
+        """Configure Elasticsearch-backed memory storage.
+
+        Args:
+            host (str): Elasticsearch host.
+            port (int): Elasticsearch port.
+            collection_name (str): Collection or index name.
+            embedding_model_dims (int): Embedding dimension count.
+            user (str | None, optional): Elasticsearch username. Defaults to None.
+            password (str | None, optional): Elasticsearch password. Defaults to None.
+            auto_create_index (bool, optional): Whether to auto-create index. Defaults to True.
+            use_ssl (bool, optional): Whether to use SSL. Defaults to False.
+            verify_certs (bool, optional): Whether to verify certificates. Defaults to False.
+
+        Returns:
+            MemoryManagerConfigBuilder: Root builder.
+        """
+    def register(self, provider: str, config: dict[str, Any] | None = None) -> MemoryManagerConfigBuilder:
+        """Register one generic memory-store provider without provider-specific defaults.
+
+        Args:
+            provider (str): Memory-store provider name passed through to the backend.
+            config (dict[str, Any] | None, optional): Provider config payload. Defaults to None.
+
+        Returns:
+            MemoryManagerConfigBuilder: Root builder.
+
+        Raises:
+            ValueError: If ``provider`` is empty.
+        """
+
+class _MemoryManagerEmbeddingBuilder:
+    """Embedding builder for ``MemoryManagerConfigBuilder``."""
+    def __init__(self, root_builder: MemoryManagerConfigBuilder) -> None:
+        """Initializes a new instance of the ``_MemoryManagerEmbeddingBuilder`` class.
+
+        Args:
+            root_builder (MemoryManagerConfigBuilder): Root builder.
+        """
+    def openai(self, *, model: str = ..., api_key: str | None = None) -> MemoryManagerConfigBuilder:
+        """Configure OpenAI embedding provider.
+
+        Args:
+            model (str, optional): Embedding model name. Defaults to ``text-embedding-3-small``.
+            api_key (str | None, optional): OpenAI API key. Defaults to None.
+
+        Returns:
+            MemoryManagerConfigBuilder: Root builder.
+        """
+    def register(self, em_invoker: Any, *, model: str | None = None, embedding_dims: int | None = None, invoke_kwargs: dict[str, Any] | None = None) -> MemoryManagerConfigBuilder:
+        """Register ``gllm_inference`` EM Invoker as the memory embedding backend.
+
+        Args:
+            em_invoker (Any): Configured EM Invoker instance.
+            model (str | None, optional): Optional model label stored in Mem0 config. Defaults to None.
+            embedding_dims (int | None, optional): Optional embedding dimension metadata. Defaults to None.
+            invoke_kwargs (dict[str, Any] | None, optional): Extra ``invoke`` kwargs. Defaults to None.
+
+        Returns:
+            MemoryManagerConfigBuilder: Root builder.
+
+        Raises:
+            ValueError: If ``em_invoker`` is ``None``.
+        """
+
+class _MemoryManagerLLMBuilder:
+    """LLM builder for ``MemoryManagerConfigBuilder``."""
+    def __init__(self, root_builder: MemoryManagerConfigBuilder) -> None:
+        """Initializes a new instance of the ``_MemoryManagerLLMBuilder`` class.
+
+        Args:
+            root_builder (MemoryManagerConfigBuilder): Root builder.
+        """
+    def register(self, lm_invoker: Any, *, model: str | None = None, temperature: float = 0.1, invoke_kwargs: dict[str, Any] | None = None) -> MemoryManagerConfigBuilder:
+        """Register ``gllm_inference`` LM Invoker as the memory LLM backend.
+
+        Args:
+            lm_invoker (Any): Configured LM Invoker instance.
+            model (str | None, optional): Optional model label stored in Mem0 config. Defaults to None.
+            temperature (float, optional): Temperature forwarded to adapter config. Defaults to 0.1.
+            invoke_kwargs (dict[str, Any] | None, optional): Extra ``invoke`` kwargs. Defaults to None.
+
+        Returns:
+            MemoryManagerConfigBuilder: Root builder.
+
+        Raises:
+            ValueError: If ``lm_invoker`` is ``None``.
+        """
+
+class _MemoryManagerRerankerBuilder:
+    """Reranker builder for ``MemoryManagerConfigBuilder``."""
+    def __init__(self, root_builder: MemoryManagerConfigBuilder) -> None:
+        """Initializes a new instance of the ``_MemoryManagerRerankerBuilder`` class.
+
+        Args:
+            root_builder (MemoryManagerConfigBuilder): Root builder.
+        """
+    def llm_reranker(self, *, llm_provider: str = ..., model: str | None = None, api_key: str | None = None, top_k: int | None = None, temperature: float = 0.0, max_tokens: int = 100, scoring_prompt: str | None = None, llm_config: dict[str, Any] | None = None) -> MemoryManagerConfigBuilder:
+        """Configure an LLM-based reranker.
+
+        Args:
+            llm_provider (str, optional): LLM provider used by the reranker. Defaults to ``openai``.
+            model (str | None, optional): Reranker LLM model name. Defaults to None.
+            api_key (str | None, optional): Provider API key. Defaults to None.
+            top_k (int | None, optional): Number of memories to keep after reranking. Defaults to None.
+            temperature (float, optional): Reranker LLM temperature. Defaults to 0.0.
+            max_tokens (int, optional): Maximum reranker LLM response tokens. Defaults to 100.
+            scoring_prompt (str | None, optional): Custom scoring prompt. Defaults to None.
+            llm_config (dict[str, Any] | None, optional): Extra nested LLM config. Defaults to None.
+
+        Returns:
+            MemoryManagerConfigBuilder: Root builder.
+
+        Raises:
+            ValueError: If ``llm_provider`` is empty.
+        """
+    def register(self, provider: str, config: dict[str, Any] | None = None) -> MemoryManagerConfigBuilder:
+        """Register one generic reranker provider without provider-specific defaults.
+
+        Args:
+            provider (str): Reranker provider name passed through to the backend.
+            config (dict[str, Any] | None, optional): Provider config payload. Defaults to None.
+
+        Returns:
+            MemoryManagerConfigBuilder: Root builder.
+
+        Raises:
+            ValueError: If ``provider`` is empty.
+        """
+
+def clone_memory_config_payload(config: dict[str, Any]) -> dict[str, Any]:
+    """Clone one config payload while preserving non-copyable runtime objects.
+
+    Args:
+        config (dict[str, Any]): Builder config.
+
+    Returns:
+        dict[str, Any]: Cloned config.
+    """

gllm_memory/builder/memory_manager_defaults.pyi

@@ -0,0 +1,99 @@
+from _typeshed import Incomplete
+from gllm_memory.backends.mem0.defaults import MEM0_HISTORY_DB_PATH_KEY as MEM0_HISTORY_DB_PATH_KEY, build_default_mem0_backend_options as build_default_mem0_backend_options
+from typing import Any
+
+DEFAULT_OPENAI_EMBEDDER_MODEL: str
+DEFAULT_OPENAI_LLM_MODEL: str
+DEFAULT_ELASTICSEARCH_AUTO_CREATE_INDEX: bool
+DEFAULT_ELASTICSEARCH_USE_SSL: bool
+DEFAULT_ELASTICSEARCH_VERIFY_CERTS: bool
+CONVERSATION_STORE_PATH_BACKEND_OPTION_KEY = MEM0_HISTORY_DB_PATH_KEY
+ELASTICSEARCH_HOST_ENV: str
+ELASTICSEARCH_PORT_ENV: str
+ELASTICSEARCH_USER_ENV: str
+ELASTICSEARCH_PASSWORD_ENV: str
+ELASTICSEARCH_COLLECTION_ENV: str
+ELASTICSEARCH_EMBEDDING_DIMS_ENV: str
+OPENAI_API_KEY_ENV: str
+OPENAI_BASE_URL_ENV: str
+OPENAI_MODEL_NAME_ENV: str
+logger: Incomplete
+
+def build_default_backend_options() -> dict[str, Any]:
+    """Build default backend options for the configured memory runtime.
+
+    Returns:
+        dict[str, Any]: Backend options for ``MemoryManagerConfig``.
+    """
+def get_required_env(name: str) -> str:
+    """Get one required environment variable or raise with an error log.
+
+    Args:
+        name (str): Environment variable name.
+
+    Returns:
+        str: Environment variable value.
+
+    Raises:
+        ValueError: If the environment variable is missing or empty.
+    """
+def get_optional_env(name: str) -> str | None:
+    """Get one optional environment variable.
+
+    Args:
+        name (str): Environment variable name.
+
+    Returns:
+        str | None: Environment variable value if present, else ``None``.
+    """
+def get_required_int_env(name: str) -> int:
+    """Get one required integer environment variable.
+
+    Args:
+        name (str): Environment variable name.
+
+    Returns:
+        int: Parsed integer value.
+
+    Raises:
+        ValueError: If the variable is missing or not an integer.
+    """
+def get_optional_int_env(name: str) -> int | None:
+    """Get one optional integer environment variable.
+
+    Args:
+        name (str): Environment variable name.
+
+    Returns:
+        int | None: Parsed integer value if present, else ``None``.
+
+    Raises:
+        ValueError: If the variable is set but not parseable as ``int``.
+    """
+def build_default_elasticsearch_config() -> dict[str, Any]:
+    """Build default Elasticsearch memory-store config from environment variables.
+
+    Returns:
+        dict[str, Any]: Elasticsearch provider config payload.
+
+    Raises:
+        ValueError: If required environment variables are missing or invalid.
+    """
+def build_default_openai_embedding_config() -> dict[str, Any]:
+    """Build default OpenAI EM Invoker config from environment variables.
+
+    Returns:
+        dict[str, Any]: ``gllm_inference`` embedding provider config payload.
+
+    Raises:
+        ValueError: If required environment variables are missing.
+    """
+def build_default_openai_llm_config() -> dict[str, Any]:
+    """Build default OpenAI LM Invoker config from environment variables.
+
+    Returns:
+        dict[str, Any]: ``gllm_inference`` provider config payload.
+
+    Raises:
+        ValueError: If required environment variables are missing.
+    """

gllm_memory/chat_history_manager/__init__.pyi

@@ -0,0 +1 @@
+from gllm_memory.chat_history_manager.chat_history_manager import ChatHistoryManager as ChatHistoryManager

gllm_memory/clients/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_memory.clients.constants import DATETIME_FULL_LENGTH as DATETIME_FULL_LENGTH, DATETIME_NO_SEC_LENGTH as DATETIME_NO_SEC_LENGTH, DATE_ONLY_LENGTH as DATE_ONLY_LENGTH, PEPPER as PEPPER, TIME_ONLY_LENGTH as TIME_ONLY_LENGTH
+
+__all__ = ['DATE_ONLY_LENGTH', 'DATETIME_FULL_LENGTH', 'DATETIME_NO_SEC_LENGTH', 'PEPPER', 'TIME_ONLY_LENGTH']

gllm_memory/clients/constants.pyi

@@ -0,0 +1,7 @@
+__all__ = ['DATE_ONLY_LENGTH', 'DATETIME_FULL_LENGTH', 'DATETIME_NO_SEC_LENGTH', 'PEPPER', 'TIME_ONLY_LENGTH']
+
+PEPPER: str
+DATETIME_FULL_LENGTH: int
+DATETIME_NO_SEC_LENGTH: int
+DATE_ONLY_LENGTH: int
+TIME_ONLY_LENGTH: int

gllm_memory/clients/mem0/__init__.pyi

@@ -0,0 +1,5 @@
+from gllm_memory.clients.mem0.core.mem0_base_client import Mem0BaseClient as Mem0BaseClient
+from gllm_memory.clients.mem0.http.mem0_client import Mem0Client as Mem0Client
+from gllm_memory.clients.mem0.sdk.mem0_sdk_client import DEFAULT_MIN_PAYLOADS_FOR_PARALLEL_PARSE as DEFAULT_MIN_PAYLOADS_FOR_PARALLEL_PARSE, Mem0SDKClient as Mem0SDKClient
+
+__all__ = ['DEFAULT_MIN_PAYLOADS_FOR_PARALLEL_PARSE', 'Mem0BaseClient', 'Mem0Client', 'Mem0SDKClient']

gllm_memory/clients/mem0/core/__init__.pyi

@@ -0,0 +1,3 @@
+from gllm_memory.clients.mem0.core.mem0_base_client import Mem0BaseClient as Mem0BaseClient
+
+__all__ = ['Mem0BaseClient']