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

memos/memories/textual/tree_text_memory/organize/relation_reason_detector.py

@@ -1,4 +1,5 @@
 import json
+import traceback
 
 from memos.embedders.factory import OllamaEmbedder
 from memos.graph_dbs.item import GraphDBNode
@@ -30,47 +31,57 @@ class RelationAndReasoningDetector:
         3) Sequence links
         4) Aggregate concepts
         """
-        if node.metadata.type == "reasoning":
-            logger.info(f"Skip reasoning for inferred node {node.id}")
-            return {
-                "relations": [],
-                "inferred_nodes": [],
-                "sequence_links": [],
-                "aggregate_nodes": [],
-            }
-
         results = {
             "relations": [],
             "inferred_nodes": [],
             "sequence_links": [],
             "aggregate_nodes": [],
         }
+        try:
+            if node.metadata.type == "reasoning":
+                logger.info(f"Skip reasoning for inferred node {node.id}")
+                return {
+                    "relations": [],
+                    "inferred_nodes": [],
+                    "sequence_links": [],
+                    "aggregate_nodes": [],
+                }
+
+            nearest = self.graph_store.get_neighbors_by_tag(
+                tags=node.metadata.tags,
+                exclude_ids=exclude_ids,
+                top_k=top_k,
+                min_overlap=2,
+            )
+            nearest = [GraphDBNode(**cand_data) for cand_data in nearest]
+
+            """
+            # 1) Pairwise relations (including CAUSE/CONDITION/CONFLICT)
+            pairwise = self._detect_pairwise_causal_condition_relations(node, nearest)
+            results["relations"].extend(pairwise["relations"])
+            """
+
+            """
+            # 2) Inferred nodes (from causal/condition)
+            inferred = self._infer_fact_nodes_from_relations(pairwise)
+            results["inferred_nodes"].extend(inferred)
+            """
+
+            """
+            3) Sequence (optional, if you have timestamps)
+            seq = self._detect_sequence_links(node, nearest)
+            results["sequence_links"].extend(seq)
+            """
+
+            # 4) Aggregate
+            agg = self._detect_aggregate_node_for_group(node, nearest, min_group_size=5)
+            if agg:
+                results["aggregate_nodes"].append(agg)
 
-        nearest = self.graph_store.get_neighbors_by_tag(
-            tags=node.metadata.tags,
-            exclude_ids=exclude_ids,
-            top_k=top_k,
-            min_overlap=2,
-        )
-        nearest = [GraphDBNode(**cand_data) for cand_data in nearest]
-
-        # 1) Pairwise relations (including CAUSE/CONDITION/CONFLICT)
-        pairwise = self._detect_pairwise_causal_condition_relations(node, nearest)
-        results["relations"].extend(pairwise["relations"])
-
-        # 2) Inferred nodes (from causal/condition)
-        inferred = self._infer_fact_nodes_from_relations(pairwise)
-        results["inferred_nodes"].extend(inferred)
-
-        # 3) Sequence (optional, if you have timestamps)
-        seq = self._detect_sequence_links(node, nearest)
-        results["sequence_links"].extend(seq)
-
-        # 4) Aggregate
-        agg = self._detect_aggregate_node_for_group(node, nearest, min_group_size=3)
-        if agg:
-            results["aggregate_nodes"].append(agg)
-
+        except Exception as e:
+            logger.error(
+                f"Error {e} while process struct reorganize: trace: {traceback.format_exc()}"
+            )
         return results
 
     def _detect_pairwise_causal_condition_relations(
@@ -80,7 +91,7 @@ class RelationAndReasoningDetector:
         Vector/tag search ➜ For each candidate, use LLM to decide:
         - CAUSE
         - CONDITION
-        - RELATE_TO
+        - RELATE
         - CONFLICT
         """
         results = {"relations": []}
@@ -168,12 +179,11 @@ class RelationAndReasoningDetector:
         combined_nodes = [node, *nearest_nodes]
 
         joined = "\n".join(f"- {n.memory}" for n in combined_nodes)
-        prompt = AGGREGATE_PROMPT.format(joined=joined)
+        prompt = AGGREGATE_PROMPT.replace("{joined}", joined)
         response_text = self._call_llm(prompt)
-        response_json = self._parse_json_result(response_text)
-        if not response_json:
+        summary = self._parse_json_result(response_text)
+        if not summary:
             return None
-        summary = json.loads(response_text)
         embedding = self.embedder.embed([summary["value"]])[0]
 
         parent_node = GraphDBNode(
@@ -205,14 +215,6 @@ class RelationAndReasoningDetector:
             logger.warning(f"[LLM Error] {e}")
             return ""
 
-    def _parse_relation_result(self, response_text: str) -> str:
-        relation = response_text.strip().upper()
-        valid = {"CAUSE", "CONDITION", "RELATE_TO", "CONFLICT", "NONE"}
-        if relation not in valid:
-            logger.warning(f"[RelationDetector] Unexpected relation: {relation}. Fallback NONE.")
-            return "NONE"
-        return relation
-
     def _parse_json_result(self, response_text):
         try:
             response_text = response_text.replace("```", "").replace("json", "")
@@ -226,7 +228,7 @@ class RelationAndReasoningDetector:
         Normalize and validate the LLM relation type output.
         """
         relation = response_text.strip().upper()
-        valid = {"CAUSE", "CONDITION", "RELATE_TO", "CONFLICT", "NONE"}
+        valid = {"CAUSE", "CONDITION", "RELATE", "CONFLICT", "NONE"}
         if relation not in valid:
             logger.warning(
                 f"[RelationDetector] Unexpected relation type: {relation}. Fallback to NONE."

memos/memories/textual/tree_text_memory/organize/reorganizer.py

@@ -3,15 +3,14 @@ import threading
 import time
 import traceback
 
+from collections import Counter, defaultdict
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from queue import PriorityQueue
 from typing import Literal
 
 import numpy as np
-import schedule
-
-from sklearn.cluster import MiniBatchKMeans
 
+from memos.dependency import require_python_package
 from memos.embedders.factory import OllamaEmbedder
 from memos.graph_dbs.item import GraphDBEdge, GraphDBNode
 from memos.graph_dbs.neo4j import Neo4jGraphDB
@@ -32,7 +31,7 @@ logger = get_logger(__name__)
 class QueueMessage:
     def __init__(
         self,
-        op: Literal["add", "remove", "merge", "update"],
+        op: Literal["add", "remove", "merge", "update", "end"],
         # `str` for node and edge IDs, `GraphDBNode` and `GraphDBEdge` for actual objects
         before_node: list[str] | list[GraphDBNode] | None = None,
         before_edge: list[str] | list[GraphDBEdge] | None = None,
@@ -49,7 +48,7 @@ class QueueMessage:
         return f"QueueMessage(op={self.op}, before_node={self.before_node if self.before_node is None else len(self.before_node)}, after_node={self.after_node if self.after_node is None else len(self.after_node)})"
 
     def __lt__(self, other: "QueueMessage") -> bool:
-        op_priority = {"add": 2, "remove": 2, "merge": 1}
+        op_priority = {"add": 2, "remove": 2, "merge": 1, "end": 0}
         return op_priority[self.op] < op_priority[other.op]
 
 
@@ -104,7 +103,7 @@ class GraphStructureReorganizer:
     def _run_message_consumer_loop(self):
         while True:
             message = self.queue.get()
-            if message is None:
+            if message.op == "end":
                 break
 
             try:
@@ -114,13 +113,20 @@ class GraphStructureReorganizer:
                 logger.error(traceback.format_exc())
             self.queue.task_done()
 
+    @require_python_package(
+        import_name="schedule",
+        install_command="pip install schedule",
+        install_link="https://schedule.readthedocs.io/en/stable/installation.html",
+    )
     def _run_structure_organizer_loop(self):
         """
         Use schedule library to periodically trigger structure optimization.
         This runs until the stop flag is set.
         """
-        schedule.every(20).seconds.do(self.optimize_structure, scope="LongTermMemory")
-        schedule.every(20).seconds.do(self.optimize_structure, scope="UserMemory")
+        import schedule
+
+        schedule.every(600).seconds.do(self.optimize_structure, scope="LongTermMemory")
+        schedule.every(600).seconds.do(self.optimize_structure, scope="UserMemory")
 
         logger.info("Structure optimizer schedule started.")
         while not getattr(self, "_stop_scheduler", False):
@@ -134,7 +140,7 @@ class GraphStructureReorganizer:
         if not self.is_reorganize:
             return
 
-        self.add_message(None)
+        self.add_message(QueueMessage(op="end"))
         self.thread.join()
         logger.info("Reorganize thread stopped.")
         self._stop_scheduler = True
@@ -152,9 +158,6 @@ class GraphStructureReorganizer:
 
     def handle_add(self, message: QueueMessage):
         logger.debug(f"Handling add operation: {str(message)[:500]}")
-        assert message.before_node is None and message.before_edge is None, (
-            "Before node and edge should be None for `add` operation."
-        )
         # ———————— 1. check for conflicts ————————
         added_node = message.after_node[0]
         conflicts = self.conflict.detect(added_node, scope=added_node.metadata.memory_type)
@@ -164,9 +167,9 @@ class GraphStructureReorganizer:
                 logger.info(f"Resolved conflict between {added_node.id} and {existing_node.id}.")
 
         # ———————— 2. check for redundancy ————————
-        redundancy = self.redundancy.detect(added_node, scope=added_node.metadata.memory_type)
-        if redundancy:
-            for added_node, existing_node in redundancy:
+        redundancies = self.redundancy.detect(added_node, scope=added_node.metadata.memory_type)
+        if redundancies:
+            for added_node, existing_node in redundancies:
                 self.redundancy.resolve_two_nodes(added_node, existing_node)
                 logger.info(f"Resolved redundancy between {added_node.id} and {existing_node.id}.")
 
@@ -176,14 +179,14 @@ class GraphStructureReorganizer:
     def handle_merge(self, message: QueueMessage):
         after_node = message.after_node[0]
         logger.debug(f"Handling merge operation: <{after_node.memory}>")
-        self.redundancy_resolver.resolve_one_node(after_node)
+        self.redundancy.resolve_one_node(after_node)
 
     def optimize_structure(
         self,
         scope: str = "LongTermMemory",
         local_tree_threshold: int = 10,
         min_cluster_size: int = 3,
-        min_group_size: int = 10,
+        min_group_size: int = 5,
     ):
         """
         Periodically reorganize the graph:
@@ -195,7 +198,7 @@ class GraphStructureReorganizer:
             logger.info(f"Already optimizing for {scope}. Skipping.")
             return
 
-        if self.graph_store.count_nodes(scope) == 0:
+        if self.graph_store.node_not_exist(scope):
             logger.debug(f"[GraphStructureReorganize] No nodes for scope={scope}. Skip.")
             return
 
@@ -248,7 +251,10 @@ class GraphStructureReorganizer:
                     try:
                         f.result()
                     except Exception as e:
-                        logger.warning(f"[Reorganize] Cluster processing failed: {e}")
+                        logger.warning(
+                            f"[Reorganize] Cluster processing "
+                            f"failed: {e}, trace: {traceback.format_exc()}"
+                        )
                 logger.info("[GraphStructure Reorganize] Structure optimization finished.")
 
         finally:
@@ -340,7 +346,7 @@ class GraphStructureReorganizer:
                         agg_node.metadata.model_dump(exclude_none=True),
                     )
                     for child_id in agg_node.metadata.sources:
-                        self.graph_store.add_edge(agg_node.id, child_id, "AGGREGATES")
+                        self.graph_store.add_edge(agg_node.id, child_id, "AGGREGATE_TO")
 
             logger.info("[Reorganizer] Cluster relation/reasoning done.")
 
@@ -358,7 +364,7 @@ class GraphStructureReorganizer:
             scene_lines.append(line)
 
         joined_scene = "\n".join(scene_lines)
-        prompt = LOCAL_SUBCLUSTER_PROMPT.format(joined_scene=joined_scene)
+        prompt = LOCAL_SUBCLUSTER_PROMPT.replace("{joined_scene}", joined_scene)
 
         messages = [{"role": "user", "content": prompt}]
         response_text = self.llm.generate(messages)
@@ -378,9 +384,12 @@ class GraphStructureReorganizer:
 
         return result_subclusters
 
-    def _partition(
-        self, nodes: list[GraphDBNode], min_cluster_size: int = 3
-    ) -> list[list[GraphDBNode]]:
+    @require_python_package(
+        import_name="sklearn",
+        install_command="pip install scikit-learn",
+        install_link="https://scikit-learn.org/stable/install.html",
+    )
+    def _partition(self, nodes, min_cluster_size: int = 3, max_cluster_size: int = 20):
         """
         Partition nodes by:
         1) Frequent tags (top N & above threshold)
@@ -394,7 +403,7 @@ class GraphStructureReorganizer:
         Returns:
             List of clusters, each as a list of GraphDBNode
         """
-        from collections import Counter, defaultdict
+        from sklearn.cluster import MiniBatchKMeans
 
         # 1) Count all tags
         tag_counter = Counter()
@@ -407,7 +416,7 @@ class GraphStructureReorganizer:
         threshold_tags = {tag for tag, count in tag_counter.items() if count >= 50}
         frequent_tags = top_n_tags | threshold_tags
 
-        # Group nodes by tags, ensure each group is unique internally
+        # Group nodes by tags
         tag_groups = defaultdict(list)
 
         for node in nodes:
@@ -420,48 +429,67 @@ class GraphStructureReorganizer:
         assigned_ids = set()
         for tag, group in tag_groups.items():
             if len(group) >= min_cluster_size:
-                filtered_tag_clusters.append(group)
-                assigned_ids.update(n.id for n in group)
+                # Split large groups into chunks of at most max_cluster_size
+                for i in range(0, len(group), max_cluster_size):
+                    sub_group = group[i : i + max_cluster_size]
+                    filtered_tag_clusters.append(sub_group)
+                    assigned_ids.update(n.id for n in sub_group)
             else:
-                logger.info(f"... dropped {tag} ...")
+                logger.info(f"... dropped tag {tag} due to low size ...")
 
         logger.info(
             f"[MixedPartition] Created {len(filtered_tag_clusters)} clusters from tags. "
             f"Nodes grouped by tags: {len(assigned_ids)} / {len(nodes)}"
         )
 
-        # 5) Remaining nodes -> embedding clustering
+        # Remaining nodes -> embedding clustering
         remaining_nodes = [n for n in nodes if n.id not in assigned_ids]
         logger.info(
             f"[MixedPartition] Remaining nodes for embedding clustering: {len(remaining_nodes)}"
         )
 
         embedding_clusters = []
-        if remaining_nodes:
-            x = np.array([n.metadata.embedding for n in remaining_nodes if n.metadata.embedding])
-            k = max(1, min(len(remaining_nodes) // min_cluster_size, 20))
-            if len(x) < k:
-                k = len(x)
 
-            if 1 < k <= len(x):
+        def recursive_clustering(nodes_list):
+            """Recursively split clusters until each is <= max_cluster_size."""
+            if len(nodes_list) <= max_cluster_size:
+                return [nodes_list]
+
+            # Try kmeans with k = ceil(len(nodes) / max_cluster_size)
+            x = np.array([n.metadata.embedding for n in nodes_list if n.metadata.embedding])
+            if len(x) < 2:
+                return [nodes_list]
+
+            k = min(len(x), (len(nodes_list) + max_cluster_size - 1) // max_cluster_size)
+            k = max(1, min(k, len(x)))
+
+            try:
                 kmeans = MiniBatchKMeans(n_clusters=k, batch_size=256, random_state=42)
                 labels = kmeans.fit_predict(x)
 
                 label_groups = defaultdict(list)
-                for node, label in zip(remaining_nodes, labels, strict=False):
+                for node, label in zip(nodes_list, labels, strict=False):
                     label_groups[label].append(node)
 
-                embedding_clusters = list(label_groups.values())
-                logger.info(
-                    f"[MixedPartition] Created {len(embedding_clusters)} clusters from embedding."
-                )
-            else:
-                embedding_clusters = [remaining_nodes]
+                result = []
+                for sub_group in label_groups.values():
+                    result.extend(recursive_clustering(sub_group))
+                return result
+            except Exception as e:
+                logger.warning(f"Clustering failed: {e}, falling back to single cluster.")
+                return [nodes_list]
+
+        if remaining_nodes:
+            clusters = recursive_clustering(remaining_nodes)
+            embedding_clusters.extend(clusters)
+            logger.info(
+                f"[MixedPartition] Created {len(embedding_clusters)} clusters from embeddings."
+            )
 
-        # Merge all & handle small clusters
+        # Merge all clusters
         all_clusters = filtered_tag_clusters + embedding_clusters
 
-        # Optional: merge tiny clusters
+        # Handle small clusters (< min_cluster_size)
         final_clusters = []
         small_nodes = []
         for group in all_clusters:
@@ -484,18 +512,15 @@ class GraphStructureReorganizer:
         if not cluster_nodes:
             raise ValueError("Cluster nodes cannot be empty.")
 
-        joined_keys = "\n".join(f"- {n.metadata.key}" for n in cluster_nodes if n.metadata.key)
-        joined_values = "\n".join(f"- {n.memory}" for n in cluster_nodes)
-        joined_backgrounds = "\n".join(
-            f"- {n.metadata.background}" for n in cluster_nodes if n.metadata.background
+        memories_items_text = "\n\n".join(
+            [
+                f"{i}. key: {n.metadata.key}\nvalue: {n.memory}\nsummary:{n.metadata.background}"
+                for i, n in enumerate(cluster_nodes)
+            ]
         )
 
         # Build prompt
-        prompt = REORGANIZE_PROMPT.format(
-            joined_keys=joined_keys,
-            joined_values=joined_values,
-            joined_backgrounds=joined_backgrounds,
-        )
+        prompt = REORGANIZE_PROMPT.replace("{memory_items_text}", memories_items_text)
 
         messages = [{"role": "user", "content": prompt}]
         response_text = self.llm.generate(messages)
@@ -505,7 +530,7 @@ class GraphStructureReorganizer:
         parent_key = response_json.get("key", "").strip()
         parent_value = response_json.get("value", "").strip()
         parent_tags = response_json.get("tags", [])
-        parent_background = response_json.get("background", "").strip()
+        parent_background = response_json.get("summary", "").strip()
 
         embedding = self.embedder.embed([parent_value])[0]
 
@@ -561,7 +586,7 @@ class GraphStructureReorganizer:
 
     def _preprocess_message(self, message: QueueMessage) -> bool:
         message = self._convert_id_to_node(message)
-        if None in message.after_node:
+        if message.after_node is None or None in message.after_node:
             logger.debug(
                 f"Found non-existent node in after_node in message: {message}, skip this message."
             )

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

@@ -127,7 +127,7 @@ class InternetGoogleRetriever:
         self.embedder = embedder
 
     def retrieve_from_internet(
-        self, query: str, top_k: int = 10, parsed_goal=None
+        self, query: str, top_k: int = 10, parsed_goal=None, info=None
     ) -> list[TextualMemoryItem]:
         """
         Retrieve information from the internet and convert to TextualMemoryItem format
@@ -136,10 +136,13 @@ class InternetGoogleRetriever:
             query: Search query
             top_k: Number of results to return
             parsed_goal: Parsed task goal (optional)
+            info (dict): Leave a record of memory consumption.
 
         Returns:
             List of TextualMemoryItem
         """
+        if not info:
+            info = {"user_id": "", "session_id": ""}
         # Get search results
         search_results = self.google_api.get_all_results(query, max_results=top_k)
 
@@ -157,8 +160,8 @@ class InternetGoogleRetriever:
             memory_content = f"Title: {title}\nSummary: {snippet}\nSource: {link}"
             # Create metadata
             metadata = TreeNodeTextualMemoryMetadata(
-                user_id=None,
-                session_id=None,
+                user_id=info.get("user_id", ""),
+                session_id=info.get("session_id", ""),
                 status="activated",
                 type="fact",  # Internet search results are usually factual information
                 memory_time=datetime.now().strftime("%Y-%m-%d"),

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

@@ -4,6 +4,7 @@ from typing import Any, ClassVar
 
 from memos.configs.internet_retriever import InternetRetrieverConfigFactory
 from memos.embedders.base import BaseEmbedder
+from memos.mem_reader.factory import MemReaderFactory
 from memos.memories.textual.tree_text_memory.retrieve.internet_retriever import (
     InternetGoogleRetriever,
 )
@@ -66,6 +67,7 @@ class InternetRetrieverFactory:
                 access_key=config.api_key,  # Use api_key as access_key for xinyu
                 search_engine_id=config.search_engine_id,
                 embedder=embedder,
+                reader=MemReaderFactory.from_config(config.reader),
                 max_results=config.max_results,
             )
         else:

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

@@ -56,7 +56,6 @@ class GraphMemoryRetriever:
         # Step 3: Merge and deduplicate results
         combined = {item.id: item for item in graph_results + vector_results}
 
-        # Debug: 打印在 graph_results 中但不在 combined 中的 id
         graph_ids = {item.id for item in graph_results}
         combined_ids = set(combined.keys())
         lost_ids = graph_ids - combined_ids

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

@@ -1,7 +1,7 @@
 import numpy as np
 
 from memos.embedders.factory import OllamaEmbedder
-from memos.llms.factory import OllamaLLM, OpenAILLM
+from memos.llms.factory import AzureLLM, OllamaLLM, OpenAILLM
 from memos.memories.textual.item import TextualMemoryItem
 from memos.memories.textual.tree_text_memory.retrieve.retrieval_mid_structs import ParsedTaskGoal
 
@@ -41,7 +41,7 @@ class MemoryReranker:
     Rank retrieved memory cards by structural priority and contextual similarity.
     """
 
-    def __init__(self, llm: OpenAILLM | OllamaLLM, embedder: OllamaEmbedder):
+    def __init__(self, llm: OpenAILLM | OllamaLLM | AzureLLM, embedder: OllamaEmbedder):
         self.llm = llm
         self.embedder = embedder
 

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

@@ -10,4 +10,6 @@ class ParsedTaskGoal:
     memories: list[str] = field(default_factory=list)
     keys: list[str] = field(default_factory=list)
     tags: list[str] = field(default_factory=list)
+    rephrased_query: str | None = None
+    internet_search: bool = False
     goal_type: str | None = None  # e.g., 'default', 'explanation', etc.