feat: Recall the original text of the knowledge base content rather than retrieving the generated memory.

src/memos/api/config.py

@@ -538,6 +538,10 @@ def get_internet_config() -> dict[str, Any]:
                         "chunker": {
                             "backend": "sentence",
                             "config": {
+                                "save_rawfile": os.getenv(
+                                    "MEM_READER_SAVE_RAWFILENODE", "true"
+                                ).lower()
+                                == "true",
                                 "tokenizer_or_token_counter": "gpt2",
                                 "chunk_size": 512,
                                 "chunk_overlap": 128,
@@ -804,6 +808,8 @@ def get_product_default_config() -> dict[str, Any]:
                     "chunker": {
                         "backend": "sentence",
                         "config": {
+                            "save_rawfile": os.getenv("MEM_READER_SAVE_RAWFILENODE", "true").lower()
+                            == "true",
                             "tokenizer_or_token_counter": "gpt2",
                             "chunk_size": 512,
                             "chunk_overlap": 128,
@@ -919,6 +925,8 @@ def create_user_config(user_name: str, user_id: str) -> tuple["MOSConfig", "Gene
                     "chunker": {
                         "backend": "sentence",
                         "config": {
+                            "save_rawfile": os.getenv("MEM_READER_SAVE_RAWFILENODE", "true").lower()
+                            == "true",
                             "tokenizer_or_token_counter": "gpt2",
                             "chunk_size": 512,
                             "chunk_overlap": 128,

src/memos/api/handlers/formatters_handler.py

@@ -113,7 +113,7 @@ def post_process_textual_mem(
         mem
         for mem in text_formatted_mem
         if mem["metadata"]["memory_type"]
-        in ["WorkingMemory", "LongTermMemory", "UserMemory", "OuterMemory"]
+        in ["WorkingMemory", "LongTermMemory", "UserMemory", "OuterMemory", "RawFileMemory"]
     ]
     tool_mem = [
         mem
@@ -157,12 +157,13 @@ def separate_knowledge_and_conversation_mem(memories: list[dict[str, Any]]):
     for item in memories:
         sources = item.get("metadata", {}).get("sources", [])
         if (
-            len(sources) > 0
+            item["metadata"]["memory_type"] != "RawFileMemory"
+            and len(sources) > 0
             and "type" in sources[0]
             and sources[0]["type"] == "file"
             and "content" in sources[0]
             and sources[0]["content"] != ""
-        ):  # TODO change to memory_type
+        ):
             knowledge_mem.append(item)
         else:
             conversation_mem.append(item)
@@ -203,8 +204,7 @@ def rerank_knowledge_mem(
         key=lambda item: item.get("metadata", {}).get("relativity", 0.0),
         reverse=True,
     )
-
-    # TODO revoke sources replace memory value
+    # replace memory value with source.content for LongTermMemory, WorkingMemory or UserMemory
     for item in reranked_knowledge_mem:
         item["memory"] = item["metadata"]["sources"][0]["content"]
         item["metadata"]["sources"] = []

src/memos/api/product_models.py

@@ -422,8 +422,8 @@ class APISearchRequest(BaseRequest):
     )
     # Internal field for search memory type
     search_memory_type: str = Field(
-        "All",
-        description="Type of memory to search: All, WorkingMemory, LongTermMemory, UserMemory, OuterMemory, ToolSchemaMemory, ToolTrajectoryMemory, SkillMemory",
+        "AllSummaryMemory",
+        description="Type of memory to search: All, WorkingMemory, LongTermMemory, UserMemory, OuterMemory, ToolSchemaMemory, ToolTrajectoryMemory, RawFileMemory, AllSummaryMemory, SkillMemory",
     )
 
     # ==== Context ====
@@ -461,6 +461,13 @@ class APISearchRequest(BaseRequest):
         description="Source of the search query [plugin will router diff search]",
     )
 
+    neighbor_discovery: bool = Field(
+        False,
+        description="Whether to enable neighbor discovery. "
+        "If enabled, the system will automatically recall neighbor chunks "
+        "relevant to the query. Default: False.",
+    )
+
     @model_validator(mode="after")
     def _convert_deprecated_fields(self) -> "APISearchRequest":
         """

src/memos/configs/chunker.py

@@ -14,6 +14,7 @@ class BaseChunkerConfig(BaseConfig):
     chunk_size: int = Field(default=512, description="Maximum tokens per chunk")
     chunk_overlap: int = Field(default=128, description="Overlap between chunks")
     min_sentences_per_chunk: int = Field(default=1, description="Minimum sentences in each chunk")
+    save_rawfile: bool = Field(default=True, description="Whether to save rawfile")  # TODO
 
 
 class SentenceChunkerConfig(BaseChunkerConfig):

src/memos/mem_feedback/feedback.py

@@ -235,20 +235,16 @@ def _single_add_operation(
             to_add_memory.metadata.tags = new_memory_item.metadata.tags
             to_add_memory.memory = new_memory_item.memory
             to_add_memory.metadata.embedding = new_memory_item.metadata.embedding
-
             to_add_memory.metadata.user_id = new_memory_item.metadata.user_id
-            to_add_memory.metadata.created_at = to_add_memory.metadata.updated_at = (
-                datetime.now().isoformat()
-            )
-            to_add_memory.metadata.background = new_memory_item.metadata.background
         else:
             to_add_memory = new_memory_item.model_copy(deep=True)
-            to_add_memory.metadata.created_at = to_add_memory.metadata.updated_at = (
-                datetime.now().isoformat()
-            )
-            to_add_memory.metadata.background = new_memory_item.metadata.background
 
-        to_add_memory.id = ""
+        to_add_memory.metadata.created_at = to_add_memory.metadata.updated_at = (
+            datetime.now().isoformat()
+        )
+        to_add_memory.metadata.background = new_memory_item.metadata.background
+        to_add_memory.metadata.sources = []
+
         added_ids = self._retry_db_operation(
             lambda: self.memory_manager.add([to_add_memory], user_name=user_name, use_batch=False)
         )
@@ -626,10 +622,39 @@ def _info_comparison(self, memory: TextualMemoryItem, _info: dict, include_keys:
 
     def _retrieve(self, query: str, info=None, top_k=20, user_name=None):
         """Retrieve memory items"""
-        retrieved_mems = self.searcher.search(
-            query, info=info, user_name=user_name, top_k=top_k, full_recall=True
+
+        def check_has_edges(mem_item: TextualMemoryItem) -> tuple[TextualMemoryItem, bool]:
+            """Check if a memory item has edges."""
+            edges = self.searcher.graph_store.get_edges(mem_item.id, user_name=user_name)
+            return (mem_item, len(edges) == 0)
+
+        text_mems = self.searcher.search(
+            query,
+            info=info,
+            memory_type="AllSummaryMemory",
+            user_name=user_name,
+            top_k=top_k,
+            full_recall=True,
         )
-        retrieved_mems = [item[0] for item in retrieved_mems if float(item[1]) > 0.01]
+        text_mems = [item[0] for item in text_mems if float(item[1]) > 0.01]
+
+        # Memory with edges is not modified by feedback
+        retrieved_mems = []
+        with ContextThreadPoolExecutor(max_workers=10) as executor:
+            futures = {executor.submit(check_has_edges, item): item for item in text_mems}
+            for future in concurrent.futures.as_completed(futures):
+                try:
+                    mem_item, has_no_edges = future.result()
+                    if has_no_edges:
+                        retrieved_mems.append(mem_item)
+                except Exception as e:
+                    logger.error(f"[0107 Feedback Core: _retrieve] Error checking edges: {e}")
+
+        if len(retrieved_mems) < len(text_mems):
+            logger.info(
+                f"[0107 Feedback Core: _retrieve] {len(text_mems) - len(retrieved_mems)} "
+                f"text memories are not modified by feedback due to edges."
+            )
 
         if self.pref_feedback:
             pref_info = {}

src/memos/mem_reader/multi_modal_struct.py

@@ -288,6 +288,7 @@ def _build_window_from_items(
         # Collect all memory texts and sources
         memory_texts = []
         all_sources = []
+        seen_content = set()  # Track seen source content to avoid duplicates
         roles = set()
         aggregated_file_ids: list[str] = []
 
@@ -301,8 +302,18 @@ def _build_window_from_items(
                 item_sources = [item_sources]
 
             for source in item_sources:
-                # Add source to all_sources
-                all_sources.append(source)
+                # Get content from source for deduplication
+                source_content = None
+                if isinstance(source, dict):
+                    source_content = source.get("content", "")
+                else:
+                    source_content = getattr(source, "content", "") or ""
+
+                # Only add if content is different (empty content is considered unique)
+                content_key = source_content if source_content else None
+                if content_key and content_key not in seen_content:
+                    seen_content.add(content_key)
+                    all_sources.append(source)
 
                 # Extract role from source
                 if hasattr(source, "role") and source.role:
@@ -464,7 +475,10 @@ def _determine_prompt_type(self, sources: list) -> str:
                 source_role = source.get("role")
             if source_role in {"user", "assistant", "system", "tool"}:
                 prompt_type = "chat"
-
+                if hasattr(source, "type"):
+                    source_type = source.type
+                    if source_type == "file":
+                        prompt_type = "doc"
         return prompt_type
 
     def _get_maybe_merged_memory(
@@ -641,11 +655,14 @@ def _process_string_fine(
     ) -> list[TextualMemoryItem]:
         """
         Process fast mode memory items through LLM to generate fine mode memories.
+        Where fast_memory_items are raw chunk memory items, not the final memory items.
         """
         if not fast_memory_items:
             return []
 
-        def _process_one_item(fast_item: TextualMemoryItem) -> list[TextualMemoryItem]:
+        def _process_one_item(
+            fast_item: TextualMemoryItem, chunk_idx: int, total_chunks: int
+        ) -> list[TextualMemoryItem]:
             """Process a single fast memory item and return a list of fine items."""
             fine_items: list[TextualMemoryItem] = []
 
@@ -749,12 +766,40 @@ def _process_one_item(fast_item: TextualMemoryItem) -> list[TextualMemoryItem]:
                 except Exception as e:
                     logger.error(f"[MultiModalFine] parse error: {e}")
 
+            # save rawfile node
+            if self.save_rawfile and prompt_type == "doc" and len(fine_items) > 0:
+                rawfile_chunk = mem_str
+                file_info = fine_items[0].metadata.sources[0].file_info
+                source = self.multi_modal_parser.file_content_parser.create_source(
+                    message={"file": file_info},
+                    info=info_per_item,
+                    chunk_index=chunk_idx,
+                    chunk_total=total_chunks,
+                    chunk_content="",
+                )
+                rawfile_node = self._make_memory_item(
+                    value=rawfile_chunk,
+                    info=info_per_item,
+                    memory_type="RawFileMemory",
+                    tags=[
+                        "mode:fine",
+                        "multimodal:file",
+                        f"chunk:{chunk_idx + 1}/{total_chunks}",
+                    ],
+                    sources=[source],
+                )
+                rawfile_node.metadata.summary_ids = [mem_node.id for mem_node in fine_items]
+                fine_items.append(rawfile_node)
             return fine_items
 
         fine_memory_items: list[TextualMemoryItem] = []
+        total_chunks_len = len(fast_memory_items)
 
         with ContextThreadPoolExecutor(max_workers=30) as executor:
-            futures = [executor.submit(_process_one_item, item) for item in fast_memory_items]
+            futures = [
+                executor.submit(_process_one_item, item, idx, total_chunks_len)
+                for idx, item in enumerate[TextualMemoryItem](fast_memory_items)
+            ]
 
             for future in concurrent.futures.as_completed(futures):
                 try:
@@ -764,6 +809,63 @@ def _process_one_item(fast_item: TextualMemoryItem) -> list[TextualMemoryItem]:
                 except Exception as e:
                     logger.error(f"[MultiModalFine] worker error: {e}")
 
+        # related preceding and following rawfilememories
+        fine_memory_items = self._relate_preceding_following_rawfile_memories(fine_memory_items)
+        return fine_memory_items
+
+    def _relate_preceding_following_rawfile_memories(
+        self, fine_memory_items: list[TextualMemoryItem]
+    ) -> list[TextualMemoryItem]:
+        """
+        Relate RawFileMemory items to each other by setting preceding_id and following_id.
+        """
+        # Filter RawFileMemory items and track their original positions
+        rawfile_items_with_pos = []
+        for idx, item in enumerate[TextualMemoryItem](fine_memory_items):
+            if (
+                hasattr(item.metadata, "memory_type")
+                and item.metadata.memory_type == "RawFileMemory"
+            ):
+                rawfile_items_with_pos.append((idx, item))
+
+        if len(rawfile_items_with_pos) <= 1:
+            return fine_memory_items
+
+        def get_chunk_idx(item_with_pos) -> int:
+            """Extract chunk_idx from item's source metadata."""
+            _, item = item_with_pos
+            if item.metadata.sources and len(item.metadata.sources) > 0:
+                source = item.metadata.sources[0]
+                # Handle both SourceMessage object and dict
+                if isinstance(source, dict):
+                    file_info = source.get("file_info")
+                    if file_info and isinstance(file_info, dict):
+                        chunk_idx = file_info.get("chunk_index")
+                        if chunk_idx is not None:
+                            return chunk_idx
+                else:
+                    # SourceMessage object
+                    file_info = getattr(source, "file_info", None)
+                    if file_info and isinstance(file_info, dict):
+                        chunk_idx = file_info.get("chunk_index")
+                        if chunk_idx is not None:
+                            return chunk_idx
+            return float("inf")
+
+        # Sort items by chunk_index
+        sorted_rawfile_items_with_pos = sorted(rawfile_items_with_pos, key=get_chunk_idx)
+
+        # Relate adjacent items
+        for i in range(len(sorted_rawfile_items_with_pos) - 1):
+            _, current_item = sorted_rawfile_items_with_pos[i]
+            _, next_item = sorted_rawfile_items_with_pos[i + 1]
+            current_item.metadata.following_id = next_item.id
+            next_item.metadata.preceding_id = current_item.id
+
+        # Replace sorted items back to original positions in fine_memory_items
+        for orig_idx, item in sorted_rawfile_items_with_pos:
+            fine_memory_items[orig_idx] = item
+
         return fine_memory_items
 
     def _get_llm_tool_trajectory_response(self, mem_str: str) -> dict: