MemoryOS 0.2.1__tar.gz → 0.2.2__tar.gz

{memoryos-0.2.1 → memoryos-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: MemoryOS
-Version: 0.2.1
+Version: 0.2.2
 Summary: Intelligence Begins with Memory
 License: Apache-2.0
 Keywords: memory,llm,language model,memoryOS,agent,kv cache,lora
@@ -35,6 +35,7 @@ Requires-Dist: ollama (>=0.4.8,<0.5.0)
 Requires-Dist: openai (>=1.77.0,<2.0.0)
 Requires-Dist: pika (>=1.3.2,<2.0.0) ; extra == "all"
 Requires-Dist: pika (>=1.3.2,<2.0.0) ; extra == "mem-scheduler"
+Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
 Requires-Dist: qdrant-client (>=1.14.2,<2.0.0) ; extra == "all"
 Requires-Dist: redis (>=6.2.0,<7.0.0) ; extra == "all"
 Requires-Dist: redis (>=6.2.0,<7.0.0) ; extra == "mem-scheduler"

{memoryos-0.2.1 → memoryos-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@
 ##############################################################################
 
 name = "MemoryOS"
-version = "0.2.1"
+version = "0.2.2"
 description = "Intelligence Begins with Memory"
 license = {text = "Apache-2.0"}
 readme = "README.md"
@@ -44,6 +44,7 @@ dependencies = [
     "sqlalchemy (>=2.0.41,<3.0.0)",  # SQL toolkit
     "scikit-learn (>=1.7.0,<2.0.0)",  # Machine learning
     "fastmcp (>=2.10.5,<3.0.0)",
+    "python-dateutil (>=2.9.0.post0,<3.0.0)",
 ]
 
 [project.urls]

{memoryos-0.2.1 → memoryos-0.2.2}/src/memos/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 from memos.configs.mem_cube import GeneralMemCubeConfig
 from memos.configs.mem_os import MOSConfig

{memoryos-0.2.1 → memoryos-0.2.2}/src/memos/api/config.py

@@ -1,3 +1,4 @@
+import json
 import os
 
 from typing import Any
@@ -115,6 +116,48 @@ class APIConfig:
                 },
             }
 
+    @staticmethod
+    def get_internet_config() -> dict[str, Any]:
+        """Get embedder configuration."""
+        return {
+            "backend": "xinyu",
+            "config": {
+                "api_key": os.getenv("XINYU_API_KEY"),
+                "search_engine_id": os.getenv("XINYU_SEARCH_ENGINE_ID"),
+                "max_results": 15,
+                "num_per_request": 10,
+                "reader": {
+                    "backend": "simple_struct",
+                    "config": {
+                        "llm": {
+                            "backend": "openai",
+                            "config": {
+                                "model_name_or_path": os.getenv("MEMRADER_MODEL"),
+                                "temperature": 0.6,
+                                "max_tokens": 5000,
+                                "top_p": 0.95,
+                                "top_k": 20,
+                                "api_key": "EMPTY",
+                                "api_base": os.getenv("MEMRADER_API_BASE"),
+                                "remove_think_prefix": True,
+                                "extra_body": {"chat_template_kwargs": {"enable_thinking": False}},
+                            },
+                        },
+                        "embedder": APIConfig.get_embedder_config(),
+                        "chunker": {
+                            "backend": "sentence",
+                            "config": {
+                                "tokenizer_or_token_counter": "gpt2",
+                                "chunk_size": 512,
+                                "chunk_overlap": 128,
+                                "min_sentences_per_chunk": 1,
+                            },
+                        },
+                    },
+                },
+            },
+        }
+
     @staticmethod
     def get_neo4j_community_config(user_id: str | None = None) -> dict[str, Any]:
         """Get Neo4j community configuration."""
@@ -126,14 +169,14 @@ class APIConfig:
             "user_name": f"memos{user_id.replace('-', '')}",
             "auto_create": True,
             "use_multi_db": False,
-            "embedding_dimension": 3072,
+            "embedding_dimension": int(os.getenv("EMBEDDING_DIMENSION", 3072)),
             "vec_config": {
                 # Pass nested config to initialize external vector DB
                 # If you use qdrant, please use Server instead of local mode.
                 "backend": "qdrant",
                 "config": {
                     "collection_name": "neo4j_vec_db",
-                    "vector_dimension": 3072,
+                    "vector_dimension": int(os.getenv("EMBEDDING_DIMENSION", 3072)),
                     "distance_metric": "cosine",
                     "host": "localhost",
                     "port": 6333,
@@ -159,7 +202,7 @@ class APIConfig:
             "password": os.getenv("NEO4J_PASSWORD", "12345678"),
             "auto_create": True,
             "use_multi_db": True,
-            "embedding_dimension": 3072,
+            "embedding_dimension": int(os.getenv("EMBEDDING_DIMENSION", 3072)),
         }
 
     @staticmethod
@@ -173,7 +216,33 @@ class APIConfig:
             "user_name": f"memos{user_id.replace('-', '')}",
             "auto_create": True,
             "use_multi_db": False,
-            "embedding_dimension": 3072,
+            "embedding_dimension": int(os.getenv("EMBEDDING_DIMENSION", 3072)),
+        }
+
+    @staticmethod
+    def get_nebular_config(user_id: str | None = None) -> dict[str, Any]:
+        """Get Nebular configuration."""
+        return {
+            "uri": json.loads(os.getenv("NEBULAR_HOSTS", '["localhost"]')),
+            "user": os.getenv("NEBULAR_USER", "root"),
+            "password": os.getenv("NEBULAR_PASSWORD", "xxxxxx"),
+            "space": os.getenv("NEBULAR_SPACE", "shared-tree-textual-memory"),
+            "user_name": f"memos{user_id.replace('-', '')}",
+            "use_multi_db": False,
+            "auto_create": True,
+            "embedding_dimension": int(os.getenv("EMBEDDING_DIMENSION", 3072)),
+        }
+
+    @staticmethod
+    def get_mysql_config() -> dict[str, Any]:
+        """Get MySQL configuration."""
+        return {
+            "host": os.getenv("MYSQL_HOST", "localhost"),
+            "port": int(os.getenv("MYSQL_PORT", "3306")),
+            "username": os.getenv("MYSQL_USERNAME", "root"),
+            "password": os.getenv("MYSQL_PASSWORD", "12345678"),
+            "database": os.getenv("MYSQL_DATABASE", "memos_users"),
+            "charset": os.getenv("MYSQL_CHARSET", "utf8mb4"),
         }
 
     @staticmethod
@@ -212,6 +281,34 @@ class APIConfig:
         """Check if default cube config is enabled via environment variable."""
         return os.getenv("MOS_ENABLE_DEFAULT_CUBE_CONFIG", "false").lower() == "true"
 
+    @staticmethod
+    def is_dingding_bot_enabled() -> bool:
+        """Check if DingDing bot is enabled via environment variable."""
+        return os.getenv("ENABLE_DINGDING_BOT", "false").lower() == "true"
+
+    @staticmethod
+    def get_dingding_bot_config() -> dict[str, Any] | None:
+        """Get DingDing bot configuration if enabled."""
+        if not APIConfig.is_dingding_bot_enabled():
+            return None
+
+        return {
+            "enabled": True,
+            "access_token_user": os.getenv("DINGDING_ACCESS_TOKEN_USER", ""),
+            "secret_user": os.getenv("DINGDING_SECRET_USER", ""),
+            "access_token_error": os.getenv("DINGDING_ACCESS_TOKEN_ERROR", ""),
+            "secret_error": os.getenv("DINGDING_SECRET_ERROR", ""),
+            "robot_code": os.getenv("DINGDING_ROBOT_CODE", ""),
+            "app_key": os.getenv("DINGDING_APP_KEY", ""),
+            "app_secret": os.getenv("DINGDING_APP_SECRET", ""),
+            "oss_endpoint": os.getenv("OSS_ENDPOINT", ""),
+            "oss_region": os.getenv("OSS_REGION", ""),
+            "oss_bucket_name": os.getenv("OSS_BUCKET_NAME", ""),
+            "oss_access_key_id": os.getenv("OSS_ACCESS_KEY_ID", ""),
+            "oss_access_key_secret": os.getenv("OSS_ACCESS_KEY_SECRET", ""),
+            "oss_public_base_url": os.getenv("OSS_PUBLIC_BASE_URL", ""),
+        }
+
     @staticmethod
     def get_product_default_config() -> dict[str, Any]:
         """Get default configuration for Product API."""
@@ -224,6 +321,7 @@ class APIConfig:
             "vllm": vllm_config,
         }
         backend = os.getenv("MOS_CHAT_MODEL_PROVIDER", "openai")
+        mysql_config = APIConfig.get_mysql_config()
         config = {
             "user_id": os.getenv("MOS_USER_ID", "root"),
             "chat_model": {"backend": backend, "config": backend_model[backend]},
@@ -260,6 +358,13 @@ class APIConfig:
         else:
             config["enable_mem_scheduler"] = False
 
+        # Add user manager configuration if enabled
+        if os.getenv("MOS_USER_MANAGER_BACKEND", "sqlite").lower() == "mysql":
+            config["user_manager"] = {
+                "backend": "mysql",
+                "config": mysql_config,
+            }
+
         return config
 
     @staticmethod
@@ -300,9 +405,9 @@ class APIConfig:
     def create_user_config(user_name: str, user_id: str) -> tuple[MOSConfig, GeneralMemCube]:
         """Create configuration for a specific user."""
         openai_config = APIConfig.get_openai_config()
-
         qwen_config = APIConfig.qwen_config()
         vllm_config = APIConfig.vllm_config()
+        mysql_config = APIConfig.get_mysql_config()
         backend = os.getenv("MOS_CHAT_MODEL_PROVIDER", "openai")
         backend_model = {
             "openai": openai_config,
@@ -341,7 +446,6 @@ class APIConfig:
             "top_k": 30,
             "max_turns_window": 20,
         }
-
         # Add scheduler configuration if enabled
         if APIConfig.is_scheduler_enabled():
             config_dict["mem_scheduler"] = APIConfig.get_scheduler_config()
@@ -349,11 +453,32 @@ class APIConfig:
         else:
             config_dict["enable_mem_scheduler"] = False
 
+        # Add user manager configuration if enabled
+        if os.getenv("MOS_USER_MANAGER_BACKEND", "sqlite").lower() == "mysql":
+            config_dict["user_manager"] = {
+                "backend": "mysql",
+                "config": mysql_config,
+            }
+
         default_config = MOSConfig(**config_dict)
 
-        if os.getenv("NEO4J_BACKEND", "neo4j_community").lower() == "neo4j_community":
-            neo4j_community_config = APIConfig.get_neo4j_community_config(user_id)
+        neo4j_community_config = APIConfig.get_neo4j_community_config(user_id)
+        neo4j_config = APIConfig.get_neo4j_config(user_id)
+        nebular_config = APIConfig.get_nebular_config(user_id)
+        internet_config = (
+            APIConfig.get_internet_config()
+            if os.getenv("ENABLE_INTERNET", "false").lower() == "true"
+            else None
+        )
+        graph_db_backend_map = {
+            "neo4j-community": neo4j_community_config,
+            "neo4j": neo4j_config,
+            "nebular": nebular_config,
+        }
+        graph_db_backend = os.getenv("NEO4J_BACKEND", "neo4j-community").lower()
+        if graph_db_backend in graph_db_backend_map:
             # Create MemCube config
+
             default_cube_config = GeneralMemCubeConfig.model_validate(
                 {
                     "user_id": user_id,
@@ -364,10 +489,11 @@ class APIConfig:
                             "extractor_llm": {"backend": "openai", "config": openai_config},
                             "dispatcher_llm": {"backend": "openai", "config": openai_config},
                             "graph_db": {
-                                "backend": "neo4j-community",
-                                "config": neo4j_community_config,
+                                "backend": graph_db_backend,
+                                "config": graph_db_backend_map[graph_db_backend],
                             },
                             "embedder": APIConfig.get_embedder_config(),
+                            "internet_retriever": internet_config,
                         },
                     },
                     "act_mem": {}
@@ -377,31 +503,7 @@ class APIConfig:
                 }
             )
         else:
-            neo4j_config = APIConfig.get_neo4j_config(user_id)
-            # Create MemCube config
-            default_cube_config = GeneralMemCubeConfig.model_validate(
-                {
-                    "user_id": user_id,
-                    "cube_id": f"{user_name}_default_cube",
-                    "text_mem": {
-                        "backend": "tree_text",
-                        "config": {
-                            "extractor_llm": {"backend": "openai", "config": openai_config},
-                            "dispatcher_llm": {"backend": "openai", "config": openai_config},
-                            "graph_db": {
-                                "backend": "neo4j",
-                                "config": neo4j_config,
-                            },
-                            "embedder": APIConfig.get_embedder_config(),
-                        },
-                    },
-                    "act_mem": {}
-                    if os.getenv("ENABLE_ACTIVATION_MEMORY", "false").lower() == "false"
-                    else APIConfig.get_activation_vllm_config(),
-                    "para_mem": {},
-                }
-            )
-
+            raise ValueError(f"Invalid Neo4j backend: {graph_db_backend}")
         default_mem_cube = GeneralMemCube(default_cube_config)
         return default_config, default_mem_cube
 
@@ -416,9 +518,21 @@ class APIConfig:
             return None
 
         openai_config = APIConfig.get_openai_config()
-
-        if os.getenv("NEO4J_BACKEND", "neo4j_community").lower() == "neo4j_community":
-            neo4j_community_config = APIConfig.get_neo4j_community_config(user_id="default")
+        neo4j_community_config = APIConfig.get_neo4j_community_config(user_id="default")
+        neo4j_config = APIConfig.get_neo4j_config(user_id="default")
+        nebular_config = APIConfig.get_nebular_config(user_id="default")
+        graph_db_backend_map = {
+            "neo4j-community": neo4j_community_config,
+            "neo4j": neo4j_config,
+            "nebular": nebular_config,
+        }
+        internet_config = (
+            APIConfig.get_internet_config()
+            if os.getenv("ENABLE_INTERNET", "false").lower() == "true"
+            else None
+        )
+        graph_db_backend = os.getenv("NEO4J_BACKEND", "neo4j-community").lower()
+        if graph_db_backend in graph_db_backend_map:
             return GeneralMemCubeConfig.model_validate(
                 {
                     "user_id": "default",
@@ -429,12 +543,13 @@ class APIConfig:
                             "extractor_llm": {"backend": "openai", "config": openai_config},
                             "dispatcher_llm": {"backend": "openai", "config": openai_config},
                             "graph_db": {
-                                "backend": "neo4j-community",
-                                "config": neo4j_community_config,
+                                "backend": graph_db_backend,
+                                "config": graph_db_backend_map[graph_db_backend],
                             },
                             "embedder": APIConfig.get_embedder_config(),
                             "reorganize": os.getenv("MOS_ENABLE_REORGANIZE", "false").lower()
                             == "true",
+                            "internet_retriever": internet_config,
                         },
                     },
                     "act_mem": {}
@@ -444,28 +559,4 @@ class APIConfig:
                 }
             )
         else:
-            neo4j_config = APIConfig.get_neo4j_config(user_id="default")
-            return GeneralMemCubeConfig.model_validate(
-                {
-                    "user_id": "default",
-                    "cube_id": "default_cube",
-                    "text_mem": {
-                        "backend": "tree_text",
-                        "config": {
-                            "extractor_llm": {"backend": "openai", "config": openai_config},
-                            "dispatcher_llm": {"backend": "openai", "config": openai_config},
-                            "graph_db": {
-                                "backend": "neo4j",
-                                "config": neo4j_config,
-                            },
-                            "embedder": APIConfig.get_embedder_config(),
-                            "reorganize": os.getenv("MOS_ENABLE_REORGANIZE", "false").lower()
-                            == "true",
-                        },
-                    },
-                    "act_mem": {}
-                    if os.getenv("ENABLE_ACTIVATION_MEMORY", "false").lower() == "false"
-                    else APIConfig.get_activation_vllm_config(),
-                    "para_mem": {},
-                }
-            )
+            raise ValueError(f"Invalid Neo4j backend: {graph_db_backend}")

memoryos-0.2.2/src/memos/api/context/context.py

@@ -0,0 +1,147 @@
+"""
+Global request context management for trace_id and request-scoped data.
+
+This module provides optional trace_id functionality that can be enabled
+when using the API components. It uses ContextVar to ensure thread safety
+and request isolation.
+"""
+
+import uuid
+
+from collections.abc import Callable
+from contextvars import ContextVar
+from typing import Any
+
+
+# Global context variable for request-scoped data
+_request_context: ContextVar[dict[str, Any] | None] = ContextVar("request_context", default=None)
+
+
+class RequestContext:
+    """
+    Request-scoped context object that holds trace_id and other request data.
+
+    This provides a Flask g-like object for FastAPI applications.
+    """
+
+    def __init__(self, trace_id: str | None = None):
+        self.trace_id = trace_id or str(uuid.uuid4())
+        self._data: dict[str, Any] = {}
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a value in the context."""
+        self._data[key] = value
+
+    def get(self, key: str, default: Any | None = None) -> Any:
+        """Get a value from the context."""
+        return self._data.get(key, default)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name.startswith("_") or name == "trace_id":
+            super().__setattr__(name, value)
+        else:
+            if not hasattr(self, "_data"):
+                super().__setattr__(name, value)
+            else:
+                self._data[name] = value
+
+    def __getattr__(self, name: str) -> Any:
+        if hasattr(self, "_data") and name in self._data:
+            return self._data[name]
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert context to dictionary."""
+        return {"trace_id": self.trace_id, "data": self._data.copy()}
+
+
+def set_request_context(context: RequestContext) -> None:
+    """
+    Set the current request context.
+
+    This is typically called by the API dependency injection system.
+    """
+    _request_context.set(context.to_dict())
+
+
+def get_current_trace_id() -> str | None:
+    """
+    Get the current request's trace_id.
+
+    Returns:
+        The trace_id if available, None otherwise.
+    """
+    context = _request_context.get()
+    if context:
+        return context.get("trace_id")
+    return None
+
+
+def get_current_context() -> RequestContext | None:
+    """
+    Get the current request context.
+
+    Returns:
+        The current RequestContext if available, None otherwise.
+    """
+    context_dict = _request_context.get()
+    if context_dict:
+        ctx = RequestContext(trace_id=context_dict.get("trace_id"))
+        ctx._data = context_dict.get("data", {}).copy()
+        return ctx
+    return None
+
+
+def require_context() -> RequestContext:
+    """
+    Get the current request context, raising an error if not available.
+
+    Returns:
+        The current RequestContext.
+
+    Raises:
+        RuntimeError: If called outside of a request context.
+    """
+    context = get_current_context()
+    if context is None:
+        raise RuntimeError(
+            "No request context available. This function must be called within a request handler."
+        )
+    return context
+
+
+# Type for trace_id getter function
+TraceIdGetter = Callable[[], str | None]
+
+# Global variable to hold the trace_id getter function
+_trace_id_getter: TraceIdGetter | None = None
+
+
+def set_trace_id_getter(getter: TraceIdGetter) -> None:
+    """
+    Set a custom trace_id getter function.
+
+    This allows the logging system to retrieve trace_id without importing
+    API-specific modules.
+    """
+    global _trace_id_getter
+    _trace_id_getter = getter
+
+
+def get_trace_id_for_logging() -> str | None:
+    """
+    Get trace_id for logging purposes.
+
+    This function is used by the logging system and will use either
+    the custom getter function or fall back to the default context.
+    """
+    if _trace_id_getter:
+        try:
+            return _trace_id_getter()
+        except Exception:
+            pass
+    return get_current_trace_id()
+
+
+# Initialize the default trace_id getter
+set_trace_id_getter(get_current_trace_id)

memoryos-0.2.2/src/memos/api/context/dependencies.py

@@ -0,0 +1,90 @@
+import logging
+
+from fastapi import Depends, Header, Request
+
+from memos.api.context.context import RequestContext, set_request_context
+
+
+logger = logging.getLogger(__name__)
+
+# Type alias for the RequestContext from context module
+G = RequestContext
+
+
+def get_trace_id_from_header(
+    trace_id: str | None = Header(None, alias="trace-id"),
+    x_trace_id: str | None = Header(None, alias="x-trace-id"),
+    g_trace_id: str | None = Header(None, alias="g-trace-id"),
+) -> str | None:
+    """
+    Extract trace_id from various possible headers.
+
+    Priority: g-trace-id > x-trace-id > trace-id
+    """
+    return g_trace_id or x_trace_id or trace_id
+
+
+def get_request_context(
+    request: Request, trace_id: str | None = Depends(get_trace_id_from_header)
+) -> RequestContext:
+    """
+    Get request context object with trace_id and request metadata.
+
+    This function creates a RequestContext and automatically sets it
+    in the global context for use throughout the request lifecycle.
+    """
+    # Create context object
+    ctx = RequestContext(trace_id=trace_id)
+
+    # Set the context globally for this request
+    set_request_context(ctx)
+
+    # Log request start
+    logger.info(f"Request started with trace_id: {ctx.trace_id}")
+
+    # Add request metadata to context
+    ctx.set("method", request.method)
+    ctx.set("path", request.url.path)
+    ctx.set("client_ip", request.client.host if request.client else None)
+
+    return ctx
+
+
+def get_g_object(trace_id: str | None = Depends(get_trace_id_from_header)) -> G:
+    """
+    Get Flask g-like object for the current request.
+
+    This creates a RequestContext and sets it globally for access
+    throughout the request lifecycle.
+    """
+    g = RequestContext(trace_id=trace_id)
+    set_request_context(g)
+    logger.info(f"Request g object created with trace_id: {g.trace_id}")
+    return g
+
+
+def get_current_g() -> G | None:
+    """
+    Get the current request's g object from anywhere in the application.
+
+    Returns:
+        The current request's g object if available, None otherwise.
+    """
+    from memos.context import get_current_context
+
+    return get_current_context()
+
+
+def require_g() -> G:
+    """
+    Get the current request's g object, raising an error if not available.
+
+    Returns:
+        The current request's g object.
+
+    Raises:
+        RuntimeError: If called outside of a request context.
+    """
+    from memos.context import require_context
+
+    return require_context()

{memoryos-0.2.1 → memoryos-0.2.2}/src/memos/api/product_models.py

@@ -83,11 +83,12 @@ class ChatRequest(BaseRequest):
     query: str = Field(..., description="Chat query message")
     mem_cube_id: str | None = Field(None, description="Cube ID to use for chat")
     history: list[MessageDict] | None = Field(None, description="Chat history")
+    internet_search: bool = Field(True, description="Whether to use internet search")
 
 
 class UserCreate(BaseRequest):
     user_name: str | None = Field(None, description="Name of the user")
-    role: str = Field("user", description="Role of the user")
+    role: str = Field("USER", description="Role of the user")
     user_id: str = Field(..., description="User ID")
 
 
@@ -142,6 +143,8 @@ class MemoryCreateRequest(BaseRequest):
     memory_content: str | None = Field(None, description="Memory content to store")
     doc_path: str | None = Field(None, description="Path to document to store")
     mem_cube_id: str | None = Field(None, description="Cube ID")
+    source: str | None = Field(None, description="Source of the memory")
+    user_profile: bool = Field(False, description="User profile memory")
 
 
 class SearchRequest(BaseRequest):
@@ -150,6 +153,7 @@ class SearchRequest(BaseRequest):
     user_id: str = Field(..., description="User ID")
     query: str = Field(..., description="Search query")
     mem_cube_id: str | None = Field(None, description="Cube ID to search in")
+    top_k: int = Field(10, description="Number of results to return")
 
 
 class SuggestionRequest(BaseRequest):