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

memos/memories/textual/general.py

@@ -12,6 +12,7 @@ from memos.llms.factory import AzureLLM, LLMFactory, OllamaLLM, OpenAILLM
 from memos.log import get_logger
 from memos.memories.textual.base import BaseTextMemory
 from memos.memories.textual.item import TextualMemoryItem
+from memos.templates.mem_reader_prompts import SIMPLE_STRUCT_MEM_READER_PROMPT
 from memos.types import MessageList
 from memos.vec_dbs.factory import QdrantVecDB, VecDBFactory
 from memos.vec_dbs.item import VecDBItem
@@ -36,11 +37,7 @@ class GeneralTextMemory(BaseTextMemory):
         stop=stop_after_attempt(3),
         retry=retry_if_exception_type(json.JSONDecodeError),
         before_sleep=lambda retry_state: logger.warning(
-            EXTRACTION_RETRY_LOG.format(
-                error=retry_state.outcome.exception(),
-                attempt_number=retry_state.attempt_number,
-                max_attempt_number=3,
-            )
+            f"Extracting memory failed due to JSON decode error: {retry_state.outcome.exception()}, Attempt retry: {retry_state.attempt_number} / {3}"
         ),
     )
     def extract(self, messages: MessageList) -> list[TextualMemoryItem]:
@@ -52,14 +49,27 @@ class GeneralTextMemory(BaseTextMemory):
         Returns:
             List of TextualMemoryItem objects representing the extracted memories.
         """
-        str_messages = json.dumps(messages)
-        user_query = EXTRACTION_PROMPT_PART_1 + EXTRACTION_PROMPT_PART_2.format(
-            messages=str_messages
+
+        str_messages = "\n".join(
+            [message["role"] + ":" + message["content"] for message in messages]
         )
-        response = self.extractor_llm.generate([{"role": "user", "content": user_query}])
-        raw_extracted_memories = json.loads(response)
+
+        prompt = SIMPLE_STRUCT_MEM_READER_PROMPT.replace("${conversation}", str_messages)
+        messages = [{"role": "user", "content": prompt}]
+        response_text = self.extractor_llm.generate(messages)
+        response_json = self.parse_json_result(response_text)
+
         extracted_memories = [
-            TextualMemoryItem(**memory_dict) for memory_dict in raw_extracted_memories
+            TextualMemoryItem(
+                memory=memory_dict["value"],
+                metadata={
+                    "key": memory_dict["key"],
+                    "source": "conversation",
+                    "tags": memory_dict["tags"],
+                    "updated_at": datetime.now().isoformat(),
+                },
+            )
+            for memory_dict in response_json["memory list"]
         ]
 
         return extracted_memories
@@ -104,7 +114,7 @@ class GeneralTextMemory(BaseTextMemory):
 
         self.vector_db.update(memory_id, vec_db_item)
 
-    def search(self, query: str, top_k: int) -> list[TextualMemoryItem]:
+    def search(self, query: str, top_k: int, info=None, **kwargs) -> list[TextualMemoryItem]:
         """Search for memories based on a query.
         Args:
             query (str): The query to search for.
@@ -206,83 +216,17 @@ class GeneralTextMemory(BaseTextMemory):
         """Embed a single sentence."""
         return self.embedder.embed([sentence])[0]
 
-
-EXTRACTION_PROMPT_PART_1 = f"""You are a memory extractor. Your task is to extract memories from the given messages.
-* You will receive a list of messages, each with a role (user or assistant) and content.
-* Your job is to extract memories related to the user's long-term goals, interests, and emotional states.
-* Each memory should be a dictionary with the following keys:
-    - "memory": The content of the memory (string). Rephrase the content if necessary.
-    - "metadata": A dictionary containing additional information about the memory.
-* The metadata dictionary should include:
-    - "type": The type of memory (string), e.g., "procedure", "fact", "event", "opinion", etc.
-    - "memory_time": The time the memory occurred or refers to (string). Must be in standard `YYYY-MM-DD` format. Relative expressions such as "yesterday" or "tomorrow" are not allowed.
-    - "source": The origin of the memory (string), e.g., `"conversation"`, `"retrieved"`, `"web"`, `"file"`.
-    - "confidence": A numeric score (float between 0 and 100) indicating how certain you are about the accuracy or reliability of the memory.
-    - "entities": A list of key entities (array of strings) mentioned in the memory, e.g., people, places, organizations, e.g., `["Alice", "Paris", "OpenAI"]`.
-    - "tags": A list of keywords or thematic labels (array of strings) associated with the memory for categorization or retrieval, e.g., `["travel", "health", "project-x"]`.
-    - "visibility": The accessibility scope of the memory (string), e.g., `"private"`, `"public"`, `"session"`, determining who or what contexts can access it.
-    - "updated_at": The timestamp of the last modification to the memory (string). Useful for tracking memory freshness or change history. Format: ISO 8601 or natural language.
-* Current date and time is {datetime.now().isoformat()}.
-* Only return the list of memories in JSON format.
-* Do not include any explanations
-* Do not include any extra text
-* Do not include code blocks (```json```)
-
-## Example
-
-### Input
-
-[
-    {{"role": "user", "content": "I plan to visit Paris next week."}},
-    {{"role": "assistant", "content": "Paris is a beautiful city with many attractions."}},
-    {{"role": "user", "content": "I love the Eiffel Tower."}},
-    {{"role": "assistant", "content": "The Eiffel Tower is a must-see landmark in Paris."}}
-]
-
-### Output
-
-[
-  {{
-    "memory": "The user plans to visit Paris on 05-26-2025.",
-    "metadata": {{
-      "type": "event",
-      "memory_time": "2025-05-26",
-      "source": "conversation",
-      "confidence": 90.0,
-      "entities": ["Paris"],
-      "tags": ["travel", "plans"],
-      "visibility": "private",
-      "updated_at": "2025-05-19T00:00:00"
-    }}
-  }},
-  {{
-    "memory": "The user loves the Eiffel Tower.",
-    "metadata": {{
-      "type": "opinion",
-      "memory_time": "2025-05-19",
-      "source": "conversation",
-      "confidence": 100.0,
-      "entities": ["Eiffel Tower"],
-      "tags": ["opinions", "landmarks"],
-      "visibility": "session",
-      "updated_at": "2025-05-19T00:00:00"
-    }}
-  }}
-]
-
-"""
-
-EXTRACTION_PROMPT_PART_2 = """
-## Query
-
-### Input
-
-{messages}
-
-### Output
-
-"""
-
-EXTRACTION_RETRY_LOG = """Extracting memory failed due to JSON decode error: {error},
-Attempt retry: {attempt_number} / {max_attempt_number}
-"""
+    def parse_json_result(self, response_text):
+        try:
+            json_start = response_text.find("{")
+            response_text = response_text[json_start:]
+            response_text = response_text.replace("```", "").strip()
+            if response_text[-1] != "}":
+                response_text += "}"
+            response_json = json.loads(response_text)
+            return response_json
+        except json.JSONDecodeError as e:
+            logger.warning(
+                f"Failed to parse LLM response as JSON: {e}\nRaw response:\n{response_text}"
+            )
+            return {}

memos/memories/textual/item.py

@@ -27,23 +27,14 @@ class TextualMemoryMetadata(BaseModel):
         default="activated",
         description="The status of the memory, e.g., 'activated', 'archived', 'deleted'.",
     )
-    type: Literal["procedure", "fact", "event", "opinion", "topic", "reasoning"] | None = Field(
-        default=None
-    )
-    memory_time: str | None = Field(
-        default=None,
-        description='The time the memory occurred or refers to. Must be in standard `YYYY-MM-DD` format. Relative expressions such as "yesterday" or "tomorrow" are not allowed.',
-    )
-    source: Literal["conversation", "retrieved", "web", "file"] | None = Field(
-        default=None, description="The origin of the memory"
-    )
+    type: str | None = Field(default=None)
+    key: str | None = Field(default=None, description="Memory key or title.")
     confidence: float | None = Field(
         default=None,
         description="A numeric score (float between 0 and 100) indicating how certain you are about the accuracy or reliability of the memory.",
     )
-    entities: list[str] | None = Field(
-        default=None,
-        description='A list of key entities mentioned in the memory, e.g., people, places, organizations, e.g., `["Alice", "Paris", "OpenAI"]`.',
+    source: Literal["conversation", "retrieved", "web", "file"] | None = Field(
+        default=None, description="The origin of the memory"
     )
     tags: list[str] | None = Field(
         default=None,
@@ -59,23 +50,6 @@ class TextualMemoryMetadata(BaseModel):
 
     model_config = ConfigDict(extra="allow")
 
-    @field_validator("memory_time")
-    @classmethod
-    def validate_memory_time(cls, v):
-        try:
-            if v:
-                datetime.strptime(v, "%Y-%m-%d")
-        except ValueError as e:
-            raise ValueError("Invalid date format. Use YYYY-MM-DD.") from e
-        return v
-
-    @field_validator("confidence")
-    @classmethod
-    def validate_confidence(cls, v):
-        if v is not None and (v < 0 or v > 100):
-            raise ValueError("Confidence must be between 0 and 100.")
-        return v
-
     def __str__(self) -> str:
         """Pretty string representation of the metadata."""
         meta = self.model_dump(exclude_none=True)
@@ -85,10 +59,9 @@ class TextualMemoryMetadata(BaseModel):
 class TreeNodeTextualMemoryMetadata(TextualMemoryMetadata):
     """Extended metadata for structured memory, layered retrieval, and lifecycle tracking."""
 
-    memory_type: Literal["WorkingMemory", "LongTermMemory", "UserMemory"] = Field(
+    memory_type: Literal["WorkingMemory", "LongTermMemory", "UserMemory", "OuterMemory"] = Field(
         default="WorkingMemory", description="Memory lifecycle type."
     )
-    key: str | None = Field(default=None, description="Memory key or title.")
     sources: list[str] | None = Field(
         default=None, description="Multiple origins of the memory (e.g., URLs, notes)."
     )
@@ -148,7 +121,6 @@ class TextualMemoryItem(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    @field_validator("id")
     @classmethod
     def validate_id(cls, v):
         try:

memos/memories/textual/tree.py

@@ -117,13 +117,19 @@ class TreeTextMemory(BaseTextMemory):
             logger.warning(
                 "Internet retriever is init by config , but  this search set manual_close_internet is True  and will close it"
             )
-            self.internet_retriever = None
-        searcher = Searcher(
-            self.dispatcher_llm,
-            self.graph_store,
-            self.embedder,
-            internet_retriever=self.internet_retriever,
-        )
+            searcher = Searcher(
+                self.dispatcher_llm,
+                self.graph_store,
+                self.embedder,
+                internet_retriever=None,
+            )
+        else:
+            searcher = Searcher(
+                self.dispatcher_llm,
+                self.graph_store,
+                self.embedder,
+                internet_retriever=self.internet_retriever,
+            )
         return searcher.search(query, top_k, info, mode, memory_type)
 
     def get_relevant_subgraph(

memos/memories/textual/tree_text_memory/organize/{conflict.py → handler.py}

@@ -1,23 +1,23 @@
 import json
 import re
-
 from datetime import datetime
 
+from dateutil import parser
+
 from memos.embedders.base import BaseEmbedder
 from memos.graph_dbs.neo4j import Neo4jGraphDB
 from memos.llms.base import BaseLLM
 from memos.log import get_logger
 from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemoryMetadata
 from memos.templates.tree_reorganize_prompts import (
-    CONFLICT_DETECTOR_PROMPT,
-    CONFLICT_RESOLVER_PROMPT,
+    MEMORY_RELATION_DETECTOR_PROMPT,
+    MEMORY_RELATION_RESOLVER_PROMPT,
 )
 
-
 logger = get_logger(__name__)
 
 
-class ConflictHandler:
+class NodeHandler:
     EMBEDDING_THRESHOLD: float = 0.8  # Threshold for embedding similarity to consider conflict
 
     def __init__(self, graph_store: Neo4jGraphDB, llm: BaseLLM, embedder: BaseEmbedder):
@@ -25,66 +25,53 @@ class ConflictHandler:
         self.llm = llm
         self.embedder = embedder
 
-    def detect(
-        self, memory: TextualMemoryItem, top_k: int = 5, scope: str | None = None
-    ) -> list[tuple[TextualMemoryItem, TextualMemoryItem]]:
-        """
-        Detect conflicts by finding the most similar items in the graph database based on embedding, then use LLM to judge conflict.
-        Args:
-            memory: The memory item (should have an embedding attribute or field).
-            top_k: Number of top similar nodes to retrieve.
-            scope: Optional memory type filter.
-        Returns:
-            List of conflict pairs (each pair is a tuple: (memory, candidate)).
-        """
+    def detect(self, memory, top_k: int = 5, scope=None):
         # 1. Search for similar memories based on embedding
         embedding = memory.metadata.embedding
         embedding_candidates_info = self.graph_store.search_by_embedding(
-            embedding, top_k=top_k, scope=scope
+            embedding, top_k=top_k, scope=scope, threshold=self.EMBEDDING_THRESHOLD
         )
         # 2. Filter based on similarity threshold
         embedding_candidates_ids = [
-            info["id"]
-            for info in embedding_candidates_info
-            if info["score"] >= self.EMBEDDING_THRESHOLD and info["id"] != memory.id
+            info["id"] for info in embedding_candidates_info if info["id"] != memory.id
         ]
         # 3. Judge conflicts using LLM
         embedding_candidates = self.graph_store.get_nodes(embedding_candidates_ids)
-        conflict_pairs = []
+        detected_relationships = []
         for embedding_candidate in embedding_candidates:
             embedding_candidate = TextualMemoryItem.from_dict(embedding_candidate)
             prompt = [
-                {
-                    "role": "system",
-                    "content": "You are a conflict detector for memory items.",
-                },
                 {
                     "role": "user",
-                    "content": CONFLICT_DETECTOR_PROMPT.format(
-                        statement_1=memory.memory,
-                        statement_2=embedding_candidate.memory,
+                    "content": MEMORY_RELATION_DETECTOR_PROMPT.format(
+                        statement_1=memory.memory, statement_2=embedding_candidate.memory
                     ),
-                },
+                }
             ]
             result = self.llm.generate(prompt).strip()
-            if "yes" in result.lower():
-                conflict_pairs.append([memory, embedding_candidate])
-        if len(conflict_pairs):
-            conflict_text = "\n".join(
-                f'"{pair[0].memory!s}" <==CONFLICT==> "{pair[1].memory!s}"'
-                for pair in conflict_pairs
-            )
-            logger.warning(
-                f"Detected {len(conflict_pairs)} conflicts for memory {memory.id}\n {conflict_text}"
-            )
-        return conflict_pairs
+            if result == "contradictory":
+                logger.warning(
+                    f'detected "{memory.memory}" <==CONFLICT==> "{embedding_candidate.memory}"'
+                )
+                detected_relationships.append([memory, embedding_candidate, "contradictory"])
+            elif result == "redundant":
+                logger.warning(
+                    f'detected "{memory.memory}" <==REDUNDANT==> "{embedding_candidate.memory}"'
+                )
+                detected_relationships.append([memory, embedding_candidate, "redundant"])
+            elif result == "independent":
+                pass
+            else:
+                pass
+        return detected_relationships
 
-    def resolve(self, memory_a: TextualMemoryItem, memory_b: TextualMemoryItem) -> None:
+    def resolve(self, memory_a: TextualMemoryItem, memory_b: TextualMemoryItem, relation) -> None:
         """
         Resolve detected conflicts between two memory items using LLM fusion.
         Args:
             memory_a: The first conflicting memory item.
             memory_b: The second conflicting memory item.
+            relation: relation
         Returns:
             A fused TextualMemoryItem representing the resolved memory.
         """
@@ -94,13 +81,10 @@ class ConflictHandler:
         metadata_1 = memory_a.metadata.model_dump_json(include=metadata_for_resolve)
         metadata_2 = memory_b.metadata.model_dump_json(include=metadata_for_resolve)
         prompt = [
-            {
-                "role": "system",
-                "content": "",
-            },
             {
                 "role": "user",
-                "content": CONFLICT_RESOLVER_PROMPT.format(
+                "content": MEMORY_RELATION_RESOLVER_PROMPT.format(
+                    relation=relation,
                     statement_1=memory_a.memory,
                     metadata_1=metadata_1,
                     statement_2=memory_b.memory,
@@ -117,7 +101,7 @@ class ConflictHandler:
             # —————— 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. "
+                    f"{relation} 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 ————
@@ -133,8 +117,8 @@ class ConflictHandler:
         """
         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)
+        time_a = parser.isoparse(memory_a.metadata.updated_at)
+        time_b = parser.isoparse(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

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

@@ -39,8 +39,8 @@ class MemoryManager:
         if not memory_size:
             self.memory_size = {
                 "WorkingMemory": 20,
-                "LongTermMemory": 10000,
-                "UserMemory": 10000,
+                "LongTermMemory": 1500,
+                "UserMemory": 480,
             }
         self._threshold = threshold
         self.is_reorganize = is_reorganize
@@ -158,106 +158,18 @@ class MemoryManager:
         - topic_summary_prefix: summary node id prefix if applicable
         - enable_summary_link: whether to auto-link to a summary node
         """
-        embedding = memory.metadata.embedding
-
-        # Step 1: Find similar nodes for possible merging
-        similar_nodes = self.graph_store.search_by_embedding(
-            vector=embedding,
-            top_k=3,
-            scope=memory_type,
-            threshold=self._threshold,
-            status="activated",
-        )
-
-        if similar_nodes and similar_nodes[0]["score"] > self._merged_threshold:
-            return self._merge(memory, similar_nodes)
-        else:
-            node_id = str(uuid.uuid4())
-            # Step 2: Add new node to graph
-            self.graph_store.add_node(
-                node_id, memory.memory, memory.metadata.model_dump(exclude_none=True)
-            )
-            self.reorganizer.add_message(
-                QueueMessage(
-                    op="add",
-                    after_node=[node_id],
-                )
-            )
-            return node_id
-
-    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.
-
-        Merge the source memory into the most similar existing node (only one),
-        and establish a MERGED_FROM edge in the graph.
-
-        Parameters:
-            source_node: The new memory item (not yet in the graph)
-            similar_nodes: A list of dicts returned by search_by_embedding(), ordered by similarity
-        """
-        original_node = similar_nodes[0]
-        original_id = original_node["id"]
-        original_data = self.graph_store.get_node(original_id)
-
-        target_text = original_data.get("memory", "")
-        merged_text = f"{target_text}\n⟵MERGED⟶\n{source_node.memory}"
-
-        original_meta = TreeNodeTextualMemoryMetadata(**original_data["metadata"])
-        source_meta = source_node.metadata
-
-        merged_key = source_meta.key or original_meta.key
-        merged_tags = list(set((original_meta.tags or []) + (source_meta.tags or [])))
-        merged_sources = list(set((original_meta.sources or []) + (source_meta.sources or [])))
-        merged_background = f"{original_meta.background}\n⟵MERGED⟶\n{source_meta.background}"
-        merged_embedding = self.embedder.embed([merged_text])[0]
-
-        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
-        merged_id = str(uuid.uuid4())
-        merged_metadata = source_meta.model_copy(
-            update={
-                "embedding": merged_embedding,
-                "updated_at": datetime.now().isoformat(),
-                "key": merged_key,
-                "tags": merged_tags,
-                "sources": merged_sources,
-                "background": merged_background,
-                "confidence": merged_confidence,
-                "usage": merged_usage,
-            }
-        )
-
+        node_id = str(uuid.uuid4())
+        # Step 2: Add new node to graph
         self.graph_store.add_node(
-            merged_id, merged_text, merged_metadata.model_dump(exclude_none=True)
+            node_id, memory.memory, memory.metadata.model_dump(exclude_none=True)
         )
-
-        # Add traceability edges: both original and new point to merged node
-        self.graph_store.add_edge(original_id, merged_id, type="MERGED_TO")
-        self.graph_store.update_node(original_id, {"status": "archived"})
-        source_id = str(uuid.uuid4())
-        source_metadata = source_node.metadata.model_copy(update={"status": "archived"})
-        self.graph_store.add_node(source_id, source_node.memory, source_metadata.model_dump())
-        self.graph_store.add_edge(source_id, merged_id, type="MERGED_TO")
-        # After creating merged node and tracing lineage
-        self._inherit_edges(original_id, merged_id)
-
-        # log to reorganizer before updating the graph
         self.reorganizer.add_message(
             QueueMessage(
-                op="merge",
-                before_node=[
-                    original_id,
-                    source_node.id,
-                ],
-                after_node=[merged_id],
+                op="add",
+                after_node=[node_id],
             )
         )
-        return merged_id
+        return node_id
 
     def _inherit_edges(self, from_id: str, to_id: str) -> None:
         """

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,53 +31,59 @@ 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=5)
-        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(
@@ -176,10 +183,9 @@ class RelationAndReasoningDetector:
         joined = "\n".join(f"- {n.memory}" for n in combined_nodes)
         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(