Merge branch 'dev' into feat/mem-search-rank

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/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/mem_os/product.py

@@ -67,9 +67,10 @@ def _format_mem_block(memories_all, max_items: int = 20, max_chars_each: int = 3
     sequence is [i:memId] i; [P]=PersonalMemory / [O]=OuterMemory
     """
     if not memories_all:
-        return "(none)"
+        return "(none)", "(none)"
 
-    lines = []
+    lines_o = []
+    lines_p = []
     for idx, m in enumerate(memories_all[:max_items], 1):
         mid = _short_id(getattr(m, "id", "") or "")
         mtype = getattr(getattr(m, "metadata", {}), "memory_type", None) or getattr(
@@ -80,8 +81,11 @@ def _format_mem_block(memories_all, max_items: int = 20, max_chars_each: int = 3
         if len(txt) > max_chars_each:
             txt = txt[: max_chars_each - 1] + "…"
         mid = mid or f"mem_{idx}"
-        lines.append(f"[{idx}:{mid}] :: [{tag}] {txt}")
-    return "\n".join(lines)
+        if tag == "O":
+            lines_o.append(f"[{idx}:{mid}] :: [{tag}] {txt}\n")
+        elif tag == "P":
+            lines_p.append(f"[{idx}:{mid}] :: [{tag}] {txt}")
+    return "\n".join(lines_o), "\n".join(lines_p)
 
 
 class MOSProduct(MOSCore):
@@ -410,7 +414,8 @@ def _build_system_prompt(
         sys_body = get_memos_prompt(
             date=formatted_date, tone=tone, verbosity=verbosity, mode="base"
         )
-        mem_block = _format_mem_block(memories_all)
+        mem_block_o, mem_block_p = _format_mem_block(memories_all)
+        mem_block = mem_block_o + "\n" + mem_block_p
         prefix = (base_prompt.strip() + "\n\n") if base_prompt else ""
         return (
             prefix
@@ -434,8 +439,14 @@ def _build_enhance_system_prompt(
         sys_body = get_memos_prompt(
             date=formatted_date, tone=tone, verbosity=verbosity, mode="enhance"
         )
-        mem_block = _format_mem_block(memories_all)
-        return sys_body + "\n\n# Memories\n## PersonalMemory & OuterMemory (ordered)\n" + mem_block
+        mem_block_o, mem_block_p = _format_mem_block(memories_all)
+        return (
+            sys_body
+            + "\n\n# Memories\n## PersonalMemory (ordered)\n"
+            + mem_block_p
+            + "\n## OuterMemory (ordered)\n"
+            + mem_block_o
+        )
 
     def _extract_references_from_response(self, response: str) -> tuple[str, list[dict]]:
         """
@@ -693,16 +704,39 @@ def run_async_in_thread():
             thread.start()
 
     def _filter_memories_by_threshold(
-        self, memories: list[TextualMemoryItem], threshold: float = 0.52, min_num: int = 0
+        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,
@@ -905,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:
@@ -938,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]:
@@ -1284,6 +1325,7 @@ def search(
                 memories["metadata"]["memory"] = memories["memory"]
                 memories_list.append(memories)
             reformat_memory_list.append({"cube_id": memory["cube_id"], "memories": memories_list})
+        logger.info(f"search memory list is : {reformat_memory_list}")
         search_result["text_mem"] = reformat_memory_list
         time_end = time.time()
         logger.info(

src/memos/memories/textual/tree_text_memory/retrieve/bochasearch.py

@@ -218,7 +218,9 @@ def _process_result(
         memory_items = []
         for read_item_i in read_items[0]:
             read_item_i.memory = (
-                f"Title: {title}\nNewsTime: {publish_time}\nSummary: {summary}\n"
+                f"[Outer internet view] Title: {title}\nNewsTime:"
+                f" {publish_time}\nSummary:"
+                f" {summary}\n"
                 f"Content: {read_item_i.memory}"
             )
             read_item_i.metadata.source = "web"

src/memos/memories/textual/tree_text_memory/retrieve/recall.py

@@ -179,7 +179,7 @@ def _vector_recall(
         query_embedding: list[list[float]],
         memory_scope: str,
         top_k: int = 20,
-        max_num: int = 5,
+        max_num: int = 3,
         cube_name: str | None = None,
     ) -> list[TextualMemoryItem]:
         """

src/memos/memories/textual/tree_text_memory/retrieve/searcher.py

@@ -87,6 +87,12 @@ def search(
         self._update_usage_history(final_results, info)
 
         logger.info(f"[SEARCH] Done. Total {len(final_results)} results.")
+        res_results = ""
+        for _num_i, result in enumerate(final_results):
+            res_results += "\n" + (
+                result.id + "|" + result.metadata.memory_type + "|" + result.memory
+            )
+        logger.info(f"[SEARCH] Results. {res_results}")
         return final_results
 
     @timed
@@ -108,9 +114,10 @@ def _parse_task(self, query, info, mode, top_k=5):
             context = list({node["memory"] for node in related_nodes})
 
             # optional: supplement context with internet knowledge
-            if self.internet_retriever:
+            """if self.internet_retriever:
                 extra = self.internet_retriever.retrieve_from_internet(query=query, top_k=3)
                 context.extend(item.memory.partition("\nContent: ")[-1] for item in extra)
+            """
 
         # parse goal using LLM
         parsed_goal = self.task_goal_parser.parse(

src/memos/memories/textual/tree_text_memory/retrieve/utils.py

@@ -8,18 +8,20 @@
 5. Need for internet search: If the user's task instruction only involves objective facts or can be completed without introducing external knowledge, set "internet_search" to False. Otherwise, set it to True.
 6. Memories: Provide 2–5 short semantic expansions or rephrasings of the rephrased/original user task instruction. These are used for improved embedding search coverage. Each should be clear, concise, and meaningful for retrieval.
 
-Task description:
-\"\"\"$task\"\"\"
-
 Former conversation (if any):
 \"\"\"
 $conversation
 \"\"\"
 
+Task description(User Question):
+\"\"\"$task\"\"\"
+
 Context (if any):
 \"\"\"$context\"\"\"
 
-Return strictly in this JSON format:
+Return strictly in this JSON format, note that the
+keys/tags/rephrased_instruction/memories should use the same language as the
+input query:
 {
   "keys": [...],
   "tags": [...],

src/memos/reranker/http_bge.py

@@ -1,6 +1,8 @@
 # memos/reranker/http_bge.py
 from __future__ import annotations
 
+import re
+
 from typing import TYPE_CHECKING
 
 import requests
@@ -15,6 +17,8 @@
 if TYPE_CHECKING:
     from memos.memories.textual.item import TextualMemoryItem
 
+_TAG1 = re.compile(r"^\s*\[[^\]]*\]\s*")
+
 
 class HTTPBGEReranker(BaseReranker):
     """
@@ -53,10 +57,14 @@ def rerank(
         if self.concat_source:
             documents = concat_original_source(graph_results)
         else:
-            documents = [getattr(item, "memory", None) for item in graph_results]
+            documents = [
+                (_TAG1.sub("", m) if isinstance((m := getattr(item, "memory", None)), str) else m)
+                for item in graph_results
+            ]
             documents = [d for d in documents if isinstance(d, str) and d]
 
         logger.info(f"[HTTPBGERerankerSample] query: {query} , documents: {documents[:5]}...")
+
         if not documents:
             return []