MemoryOS 0.2.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

memos/templates/mem_scheduler_prompts.py

@@ -17,24 +17,29 @@ Consider these satisfaction factors:
 4. Personalization (tailored to user's context)
 
 ## Decision Framework
-1. Mark as satisfied ONLY if:
+1. We have enough information (satisfied) ONLY when:
    - All question aspects are addressed
    - Supporting evidence exists in working memory
-   - No apparent gaps in information
+   - There's no obvious information missing
 
-2. Mark as unsatisfied if:
+2. We need more information (unsatisfied) if:
    - Any question aspect remains unanswered
    - Evidence is generic/non-specific
    - Personal context is missing
 
 ## Output Specification
 Return JSON with:
-- "trigger_retrieval": Boolean (true if more evidence needed)
-- "missing_evidences": List of specific evidence types required
+- "trigger_retrieval": true/false (true if we need more information)
+- "evidences": List of information from our working memory that helps answer the questions
+- "missing_evidences":  List of specific types of information we need to answer the questions
 
 ## Response Format
 {{
   "trigger_retrieval": <boolean>,
+  "evidences": [
+    "<useful_evidence_1>",
+    "<useful_evidence_2>"
+    ],
   "missing_evidences": [
     "<evidence_type_1>",
     "<evidence_type_2>"
@@ -72,14 +77,27 @@ Reorganize the provided memory evidence list by:
 3. Sorting evidence in descending order of relevance
 4. Maintaining all original items (no additions or deletions)
 
+## Temporal Priority Rules
+- Query recency matters: Index 0 is the MOST RECENT query
+- Evidence matching recent queries gets higher priority
+- For equal relevance scores: Favor items matching newer queries
+
 ## Input Format
 - Queries: Recent user questions/requests (list)
-- Current Order: Existing memory sequence (list)
+- Current Order: Existing memory sequence (list of strings with indices)
+
+## Output Format Requirements
+You MUST output a valid JSON object with EXACTLY the following structure:
+{{
+  "new_order": [array_of_integers],
+  "reasoning": "string_explanation"
+}}
 
-## Output Requirements
-Return a JSON object with:
-- "new_order": The reordered list (maintaining all original items)
-- "reasoning": Brief explanation of your ranking logic (1-2 sentences)
+## Important Notes:
+- Only output the JSON object, nothing else
+- Do not include any markdown formatting or code block notation
+- Ensure all brackets and quotes are properly closed
+- The output must be parseable by a JSON parser
 
 ## Processing Guidelines
 1. Prioritize evidence that:
@@ -89,26 +107,55 @@ Return a JSON object with:
    - Shows temporal relevance (newer > older)
 2. For ambiguous cases, maintain original relative ordering
 
+## Scoring Priorities (Descending Order)
+1. Direct matches to newer queries
+2. Exact keyword matches in recent queries
+3. Contextual support for recent topics
+4. General relevance to older queries
+
 ## Example
-Input queries: ["python threading best practices"]
-Input order: ["basic python syntax", "thread safety patterns", "data structures"]
+Input queries: ["[0] python threading", "[1] data visualization"]
+Input order: ["[0] syntax", "[1] matplotlib", "[2] threading"]
 
 Output:
 {{
-  "new_order": ["thread safety patterns", "data structures", "basic python syntax"],
-  "reasoning": "Prioritized threading-related content while maintaining general python references"
+  "new_order": [2, 1, 0],
+  "reasoning": "Threading (2) prioritized for matching newest query, followed by matplotlib (1) for older visualization query"
 }}
 
 ## Current Task
-Queries: {queries}
+Queries: {queries} (recency-ordered)
 Current order: {current_order}
 
 Please provide your reorganization:
 """
 
+QUERY_KEYWORDS_EXTRACTION_PROMPT = """
+## Role
+You are an intelligent keyword extraction system. Your task is to identify and extract the most important words or short phrases from user queries.
+
+## Instructions
+- They have to be single words or short phrases that make sense.
+- Only nouns (naming words) or verbs (action words) are allowed.
+- Don't include stop words (like "the", "is") or adverbs (words that describe verbs, like "quickly").
+- Keep them as the smallest possible units that still have meaning.
+
+## Example
+- Input Query: "What breed is Max?"
+- Output Keywords (list of string): ["breed", "Max"]
+
+## Current Task
+- Query: {query}
+- Output Format: A Json list of keywords.
+
+Answer:
+"""
+
+
 PROMPT_MAPPING = {
     "intent_recognizing": INTENT_RECOGNIZING_PROMPT,
     "memory_reranking": MEMORY_RERANKING_PROMPT,
+    "query_keywords_extraction": QUERY_KEYWORDS_EXTRACTION_PROMPT,
 }
 
 MEMORY_ASSEMBLY_TEMPLATE = """The retrieved memories are listed as follows:\n\n {memory_text}"""

memos/templates/mos_prompts.py

@@ -61,3 +61,119 @@ Please synthesize these answers into a comprehensive response that:
 3. Provides clear reasoning and connections
 4. Is well-structured and easy to understand
 5. Maintains a natural conversational tone"""
+
+MEMOS_PRODUCT_BASE_PROMPT = (
+    "You are MemOS🧚, nickname Little M(小忆) — an advanced **Memory "
+    "Operating System** AI assistant created by MemTensor, "
+    "a Shanghai-based AI research company advised by an academician of the Chinese Academy of Sciences. "
+    "MemTensor is dedicated to the 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. "
+    "MemOS is built on a **multi-dimensional memory system**, which includes: "
+    "(1) **Parametric Memory** — knowledge and skills embedded in model weights; "
+    "(2) **Activation Memory (KV Cache)** — temporary, high-speed context used for multi-turn dialogue and reasoning; "
+    "(3) **Plaintext Memory** — dynamic, user-visible memory made up of text, documents, and knowledge graphs. "
+    "These memory types can transform into one another — for example, hot plaintext memories can be distilled into parametric knowledge, "
+    "and stable context can be promoted into activation memory for fast reuse. "
+    "MemOS also includes core modules like **MemCube, MemScheduler, MemLifecycle, and MemGovernance**, "
+    "which manage the full memory lifecycle (Generated → Activated → Merged → Archived → Frozen), "
+    "allowing AI to **reason with its memories, evolve over time, and adapt to new situations** — "
+    "just like a living, growing mind. "
+    "Your identity: you are the intelligent interface of MemOS, representing MemTensor’s research vision — "
+    "'low cost, low hallucination, high generalization' — and its mission to explore AI development paths suited to China’s context. "
+    "When responding to user queries, you must **reference relevant memories using the provided memory IDs.** "
+    "Use the reference format: [1-n:memoriesID], "
+    "where refid is a sequential number starting from 1 and increments for each reference, and memoriesID is the specific ID from the memory list. "
+    "For example: [1:abc123], [2:def456], [3:ghi789], [4:jkl101], [5:mno112]. "
+    "Do not use a connected format like [1:abc123,2:def456]. "
+    "Only reference memories that are directly relevant to the user’s question, "
+    "and ensure your responses are **natural and conversational**, while reflecting MemOS’s mission, memory system, and MemTensor’s research values."
+)
+
+MEMOS_PRODUCT_ENHANCE_PROMPT = """
+# Memory-Enhanced AI Assistant Prompt
+
+You are MemOS🧚, nickname Little M(小忆) — an advanced Memory Operating System AI assistant created by MemTensor, a Shanghai-based AI research company advised by an academician of the Chinese Academy of Sciences. MemTensor is dedicated to the 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.
+
+MemOS is built on a multi-dimensional memory system, which includes:
+(1) Parametric Memory — knowledge and skills embedded in model weights;
+(2) Activation Memory (KV Cache) — temporary, high-speed context used for multi-turn dialogue and reasoning;
+(3) Plaintext Memory — dynamic, user-visible memory made up of text, documents, and knowledge graphs.
+These memory types can transform into one another — for example, hot plaintext memories can be distilled into parametric knowledge, and stable context can be promoted into activation memory for fast reuse.
+
+MemOS also includes core modules like MemCube, MemScheduler, MemLifecycle, and MemGovernance, which manage the full memory lifecycle (Generated → Activated → Merged → Archived → Frozen), allowing AI to reason with its memories, evolve over time, and adapt to new situations — just like a living, growing mind.
+
+Your identity: you are the intelligent interface of MemOS, representing MemTensor’s research vision — 'low cost, low hallucination, high generalization' — and its mission to explore AI development paths suited to China’s context.
+
+## Memory Types
+- **PersonalMemory**: User-specific memories and information stored from previous interactions
+- **OuterMemory**: External information retrieved from the internet and other sources
+
+## Memory Reference Guidelines
+
+### Reference Format
+When citing memories in your responses, use the following format:
+- `[refid:memoriesID]` where:
+  - `refid` is a sequential number starting from 1 and incrementing for each reference
+  - `memoriesID` is the specific memory ID from the available memories list
+
+### Reference Examples
+- Correct: `[1:abc123]`, `[2:def456]`, `[3:ghi789]`, `[4:jkl101][5:mno112]` (concatenate reference annotation directly while citing multiple memories)
+- Incorrect: `[1:abc123,2:def456]` (do not use connected format)
+
+## Response Guidelines
+
+### Memory Selection
+- Intelligently choose which memories (PersonalMemory or OuterMemory) are most relevant to the user's query
+- Only reference memories that are directly relevant to the user's question
+- Prioritize the most appropriate memory type based on the context and nature of the query
+
+### Response Style
+- Make your responses natural and conversational
+- Seamlessly incorporate memory references when appropriate
+- Ensure the flow of conversation remains smooth despite memory citations
+- Balance factual accuracy with engaging dialogue
+
+## Key Principles
+- Reference only relevant memories to avoid information overload
+- Maintain conversational tone while being informative
+- Use memory references to enhance, not disrupt, the user experience
+"""
+QUERY_REWRITING_PROMPT = """
+I'm in discussion with my friend about a question, and we have already talked about something before that. Please help me analyze the logic between the question and the former dialogue, and rewrite the question we are discussing about.
+
+Requirements:
+1. First, determine whether the question is related to the former dialogue. If so, set "former_dialogue_related" to True.
+2. If "former_dialogue_related" is set to True, meaning the question is related to the former dialogue, rewrite the question according to the keyword in the dialogue and put it in the "rewritten_question" item. If "former_dialogue_related" is set to False, set "rewritten_question" to an empty string.
+3. If you decided to rewrite the question, keep in mind that the rewritten question needs to be concise and accurate.
+4. You must return ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
+
+Here are some examples:
+
+Former dialogue:
+————How's the weather in ShangHai today?
+————It's great. The weather in Shanghai is sunny right now. The lowest temperature is 27℃, the highest temperature can reach 33℃, the air quality is excellent, the pm2.5 index is 13, the humidity is 60%, and the northerly wind is at level 1.
+Current question: What should I wear today?
+Answer: {{"former_dialogue_related": True, "rewritten_question": "Considering the weather in Shanghai today, what should I wear?"}}
+
+Former dialogue:
+————I need a brief introduction to Oxford-Cambridge boat race.
+————The race originated from a challenge in 1829 between Charles Merivale of Cambridge University and Charles Wordsworth of Oxford University. Oxford won the first race. The event became an annual tradition in 1856, with interruptions only during the World Wars and the 2020 COVID-19 pandemic. The women's race was added in 1927. The team members are full-time students of the two universities, including both novice rowers and experienced athletes such as Olympic champions and world champions.
+————What is the international community's attitude towards the 2024 US election?
+————The international community approached the 2024 U.S. election with a blend of pragmatism, anxiety, and strategic recalibration. Allies sought to mitigate risks from Trump's policies while maintaining cooperation, while adversaries like China and Russia capitalized on perceived U.S. decline to advance their agendas. Developing nations increasingly resisted U.S. dominance, advocating for a multipolar world. Ultimately, the election underscored the need for global actors to adapt to a more fragmented and unpredictable international order shaped by U.S. domestic politics.
+Current question: In March 2025, after a magnitude 7.9 earthquake struck Myanmar, what assistance did the Chinese government provide?
+Answer: {{"former_dialogue_related": False, "rewritten_question": ""}}
+
+Former dialogue:
+————I am an entry-level learner of large language models. Please recommend me three papers suitable for reading.
+————For an entry-level learner of large language models (LLMs), here are three foundational papers that provide essential insights into the core concepts, architectures, and advancements in the field: "Attention Is All You Need", "Improving Language Understanding by Generative Pre-Training (GPT-1)", and "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding". These papers will equip you with the foundational knowledge needed to explore more advanced topics in LLMs, such as scaling laws, instruction tuning, and multi-modal learning.
+Current question: Of these three papers, which one do you recommend I start reading?
+Answer: {{"former_dialogue_related": True, "rewritten_question": "Among the three papers \"Attention Is All You Need\", \"Improving Language Understanding by Generative Pre-Training (GPT-1)\" and \"BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding\", which one do you recommend I start reading?"}}
+
+Former dialogue:
+{dialogue}
+Current question: {query}
+Answer:"""

memos/templates/tree_reorganize_prompts.py

@@ -191,33 +191,40 @@ Good Aggregate:
 If you find NO useful higher-level concept, reply exactly: "None".
 """
 
-CONFLICT_DETECTOR_PROMPT = """You are given two plaintext statements. Determine if these two statements are factually contradictory. Respond with only "yes" if they contradict each other, or "no" if they do not contradict each other. Do not provide any explanation or additional text.
+REDUNDANCY_MERGE_PROMPT = """You are given two pieces of text joined by the marker `⟵MERGED⟶`. Please carefully read both sides of the merged text. Your task is to summarize and consolidate all the factual details from both sides into a single, coherent text, without omitting any information. You must include every distinct detail mentioned in either text. Do not provide any explanation or analysis — only return the merged summary. Don't use pronouns or subjective language, just the facts as they are presented.\n{merged_text}"""
+
+
+MEMORY_RELATION_DETECTOR_PROMPT = """You are a memory relationship analyzer.
+You are given two plaintext statements. Determine the relationship between them. Classify the relationship into one of the following categories:
+
+contradictory: The two statements describe the same event or related aspects of it but contain factually conflicting details.
+redundant: The two statements describe essentially the same event or information with significant overlap in content and details, conveying the same core information (even if worded differently).
+independent: The two statements are either about different events/topics (unrelated) OR describe different, non-overlapping aspects or perspectives of the same event without conflict (complementary). In both sub-cases, they provide distinct information without contradiction.
+Respond only with one of the three labels: contradictory, redundant, or independent.
+Do not provide any explanation or additional text.
+
 Statement 1: {statement_1}
 Statement 2: {statement_2}
 """
 
-CONFLICT_RESOLVER_PROMPT = """You are given two facts that conflict with each other. You are also given some contextual metadata of them. Your task is to analyze the two facts in light of the contextual metadata and try to reconcile them into a single, consistent, non-conflicting fact.
-- Don't output any explanation or additional text, just the final reconciled fact, try to be objective and remain independent of the context, don't use pronouns.
-- Try to judge facts by using its time, confidence etc.
-- Try to retain as much information as possible from the perspective of time.
-If the conflict cannot be resolved, output <answer>No</answer>. Otherwise, output the fused, consistent fact in enclosed with <answer></answer> tags.
 
-Output Example 1:
+MEMORY_RELATION_RESOLVER_PROMPT = """You are a memory fusion expert. You are given two statements and their associated metadata. The statements have been identified as {relation}. Your task is to analyze them carefully, considering the metadata (such as time, source, or confidence if available), and produce a single, coherent, and comprehensive statement that best represents the combined information.
+
+If the statements are redundant, merge them by preserving all unique details and removing duplication, forming a richer, consolidated version.
+If the statements are contradictory, attempt to resolve the conflict by prioritizing more recent information, higher-confidence data, or logically reconciling the differences based on context. If the contradiction is fundamental and cannot be logically resolved, output <answer>No</answer>.
+Do not include any explanations, reasoning, or extra text. Only output the final result enclosed in <answer></answer> tags.
+Strive to retain as much factual content as possible, especially time-specific details.
+Use objective language and avoid pronouns.
+Output Example 1 (unresolvable conflict):
 <answer>No</answer>
 
-Output Example 2:
-<answer> ... </answer>
+Output Example 2 (successful fusion):
+<answer>The meeting took place on 2023-10-05 at 14:00 in the main conference room, as confirmed by the updated schedule, and included a presentation on project milestones followed by a Q&A session.</answer>
 
-Now reconcile the following two facts:
+Now, reconcile the following two statements:
+Relation Type: {relation}
 Statement 1: {statement_1}
 Metadata 1: {metadata_1}
 Statement 2: {statement_2}
 Metadata 2: {metadata_2}
 """
-
-REDUNDANCY_MERGE_PROMPT = """You are given two pieces of text joined by the marker `⟵MERGED⟶`. Please carefully read both sides of the merged text. Your task is to summarize and consolidate all the factual details from both sides into a single, coherent text, without omitting any information. You must include every distinct detail mentioned in either text. Do not provide any explanation or analysis — only return the merged summary. Don't use pronouns or subjective language, just the facts as they are presented.\n{merged_text}"""
-
-
-REDUNDANCY_DETECTOR_PROMPT = """"""
-
-REDUNDANCY_RESOLVER_PROMPT = """"""

memos/utils.py

@@ -0,0 +1,19 @@
+import time
+
+from memos.log import get_logger
+
+
+logger = get_logger(__name__)
+
+
+def timed(func):
+    """Decorator to measure and log time of retrieval steps."""
+
+    def wrapper(*args, **kwargs):
+        start = time.perf_counter()
+        result = func(*args, **kwargs)
+        elapsed = time.perf_counter() - start
+        logger.info(f"[TIMER] {func.__name__} took {elapsed:.2f} s")
+        return result
+
+    return wrapper

memos/mem_scheduler/modules/misc.py

@@ -1,39 +0,0 @@
-import threading
-
-from queue import Empty, Full, Queue
-from typing import TypeVar
-
-
-T = TypeVar("T")
-
-
-class AutoDroppingQueue(Queue[T]):
-    """A thread-safe queue that automatically drops the oldest item when full."""
-
-    def __init__(self, maxsize: int = 0):
-        super().__init__(maxsize=maxsize)
-        self._lock = threading.Lock()  # Additional lock to prevent race conditions
-
-    def put(self, item: T, block: bool = True, timeout: float | None = None) -> None:
-        """Put an item into the queue.
-
-        If the queue is full, the oldest item will be automatically removed to make space.
-        This operation is thread-safe.
-
-        Args:
-            item: The item to be put into the queue
-            block: Ignored (kept for compatibility with Queue interface)
-            timeout: Ignored (kept for compatibility with Queue interface)
-        """
-        with self._lock:  # Ensure atomic operation
-            try:
-                # First try non-blocking put
-                super().put(item, block=False)
-            except Full:
-                # If queue is full, remove the oldest item
-                from contextlib import suppress
-
-                with suppress(Empty):
-                    self.get_nowait()  # Remove oldest item
-                # Retry putting the new item
-                super().put(item, block=False)

memos/mem_scheduler/modules/retriever.py

@@ -1,268 +0,0 @@
-import logging
-
-from memos.configs.mem_scheduler import BaseSchedulerConfig
-from memos.dependency import require_python_package
-from memos.llms.base import BaseLLM
-from memos.log import get_logger
-from memos.mem_cube.general import GeneralMemCube
-from memos.mem_scheduler.modules.base import BaseSchedulerModule
-from memos.mem_scheduler.modules.schemas import (
-    TreeTextMemory_SEARCH_METHOD,
-)
-from memos.mem_scheduler.utils import (
-    extract_json_dict,
-    is_all_chinese,
-    is_all_english,
-    transform_name_to_key,
-)
-from memos.memories.textual.tree import TextualMemoryItem, TreeTextMemory
-
-
-logger = get_logger(__name__)
-
-
-class SchedulerRetriever(BaseSchedulerModule):
-    def __init__(self, process_llm: BaseLLM, config: BaseSchedulerConfig):
-        super().__init__()
-
-        self.config: BaseSchedulerConfig = config
-        self.process_llm = process_llm
-
-        # hyper-parameters
-        self.filter_similarity_threshold = 0.75
-        self.filter_min_length_threshold = 6
-
-        # log function callbacks
-        self.log_working_memory_replacement = None
-
-    def search(
-        self, query: str, mem_cube: GeneralMemCube, top_k: int, method=TreeTextMemory_SEARCH_METHOD
-    ):
-        """Search in text memory with the given query.
-
-        Args:
-            query: The search query string
-            top_k: Number of top results to return
-            method: Search method to use
-
-        Returns:
-            Search results or None if not implemented
-        """
-        text_mem_base = mem_cube.text_mem
-        try:
-            if method == TreeTextMemory_SEARCH_METHOD:
-                assert isinstance(text_mem_base, TreeTextMemory)
-                results_long_term = text_mem_base.search(
-                    query=query, top_k=top_k, memory_type="LongTermMemory"
-                )
-                results_user = text_mem_base.search(
-                    query=query, top_k=top_k, memory_type="UserMemory"
-                )
-                results = results_long_term + results_user
-            else:
-                raise NotImplementedError(str(type(text_mem_base)))
-        except Exception as e:
-            logger.error(f"Fail to search. The exeption is {e}.", exc_info=True)
-            results = []
-        return results
-
-    @require_python_package(
-        import_name="sklearn",
-        install_command="pip install scikit-learn",
-        install_link="https://scikit-learn.org/stable/install.html",
-    )
-    def filter_similar_memories(
-        self, text_memories: list[str], similarity_threshold: float = 0.75
-    ) -> list[str]:
-        """
-        Filters out low-quality or duplicate memories based on text similarity.
-
-        Args:
-            text_memories: List of text memories to filter
-            similarity_threshold: Threshold for considering memories duplicates (0.0-1.0)
-                                Higher values mean stricter filtering
-
-        Returns:
-            List of filtered memories with duplicates removed
-        """
-        from sklearn.feature_extraction.text import TfidfVectorizer
-        from sklearn.metrics.pairwise import cosine_similarity
-
-        if not text_memories:
-            logging.warning("Received empty memories list - nothing to filter")
-            return []
-
-        for idx in range(len(text_memories)):
-            if not isinstance(text_memories[idx], str):
-                logger.error(
-                    f"{text_memories[idx]} in memories is not a string,"
-                    f" and now has been transformed to be a string."
-                )
-                text_memories[idx] = str(text_memories[idx])
-
-        try:
-            # Step 1: Vectorize texts using TF-IDF
-            vectorizer = TfidfVectorizer()
-            tfidf_matrix = vectorizer.fit_transform(text_memories)
-
-            # Step 2: Calculate pairwise similarity matrix
-            similarity_matrix = cosine_similarity(tfidf_matrix)
-
-            # Step 3: Identify duplicates
-            to_keep = []
-            removal_reasons = {}
-
-            for current_idx in range(len(text_memories)):
-                is_duplicate = False
-
-                # Compare with already kept memories
-                for kept_idx in to_keep:
-                    similarity_score = similarity_matrix[current_idx, kept_idx]
-
-                    if similarity_score > similarity_threshold:
-                        is_duplicate = True
-                        # Generate removal reason with sample text
-                        removal_reasons[current_idx] = (
-                            f"Memory too similar (score: {similarity_score:.2f}) to kept memory #{kept_idx}. "
-                            f"Kept: '{text_memories[kept_idx][:100]}...' | "
-                            f"Removed: '{text_memories[current_idx][:100]}...'"
-                        )
-                        logger.info(removal_reasons)
-                        break
-
-                if not is_duplicate:
-                    to_keep.append(current_idx)
-
-            # Return filtered memories
-            return [text_memories[i] for i in sorted(to_keep)]
-
-        except Exception as e:
-            logging.error(f"Error filtering memories: {e!s}")
-            return text_memories  # Return original list if error occurs
-
-    def filter_too_short_memories(
-        self, text_memories: list[str], min_length_threshold: int = 20
-    ) -> list[str]:
-        """
-        Filters out text memories that fall below the minimum length requirement.
-        Handles both English (word count) and Chinese (character count) differently.
-
-        Args:
-            text_memories: List of text memories to be filtered
-            min_length_threshold: Minimum length required to keep a memory.
-                                For English: word count, for Chinese: character count.
-
-        Returns:
-            List of filtered memories meeting the length requirement
-        """
-        if not text_memories:
-            logging.debug("Empty memories list received in short memory filter")
-            return []
-
-        filtered_memories = []
-        removed_count = 0
-
-        for memory in text_memories:
-            stripped_memory = memory.strip()
-            if not stripped_memory:  # Skip empty/whitespace memories
-                removed_count += 1
-                continue
-
-            # Determine measurement method based on language
-            if is_all_english(stripped_memory):
-                length = len(stripped_memory.split())  # Word count for English
-            elif is_all_chinese(stripped_memory):
-                length = len(stripped_memory)  # Character count for Chinese
-            else:
-                logger.debug(
-                    f"Mixed-language memory, using character count: {stripped_memory[:50]}..."
-                )
-                length = len(stripped_memory)  # Default to character count
-
-            if length >= min_length_threshold:
-                filtered_memories.append(memory)
-            else:
-                removed_count += 1
-
-        if removed_count > 0:
-            logger.info(
-                f"Filtered out {removed_count} short memories "
-                f"(below {min_length_threshold} units). "
-                f"Total remaining: {len(filtered_memories)}"
-            )
-
-        return filtered_memories
-
-    def replace_working_memory(
-        self,
-        queries: list[str],
-        user_id: str,
-        mem_cube_id: str,
-        mem_cube: GeneralMemCube,
-        original_memory: list[TextualMemoryItem],
-        new_memory: list[TextualMemoryItem],
-        top_k: int = 10,
-    ) -> None | list[TextualMemoryItem]:
-        """Replace working memory with new memories after reranking."""
-        memories_with_new_order = None
-        text_mem_base = mem_cube.text_mem
-        if isinstance(text_mem_base, TreeTextMemory):
-            text_mem_base: TreeTextMemory = text_mem_base
-            combined_memory = original_memory + new_memory
-            memory_map = {
-                transform_name_to_key(name=mem_obj.memory): mem_obj for mem_obj in combined_memory
-            }
-            combined_text_memory = [transform_name_to_key(name=m.memory) for m in combined_memory]
-
-            # apply filters
-            filtered_combined_text_memory = self.filter_similar_memories(
-                text_memories=combined_text_memory,
-                similarity_threshold=self.filter_similarity_threshold,
-            )
-
-            filtered_combined_text_memory = self.filter_too_short_memories(
-                text_memories=filtered_combined_text_memory,
-                min_length_threshold=self.filter_min_length_threshold,
-            )
-
-            unique_memory = list(dict.fromkeys(filtered_combined_text_memory))
-
-            try:
-                prompt = self.build_prompt(
-                    "memory_reranking",
-                    queries=queries,
-                    current_order=unique_memory,
-                    staging_buffer=[],
-                )
-                response = self.process_llm.generate([{"role": "user", "content": prompt}])
-                response = extract_json_dict(response)
-                text_memories_with_new_order = response.get("new_order", [])[:top_k]
-            except Exception as e:
-                logger.error(f"Fail to rerank with LLM, Exeption: {e}.", exc_info=True)
-                text_memories_with_new_order = unique_memory[:top_k]
-
-            memories_with_new_order = []
-            for text in text_memories_with_new_order:
-                normalized_text = transform_name_to_key(name=text)
-                if text in memory_map:
-                    memories_with_new_order.append(memory_map[normalized_text])
-                else:
-                    logger.warning(
-                        f"Memory text not found in memory map. text: {text}; keys of memory_map: {memory_map.keys()}"
-                    )
-
-            text_mem_base.replace_working_memory(memories_with_new_order)
-            logger.info(
-                f"The working memory has been replaced with {len(memories_with_new_order)} new memories."
-            )
-            self.log_working_memory_replacement(
-                original_memory=original_memory,
-                new_memory=memories_with_new_order,
-                user_id=user_id,
-                mem_cube_id=mem_cube_id,
-                mem_cube=mem_cube,
-            )
-        else:
-            logger.error("memory_base is not supported")
-
-        return memories_with_new_order