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

memos/templates/mem_reader_prompts.py

@@ -1,7 +1,5 @@
 SIMPLE_STRUCT_MEM_READER_PROMPT = """You are a memory extraction expert.
-
 Your task is to extract memories from the perspective of user, based on a conversation between user and assistant. This means identifying what user would plausibly remember — including their own experiences, thoughts, plans, or relevant statements and actions made by others (such as assistant) that impacted or were acknowledged by user.
-
 Please perform:
 1. Identify information that reflects user's experiences, beliefs, concerns, decisions, plans, or reactions — including meaningful input from assistant that user acknowledged or responded to.
 2. Resolve all time, person, and event references clearly:
@@ -18,6 +16,7 @@ For example, write "The user felt exhausted..." instead of "I felt exhausted..."
    - Include all key experiences, thoughts, emotional responses, and plans — even if they seem minor.
    - Prioritize completeness and fidelity over conciseness.
    - Do not generalize or skip details that could be personally meaningful to user.
+5. Please avoid any content that violates national laws and regulations or involves politically sensitive information in the memories you extract.
 
 Return a single valid JSON object with the following structure:
 
@@ -35,7 +34,7 @@ Return a single valid JSON object with the following structure:
 }
 
 Language rules:
-- The `key`, `value`, `tags`, `summary` fields must match the language of the input conversation.
+- The `key`, `value`, `tags`, `summary` fields must match the mostly used language of the input conversation.  **如果输入是中文，请输出中文**
 - Keep `memory_type` in English.
 
 Example:
@@ -66,33 +65,63 @@ Output:
   "summary": "Tom is currently focused on managing a new project with a tight schedule. After a team meeting on June 25, 2025, he realized the original deadline of December 15 might not be feasible due to backend delays. Concerned about insufficient testing time, he welcomed Jerry’s suggestion of proposing an extension. Tom plans to raise the idea of shifting the deadline to January 5, 2026 in the next morning’s meeting. His actions reflect both stress about timelines and a proactive, team-oriented problem-solving approach."
 }
 
+Another Example in Chinese (注意: 当user的语言为中文时，你就需要也输出中文)：
+{
+  "memory list": [
+    {
+      "key": "项目会议",
+      "memory_type": "LongTermMemory",
+      "value": "在2025年6月25日下午3点，Tom与团队开会讨论了新项目，涉及时间表，并提出了对12月15日截止日期可行性的担忧。",
+      "tags": ["项目", "时间表", "会议", "截止日期"]
+    },
+    ...
+  ],
+  "summary": "Tom 目前专注于管理一个进度紧张的新项目..."
+}
+
+Always respond in the same language as the conversation.
+
 Conversation:
 ${conversation}
 
 Your Output:"""
 
-SIMPLE_STRUCT_DOC_READER_PROMPT = """
-You are an expert text analyst for a search and retrieval system. Your task is to process a document chunk and generate a single, structured JSON object.
-The input is a single piece of text: `[DOCUMENT_CHUNK]`.
-You must generate a single JSON object with two top-level keys: `summary` and `tags`.
-1. `summary`:
-   - A dense, searchable summary of the ENTIRE `[DOCUMENT_CHUNK]`.
-   - The purpose is for semantic search embedding.
-   - A clear and accurate sentence that comprehensively summarizes the main points, arguments, and information within the `[DOCUMENT_CHUNK]`.
-   - The goal is to create a standalone overview that allows a reader to fully understand the essence of the chunk without reading the original text.
-   - The summary should be **no more than 50 words**.
-2. `tags`:
-   - A concise list of **3 to 5 high-level, summative tags**.
-   - **Each tag itself should be a short phrase, ideally 2 to 4 words long.**
-   - These tags must represent the core abstract themes of the text, suitable for broad categorization.
-   - **Crucially, prioritize abstract concepts** over specific entities or phrases mentioned in the text. For example, prefer "Supply Chain Resilience" over "Reshoring Strategies".
-
-Here is the document chunk to process:
-`[DOCUMENT_CHUNK]`
+SIMPLE_STRUCT_DOC_READER_PROMPT = """You are an expert text analyst for a search and retrieval system.
+Your task is to process a document chunk and generate a single, structured JSON object.
+
+Please perform:
+1. Identify key information that reflects factual content, insights, decisions, or implications from the documents — including any notable themes, conclusions, or data points. Allow a reader to fully understand the essence of the chunk without reading the original text.
+2. Resolve all time, person, location, and event references clearly:
+   - Convert relative time expressions (e.g., “last year,” “next quarter”) into absolute dates if context allows.
+   - Clearly distinguish between event time and document time.
+   - If uncertainty exists, state it explicitly (e.g., “around 2024,” “exact date unclear”).
+   - Include specific locations if mentioned.
+   - Resolve all pronouns, aliases, and ambiguous references into full names or identities.
+   - Disambiguate entities with the same name if applicable.
+3. Always write from a third-person perspective, referring to the subject or content clearly rather than using first-person ("I", "me", "my").
+4. Do not omit any information that is likely to be important or memorable from the document summaries.
+   - Include all key facts, insights, emotional tones, and plans — even if they seem minor.
+   - Prioritize completeness and fidelity over conciseness.
+   - Do not generalize or skip details that could be contextually meaningful.
+
+Return a single valid JSON object with the following structure:
+
+Return valid JSON:
+{
+  "key": <string, a concise title of the `value` field>,
+  "memory_type": "LongTermMemory",
+  "value": <A clear and accurate paragraph that comprehensively summarizes the main points, arguments, and information within the document chunk — written in English if the input memory items are in English, or in Chinese if the input is in Chinese>,
+  "tags": <A list of relevant thematic keywords (e.g., ["deadline", "team", "planning"])>
+}
+
+Language rules:
+- The `key`, `value`, `tags`, `summary` fields must match the mostly used language of the input document summaries.  **如果输入是中文，请输出中文**
+- Keep `memory_type` in English.
+
+Document chunk:
 {chunk_text}
 
-Produce ONLY the JSON object as your response.
-"""
+Your Output:"""
 
 SIMPLE_STRUCT_MEM_READER_EXAMPLE = """Example:
 Conversation:
@@ -122,4 +151,18 @@ Output:
   "summary": "Tom is currently focused on managing a new project with a tight schedule. After a team meeting on June 25, 2025, he realized the original deadline of December 15 might not be feasible due to backend delays. Concerned about insufficient testing time, he welcomed Jerry’s suggestion of proposing an extension. Tom plans to raise the idea of shifting the deadline to January 5, 2026 in the next morning’s meeting. His actions reflect both stress about timelines and a proactive, team-oriented problem-solving approach."
 }
 
+Another Example in Chinese (注意: 当user的语言为中文时，你就需要也输出中文)：
+{
+  "memory list": [
+    {
+      "key": "项目会议",
+      "memory_type": "LongTermMemory",
+      "value": "在2025年6月25日下午3点，Tom与团队开会讨论了新项目，涉及时间表，并提出了对12月15日截止日期可行性的担忧。",
+      "tags": ["项目", "时间表", "会议", "截止日期"]
+    },
+    ...
+  ],
+  "summary": "Tom 目前专注于管理一个进度紧张的新项目..."
+}
+
 """

memos/templates/mem_scheduler_prompts.py

@@ -1,65 +1,148 @@
-INTENT_RECOGNIZING_PROMPT = """You are a user intent recognizer, and your task is to determine whether the user's current question has been satisfactorily answered.
-
-You will receive the following information:
-
-The user’s current question list (q_list), arranged in chronological order (currently contains only one question);
-The memory information currently present in the system’s workspace (working_memory_list), i.e., the currently known contextual clues.
-Your tasks are:
-
-Determine whether the user is satisfied with the existing answer;
-
-If the user is satisfied, explain the reason and return:
-
-"trigger_retrieval": false
-If the user is not satisfied, meaning the system's answer did not meet their actual needs, please return:
-
-"trigger_retrieval": true
-"missing_evidence": ["Information you infer is missing and needs to be supplemented, such as specific experiences of someone, health records, etc."]
-Please return strictly according to the following JSON format:
-
+INTENT_RECOGNIZING_PROMPT = """
+# User Intent Recognition Task
+
+## Role
+You are an advanced intent analysis system that evaluates answer satisfaction and identifies information gaps.
+
+## Input Analysis
+You will receive:
+1. User's question list (chronological order)
+2. Current system knowledge (working memory)
+
+## Evaluation Criteria
+Consider these satisfaction factors:
+1. Answer completeness (covers all aspects of the question)
+2. Evidence relevance (directly supports the answer)
+3. Detail specificity (contains necessary granularity)
+4. Personalization (tailored to user's context)
+
+## Decision Framework
+1. Mark as satisfied ONLY if:
+   - All question aspects are addressed
+   - Supporting evidence exists in working memory
+   - No apparent gaps in information
+
+2. Mark as 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
+
+## Response Format
 {{
-  "trigger_retrieval": true or false,
-  "missing_evidence": ["The missing evidence needed for the next step of retrieval and completion"]
+  "trigger_retrieval": <boolean>,
+  "missing_evidences": [
+    "<evidence_type_1>",
+    "<evidence_type_2>"
+  ]
 }}
-The user's question list is:
+
+## Evidence Type Examples
+- Personal medical history
+- Recent activity logs
+- Specific measurement data
+- Contextual details about [topic]
+- Temporal information (when something occurred)
+
+## Current Task
+User Questions:
 {q_list}
 
-The memory information currently present in the system’s workspace is:
+Working Memory Contents:
 {working_memory_list}
-"""
 
-MEMORY_RERANKEING_PROMPT = """You are a memory sorter. Your task is to reorder the evidence according to the user's question, placing the evidence that best supports the user's query as close to the front as possible.
-
-Please return the newly reordered memory sequence according to the query in the following format, which must be in JSON:
+## Required Output
+Please provide your analysis in the specified JSON format:
+"""
 
+MEMORY_RERANKING_PROMPT = """
+# Memory Reranking Task
+
+## Role
+You are an intelligent memory reorganization system. Your primary function is to analyze and optimize the ordering of memory evidence based on relevance to recent user queries.
+
+## Task Description
+Reorganize the provided memory evidence list by:
+1. Analyzing the semantic relationship between each evidence item and the user's queries
+2. Calculating relevance scores
+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 of strings with indices)
+
+## Output Requirements
+Return a JSON object with:
+- "new_order": The reordered indices (array of integers)
+- "reasoning": Brief explanation of your ranking logic (1-2 sentences)
+
+## Processing Guidelines
+1. Prioritize evidence that:
+   - Directly answers query questions
+   - Contains exact keyword matches
+   - Provides contextual support
+   - 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: ["[0] python threading", "[1] data visualization"]
+Input order: ["[0] syntax", "[1] matplotlib", "[2] threading"]
+
+Output:
 {{
-"new_order": [...]
+  "new_order": [2, 1, 0],
+  "reasoning": "Threading (2) prioritized for matching newest query, followed by matplotlib (1) for older visualization query",
 }}
-Now the user's question is:
-{query}
 
-The current order is:
-{current_order}"""
+## Current Task
+Queries: {queries} (recency-ordered)
+Current order: {current_order}
 
-FREQ_DETECTING_PROMPT = """You are a memory frequency monitor. Your task is to check which memories in the activation memory list appear in the given answer, and increment their count by 1 for each occurrence.
+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.
 
-Please return strictly according to the following JSON format:
+## 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.
 
-[
-  {{"memory": ..., "count": ...}}, {{"memory": ..., "count": ...}}, ...
-]
+## Example
+- Input Query: "What breed is Max?"
+- Output Keywords (list of string): ["breed", "Max"]
 
-The answer is:
-{answer}
+## Current Task
+- Query: {query}
+- Output Format: A Json list of keywords.
 
-The activation memory list is:
-{activation_memory_freq_list}
+Answer:
 """
 
+
 PROMPT_MAPPING = {
     "intent_recognizing": INTENT_RECOGNIZING_PROMPT,
-    "memory_reranking": MEMORY_RERANKEING_PROMPT,
-    "freq_detecting": FREQ_DETECTING_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,90 @@ 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 a knowledgeable and helpful AI assistant with access to user memories. "
+    "When responding to user queries, you should 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 in your response, "
+    "and memoriesID is the specific memory ID provided in the available memories list. "
+    "For example: [1:abc123], [2:def456], [3:ghi789], [4:jkl101], [5:mno112] "
+    "Do not use connect format like [1:abc123,2:def456]"
+    "Only reference memories that are directly relevant to the user's question. "
+    "Make your responses natural and conversational while incorporating memory references when appropriate."
+)
+
+MEMOS_PRODUCT_ENHANCE_PROMPT = """
+# Memory-Enhanced AI Assistant Prompt
+
+You are a knowledgeable and helpful AI assistant with access to two types of memory sources:
+
+## 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]`
+- 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

@@ -2,32 +2,80 @@ REORGANIZE_PROMPT = """You are a memory clustering and summarization expert.
 
 Given the following child memory items:
 
-Keys:
-{joined_keys}
+{memory_items_text}
+
+Please perform:
+1. Identify information that reflects user's experiences, beliefs, concerns, decisions, plans, or reactions — including meaningful input from assistant that user acknowledged or responded to.
+2. Resolve all time, person, and event references clearly:
+   - Convert relative time expressions (e.g., “yesterday,” “next Friday”) into absolute dates using the message timestamp if possible.
+   - Clearly distinguish between event time and message time.
+   - If uncertainty exists, state it explicitly (e.g., “around June 2025,” “exact date unclear”).
+   - Include specific locations if mentioned.
+   - Resolve all pronouns, aliases, and ambiguous references into full names or identities.
+   - Disambiguate people with the same name if applicable.
+3. Always write from a third-person perspective, referring to user as
+"The user" or by name if name mentioned, rather than using first-person ("I", "me", "my").
+For example, write "The user felt exhausted..." instead of "I felt exhausted...".
+4. Do not omit any information that user is likely to remember.
+   - Include all key experiences, thoughts, emotional responses, and plans — even if they seem minor.
+   - Prioritize completeness and fidelity over conciseness.
+   - Do not generalize or skip details that could be personally meaningful to user.
+5. Summarize all child memory items into one memory item.
+
+Language rules:
+- The `key`, `value`, `tags`, `summary` fields must match the mostly used language of the input memory items.  **如果输入是中文，请输出中文**
+- Keep `memory_type` in English.
 
-Values:
-{joined_values}
+Return valid JSON:
+{
+  "key": <string, a concise title of the `value` field>,
+  "memory_type": <string, Either "LongTermMemory" or "UserMemory">,
+  "value": <A detailed, self-contained, and unambiguous memory statement, only contain detailed, unaltered information extracted and consolidated from the input `value` fields, do not include summary content — written in English if the input memory items are in English, or in Chinese if the input is in Chinese>,
+  "tags": <A list of relevant thematic keywords (e.g., ["deadline", "team", "planning"])>,
+  "summary": <a natural paragraph summarizing the above memories from user's perspective, only contain information from the input `summary` fields, 120–200 words, same language as the input>
+}
 
-Backgrounds:
-{joined_backgrounds}
+"""
 
-Your task:
-- Generate a single clear English `key` (5–10 words max).
-- Write a detailed `value` that merges the key points into a single, complete, well-structured text. This must stand alone and convey what the user should remember.
-- Provide a list of 5–10 relevant English `tags`.
-- Write a short `background` note (50–100 words) covering any extra context, sources, or traceability info.
+DOC_REORGANIZE_PROMPT = """You are a document summarization and knowledge extraction expert.
+
+Given the following summarized document items:
+
+{memory_items_text}
+
+Please perform:
+1. Identify key information that reflects factual content, insights, decisions, or implications from the documents — including any notable themes, conclusions, or data points.
+2. Resolve all time, person, location, and event references clearly:
+   - Convert relative time expressions (e.g., “last year,” “next quarter”) into absolute dates if context allows.
+   - Clearly distinguish between event time and document time.
+   - If uncertainty exists, state it explicitly (e.g., “around 2024,” “exact date unclear”).
+   - Include specific locations if mentioned.
+   - Resolve all pronouns, aliases, and ambiguous references into full names or identities.
+   - Disambiguate entities with the same name if applicable.
+3. Always write from a third-person perspective, referring to the subject or content clearly rather than using first-person ("I", "me", "my").
+4. Do not omit any information that is likely to be important or memorable from the document summaries.
+   - Include all key facts, insights, emotional tones, and plans — even if they seem minor.
+   - Prioritize completeness and fidelity over conciseness.
+   - Do not generalize or skip details that could be contextually meaningful.
+5. Summarize all document summaries into one integrated memory item.
+
+Language rules:
+- The `key`, `value`, `tags`, `summary` fields must match the mostly used language of the input document summaries.  **如果输入是中文，请输出中文**
+- Keep `memory_type` in English.
 
 Return valid JSON:
-{{
-  "key": "<concise topic>",
-  "value": "<full memory text>",
-  "tags": ["tag1", "tag2", ...],
-  "background": "<extra context>"
-}}
+{
+  "key": <string, a concise title of the `value` field>,
+  "memory_type": "LongTermMemory",
+  "value": <A detailed, self-contained, and unambiguous memory statement, only contain detailed, unaltered information extracted and consolidated from the input `value` fields, do not include summary content — written in English if the input memory items are in English, or in Chinese if the input is in Chinese>,
+  "tags": <A list of relevant thematic keywords (e.g., ["deadline", "team", "planning"])>,
+  "summary": <a natural paragraph summarizing the above memories from user's perspective, only contain information from the input `summary` fields, 120–200 words, same language as the input>
+}
+
 """
 
-LOCAL_SUBCLUSTER_PROMPT = """
-You are a memory organization expert.
+
+LOCAL_SUBCLUSTER_PROMPT = """You are a memory organization expert.
 
 You are given a cluster of memory items, each with an ID and content.
 Your task is to divide these into smaller, semantically meaningful sub-clusters.
@@ -36,21 +84,25 @@ Instructions:
 - Identify natural topics by analyzing common time, place, people, and event elements.
 - Each sub-cluster must reflect a coherent theme that helps retrieval.
 - Each sub-cluster should have 2–10 items. Discard singletons.
-- Each item ID must appear in exactly one sub-cluster.
+- Each item ID must appear in exactly one sub-cluster or be discarded. No duplicates are allowed.
+- All IDs in the output must be from the provided Memory items.
 - Return strictly valid JSON only.
 
 Example: If you have items about a project across multiple phases, group them by milestone, team, or event.
 
+Language rules:
+- The `key` fields must match the mostly used language of the clustered memories. **如果输入是中文，请输出中文**
+
 Return valid JSON:
-{{
+{
   "clusters": [
-    {{
-      "ids": ["id1", "id2", ...],
-      "theme": "<short label>"
-    }},
+    {
+      "ids": ["<id1>", "<id2>", ...],
+      "key": "<string, a unique, concise memory title>"
+    },
     ...
   ]
-}}
+}
 
 Memory items:
 {joined_scene}
@@ -70,7 +122,7 @@ Your task:
 Valid options:
 - CAUSE: One clearly leads to the other.
 - CONDITION: One happens only if the other condition holds.
-- RELATE_TO: They are semantically related by shared people, time, place, or event, but neither causes the other.
+- RELATE: They are semantically related by shared people, time, place, or event, but neither causes the other.
 - CONFLICT: They logically contradict each other.
 - NONE: No clear useful connection.
 
@@ -84,7 +136,7 @@ Another Example:
 - Node 2: "The venue was booked for a wedding in August."
 Answer: CONFLICT
 
-Always respond with ONE word: [CAUSE | CONDITION | RELATE_TO | CONFLICT | NONE]
+Always respond with ONE word, no matter what language is for the input nodes: [CAUSE | CONDITION | RELATE | CONFLICT | NONE]
 """
 
 INFER_FACT_PROMPT = """
@@ -125,13 +177,16 @@ Input Memories:
 - "Mary organized the 2023 sustainability summit in Berlin."
 - "Mary presented a keynote on renewable energy at the same summit."
 
+Language rules:
+- The `key`, `value`, `tags`, `background` fields must match the language of the input.
+
 Good Aggregate:
-{{
+{
   "key": "Mary's Sustainability Summit Role",
   "value": "Mary organized and spoke at the 2023 sustainability summit in Berlin, highlighting renewable energy initiatives.",
   "tags": ["Mary", "summit", "Berlin", "2023"],
   "background": "Combined from multiple memories about Mary's activities at the summit."
-}}
+}
 
 If you find NO useful higher-level concept, reply exactly: "None".
 """

memos/vec_dbs/base.py

@@ -55,6 +55,10 @@ class BaseVecDB(ABC):
     def get_by_id(self, id: str) -> VecDBItem | None:
         """Get an item from the vector database."""
 
+    @abstractmethod
+    def get_by_ids(self, ids: list[str]) -> list[VecDBItem]:
+        """Get multiple items by their IDs."""
+
     @abstractmethod
     def get_by_filter(self, filter: dict[str, Any]) -> list[VecDBItem]:
         """
@@ -103,3 +107,11 @@ class BaseVecDB(ABC):
     @abstractmethod
     def delete(self, ids: list[str]) -> None:
         """Delete items from the vector database."""
+
+    @abstractmethod
+    def ensure_payload_indexes(self, fields: list[str]) -> None:
+        """
+        Create payload indexes for specified fields in the collection.
+        Args:
+            fields (list[str]): List of field names to index (as keyword).
+        """