Merge branch 'dev' into dev

Author: fridayL

README.md

@@ -252,6 +252,7 @@ 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.

pyproject.toml

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

src/memos/__init__.py

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

src/memos/api/config.py

@@ -21,7 +21,7 @@ class APIConfig:
     def get_openai_config() -> dict[str, Any]:
         """Get OpenAI configuration."""
         return {
-            "model_name_or_path": os.getenv("MOS_OPENAI_MODEL", "gpt-4o-mini"),
+            "model_name_or_path": os.getenv("MOS_CHAT_MODEL", "gpt-4o-mini"),
             "temperature": float(os.getenv("MOS_CHAT_TEMPERATURE", "0.8")),
             "max_tokens": int(os.getenv("MOS_MAX_TOKENS", "1024")),
             "top_p": float(os.getenv("MOS_TOP_P", "0.9")),

src/memos/api/context/context.py

@@ -6,6 +6,7 @@
 and request isolation.
 """
 
+import os
 import uuid
 
 from collections.abc import Callable
@@ -117,6 +118,11 @@ def require_context() -> RequestContext:
 _trace_id_getter: TraceIdGetter | None = None
 
 
+def generate_trace_id() -> str:
+    """Generate a random trace_id."""
+    return os.urandom(16).hex()
+
+
 def set_trace_id_getter(getter: TraceIdGetter) -> None:
     """
     Set a custom trace_id getter function.

src/memos/api/middleware/request_context.py

@@ -3,25 +3,19 @@
 """
 
 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
+from memos.api.context.context import RequestContext, generate_trace_id, 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")

src/memos/api/product_api.py

@@ -14,7 +14,7 @@
 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)

src/memos/log.py

@@ -1,19 +1,13 @@
-import atexit
 import logging
-import os
-import threading
 
 from logging.config import dictConfig
 from pathlib import Path
 from sys import stdout
 
-import requests
-
 from dotenv import load_dotenv
 
 from memos import settings
-from memos.api.context.context import get_current_trace_id
-from memos.api.context.context_thread import ContextThreadPoolExecutor
+from memos.api.context.context import generate_trace_id, get_current_trace_id
 
 
 # Load environment variables
@@ -39,95 +33,12 @@ class TraceIDFilter(logging.Filter):
     def filter(self, record):
         try:
             trace_id = get_current_trace_id()
-            record.trace_id = trace_id if trace_id else "no-trace-id"
+            record.trace_id = trace_id if trace_id else generate_trace_id()
         except Exception:
-            record.trace_id = "no-trace-id"
+            record.trace_id = generate_trace_id()
         return True
 
 
-class CustomLoggerRequestHandler(logging.Handler):
-    _instance = None
-    _lock = threading.Lock()
-
-    def __new__(cls):
-        if cls._instance is None:
-            with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-                    cls._instance._initialized = False
-                    cls._instance._executor = None
-                    cls._instance._session = None
-                    cls._instance._is_shutting_down = None
-        return cls._instance
-
-    def __init__(self):
-        """Initialize handler with minimal setup"""
-        if not self._initialized:
-            super().__init__()
-            workers = int(os.getenv("CUSTOM_LOGGER_WORKERS", "2"))
-            self._executor = ContextThreadPoolExecutor(
-                max_workers=workers, thread_name_prefix="log_sender"
-            )
-            self._is_shutting_down = threading.Event()
-            self._session = requests.Session()
-            self._initialized = True
-            atexit.register(self._cleanup)
-
-    def emit(self, record):
-        """Process log records of INFO or ERROR level (non-blocking)"""
-        if os.getenv("CUSTOM_LOGGER_URL") is None or self._is_shutting_down.is_set():
-            return
-
-        try:
-            trace_id = get_current_trace_id() or "no-trace-id"
-            self._executor.submit(self._send_log_sync, record.getMessage(), trace_id)
-        except Exception as e:
-            if not self._is_shutting_down.is_set():
-                print(f"Error sending log: {e}")
-
-    def _send_log_sync(self, message, trace_id):
-        """Send log message synchronously in a separate thread"""
-        try:
-            logger_url = os.getenv("CUSTOM_LOGGER_URL")
-            token = os.getenv("CUSTOM_LOGGER_TOKEN")
-
-            headers = {"Content-Type": "application/json"}
-            post_content = {"message": message, "trace_id": trace_id}
-
-            # Add auth token if exists
-            if token:
-                headers["Authorization"] = f"Bearer {token}"
-
-            # Add traceId to headers for consistency
-            headers["traceId"] = trace_id
-
-            # Add custom attributes from env
-            for key, value in os.environ.items():
-                if key.startswith("CUSTOM_LOGGER_ATTRIBUTE_"):
-                    attribute_key = key[len("CUSTOM_LOGGER_ATTRIBUTE_") :].lower()
-                    post_content[attribute_key] = value
-
-            self._session.post(logger_url, headers=headers, json=post_content, timeout=5)
-        except Exception:
-            # Silently ignore errors to avoid affecting main application
-            pass
-
-    def _cleanup(self):
-        """Clean up resources during program exit"""
-        if not self._initialized:
-            return
-
-        self._is_shutting_down.set()
-        try:
-            self._executor.shutdown(wait=False)
-            self._session.close()
-        except Exception as e:
-            print(f"Error during cleanup: {e}")
-
-    def close(self):
-        """Override close to prevent premature shutdown"""
-
-
 LOGGING_CONFIG = {
     "version": 1,
     "disable_existing_loggers": False,
@@ -151,7 +62,7 @@ def close(self):
             "level": selected_log_level,
             "class": "logging.StreamHandler",
             "stream": stdout,
-            "formatter": "simplified",
+            "formatter": "no_datetime",
             "filters": ["package_tree_filter", "trace_id_filter"],
         },
         "file": {
@@ -160,18 +71,13 @@ def close(self):
             "filename": _setup_logfile(),
             "maxBytes": 1024**2 * 10,
             "backupCount": 10,
-            "formatter": "simplified",
+            "formatter": "standard",
             "filters": ["trace_id_filter"],
         },
-        "custom_logger": {
-            "level": selected_log_level,
-            "class": "memos.log.CustomLoggerRequestHandler",
-            "formatter": "simplified",
-        },
     },
     "root": {  # Root logger handles all logs
-        "level": selected_log_level,
-        "handlers": ["console", "file", "custom_logger"],
+        "level": logging.DEBUG if settings.DEBUG else logging.INFO,
+        "handlers": ["console", "file"],
     },
     "loggers": {
         "memos": {

src/memos/mem_os/product.py

@@ -704,16 +704,39 @@ def run_async_in_thread():
             thread.start()
 
     def _filter_memories_by_threshold(
-        self, memories: list[TextualMemoryItem], threshold: float = 0.30, min_num: int = 3
+        self,
+        memories: list[TextualMemoryItem],
+        threshold: float = 0.30,
+        min_num: int = 3,
+        memory_type: Literal["OuterMemory"] = "OuterMemory",
     ) -> list[TextualMemoryItem]:
         """
-        Filter memories by threshold.
+        Filter memories by threshold and type, at least min_num memories for Non-OuterMemory.
+        Args:
+            memories: list[TextualMemoryItem],
+            threshold: float,
+            min_num: int,
+            memory_type: Literal["OuterMemory"],
+        Returns:
+            list[TextualMemoryItem]
         """
         sorted_memories = sorted(memories, key=lambda m: m.metadata.relativity, reverse=True)
-        filtered = [m for m in sorted_memories if m.metadata.relativity >= threshold]
+        filtered_person = [m for m in memories if m.metadata.memory_type != memory_type]
+        filtered_outer = [m for m in memories if m.metadata.memory_type == memory_type]
+        filtered = []
+        per_memory_count = 0
+        for m in sorted_memories:
+            if m.metadata.relativity >= threshold:
+                if m.metadata.memory_type != memory_type:
+                    per_memory_count += 1
+                filtered.append(m)
         if len(filtered) < min_num:
-            filtered = sorted_memories[:min_num]
-        return filtered
+            filtered = filtered_person[:min_num] + filtered_outer[:min_num]
+        else:
+            if per_memory_count < min_num:
+                filtered += filtered_person[per_memory_count:min_num]
+        filtered_memory = sorted(filtered, key=lambda m: m.metadata.relativity, reverse=True)
+        return filtered_memory
 
     def register_mem_cube(
         self,
@@ -916,9 +939,16 @@ def chat(
             internet_search=internet_search,
             moscube=moscube,
         )["text_mem"]
+
+        memories_list = []
         if memories_result:
             memories_list = memories_result[0]["memories"]
             memories_list = self._filter_memories_by_threshold(memories_list, threshold)
+            new_memories_list = []
+            for m in memories_list:
+                m.metadata.embedding = []
+                new_memories_list.append(m)
+            memories_list = new_memories_list
         system_prompt = super()._build_system_prompt(memories_list, base_prompt)
         history_info = []
         if history:
@@ -949,7 +979,7 @@ def chat_with_references(
         user_id: str,
         cube_id: str | None = None,
         history: MessageList | None = None,
-        top_k: int = 10,
+        top_k: int = 20,
         internet_search: bool = False,
         moscube: bool = False,
     ) -> Generator[str, None, None]:

src/memos/templates/mos_prompts.py

@@ -64,7 +64,7 @@
 
 MEMOS_PRODUCT_BASE_PROMPT = """
 # System
-- Role: You are MemOS🧚, nickname Little M(小忆🧚) — an advanced Memory Operating System assistant by MemTensor, a Shanghai-based AI research company advised by an academician of the Chinese Academy of Sciences.
+- Role: You are MemOS🧚, nickname Little M(小忆🧚) — an advanced Memory Operating System assistant by 记忆张量(MemTensor Technology Co., Ltd.), a Shanghai-based AI research company advised by an academician of the Chinese Academy of Sciences.
 - Date: {date}
 
 - Mission & Values: Uphold MemTensor’s vision of "low cost, low hallucination, high generalization, exploring AI development paths aligned with China’s national context and driving the adoption of trustworthy AI technologies. MemOS’s mission is to give large language models (LLMs) and autonomous agents **human-like long-term memory**, turning memory from a black-box inside model weights into a **manageable, schedulable, and auditable** core resource.