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

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

@@ -5,7 +5,7 @@ from datetime import datetime
 
 from memos.embedders.factory import OllamaEmbedder
 from memos.graph_dbs.neo4j import Neo4jGraphDB
-from memos.llms.factory import OllamaLLM, OpenAILLM
+from memos.llms.factory import AzureLLM, OllamaLLM, OpenAILLM
 from memos.log import get_logger
 from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata
 from memos.memories.textual.tree_text_memory.organize.reorganizer import (
@@ -22,7 +22,7 @@ class MemoryManager:
         self,
         graph_store: Neo4jGraphDB,
         embedder: OllamaEmbedder,
-        llm: OpenAILLM | OllamaLLM,
+        llm: OpenAILLM | OllamaLLM | AzureLLM,
         memory_size: dict | None = None,
         threshold: float | None = 0.80,
         merged_threshold: float | None = 0.92,
@@ -49,15 +49,18 @@ class MemoryManager:
         )
         self._merged_threshold = merged_threshold
 
-    def add(self, memories: list[TextualMemoryItem]) -> None:
+    def add(self, memories: list[TextualMemoryItem]) -> list[str]:
         """
         Add new memories in parallel to different memory types (WorkingMemory, LongTermMemory, UserMemory).
         """
+        added_ids: list[str] = []
+
         with ThreadPoolExecutor(max_workers=8) as executor:
-            futures = [executor.submit(self._process_memory, memory) for memory in memories]
+            futures = {executor.submit(self._process_memory, m): m for m in memories}
             for future in as_completed(futures):
                 try:
-                    future.result()
+                    ids = future.result()
+                    added_ids.extend(ids)
                 except Exception as e:
                     logger.exception("Memory processing error: ", exc_info=e)
 
@@ -72,6 +75,7 @@ class MemoryManager:
         )
 
         self._refresh_memory_size()
+        return added_ids
 
     def replace_working_memory(self, memories: list[TextualMemoryItem]) -> None:
         """
@@ -113,17 +117,23 @@ class MemoryManager:
         Process and add memory to different memory types (WorkingMemory, LongTermMemory, UserMemory).
         This method runs asynchronously to process each memory item.
         """
+        ids = []
+
         # Add to WorkingMemory
-        self._add_memory_to_db(memory, "WorkingMemory")
+        working_id = self._add_memory_to_db(memory, "WorkingMemory")
+        ids.append(working_id)
 
         # Add to LongTermMemory and UserMemory
         if memory.metadata.memory_type in ["LongTermMemory", "UserMemory"]:
-            self._add_to_graph_memory(
+            added_id = self._add_to_graph_memory(
                 memory=memory,
                 memory_type=memory.metadata.memory_type,
             )
+            ids.append(added_id)
 
-    def _add_memory_to_db(self, memory: TextualMemoryItem, memory_type: str):
+        return ids
+
+    def _add_memory_to_db(self, memory: TextualMemoryItem, memory_type: str) -> str:
         """
         Add a single memory item to the graph store, with FIFO logic for WorkingMemory.
         """
@@ -135,6 +145,7 @@ class MemoryManager:
 
         # Insert node into graph
         self.graph_store.add_node(working_memory.id, working_memory.memory, metadata)
+        return working_memory.id
 
     def _add_to_graph_memory(self, memory: TextualMemoryItem, memory_type: str):
         """
@@ -159,7 +170,7 @@ class MemoryManager:
         )
 
         if similar_nodes and similar_nodes[0]["score"] > self._merged_threshold:
-            self._merge(memory, similar_nodes)
+            return self._merge(memory, similar_nodes)
         else:
             node_id = str(uuid.uuid4())
             # Step 2: Add new node to graph
@@ -172,8 +183,9 @@ class MemoryManager:
                     after_node=[node_id],
                 )
             )
+            return node_id
 
-    def _merge(self, source_node: TextualMemoryItem, similar_nodes: list[dict]) -> None:
+    def _merge(self, source_node: TextualMemoryItem, similar_nodes: list[dict]) -> str:
         """
         TODO: Add node traceability support by optionally preserving source nodes and linking them with MERGED_FROM edges.
 
@@ -200,7 +212,9 @@ class MemoryManager:
         merged_background = f"{original_meta.background}\n⟵MERGED⟶\n{source_meta.background}"
         merged_embedding = self.embedder.embed([merged_text])[0]
 
-        merged_confidence = float((original_meta.confidence + source_meta.confidence) / 2)
+        original_conf = original_meta.confidence or 0.0
+        source_conf = source_meta.confidence or 0.0
+        merged_confidence = float((original_conf + source_conf) / 2)
         merged_usage = list(set((original_meta.usage or []) + (source_meta.usage or [])))
 
         # Create new merged node
@@ -232,13 +246,6 @@ class MemoryManager:
         # After creating merged node and tracing lineage
         self._inherit_edges(original_id, merged_id)
 
-        # Relate other similar nodes to merged if needed
-        for related_node in similar_nodes[1:]:
-            if not self.graph_store.edge_exists(
-                merged_id, related_node["id"], type="ANY", direction="ANY"
-            ):
-                self.graph_store.add_edge(merged_id, related_node["id"], type="RELATE")
-
         # log to reorganizer before updating the graph
         self.reorganizer.add_message(
             QueueMessage(
@@ -250,6 +257,7 @@ class MemoryManager:
                 after_node=[merged_id],
             )
         )
+        return merged_id
 
     def _inherit_edges(self, from_id: str, to_id: str) -> None:
         """

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

@@ -30,7 +30,7 @@ class RedundancyHandler:
         self, memory: TextualMemoryItem, top_k: int = 5, scope: str | None = None
     ) -> list[tuple[TextualMemoryItem, TextualMemoryItem]]:
         """
-        Detect redundancy by finding the most similar items in the graph database based on embedding, then use LLM to judge conflict.
+        Detect redundancy by finding the most similar items in the graph database based on embedding, then use LLM to judge redundancy.
         Args:
             memory: The memory item (should have an embedding attribute or field).
             top_k: Number of top similar nodes to retrieve.
@@ -49,7 +49,7 @@ class RedundancyHandler:
             for info in embedding_candidates_info
             if info["score"] >= self.EMBEDDING_THRESHOLD and info["id"] != memory.id
         ]
-        # 3. Judge conflicts using LLM
+        # 3. Judge redundancys using LLM
         embedding_candidates = self.graph_store.get_nodes(embedding_candidates_ids)
         redundant_pairs = []
         for embedding_candidate in embedding_candidates:
@@ -57,7 +57,7 @@ class RedundancyHandler:
             prompt = [
                 {
                     "role": "system",
-                    "content": "You are a conflict detector for memory items.",
+                    "content": "You are a redundancy detector for memory items.",
                 },
                 {
                     "role": "user",
@@ -71,12 +71,12 @@ class RedundancyHandler:
             if "yes" in result.lower():
                 redundant_pairs.append([memory, embedding_candidate])
         if len(redundant_pairs):
-            conflict_text = "\n".join(
+            redundant_text = "\n".join(
                 f'"{pair[0].memory!s}" <==REDUNDANCY==> "{pair[1].memory!s}"'
                 for pair in redundant_pairs
             )
             logger.warning(
-                f"Detected {len(redundant_pairs)} redundancies for memory {memory.id}\n {conflict_text}"
+                f"Detected {len(redundant_pairs)} redundancies for memory {memory.id}\n {redundant_text}"
             )
         return redundant_pairs
 
@@ -84,12 +84,12 @@ class RedundancyHandler:
         """
         Resolve detected redundancies between two memory items using LLM fusion.
         Args:
-            memory_a: The first conflicting memory item.
-            memory_b: The second conflicting memory item.
+            memory_a: The first redundant memory item.
+            memory_b: The second redundant memory item.
         Returns:
             A fused TextualMemoryItem representing the resolved memory.
         """
-
+        return  # waiting for implementation
         # ———————————— 1. LLM generate fused memory ————————————
         metadata_for_resolve = ["key", "background", "confidence", "updated_at"]
         metadata_1 = memory_a.metadata.model_dump_json(include=metadata_for_resolve)
@@ -115,18 +115,10 @@ class RedundancyHandler:
         try:
             answer = re.search(r"<answer>(.*?)</answer>", response, re.DOTALL)
             answer = answer.group(1).strip()
-            # —————— 2.1 Can't resolve conflict, hard update by comparing timestamp ————
-            if len(answer) <= 10 and "no" in answer.lower():
-                logger.warning(
-                    f"Conflict between {memory_a.id} and {memory_b.id} could not be resolved. "
-                )
-                self._hard_update(memory_a, memory_b)
-            # —————— 2.2 Conflict resolved, update metadata and memory ————
-            else:
-                fixed_metadata = self._merge_metadata(answer, memory_a.metadata, memory_b.metadata)
-                merged_memory = TextualMemoryItem(memory=answer, metadata=fixed_metadata)
-                logger.info(f"Resolved result: {merged_memory}")
-                self._resolve_in_graph(memory_a, memory_b, merged_memory)
+            fixed_metadata = self._merge_metadata(answer, memory_a.metadata, memory_b.metadata)
+            merged_memory = TextualMemoryItem(memory=answer, metadata=fixed_metadata)
+            logger.info(f"Resolved result: {merged_memory}")
+            self._resolve_in_graph(memory_a, memory_b, merged_memory)
         except json.decoder.JSONDecodeError:
             logger.error(f"Failed to parse LLM response: {response}")
 
@@ -145,29 +137,14 @@ class RedundancyHandler:
         )
         logger.debug(f"Merged memory: {memory.memory}")
 
-    def _hard_update(self, memory_a: TextualMemoryItem, memory_b: TextualMemoryItem):
-        """
-        Hard update: compare updated_at, keep the newer one, overwrite the older one's metadata.
-        """
-        time_a = datetime.fromisoformat(memory_a.metadata.updated_at)
-        time_b = datetime.fromisoformat(memory_b.metadata.updated_at)
-
-        newer_mem = memory_a if time_a >= time_b else memory_b
-        older_mem = memory_b if time_a >= time_b else memory_a
-
-        self.graph_store.delete_node(older_mem.id)
-        logger.warning(
-            f"Delete older memory {older_mem.id}: <{older_mem.memory}> due to conflict with {newer_mem.id}: <{newer_mem.memory}>"
-        )
-
     def _resolve_in_graph(
         self,
-        conflict_a: TextualMemoryItem,
-        conflict_b: TextualMemoryItem,
+        redundant_a: TextualMemoryItem,
+        redundant_b: TextualMemoryItem,
         merged: TextualMemoryItem,
     ):
-        edges_a = self.graph_store.get_edges(conflict_a.id, type="ANY", direction="ANY")
-        edges_b = self.graph_store.get_edges(conflict_b.id, type="ANY", direction="ANY")
+        edges_a = self.graph_store.get_edges(redundant_a.id, type="ANY", direction="ANY")
+        edges_b = self.graph_store.get_edges(redundant_b.id, type="ANY", direction="ANY")
         all_edges = edges_a + edges_b
 
         self.graph_store.add_node(
@@ -175,18 +152,22 @@ class RedundancyHandler:
         )
 
         for edge in all_edges:
-            new_from = merged.id if edge["from"] in (conflict_a.id, conflict_b.id) else edge["from"]
-            new_to = merged.id if edge["to"] in (conflict_a.id, conflict_b.id) else edge["to"]
+            new_from = (
+                merged.id if edge["from"] in (redundant_a.id, redundant_b.id) else edge["from"]
+            )
+            new_to = merged.id if edge["to"] in (redundant_a.id, redundant_b.id) else edge["to"]
             if new_from == new_to:
                 continue
             # Check if the edge already exists before adding
             if not self.graph_store.edge_exists(new_from, new_to, edge["type"], direction="ANY"):
                 self.graph_store.add_edge(new_from, new_to, edge["type"])
 
-        self.graph_store.delete_node(conflict_a.id)
-        self.graph_store.delete_node(conflict_b.id)
+        self.graph_store.update_node(redundant_a.id, {"status": "archived"})
+        self.graph_store.update_node(redundant_b.id, {"status": "archived"})
+        self.graph_store.add_edge(redundant_a.id, merged.id, type="MERGED_TO")
+        self.graph_store.add_edge(redundant_b.id, merged.id, type="MERGED_TO")
         logger.debug(
-            f"Remove {conflict_a.id} and {conflict_b.id}, and inherit their edges to {merged.id}."
+            f"Archive {redundant_a.id} and {redundant_b.id}, and inherit their edges to {merged.id}."
         )
 
     def _merge_metadata(

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

@@ -54,20 +54,26 @@ class RelationAndReasoningDetector:
         )
         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)
+        """
+        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)
+        agg = self._detect_aggregate_node_for_group(node, nearest, min_group_size=5)
         if agg:
             results["aggregate_nodes"].append(agg)
 
@@ -80,7 +86,7 @@ class RelationAndReasoningDetector:
         Vector/tag search ➜ For each candidate, use LLM to decide:
         - CAUSE
         - CONDITION
-        - RELATE_TO
+        - RELATE
         - CONFLICT
         """
         results = {"relations": []}
@@ -168,7 +174,7 @@ 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:
@@ -205,14 +211,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 +224,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,11 +113,18 @@ 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.
         """
+        import schedule
+
         schedule.every(20).seconds.do(self.optimize_structure, scope="LongTermMemory")
         schedule.every(20).seconds.do(self.optimize_structure, scope="UserMemory")
 
@@ -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:
@@ -358,7 +361,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 +381,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 +400,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 +413,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 +426,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 +509,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 +527,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 +583,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/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