MemoryOS 0.2.2__tar.gz → 1.0.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: MemoryOS
-Version: 0.2.2
+Version: 1.0.1
 Summary: Intelligence Begins with Memory
 License: Apache-2.0
 Keywords: memory,llm,language model,memoryOS,agent,kv cache,lora
@@ -310,6 +310,12 @@ MemOS is licensed under the [Apache 2.0 License](./LICENSE).
 
 Stay up to date with the latest MemOS announcements, releases, and community highlights.
 
+
+- **2025-09-10** - 🎉 *MemOS v1.0.1 (Group Q&A Bot)*: Group Q&A bot based on MemOS Cube, updated KV-Cache performance comparison data across different GPU deployment schemes, optimized test benchmarks and statistics, added plaintext memory Reranker sorting, optimized plaintext memory hallucination issues, and Playground version updates. [Try PlayGround](https://memos-playground.openmem.net/login/)
+- **2025-08-07** - 🎉 *MemOS v1.0.0 (MemCube Release)*: First MemCube with word game demo, LongMemEval evaluation, BochaAISearchRetriever integration, NebulaGraph support, enhanced search capabilities, and official Playground launch.
+- **2025-07-29** – 🎉 *MemOS v0.2.2 (Nebula Update)*: Internet search+Nebula DB integration, refactored memory scheduler, KV Cache stress tests, MemCube Cookbook release (CN/EN), and 4b/1.7b/0.6b memory ops models.
+- **2025-07-21** – 🎉 *MemOS v0.2.1 (Neo Release)*: Lightweight Neo version with plaintext+KV Cache functionality, Docker/multi-tenant support, MCP expansion, and new Cookbook/Mud game examples.
+- **2025-07-11** – 🎉 *MemOS v0.2.0 (Cross-Platform)*: Added doc search/bilingual UI, MemReader-4B (local deploy), full Win/Mac/Linux support, and playground end-to-end connection.
 - **2025-07-07** – 🎉 *MemOS 1.0 (Stellar) Preview Release*: A SOTA Memory OS for LLMs is now open-sourced.
 - **2025-07-04** – 🎉 *MemOS Paper Released*: [MemOS: A Memory OS for AI System](https://arxiv.org/abs/2507.03724) was published on arXiv.
 - **2025-05-28** – 🎉 *Short Paper Uploaded*: [MemOS: An Operating System for Memory-Augmented Generation (MAG) in Large Language Models](https://arxiv.org/abs/2505.22101) was published on arXiv.

{memoryos-0.2.2 → memoryos-1.0.1}/README.md

@@ -251,6 +251,12 @@ MemOS is licensed under the [Apache 2.0 License](./LICENSE).
 
 Stay up to date with the latest MemOS announcements, releases, and community highlights.
 
+
+- **2025-09-10** - 🎉 *MemOS v1.0.1 (Group Q&A Bot)*: Group Q&A bot based on MemOS Cube, updated KV-Cache performance comparison data across different GPU deployment schemes, optimized test benchmarks and statistics, added plaintext memory Reranker sorting, optimized plaintext memory hallucination issues, and Playground version updates. [Try PlayGround](https://memos-playground.openmem.net/login/)
+- **2025-08-07** - 🎉 *MemOS v1.0.0 (MemCube Release)*: First MemCube with word game demo, LongMemEval evaluation, BochaAISearchRetriever integration, NebulaGraph support, enhanced search capabilities, and official Playground launch.
+- **2025-07-29** – 🎉 *MemOS v0.2.2 (Nebula Update)*: Internet search+Nebula DB integration, refactored memory scheduler, KV Cache stress tests, MemCube Cookbook release (CN/EN), and 4b/1.7b/0.6b memory ops models.
+- **2025-07-21** – 🎉 *MemOS v0.2.1 (Neo Release)*: Lightweight Neo version with plaintext+KV Cache functionality, Docker/multi-tenant support, MCP expansion, and new Cookbook/Mud game examples.
+- **2025-07-11** – 🎉 *MemOS v0.2.0 (Cross-Platform)*: Added doc search/bilingual UI, MemReader-4B (local deploy), full Win/Mac/Linux support, and playground end-to-end connection.
 - **2025-07-07** – 🎉 *MemOS 1.0 (Stellar) Preview Release*: A SOTA Memory OS for LLMs is now open-sourced.
 - **2025-07-04** – 🎉 *MemOS Paper Released*: [MemOS: A Memory OS for AI System](https://arxiv.org/abs/2507.03724) was published on arXiv.
 - **2025-05-28** – 🎉 *Short Paper Uploaded*: [MemOS: An Operating System for Memory-Augmented Generation (MAG) in Large Language Models](https://arxiv.org/abs/2505.22101) was published on arXiv.

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

@@ -4,7 +4,7 @@
 ##############################################################################
 
 name = "MemoryOS"
-version = "0.2.2"
+version = "1.0.1"
 description = "Intelligence Begins with Memory"
 license = {text = "Apache-2.0"}
 readme = "README.md"

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

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

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

@@ -90,6 +90,29 @@ class APIConfig:
             },
         }
 
+    @staticmethod
+    def get_reranker_config() -> dict[str, Any]:
+        """Get embedder configuration."""
+        embedder_backend = os.getenv("MOS_RERANKER_BACKEND", "http_bge")
+
+        if embedder_backend == "http_bge":
+            return {
+                "backend": "http_bge",
+                "config": {
+                    "url": os.getenv("MOS_RERANKER_URL"),
+                    "model": "bge-reranker-v2-m3",
+                    "timeout": 10,
+                },
+            }
+        else:
+            return {
+                "backend": "cosine_local",
+                "config": {
+                    "level_weights": {"topic": 1.0, "concept": 1.0, "fact": 1.0},
+                    "level_field": "background",
+                },
+            }
+
     @staticmethod
     def get_embedder_config() -> dict[str, Any]:
         """Get embedder configuration."""
@@ -100,9 +123,9 @@ class APIConfig:
                 "backend": "universal_api",
                 "config": {
                     "provider": os.getenv("MOS_EMBEDDER_PROVIDER", "openai"),
-                    "api_key": os.getenv("OPENAI_API_KEY", "sk-xxxx"),
+                    "api_key": os.getenv("MOS_EMBEDDER_API_KEY", "sk-xxxx"),
                     "model_name_or_path": os.getenv("MOS_EMBEDDER_MODEL", "text-embedding-3-large"),
-                    "base_url": os.getenv("OPENAI_API_BASE", "http://openai.com"),
+                    "base_url": os.getenv("MOS_EMBEDDER_API_BASE", "http://openai.com"),
                 },
             }
         else:  # ollama
@@ -120,10 +143,9 @@ class APIConfig:
     def get_internet_config() -> dict[str, Any]:
         """Get embedder configuration."""
         return {
-            "backend": "xinyu",
+            "backend": "bocha",
             "config": {
-                "api_key": os.getenv("XINYU_API_KEY"),
-                "search_engine_id": os.getenv("XINYU_SEARCH_ENGINE_ID"),
+                "api_key": os.getenv("BOCHA_API_KEY"),
                 "max_results": 15,
                 "num_per_request": 10,
                 "reader": {
@@ -137,7 +159,7 @@ class APIConfig:
                                 "max_tokens": 5000,
                                 "top_p": 0.95,
                                 "top_k": 20,
-                                "api_key": "EMPTY",
+                                "api_key": os.getenv("MEMRADER_API_KEY", "EMPTY"),
                                 "api_base": os.getenv("MEMRADER_API_BASE"),
                                 "remove_think_prefix": True,
                                 "extra_body": {"chat_template_kwargs": {"enable_thinking": False}},
@@ -252,7 +274,6 @@ class APIConfig:
             "backend": "general_scheduler",
             "config": {
                 "top_k": int(os.getenv("MOS_SCHEDULER_TOP_K", "10")),
-                "top_n": int(os.getenv("MOS_SCHEDULER_TOP_N", "5")),
                 "act_mem_update_interval": int(
                     os.getenv("MOS_SCHEDULER_ACT_MEM_UPDATE_INTERVAL", "300")
                 ),
@@ -267,7 +288,7 @@ class APIConfig:
                     "MOS_SCHEDULER_ENABLE_PARALLEL_DISPATCH", "true"
                 ).lower()
                 == "true",
-                "enable_act_memory_update": True,
+                "enable_activation_memory": True,
             },
         }
 
@@ -494,6 +515,7 @@ class APIConfig:
                             },
                             "embedder": APIConfig.get_embedder_config(),
                             "internet_retriever": internet_config,
+                            "reranker": APIConfig.get_reranker_config(),
                         },
                     },
                     "act_mem": {}
@@ -547,6 +569,7 @@ class APIConfig:
                                 "config": graph_db_backend_map[graph_db_backend],
                             },
                             "embedder": APIConfig.get_embedder_config(),
+                            "reranker": APIConfig.get_reranker_config(),
                             "reorganize": os.getenv("MOS_ENABLE_REORGANIZE", "false").lower()
                             == "true",
                             "internet_retriever": internet_config,

{memoryos-0.2.2 → memoryos-1.0.1}/src/memos/api/context/context.py

@@ -122,7 +122,7 @@ 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.
+    API-specific general_modules.
     """
     global _trace_id_getter
     _trace_id_getter = getter

memoryos-1.0.1/src/memos/api/context/context_thread.py

@@ -0,0 +1,96 @@
+import functools
+import threading
+
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, TypeVar
+
+from memos.api.context.context import (
+    RequestContext,
+    get_current_context,
+    get_current_trace_id,
+    set_request_context,
+)
+
+
+T = TypeVar("T")
+
+
+class ContextThread(threading.Thread):
+    """
+    Thread class that automatically propagates the main thread's trace_id to child threads.
+    """
+
+    def __init__(self, target, args=(), kwargs=None, **thread_kwargs):
+        super().__init__(**thread_kwargs)
+        self.target = target
+        self.args = args
+        self.kwargs = kwargs or {}
+
+        self.main_trace_id = get_current_trace_id()
+        self.main_context = get_current_context()
+
+    def run(self):
+        # Create a new RequestContext with the main thread's trace_id
+        if self.main_context:
+            # Copy the context data
+            child_context = RequestContext(trace_id=self.main_trace_id)
+            child_context._data = self.main_context._data.copy()
+
+            # Set the context in the child thread
+            set_request_context(child_context)
+
+        # Run the target function
+        self.target(*self.args, **self.kwargs)
+
+
+class ContextThreadPoolExecutor(ThreadPoolExecutor):
+    """
+    ThreadPoolExecutor that automatically propagates the main thread's trace_id to worker threads.
+    """
+
+    def submit(self, fn: Callable[..., T], *args: Any, **kwargs: Any) -> Any:
+        """
+        Submit a callable to be executed with the given arguments.
+        Automatically propagates the current thread's context to the worker thread.
+        """
+        main_trace_id = get_current_trace_id()
+        main_context = get_current_context()
+
+        @functools.wraps(fn)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            if main_context:
+                # Create and set new context in worker thread
+                child_context = RequestContext(trace_id=main_trace_id)
+                child_context._data = main_context._data.copy()
+                set_request_context(child_context)
+
+            return fn(*args, **kwargs)
+
+        return super().submit(wrapper, *args, **kwargs)
+
+    def map(
+        self,
+        fn: Callable[..., T],
+        *iterables: Any,
+        timeout: float | None = None,
+        chunksize: int = 1,
+    ) -> Any:
+        """
+        Returns an iterator equivalent to map(fn, iter).
+        Automatically propagates the current thread's context to worker threads.
+        """
+        main_trace_id = get_current_trace_id()
+        main_context = get_current_context()
+
+        @functools.wraps(fn)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            if main_context:
+                # Create and set new context in worker thread
+                child_context = RequestContext(trace_id=main_trace_id)
+                child_context._data = main_context._data.copy()
+                set_request_context(child_context)
+
+            return fn(*args, **kwargs)
+
+        return super().map(wrapper, *iterables, timeout=timeout, chunksize=chunksize)

memoryos-1.0.1/src/memos/api/middleware/request_context.py

@@ -0,0 +1,94 @@
+"""
+Request context middleware for automatic trace_id injection.
+"""
+
+import logging
+import os
+
+from collections.abc import Callable
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+from memos.api.context.context import RequestContext, set_request_context
+
+
+logger = logging.getLogger(__name__)
+
+
+def generate_trace_id() -> str:
+    """Generate a random trace_id."""
+    return os.urandom(16).hex()
+
+
+def extract_trace_id_from_headers(request: Request) -> str | None:
+    """Extract trace_id from various possible headers with priority: g-trace-id > x-trace-id > trace-id."""
+    trace_id = request.headers.get("g-trace-id")
+    if trace_id:
+        return trace_id
+
+    trace_id = request.headers.get("x-trace-id")
+    if trace_id:
+        return trace_id
+
+    trace_id = request.headers.get("trace-id")
+    if trace_id:
+        return trace_id
+
+    return None
+
+
+class RequestContextMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware to automatically inject request context for every HTTP request.
+
+    This middleware:
+    1. Extracts trace_id from headers or generates a new one
+    2. Creates a RequestContext and sets it globally
+    3. Ensures the context is available throughout the request lifecycle
+    """
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        # Extract or generate trace_id
+        trace_id = extract_trace_id_from_headers(request)
+        if not trace_id:
+            trace_id = generate_trace_id()
+
+        # Create and set request context
+        context = RequestContext(trace_id=trace_id)
+        set_request_context(context)
+
+        # Add request metadata to context
+        context.set("method", request.method)
+        context.set("path", request.url.path)
+        context.set("client_ip", request.client.host if request.client else None)
+
+        # Log request start with parameters
+        params_log = {}
+
+        # Get query parameters
+        if request.query_params:
+            params_log["query_params"] = dict(request.query_params)
+
+        # Get request body if it's available
+        try:
+            params_log = await request.json()
+        except Exception as e:
+            logger.error(f"Error getting request body: {e}")
+            # If body is not JSON or empty, ignore it
+
+        logger.info(
+            f"Request started: {request.method} {request.url.path} - Parameters: {params_log}"
+        )
+
+        # Process the request
+        response = await call_next(request)
+
+        # Log request completion with output
+        logger.info(f"Request completed: {request.url.path}, status: {response.status_code}")
+
+        # Add trace_id to response headers for debugging
+        response.headers["x-trace-id"] = trace_id
+
+        return response

{memoryos-0.2.2 → memoryos-1.0.1}/src/memos/api/product_api.py

@@ -3,6 +3,7 @@ import logging
 from fastapi import FastAPI
 
 from memos.api.exceptions import APIExceptionHandler
+from memos.api.middleware.request_context import RequestContextMiddleware
 from memos.api.routers.product_router import router as product_router
 
 
@@ -13,9 +14,12 @@ logger = logging.getLogger(__name__)
 app = FastAPI(
     title="MemOS Product REST APIs",
     description="A REST API for managing multiple users with MemOS Product.",
-    version="1.0.0",
+    version="1.0.1",
 )
 
+# Add request context middleware (must be added first)
+app.add_middleware(RequestContextMiddleware)
+
 # Include routers
 app.include_router(product_router)
 

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

@@ -84,6 +84,21 @@ class ChatRequest(BaseRequest):
     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")
+    moscube: bool = Field(False, description="Whether to use MemOSCube")
+
+
+class ChatCompleteRequest(BaseRequest):
+    """Request model for chat operations."""
+
+    user_id: str = Field(..., description="User ID")
+    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(False, description="Whether to use internet search")
+    moscube: bool = Field(False, description="Whether to use MemOSCube")
+    base_prompt: str | None = Field(None, description="Base prompt to use for chat")
+    top_k: int = Field(10, description="Number of results to return")
+    threshold: float = Field(0.5, description="Threshold for filtering references")
 
 
 class UserCreate(BaseRequest):
@@ -161,3 +176,4 @@ class SuggestionRequest(BaseRequest):
 
     user_id: str = Field(..., description="User ID")
     language: Literal["zh", "en"] = Field("zh", description="Language for suggestions")
+    message: list[MessageDict] | None = Field(None, description="List of messages to store.")

{memoryos-0.2.2 → memoryos-1.0.1}/src/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."""

{memoryos-0.2.2 → memoryos-1.0.1}/src/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."""

{memoryos-0.2.2 → memoryos-1.0.1}/src/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")

{memoryos-0.2.2 → memoryos-1.0.1}/src/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

{memoryos-0.2.2 → memoryos-1.0.1}/src/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 ──────────────────────────────────────────