MemoryOS 0.2.2__py3-none-any.whl → 1.0.1__py3-none-any.whl

memos/api/routers/product_router.py

@@ -1,5 +1,4 @@
 import json
-import logging
 import traceback
 
 from datetime import datetime
@@ -12,6 +11,7 @@ from memos.api.config import APIConfig
 from memos.api.context.dependencies import G, get_g_object
 from memos.api.product_models import (
     BaseResponse,
+    ChatCompleteRequest,
     ChatRequest,
     GetMemoryRequest,
     MemoryCreateRequest,
@@ -25,11 +25,12 @@ from memos.api.product_models import (
     UserRegisterResponse,
 )
 from memos.configs.mem_os import MOSConfig
+from memos.log import get_logger
 from memos.mem_os.product import MOSProduct
 from memos.memos_tools.notification_service import get_error_bot_function, get_online_bot_function
 
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 router = APIRouter(prefix="/product", tags=["Product API"])
 
@@ -148,7 +149,9 @@ def get_suggestion_queries_post(suggestion_req: SuggestionRequest):
     try:
         mos_product = get_mos_product_instance()
         suggestions = mos_product.get_suggestion_query(
-            user_id=suggestion_req.user_id, language=suggestion_req.language
+            user_id=suggestion_req.user_id,
+            language=suggestion_req.language,
+            message=suggestion_req.message,
         )
         return SuggestionResponse(
             message="Suggestions retrieved successfully", data={"query": suggestions}
@@ -246,6 +249,7 @@ def chat(chat_req: ChatRequest):
                     cube_id=chat_req.mem_cube_id,
                     history=chat_req.history,
                     internet_search=chat_req.internet_search,
+                    moscube=chat_req.moscube,
                 )
 
             except Exception as e:
@@ -273,6 +277,38 @@ def chat(chat_req: ChatRequest):
         raise HTTPException(status_code=500, detail=str(traceback.format_exc())) from err
 
 
+@router.post("/chat/complete", summary="Chat with MemOS (Complete Response)")
+def chat_complete(chat_req: ChatCompleteRequest):
+    """Chat with MemOS for a specific user. Returns complete response (non-streaming)."""
+    try:
+        mos_product = get_mos_product_instance()
+
+        # Collect all responses from the generator
+        content, references = mos_product.chat(
+            query=chat_req.query,
+            user_id=chat_req.user_id,
+            cube_id=chat_req.mem_cube_id,
+            history=chat_req.history,
+            internet_search=chat_req.internet_search,
+            moscube=chat_req.moscube,
+            base_prompt=chat_req.base_prompt,
+            top_k=chat_req.top_k,
+            threshold=chat_req.threshold,
+        )
+
+        # Return the complete response
+        return {
+            "message": "Chat completed successfully",
+            "data": {"response": content, "references": references},
+        }
+
+    except ValueError as err:
+        raise HTTPException(status_code=404, detail=str(traceback.format_exc())) from err
+    except Exception as err:
+        logger.error(f"Failed to start chat: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=str(traceback.format_exc())) from err
+
+
 @router.get("/users", summary="List all users", response_model=BaseResponse[list])
 def list_users():
     """List all registered users."""

memos/api/start_api.py

@@ -9,6 +9,7 @@ from fastapi.requests import Request
 from fastapi.responses import JSONResponse, RedirectResponse
 from pydantic import BaseModel, Field
 
+from memos.api.middleware.request_context import RequestContextMiddleware
 from memos.configs.mem_os import MOSConfig
 from memos.mem_os.main import MOS
 from memos.mem_user.user_manager import UserManager, UserRole
@@ -78,6 +79,8 @@ app = FastAPI(
     version="1.0.0",
 )
 
+app.add_middleware(RequestContextMiddleware)
+
 
 class BaseRequest(BaseModel):
     """Base model for all requests."""

memos/configs/internet_retriever.py

@@ -55,6 +55,18 @@ class XinyuSearchConfig(BaseInternetRetrieverConfig):
     )
 
 
+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."""
 
@@ -69,6 +81,7 @@ class InternetRetrieverConfigFactory(BaseConfig):
         "google": GoogleCustomSearchConfig,
         "bing": BingSearchConfig,
         "xinyu": XinyuSearchConfig,
+        "bocha": BochaSearchConfig,
     }
 
     @field_validator("backend")

memos/configs/mem_scheduler.py

@@ -6,7 +6,7 @@ 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.misc import DictConversionMixin
+from memos.mem_scheduler.general_modules.misc import DictConversionMixin
 from memos.mem_scheduler.schemas.general_schemas import (
     BASE_DIR,
     DEFAULT_ACT_MEM_DUMP_PATH,
@@ -21,8 +21,6 @@ class BaseSchedulerConfig(BaseConfig):
     top_k: int = Field(
         default=10, description="Number of top candidates to consider in initial retrieval"
     )
-    # TODO: The 'top_n' field is deprecated and will be removed in future versions.
-    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"
     )
@@ -45,6 +43,7 @@ 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"
     )
@@ -55,9 +54,15 @@ class GeneralSchedulerConfig(BaseSchedulerConfig):
         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):
@@ -137,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/memory.py

@@ -7,6 +7,7 @@ from memos.configs.embedder import EmbedderConfigFactory
 from memos.configs.graph_db import GraphDBConfigFactory
 from memos.configs.internet_retriever import InternetRetrieverConfigFactory
 from memos.configs.llm import LLMConfigFactory
+from memos.configs.reranker import RerankerConfigFactory
 from memos.configs.vec_db import VectorDBConfigFactory
 from memos.exceptions import ConfigurationError
 
@@ -151,6 +152,10 @@ class TreeTextMemoryConfig(BaseTextMemoryConfig):
         default_factory=EmbedderConfigFactory,
         description="Embedder configuration for the memory embedding",
     )
+    reranker: RerankerConfigFactory | None = Field(
+        None,
+        description="Reranker configuration (optional, defaults to cosine_local).",
+    )
     graph_db: GraphDBConfigFactory = Field(
         ...,
         default_factory=GraphDBConfigFactory,
@@ -166,6 +171,14 @@ class TreeTextMemoryConfig(BaseTextMemoryConfig):
         description="Optional description for this memory configuration.",
     )
 
+    memory_size: dict[str, Any] | None = Field(
+        default=None,
+        description=(
+            "Maximum item counts per memory bucket, e.g.: "
+            '{"WorkingMemory": 20, "LongTermMemory": 10000, "UserMemory": 10000}'
+        ),
+    )
+
 
 # ─── 3. Global Memory Config Factory ──────────────────────────────────────────
 

memos/configs/reranker.py

@@ -0,0 +1,18 @@
+# memos/configs/reranker.py
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class RerankerConfigFactory(BaseModel):
+    """
+    {
+      "backend": "http_bge" | "cosine_local" | "noop",
+      "config": { ... backend-specific ... }
+    }
+    """
+
+    backend: str = Field(..., description="Reranker backend id")
+    config: dict[str, Any] = Field(default_factory=dict, description="Backend-specific options")

memos/graph_dbs/base.py

@@ -70,15 +70,29 @@ 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, **kwargs
+    ) -> 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"
@@ -129,7 +143,7 @@ class BaseGraphDB(ABC):
 
     # Search / recall operations
     @abstractmethod
-    def search_by_embedding(self, vector: list[float], top_k: int = 5) -> list[dict]:
+    def search_by_embedding(self, vector: list[float], top_k: int = 5, **kwargs) -> list[dict]:
         """
         Retrieve node IDs based on vector similarity.
 
@@ -163,7 +177,9 @@ class BaseGraphDB(ABC):
         """
 
     @abstractmethod
-    def get_structure_optimization_candidates(self, scope: str) -> list[dict]:
+    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.
@@ -205,7 +221,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.
 
@@ -221,3 +237,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.
+        """