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

memos/memories/textual/general.py

@@ -7,11 +7,12 @@ from typing import Any
 from tenacity import retry, retry_if_exception_type, stop_after_attempt
 
 from memos.configs.memory import GeneralTextMemoryConfig
-from memos.embedders.factory import EmbedderFactory, OllamaEmbedder
-from memos.llms.factory import LLMFactory, OllamaLLM, OpenAILLM
+from memos.embedders.factory import ArkEmbedder, EmbedderFactory, OllamaEmbedder
+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
@@ -26,19 +27,17 @@ class GeneralTextMemory(BaseTextMemory):
     def __init__(self, config: GeneralTextMemoryConfig):
         """Initialize memory with the given configuration."""
         self.config: GeneralTextMemoryConfig = config
-        self.extractor_llm: OpenAILLM | OllamaLLM = LLMFactory.from_config(config.extractor_llm)
+        self.extractor_llm: OpenAILLM | OllamaLLM | AzureLLM = LLMFactory.from_config(
+            config.extractor_llm
+        )
         self.vector_db: QdrantVecDB = VecDBFactory.from_config(config.vector_db)
-        self.embedder: OllamaEmbedder = EmbedderFactory.from_config(config.embedder)
+        self.embedder: OllamaEmbedder | ArkEmbedder = EmbedderFactory.from_config(config.embedder)
 
     @retry(
         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]:
@@ -50,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
@@ -202,85 +214,19 @@ class GeneralTextMemory(BaseTextMemory):
 
     def _embed_one_sentence(self, sentence: str) -> list[float]:
         """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}
-"""
+        return self.embedder.embed([sentence])[0]
+
+    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

@@ -10,7 +10,7 @@ from typing import Any
 from memos.configs.memory import TreeTextMemoryConfig
 from memos.embedders.factory import EmbedderFactory, OllamaEmbedder
 from memos.graph_dbs.factory import GraphStoreFactory, Neo4jGraphDB
-from memos.llms.factory import LLMFactory, OllamaLLM, OpenAILLM
+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, TreeNodeTextualMemoryMetadata
@@ -31,8 +31,12 @@ class TreeTextMemory(BaseTextMemory):
     def __init__(self, config: TreeTextMemoryConfig):
         """Initialize memory with the given configuration."""
         self.config: TreeTextMemoryConfig = config
-        self.extractor_llm: OpenAILLM | OllamaLLM = LLMFactory.from_config(config.extractor_llm)
-        self.dispatcher_llm: OpenAILLM | OllamaLLM = LLMFactory.from_config(config.dispatcher_llm)
+        self.extractor_llm: OpenAILLM | OllamaLLM | AzureLLM = LLMFactory.from_config(
+            config.extractor_llm
+        )
+        self.dispatcher_llm: OpenAILLM | OllamaLLM | AzureLLM = LLMFactory.from_config(
+            config.dispatcher_llm
+        )
         self.embedder: OllamaEmbedder = EmbedderFactory.from_config(config.embedder)
         self.graph_store: Neo4jGraphDB = GraphStoreFactory.from_config(config.graph_db)
         self.is_reorganize = config.reorganize
@@ -53,7 +57,7 @@ class TreeTextMemory(BaseTextMemory):
         else:
             logger.info("No internet retriever configured")
 
-    def add(self, memories: list[TextualMemoryItem | dict[str, Any]]) -> None:
+    def add(self, memories: list[TextualMemoryItem | dict[str, Any]]) -> list[str]:
         """Add memories.
         Args:
             memories: List of TextualMemoryItem objects or dictionaries to add.
@@ -63,7 +67,7 @@ class TreeTextMemory(BaseTextMemory):
             plan = plan_memory_operations(memory_items, metadata, self.graph_store)
             execute_plan(memory_items, metadata, plan, self.graph_store)
         """
-        self.memory_manager.add(memories)
+        return self.memory_manager.add(memories)
 
     def replace_working_memory(self, memories: list[TextualMemoryItem]) -> None:
         self.memory_manager.replace_working_memory(memories)
@@ -113,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

@@ -3,6 +3,8 @@ 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
@@ -133,8 +135,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
@@ -167,10 +169,12 @@ class ConflictHandler:
             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(conflict_a.id, {"status": "archived"})
+        self.graph_store.update_node(conflict_b.id, {"status": "archived"})
+        self.graph_store.add_edge(conflict_a.id, merged.id, type="MERGED_TO")
+        self.graph_store.add_edge(conflict_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 {conflict_a.id} and {conflict_b.id}, and inherit their edges to {merged.id}."
         )
 
     def _merge_metadata(

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(