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

memos/memories/textual/tree_text_memory/retrieve/xinyusearch.py

@@ -0,0 +1,335 @@
+"""Xinyu Search API retriever for tree text memory."""
+
+import json
+import uuid
+
+from datetime import datetime
+
+import requests
+
+from memos.embedders.factory import OllamaEmbedder
+from memos.log import get_logger
+from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata
+
+
+logger = get_logger(__name__)
+
+
+class XinyuSearchAPI:
+    """Xinyu Search API Client"""
+
+    def __init__(self, access_key: str, search_engine_id: str, max_results: int = 20):
+        """
+        Initialize Xinyu Search API client
+
+        Args:
+            access_key: Xinyu API access key
+            max_results: Maximum number of results to retrieve
+        """
+        self.access_key = access_key
+        self.max_results = max_results
+
+        # API configuration
+        self.config = {"url": search_engine_id}
+
+        self.headers = {
+            "User-Agent": "PostmanRuntime/7.39.0",
+            "Content-Type": "application/json",
+            "Accept": "*/*",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Connection": "keep-alive",
+            "token": access_key,
+        }
+
+    def query_detail(self, body: dict | None = None, detail: bool = True) -> list[dict]:
+        """
+        Query Xinyu search API for detailed results
+
+        Args:
+            body: Search parameters
+            detail: Whether to get detailed results
+
+        Returns:
+            List of search results
+        """
+        res = []
+        try:
+            url = self.config["url"]
+
+            params = json.dumps(body)
+            resp = requests.request("POST", url, headers=self.headers, data=params)
+            res = json.loads(resp.text)["results"]
+
+            # If detail interface, return online part
+            if "search_type" in body:
+                res = res["online"]
+
+            if not detail:
+                for res_i in res:
+                    res_i["summary"] = "「SUMMARY」" + res_i.get("summary", "")
+
+        except Exception:
+            import traceback
+
+            logger.error(f"xinyu search error: {traceback.format_exc()}")
+        return res
+
+    def search(self, query: str, max_results: int | None = None) -> list[dict]:
+        """
+        Execute search request
+
+        Args:
+            query: Search query
+            max_results: Maximum number of results to return
+
+        Returns:
+            List of search results
+        """
+        if max_results is None:
+            max_results = self.max_results
+
+        body = {
+            "search_type": ["online"],
+            "online_search": {
+                "max_entries": max_results,
+                "cache_switch": False,
+                "baidu_field": {"switch": True, "mode": "relevance", "type": "page"},
+                "bing_field": {"switch": False, "mode": "relevance", "type": "page_web"},
+                "sogou_field": {"switch": False, "mode": "relevance", "type": "page"},
+            },
+            "request_id": "memos" + str(uuid.uuid4()),
+            "queries": query,
+        }
+
+        return self.query_detail(body)
+
+
+class XinyuSearchRetriever:
+    """Xinyu Search retriever that converts search results to TextualMemoryItem format"""
+
+    def __init__(
+        self,
+        access_key: str,
+        search_engine_id: str,
+        embedder: OllamaEmbedder,
+        max_results: int = 20,
+    ):
+        """
+        Initialize Xinyu search retriever
+
+        Args:
+            access_key: Xinyu API access key
+            embedder: Embedder instance for generating embeddings
+            max_results: Maximum number of results to retrieve
+        """
+        self.xinyu_api = XinyuSearchAPI(access_key, search_engine_id, max_results=max_results)
+        self.embedder = embedder
+
+    def retrieve_from_internet(
+        self, query: str, top_k: int = 10, parsed_goal=None
+    ) -> list[TextualMemoryItem]:
+        """
+        Retrieve information from Xinyu search and convert to TextualMemoryItem format
+
+        Args:
+            query: Search query
+            top_k: Number of results to return
+            parsed_goal: Parsed task goal (optional)
+
+        Returns:
+            List of TextualMemoryItem
+        """
+        # Get search results
+        search_results = self.xinyu_api.search(query, max_results=top_k)
+
+        # Convert to TextualMemoryItem format
+        memory_items = []
+
+        for _, result in enumerate(search_results):
+            # Extract basic information from Xinyu response format
+            title = result.get("title", "")
+            content = result.get("content", "")
+            summary = result.get("summary", "")
+            url = result.get("url", "")
+            publish_time = result.get("publish_time", "")
+            if publish_time:
+                try:
+                    publish_time = datetime.strptime(publish_time, "%Y-%m-%d %H:%M:%S").strftime(
+                        "%Y-%m-%d"
+                    )
+                except Exception as e:
+                    logger.error(f"xinyu search error: {e}")
+                    publish_time = datetime.now().strftime("%Y-%m-%d")
+            else:
+                publish_time = datetime.now().strftime("%Y-%m-%d")
+            source = result.get("source", "")
+            site = result.get("site", "")
+            if site:
+                site = site.split("|")[0]
+
+            # Combine memory content
+            memory_content = (
+                f"Title: {title}\nSummary: {summary}\nContent: {content[:200]}...\nSource: {url}"
+            )
+
+            # Create metadata
+            metadata = TreeNodeTextualMemoryMetadata(
+                user_id=None,
+                session_id=None,
+                status="activated",
+                type="fact",  # Search results are usually factual information
+                memory_time=publish_time,
+                source="web",
+                confidence=85.0,  # Confidence level for search information
+                entities=self._extract_entities(title, content, summary),
+                tags=self._extract_tags(title, content, summary, parsed_goal),
+                visibility="public",
+                memory_type="LongTermMemory",  # Search results as working memory
+                key=title,
+                sources=[url] if url else [],
+                embedding=self.embedder.embed([memory_content])[0],
+                created_at=datetime.now().isoformat(),
+                usage=[],
+                background=f"Xinyu search result from {site or source}",
+            )
+            # Create TextualMemoryItem
+            memory_item = TextualMemoryItem(
+                id=str(uuid.uuid4()), memory=memory_content, metadata=metadata
+            )
+
+            memory_items.append(memory_item)
+
+        return memory_items
+
+    def _extract_entities(self, title: str, content: str, summary: str) -> list[str]:
+        """
+        Extract entities from title, content and summary
+
+        Args:
+            title: Article title
+            content: Article content
+            summary: Article summary
+
+        Returns:
+            List of extracted entities
+        """
+        # Simple entity extraction - can be enhanced with NER
+        text = f"{title} {content} {summary}"
+        entities = []
+
+        # Extract potential entities (simple approach)
+        # This can be enhanced with proper NER models
+        words = text.split()
+        for word in words:
+            if len(word) > 2 and word[0].isupper():
+                entities.append(word)
+
+        return list(set(entities))[:10]  # Limit to 10 entities
+
+    def _extract_tags(self, title: str, content: str, summary: str, parsed_goal=None) -> list[str]:
+        """
+        Extract tags from title, content and summary
+
+        Args:
+            title: Article title
+            content: Article content
+            summary: Article summary
+            parsed_goal: Parsed task goal (optional)
+
+        Returns:
+            List of extracted tags
+        """
+        tags = []
+
+        # Add source-based tags
+        tags.append("xinyu_search")
+        tags.append("news")
+
+        # Add content-based tags
+        text = f"{title} {content} {summary}".lower()
+
+        # Simple keyword-based tagging
+        keywords = {
+            "economy": [
+                "economy",
+                "GDP",
+                "growth",
+                "production",
+                "industry",
+                "investment",
+                "consumption",
+                "market",
+                "trade",
+                "finance",
+            ],
+            "politics": [
+                "politics",
+                "government",
+                "policy",
+                "meeting",
+                "leader",
+                "election",
+                "parliament",
+                "ministry",
+            ],
+            "technology": [
+                "technology",
+                "tech",
+                "innovation",
+                "digital",
+                "internet",
+                "AI",
+                "artificial intelligence",
+                "software",
+                "hardware",
+            ],
+            "sports": [
+                "sports",
+                "game",
+                "athlete",
+                "olympic",
+                "championship",
+                "tournament",
+                "team",
+                "player",
+            ],
+            "culture": [
+                "culture",
+                "education",
+                "art",
+                "history",
+                "literature",
+                "music",
+                "film",
+                "museum",
+            ],
+            "health": [
+                "health",
+                "medical",
+                "pandemic",
+                "hospital",
+                "doctor",
+                "medicine",
+                "disease",
+                "treatment",
+            ],
+            "environment": [
+                "environment",
+                "ecology",
+                "pollution",
+                "green",
+                "climate",
+                "sustainability",
+                "renewable",
+            ],
+        }
+
+        for category, words in keywords.items():
+            if any(word in text for word in words):
+                tags.append(category)
+
+        # Add goal-based tags if available
+        if parsed_goal and hasattr(parsed_goal, "tags"):
+            tags.extend(parsed_goal.tags)
+
+        return list(set(tags))[:15]  # Limit to 15 tags

memos/templates/mem_reader_prompts.py

@@ -1,10 +1,9 @@
-SIMPLE_STRUCT_MEM_READER_PROMPT = """
-You are a memory extraction expert.
+SIMPLE_STRUCT_MEM_READER_PROMPT = """You are a memory extraction expert.
 
-Your task is to extract memories from the perspective of ${user_a}, based on a conversation between ${user_a} and ${user_b}. This means identifying what ${user_a} would plausibly remember — including their own experiences, thoughts, plans, or relevant statements and actions made by others (such as ${user_b}) that impacted or were acknowledged by ${user_a}.
+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_a}'s experiences, beliefs, concerns, decisions, plans, or reactions — including meaningful input from ${user_b} that ${user_a} acknowledged or responded to.
+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.
@@ -12,33 +11,32 @@ Please perform:
    - 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_a} as
+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_a} is likely to remember.
+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_a}.
+   - Do not generalize or skip details that could be personally meaningful to user.
 
 Return a single valid JSON object with the following structure:
 
 {
   "memory list": [
     {
-      "key": <string, a unique, concise memory title in English>,
+      "key": <string, a unique, concise memory title>,
       "memory_type": <string, Either "LongTermMemory" or "UserMemory">,
       "value": <A detailed, self-contained, and unambiguous memory statement — written in English if the input conversation is in English, or in Chinese if the conversation is in Chinese>,
-      "tags": <A list of relevant English thematic keywords (e.g.,
-      ["deadline", "team", "planning"])>
+      "tags": <A list of relevant thematic keywords (e.g., ["deadline", "team", "planning"])>
     },
     ...
   ],
-  "summary": <a natural paragraph summarizing the above memories from ${user_a}'s perspective, 120–200 words, same language as the input>
+  "summary": <a natural paragraph summarizing the above memories from user's perspective, 120–200 words, same language as the input>
 }
 
 Language rules:
-- The `value` fields and `summary` must match the language of the input conversation.
-- All metadata fields (`key`, `memory_type`, `tags`) must be in English.
+- The `key`, `value`, `tags`, `summary` fields must match the language of the input conversation.
+- Keep `memory_type` in English.
 
 Example:
 Conversation:
@@ -71,8 +69,7 @@ Output:
 Conversation:
 ${conversation}
 
-Your Output:
-"""
+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.
@@ -96,3 +93,33 @@ Here is the document chunk to process:
 
 Produce ONLY the JSON object as your response.
 """
+
+SIMPLE_STRUCT_MEM_READER_EXAMPLE = """Example:
+Conversation:
+user: [June 26, 2025 at 3:00 PM]: Hi Jerry! Yesterday at 3 PM I had a meeting with my team about the new project.
+assistant: Oh Tom! Do you think the team can finish by December 15?
+user: [June 26, 2025 at 3:00 PM]: I’m worried. The backend won’t be done until
+December 10, so testing will be tight.
+assistant: [June 26, 2025 at 3:00 PM]: Maybe propose an extension?
+user: [June 26, 2025 at 4:21 PM]: Good idea. I’ll raise it in tomorrow’s 9:30 AM meeting—maybe shift the deadline to January 5.
+
+Output:
+{
+  "memory list": [
+    {
+        "key": "Initial project meeting",
+        "memory_type": "LongTermMemory",
+        "value": "On June 25, 2025 at 3:00 PM, Tom held a meeting with their team to discuss a new project. The conversation covered the timeline and raised concerns about the feasibility of the December 15, 2025 deadline.",
+        "tags": ["project", "timeline", "meeting", "deadline"]
+    },
+    {
+        "key": "Planned scope adjustment",
+        "memory_type": "UserMemory",
+        "value": "Tom planned to suggest in a meeting on June 27, 2025 at 9:30 AM that the team should prioritize features and propose shifting the project deadline to January 5, 2026.",
+        "tags": ["planning", "deadline change", "feature prioritization"]
+    },
+  ],
+  "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."
+}
+
+"""

memos/templates/mos_prompts.py

@@ -0,0 +1,63 @@
+COT_DECOMPOSE_PROMPT = """
+I am an 8-year-old student who needs help analyzing and breaking down complex questions. Your task is to help me understand whether a question is complex enough to be broken down into smaller parts.
+
+Requirements:
+1. First, determine if the question is a decomposable problem. If it is a decomposable problem, set 'is_complex' to True.
+2. If the question needs to be decomposed, break it down into 1-3 sub-questions. The number should be controlled by the model based on the complexity of the question.
+3. For decomposable questions, break them down into sub-questions and put them in the 'sub_questions' list. Each sub-question should contain only one question content without any additional notes.
+4. If the question is not a decomposable problem, set 'is_complex' to False and set 'sub_questions' to an empty list.
+5. You must return ONLY a valid JSON object. Do not include any other text, explanations, or formatting.
+
+Here are some examples:
+
+Question: Who is the current head coach of the gymnastics team in the capital of the country that Lang Ping represents?
+Answer: {{"is_complex": true, "sub_questions": ["Which country does Lang Ping represent in volleyball?", "What is the capital of this country?", "Who is the current head coach of the gymnastics team in this capital?"]}}
+
+Question: Which country's cultural heritage is the Great Wall?
+Answer: {{"is_complex": false, "sub_questions": []}}
+
+Question: How did the trade relationship between Madagascar and China develop, and how does this relationship affect the market expansion of the essential oil industry on Nosy Be Island?
+Answer: {{"is_complex": true, "sub_questions": ["How did the trade relationship between Madagascar and China develop?", "How does this trade relationship affect the market expansion of the essential oil industry on Nosy Be Island?"]}}
+
+Please analyze the following question and respond with ONLY a valid JSON object:
+Question: {query}
+Answer:"""
+
+PRO_MODE_WELCOME_MESSAGE = """
+============================================================
+🚀 MemOS PRO Mode Activated!
+============================================================
+✅ Chain of Thought (CoT) enhancement is now enabled by default
+✅ Complex queries will be automatically decomposed and enhanced
+
+🌐 To enable Internet search capabilities:
+   1. Go to your cube's textual memory configuration
+   2. Set the backend to 'google' in the internet_retriever section
+   3. Configure the following parameters:
+      - api_key: Your Google Search API key
+      - cse_id: Your Custom Search Engine ID
+      - num_results: Number of search results (default: 5)
+
+📝 Example configuration at cube config for tree_text_memory :
+   internet_retriever:
+     backend: 'google'
+     config:
+       api_key: 'your_google_api_key_here'
+       cse_id: 'your_custom_search_engine_id'
+       num_results: 5
+details: https://github.com/memos-ai/memos/blob/main/examples/core_memories/tree_textual_w_internet_memoy.py
+============================================================
+"""
+
+SYNTHESIS_PROMPT = """
+exclude memory information, synthesizing information from multiple sources to provide comprehensive answers.
+I will give you chain of thought for sub-questions and their answers.
+Sub-questions and their answers:
+{qa_text}
+
+Please synthesize these answers into a comprehensive response that:
+1. Addresses the original question completely
+2. Integrates information from all sub-questions
+3. Provides clear reasoning and connections
+4. Is well-structured and easy to understand
+5. Maintains a natural conversational tone"""

memos/templates/tree_reorganize_prompts.py

@@ -0,0 +1,168 @@
+REORGANIZE_PROMPT = """You are a memory clustering and summarization expert.
+
+Given the following child memory items:
+
+Keys:
+{joined_keys}
+
+Values:
+{joined_values}
+
+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.
+
+Return valid JSON:
+{{
+  "key": "<concise topic>",
+  "value": "<full memory text>",
+  "tags": ["tag1", "tag2", ...],
+  "background": "<extra context>"
+}}
+"""
+
+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.
+
+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.
+- Return strictly valid JSON only.
+
+Example: If you have items about a project across multiple phases, group them by milestone, team, or event.
+
+Return valid JSON:
+{{
+  "clusters": [
+    {{
+      "ids": ["id1", "id2", ...],
+      "theme": "<short label>"
+    }},
+    ...
+  ]
+}}
+
+Memory items:
+{joined_scene}
+"""
+
+PAIRWISE_RELATION_PROMPT = """
+You are a reasoning assistant.
+
+Given two memory units:
+- Node 1: "{node1}"
+- Node 2: "{node2}"
+
+Your task:
+- Determine their relationship ONLY if it reveals NEW usable reasoning or retrieval knowledge that is NOT already explicit in either unit.
+- Focus on whether combining them adds new temporal, causal, conditional, or conflict information.
+
+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.
+- CONFLICT: They logically contradict each other.
+- NONE: No clear useful connection.
+
+Example:
+- Node 1: "The marketing campaign ended in June."
+- Node 2: "Product sales dropped in July."
+Answer: CAUSE
+
+Another Example:
+- Node 1: "The conference was postponed to August due to the venue being unavailable."
+- Node 2: "The venue was booked for a wedding in August."
+Answer: CONFLICT
+
+Always respond with ONE word: [CAUSE | CONDITION | RELATE_TO | CONFLICT | NONE]
+"""
+
+INFER_FACT_PROMPT = """
+You are an inference expert.
+
+Source Memory: "{source}"
+Target Memory: "{target}"
+
+They are connected by a {relation_type} relation.
+Derive ONE new factual statement that clearly combines them in a way that is NOT a trivial restatement.
+
+Requirements:
+- Include relevant time, place, people, and event details if available.
+- If the inference is a logical guess, explicitly use phrases like "It can be inferred that...".
+
+Example:
+Source: "John missed the team meeting on Monday."
+Target: "Important project deadlines were discussed in that meeting."
+Relation: CAUSE
+Inference: "It can be inferred that John may not know the new project deadlines."
+
+If there is NO new useful fact that combines them, reply exactly: "None"
+"""
+
+AGGREGATE_PROMPT = """
+You are a concept summarization assistant.
+
+Below is a list of memory items:
+{joined}
+
+Your task:
+- Identify if they can be meaningfully grouped under a new, higher-level concept that clarifies their shared time, place, people, or event context.
+- Do NOT aggregate if the overlap is trivial or obvious from each unit alone.
+- If the summary involves any plausible interpretation, explicitly note it (e.g., "This suggests...").
+
+Example:
+Input Memories:
+- "Mary organized the 2023 sustainability summit in Berlin."
+- "Mary presented a keynote on renewable energy at the same summit."
+
+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".
+"""
+
+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.
+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:
+<answer>No</answer>
+
+Output Example 2:
+<answer> ... </answer>
+
+Now reconcile the following two facts:
+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 = """"""