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

memos/mem_scheduler/{modules/monitor.py → monitors/general_monitor.py}

@@ -1,11 +1,12 @@
 from datetime import datetime
+from threading import Lock
 from typing import Any
 
 from memos.configs.mem_scheduler import BaseSchedulerConfig
 from memos.llms.base import BaseLLM
 from memos.log import get_logger
 from memos.mem_cube.general import GeneralMemCube
-from memos.mem_scheduler.modules.base import BaseSchedulerModule
+from memos.mem_scheduler.general_modules.base import BaseSchedulerModule
 from memos.mem_scheduler.schemas.general_schemas import (
     DEFAULT_ACTIVATION_MEM_MONITOR_SIZE_LIMIT,
     DEFAULT_WEIGHT_VECTOR_FOR_RANKING,
@@ -28,7 +29,7 @@ from memos.memories.textual.tree import TreeTextMemory
 logger = get_logger(__name__)
 
 
-class SchedulerMonitor(BaseSchedulerModule):
+class SchedulerGeneralMonitor(BaseSchedulerModule):
     """Monitors and manages scheduling operations with LLM integration."""
 
     def __init__(self, process_llm: BaseLLM, config: BaseSchedulerConfig):
@@ -41,14 +42,16 @@ class SchedulerMonitor(BaseSchedulerModule):
 
         # Partial Retention Strategy
         self.partial_retention_number = 2
-        self.working_mem_monitor_capacity = DEFAULT_WORKING_MEM_MONITOR_SIZE_LIMIT
-        self.activation_mem_monitor_capacity = DEFAULT_ACTIVATION_MEM_MONITOR_SIZE_LIMIT
+        self.working_mem_monitor_capacity = self.config.get(
+            "working_mem_monitor_capacity", DEFAULT_WORKING_MEM_MONITOR_SIZE_LIMIT
+        )
+        self.activation_mem_monitor_capacity = self.config.get(
+            "activation_mem_monitor_capacity", DEFAULT_ACTIVATION_MEM_MONITOR_SIZE_LIMIT
+        )
 
         # attributes
         # recording query_messages
-        self.query_monitors: QueryMonitorQueue[QueryMonitorItem] = QueryMonitorQueue(
-            maxsize=self.config.context_window_size
-        )
+        self.query_monitors: dict[UserID, dict[MemCubeID, QueryMonitorQueue[QueryMonitorItem]]] = {}
 
         self.working_memory_monitors: dict[UserID, dict[MemCubeID, MemoryMonitorManager]] = {}
         self.activation_memory_monitors: dict[UserID, dict[MemCubeID, MemoryMonitorManager]] = {}
@@ -57,6 +60,7 @@ class SchedulerMonitor(BaseSchedulerModule):
         self.last_activation_mem_update_time = datetime.min
         self.last_query_consume_time = datetime.min
 
+        self._register_lock = Lock()
         self._process_llm = process_llm
 
     def extract_query_keywords(self, query: str) -> list:
@@ -78,15 +82,34 @@ class SchedulerMonitor(BaseSchedulerModule):
             keywords = [query]
         return keywords
 
+    def register_query_monitor_if_not_exists(
+        self,
+        user_id: UserID | str,
+        mem_cube_id: MemCubeID | str,
+    ) -> None:
+        # First check (lock-free, fast path)
+        if user_id in self.query_monitors and mem_cube_id in self.query_monitors[user_id]:
+            return
+
+        # Second check (with lock, ensures uniqueness)
+        with self._register_lock:
+            if user_id not in self.query_monitors:
+                self.query_monitors[user_id] = {}
+            if mem_cube_id not in self.query_monitors[user_id]:
+                self.query_monitors[user_id][mem_cube_id] = QueryMonitorQueue(
+                    maxsize=self.config.context_window_size
+                )
+
     def register_memory_manager_if_not_exists(
         self,
-        user_id: str,
-        mem_cube_id: str,
+        user_id: UserID | str,
+        mem_cube_id: MemCubeID | str,
         memory_monitors: dict[UserID, dict[MemCubeID, MemoryMonitorManager]],
         max_capacity: int,
     ) -> None:
         """
         Register a new MemoryMonitorManager for the given user and memory cube if it doesn't exist.
+        Thread-safe implementation using double-checked locking pattern.
 
         Checks if a MemoryMonitorManager already exists for the specified user_id and mem_cube_id.
         If not, creates a new MemoryMonitorManager with appropriate capacity settings and registers it.
@@ -94,14 +117,34 @@ class SchedulerMonitor(BaseSchedulerModule):
         Args:
             user_id: The ID of the user to associate with the memory manager
             mem_cube_id: The ID of the memory cube to monitor
+            memory_monitors: Dictionary storing existing memory monitor managers
+            max_capacity: Maximum capacity for the new memory monitor manager
+            lock: Threading lock to ensure safe concurrent access
 
         Note:
             This function will update the loose_max_working_memory_capacity based on the current
             WorkingMemory size plus partial retention number before creating a new manager.
         """
-        # Check if a MemoryMonitorManager already exists for the current user_id and mem_cube_id
-        # If doesn't exist, create and register a new one
-        if (user_id not in memory_monitors) or (mem_cube_id not in memory_monitors[user_id]):
+        # First check (lock-free, fast path)
+        # Quickly verify existence without lock overhead
+        if user_id in memory_monitors and mem_cube_id in memory_monitors[user_id]:
+            logger.info(
+                f"MemoryMonitorManager already exists for user_id={user_id}, "
+                f"mem_cube_id={mem_cube_id} in the provided memory_monitors dictionary"
+            )
+            return
+
+        # Second check (with lock, ensures uniqueness)
+        # Acquire lock before modification and verify again to prevent race conditions
+        with self._register_lock:
+            # Re-check after acquiring lock, as another thread might have created it
+            if user_id in memory_monitors and mem_cube_id in memory_monitors[user_id]:
+                logger.info(
+                    f"MemoryMonitorManager already exists for user_id={user_id}, "
+                    f"mem_cube_id={mem_cube_id} in the provided memory_monitors dictionary"
+                )
+                return
+
             # Initialize MemoryMonitorManager with user ID, memory cube ID, and max capacity
             monitor_manager = MemoryMonitorManager(
                 user_id=user_id, mem_cube_id=mem_cube_id, max_capacity=max_capacity
@@ -113,11 +156,6 @@ class SchedulerMonitor(BaseSchedulerModule):
                 f"Registered new MemoryMonitorManager for user_id={user_id},"
                 f" mem_cube_id={mem_cube_id} with max_capacity={max_capacity}"
             )
-        else:
-            logger.info(
-                f"MemoryMonitorManager already exists for user_id={user_id}, "
-                f"mem_cube_id={mem_cube_id} in the provided memory_monitors dictionary"
-            )
 
     def update_working_memory_monitors(
         self,
@@ -174,11 +212,11 @@ class SchedulerMonitor(BaseSchedulerModule):
         )
 
     def timed_trigger(self, last_time: datetime, interval_seconds: float) -> bool:
-        now = datetime.now()
+        now = datetime.utcnow()
         elapsed = (now - last_time).total_seconds()
         if elapsed >= interval_seconds:
             return True
-        logger.debug(f"Time trigger not ready, {elapsed:.1f}s elapsed (needs {interval_seconds}s)")
+        logger.info(f"Time trigger not ready, {elapsed:.1f}s elapsed (needs {interval_seconds}s)")
         return False
 
     def get_monitor_memories(

memos/mem_scheduler/mos_for_test_scheduler.py

@@ -81,7 +81,13 @@ class MOSForTestScheduler(MOS):
 
                 # from mem_cube
                 memories = mem_cube.text_mem.search(
-                    query, top_k=self.config.top_k - topk_for_scheduler
+                    query,
+                    top_k=self.config.top_k - topk_for_scheduler,
+                    info={
+                        "user_id": target_user_id,
+                        "session_id": self.session_id,
+                        "chat_history": chat_history.chat_history,
+                    },
                 )
                 text_memories = [m.memory for m in memories]
                 print(f"Search results with new working memories: {text_memories}")

memos/mem_scheduler/schemas/general_schemas.py

@@ -10,11 +10,12 @@ ANSWER_LABEL = "answer"
 ADD_LABEL = "add"
 
 TreeTextMemory_SEARCH_METHOD = "tree_text_memory_search"
+TreeTextMemory_FINE_SEARCH_METHOD = "tree_text_memory_fine_search"
 TextMemory_SEARCH_METHOD = "text_memory_search"
 DIRECT_EXCHANGE_TYPE = "direct"
 FANOUT_EXCHANGE_TYPE = "fanout"
-DEFAULT_WORKING_MEM_MONITOR_SIZE_LIMIT = 20
-DEFAULT_ACTIVATION_MEM_MONITOR_SIZE_LIMIT = 5
+DEFAULT_WORKING_MEM_MONITOR_SIZE_LIMIT = 30
+DEFAULT_ACTIVATION_MEM_MONITOR_SIZE_LIMIT = 20
 DEFAULT_ACT_MEM_DUMP_PATH = f"{BASE_DIR}/outputs/mem_scheduler/mem_cube_scheduler_test.kv_cache"
 DEFAULT_THREAD__POOL_MAX_WORKERS = 5
 DEFAULT_CONSUME_INTERVAL_SECONDS = 3

memos/mem_scheduler/schemas/message_schemas.py

@@ -7,7 +7,7 @@ from typing_extensions import TypedDict
 
 from memos.log import get_logger
 from memos.mem_cube.general import GeneralMemCube
-from memos.mem_scheduler.modules.misc import DictConversionMixin
+from memos.mem_scheduler.general_modules.misc import DictConversionMixin
 
 from .general_schemas import NOT_INITIALIZED
 
@@ -138,6 +138,7 @@ class ScheduleLogForWebItem(BaseModel, DictConversionMixin):
     def debug_info(self) -> dict[str, Any]:
         """Return structured debug information for logging purposes."""
         return {
+            "content_preview:": self.log_content[:50],
             "log_id": self.item_id,
             "user_id": self.user_id,
             "mem_cube_id": self.mem_cube_id,

memos/mem_scheduler/schemas/monitor_schemas.py

@@ -1,3 +1,5 @@
+import threading
+
 from collections import Counter
 from datetime import datetime
 from pathlib import Path
@@ -7,7 +9,7 @@ from uuid import uuid4
 from pydantic import BaseModel, Field, computed_field, field_validator
 
 from memos.log import get_logger
-from memos.mem_scheduler.modules.misc import AutoDroppingQueue, DictConversionMixin
+from memos.mem_scheduler.general_modules.misc import AutoDroppingQueue, DictConversionMixin
 from memos.mem_scheduler.schemas.general_schemas import (
     DEFAULT_MAX_QUERY_KEY_WORDS,
     DEFAULT_WEIGHT_VECTOR_FOR_RANKING,
@@ -76,7 +78,7 @@ class QueryMonitorQueue(AutoDroppingQueue[QueryMonitorItem]):
     Each item is expected to be a dictionary containing:
     """
 
-    def put(self, item: QueryMonitorItem, block: bool = True, timeout: float | None = None) -> None:
+    def put(self, item: QueryMonitorItem, block: bool = True, timeout: float | None = 5.0) -> None:
         """
         Add a query item to the queue. Ensures the item is of correct type.
 
@@ -85,6 +87,9 @@ class QueryMonitorQueue(AutoDroppingQueue[QueryMonitorItem]):
         """
         if not isinstance(item, QueryMonitorItem):
             raise ValueError("Item must be an instance of QueryMonitorItem")
+        logger.debug(
+            f"Thread {threading.get_ident()} acquired mutex. Timeout is set to {timeout} seconds"
+        )
         super().put(item, block, timeout)
 
     def get_queries_by_timestamp(
@@ -94,6 +99,7 @@ class QueryMonitorQueue(AutoDroppingQueue[QueryMonitorItem]):
         Retrieve queries added between the specified time range.
         """
         with self.mutex:
+            logger.debug(f"Thread {threading.get_ident()} acquired mutex.")
             return [item for item in self.queue if start_time <= item.timestamp <= end_time]
 
     def get_keywords_collections(self) -> Counter:
@@ -104,6 +110,7 @@ class QueryMonitorQueue(AutoDroppingQueue[QueryMonitorItem]):
             Counter object with keyword counts
         """
         with self.mutex:
+            logger.debug(f"Thread {threading.get_ident()} acquired mutex.")
             all_keywords = [kw for item in self.queue for kw in item.keywords]
             return Counter(all_keywords)
 
@@ -119,6 +126,7 @@ class QueryMonitorQueue(AutoDroppingQueue[QueryMonitorItem]):
             List of query items sorted by timestamp
         """
         with self.mutex:
+            logger.debug(f"Thread {threading.get_ident()} acquired mutex.")
             return [
                 monitor.query_text
                 for monitor in sorted(self.queue, key=lambda x: x.timestamp, reverse=reverse)

memos/mem_scheduler/utils/misc_utils.py

@@ -1,4 +1,5 @@
 import json
+import re
 
 from functools import wraps
 from pathlib import Path
@@ -12,12 +13,52 @@ logger = get_logger(__name__)
 
 
 def extract_json_dict(text: str):
+    """
+    Safely extracts JSON from LLM response text with robust error handling.
+
+    Args:
+        text: Raw text response from LLM that may contain JSON
+
+    Returns:
+        Parsed JSON data (dict or list)
+
+    Raises:
+        ValueError: If no valid JSON can be extracted
+    """
+    if not text:
+        raise ValueError("Empty input text")
+
+    # Normalize the text
     text = text.strip()
+
+    # Remove common code block markers
     patterns_to_remove = ["json```", "```python", "```json", "latex```", "```latex", "```"]
     for pattern in patterns_to_remove:
         text = text.replace(pattern, "")
-    res = json.loads(text.strip())
-    return res
+
+    # Try: direct JSON parse first
+    try:
+        return json.loads(text.strip())
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse JSON from text: {text}. Error: {e!s}", exc_info=True)
+
+    # Fallback 1: Extract JSON using regex
+    json_pattern = r"\{[\s\S]*\}|\[[\s\S]*\]"
+    matches = re.findall(json_pattern, text)
+    if matches:
+        try:
+            return json.loads(matches[0])
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse JSON from text: {text}. Error: {e!s}", exc_info=True)
+
+    # Fallback 2: Handle malformed JSON (common LLM issues)
+    try:
+        # Try adding missing quotes around keys
+        text = re.sub(r"([\{\s,])(\w+)(:)", r'\1"\2"\3', text)
+        return json.loads(text)
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse JSON from text: {text}. Error: {e!s}", exc_info=True)
+        raise ValueError(text) from e
 
 
 def parse_yaml(yaml_file: str | Path):

memos/memories/activation/item.py

@@ -23,7 +23,7 @@ class KVCacheRecords(BaseModel):
         description="Single string combining all text_memories using assembly template",
     )
     timestamp: datetime = Field(
-        default_factory=datetime.now, description="submit time for schedule_messages"
+        default_factory=datetime.utcnow, description="submit time for schedule_messages"
     )
 
 

memos/memories/activation/kv.py

@@ -1,7 +1,8 @@
 import os
 import pickle
-
 from datetime import datetime
+from importlib.metadata import version
+from packaging.version import Version
 
 from transformers import DynamicCache
 
@@ -211,13 +212,24 @@ class KVCacheMemory(BaseActMemory):
         merged = DynamicCache()
         num_layers = len(caches[0].key_cache)
 
-        for layer in range(num_layers):
-            # gather all K and V for this layer
-            keys = [c.key_cache[layer] for c in caches]
-            vals = [c.value_cache[layer] for c in caches]
-            # single concat per layer
-            merged.key_cache.append(torch.cat(keys, dim=-2))
-            merged.value_cache.append(torch.cat(vals, dim=-2))
+        if Version(version("transformers")) >= Version("4.54.0"):
+            merged.append_new_layers(num_layers - 1)
+            for layer in range(num_layers):
+                # gather all K and V for this layer
+                keys = [c.layers[layer].keys for c in caches]
+                vals = [c.layers[layer].values for c in caches]
+                # single concat per layer
+                merged.layers[layer].keys = torch.cat(keys, dim=-2)
+                merged.layers[layer].values = torch.cat(vals, dim=-2)
+
+        else:
+            for layer in range(num_layers):
+                # gather all K and V for this layer
+                keys = [c.key_cache[layer] for c in caches]
+                vals = [c.value_cache[layer] for c in caches]
+                # single concat per layer
+                merged.key_cache.append(torch.cat(keys, dim=-2))
+                merged.value_cache.append(torch.cat(vals, dim=-2))
 
         return merged
 

memos/memories/textual/base.py

@@ -36,7 +36,7 @@ class BaseTextMemory(BaseMemory):
         """Update a memory by memory_id."""
 
     @abstractmethod
-    def search(self, query: str, top_k: int, info=None) -> 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.

memos/memories/textual/general.py

@@ -114,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.

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

@@ -1,6 +1,5 @@
 import json
 import re
-
 from datetime import datetime
 
 from dateutil import parser
@@ -11,15 +10,14 @@ 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):
@@ -27,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.
         """
@@ -96,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,
@@ -119,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 ————

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:
         """