diff --git a/apps/memos-local-openclaw/src/viewer/html.ts b/apps/memos-local-openclaw/src/viewer/html.ts
index 03b0eeab7..c3b48c7b4 100644
--- a/apps/memos-local-openclaw/src/viewer/html.ts
+++ b/apps/memos-local-openclaw/src/viewer/html.ts
@@ -1,4 +1,6 @@
-export const viewerHTML = `<!DOCTYPE html>
+export function viewerHTML(pluginVersion?: string): string {
+const vBadge = pluginVersion ? `<span class="version-badge">v${pluginVersion}</span>` : '';
+return `<!DOCTYPE html>
 <html lang="zh-CN">
 <head>
 <meta charset="UTF-8">
@@ -110,6 +112,8 @@ input,textarea,select{font-family:inherit;font-size:inherit}
 .topbar .brand{display:flex;align-items:center;gap:10px;font-weight:700;font-size:15px;color:var(--text);letter-spacing:-.02em;flex-shrink:0}
 .topbar .brand .icon{width:32px;height:32px;display:flex;align-items:center;justify-content:center;font-size:22px;background:none;border-radius:0}
 .topbar .brand .sub{font-weight:400;color:var(--text-muted);font-size:11px}
+.version-badge{font-size:10px;font-weight:600;color:var(--text-muted);background:rgba(255,255,255,.08);border:1px solid rgba(255,255,255,.1);padding:1px 7px;border-radius:6px;margin-left:6px;letter-spacing:.02em;user-select:all}
+[data-theme="light"] .version-badge{background:rgba(0,0,0,.05);border-color:rgba(0,0,0,.08);color:var(--text-sec)}
 .topbar-center{flex:1;display:flex;justify-content:center}
 .topbar .actions{display:flex;align-items:center;gap:6px;flex-shrink:0}
 
@@ -711,7 +715,7 @@ input,textarea,select{font-family:inherit;font-size:inherit}
   <div class="topbar">
     <div class="brand">
       <div class="icon"><svg width="24" height="24" viewBox="0 0 120 120" fill="none" xmlns="http://www.w3.org/2000/svg" style="filter:drop-shadow(0 0 8px rgba(255,77,77,.3))"><defs><linearGradient id="tLG" x1="0%" y1="0%" x2="100%" y2="100%"><stop offset="0%" stop-color="#ff4d4d"/><stop offset="100%" stop-color="#991b1b"/></linearGradient></defs><path d="M60 10C30 10 15 35 15 55C15 75 30 95 45 100L45 110L55 110L55 100C55 100 60 102 65 100L65 110L75 110L75 100C90 95 105 75 105 55C105 35 90 10 60 10Z" fill="url(#tLG)"/><path d="M20 45C5 40 0 50 5 60C10 70 20 65 25 55C28 48 25 45 20 45Z" fill="url(#tLG)"/><path d="M100 45C115 40 120 50 115 60C110 70 100 65 95 55C92 48 95 45 100 45Z" fill="url(#tLG)"/><path d="M45 15Q35 5 30 8" stroke="#ff4d4d" stroke-width="2" stroke-linecap="round"/><path d="M75 15Q85 5 90 8" stroke="#ff4d4d" stroke-width="2" stroke-linecap="round"/><circle cx="45" cy="35" r="6" fill="#050810"/><circle cx="75" cy="35" r="6" fill="#050810"/><circle cx="46" cy="34" r="2" fill="#00e5cc"/><circle cx="76" cy="34" r="2" fill="#00e5cc"/></svg></div>
-      <span data-i18n="title">OpenClaw Memory</span>
+      <span data-i18n="title">OpenClaw Memory</span>${vBadge}
     </div>
     <div class="topbar-center">
       <nav class="nav-tabs">
@@ -4103,3 +4107,4 @@ checkAuth();
 
 </body>
 </html>`;
+}
diff --git a/apps/memos-local-openclaw/src/viewer/server.ts b/apps/memos-local-openclaw/src/viewer/server.ts
index cbd76d35c..30d4be803 100644
--- a/apps/memos-local-openclaw/src/viewer/server.ts
+++ b/apps/memos-local-openclaw/src/viewer/server.ts
@@ -43,6 +43,14 @@ export class ViewerServer {
   private readonly ctx?: PluginContext;
 
   private static readonly SESSION_TTL = 24 * 60 * 60 * 1000;
+  private static readonly PLUGIN_VERSION: string = (() => {
+    try {
+      const pkgPath = path.resolve(__dirname, "../../package.json");
+      return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version ?? "unknown";
+    } catch {
+      return "unknown";
+    }
+  })();
   private resetToken: string;
   private migrationRunning = false;
   private migrationAbort = false;
@@ -336,7 +344,7 @@ export class ViewerServer {
 
   private serveViewer(res: http.ServerResponse): void {
     res.writeHead(200, { "Content-Type": "text/html; charset=utf-8", "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0", "Pragma": "no-cache", "Expires": "0" });
-    res.end(viewerHTML);
+    res.end(viewerHTML(ViewerServer.PLUGIN_VERSION));
   }
 
   // ─── Data APIs ───
diff --git a/src/memos/api/config.py b/src/memos/api/config.py
index fa12bcf55..06aa50c65 100644
--- a/src/memos/api/config.py
+++ b/src/memos/api/config.py
@@ -321,7 +321,7 @@ def get_activation_config() -> dict[str, Any]:
 
     @staticmethod
     def get_memreader_config() -> dict[str, Any]:
-        """Get MemReader configuration."""
+        """Get MemReader configuration for chat/doc extraction (fine-tuned 0.6B model)."""
         return {
             "backend": "openai",
             "config": {
@@ -338,6 +338,107 @@ def get_memreader_config() -> dict[str, Any]:
             },
         }
 
+    @staticmethod
+    def get_memreader_general_llm_config() -> dict[str, Any]:
+        """Get general LLM configuration for non-chat/doc tasks.
+
+        Used for: hallucination filter, memory rewrite, memory merge,
+        tool trajectory extraction, skill memory extraction.
+
+        This is the fallback for image_parser_llm and preference_extractor_llm.
+        Fallback chain: MEMREADER_GENERAL_MODEL -> MEMRADER_MODEL (memreader config)
+
+        Note: If you have fine-tuned a custom model for chat/doc extraction only,
+        you should configure MEMREADER_GENERAL_MODEL to use a general-purpose LLM
+        for other tasks. Otherwise, all tasks will use the same MEMRADER_MODEL.
+        """
+        # Check if specific general model is configured
+        general_model = os.getenv("MEMREADER_GENERAL_MODEL")
+        if general_model:
+            return {
+                "backend": os.getenv("MEMREADER_GENERAL_BACKEND", "openai"),
+                "config": {
+                    "model_name_or_path": general_model,
+                    "temperature": 0.6,
+                    "max_tokens": int(os.getenv("MEMREADER_GENERAL_MAX_TOKENS", "8000")),
+                    "top_p": 0.95,
+                    "top_k": 20,
+                    "api_key": os.getenv(
+                        "MEMREADER_GENERAL_API_KEY", os.getenv("OPENAI_API_KEY", "EMPTY")
+                    ),
+                    "api_base": os.getenv(
+                        "MEMREADER_GENERAL_API_BASE",
+                        os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+                    ),
+                    "remove_think_prefix": True,
+                },
+            }
+        # Fallback to memreader config (same behavior as before for users who don't customize)
+        return APIConfig.get_memreader_config()
+
+    @staticmethod
+    def get_image_parser_llm_config() -> dict[str, Any]:
+        """Get LLM configuration for image parsing (requires vision model).
+
+        Used for: image content extraction and analysis.
+        Requires a vision-capable model like GPT-4V, GPT-4o, etc.
+
+        Fallback chain: IMAGE_PARSER_MODEL -> general_llm -> OpenAI config
+        """
+        image_model = os.getenv("IMAGE_PARSER_MODEL")
+        if image_model:
+            return {
+                "backend": os.getenv("IMAGE_PARSER_BACKEND", "openai"),
+                "config": {
+                    "model_name_or_path": image_model,
+                    "temperature": 0.6,
+                    "max_tokens": int(os.getenv("IMAGE_PARSER_MAX_TOKENS", "4096")),
+                    "top_p": 0.95,
+                    "top_k": 20,
+                    "api_key": os.getenv(
+                        "IMAGE_PARSER_API_KEY", os.getenv("OPENAI_API_KEY", "EMPTY")
+                    ),
+                    "api_base": os.getenv(
+                        "IMAGE_PARSER_API_BASE",
+                        os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+                    ),
+                    "remove_think_prefix": True,
+                },
+            }
+        # Fallback to general_llm config (which itself falls back to OpenAI)
+        return APIConfig.get_memreader_general_llm_config()
+
+    @staticmethod
+    def get_preference_extractor_llm_config() -> dict[str, Any]:
+        """Get LLM configuration for preference extraction.
+
+        Used for: extracting user preferences from conversations.
+
+        Fallback chain: PREFERENCE_EXTRACTOR_MODEL -> general_llm -> OpenAI config
+        """
+        pref_model = os.getenv("PREFERENCE_EXTRACTOR_MODEL")
+        if pref_model:
+            return {
+                "backend": os.getenv("PREFERENCE_EXTRACTOR_BACKEND", "openai"),
+                "config": {
+                    "model_name_or_path": pref_model,
+                    "temperature": 0.6,
+                    "max_tokens": int(os.getenv("PREFERENCE_EXTRACTOR_MAX_TOKENS", "8000")),
+                    "top_p": 0.95,
+                    "top_k": 20,
+                    "api_key": os.getenv(
+                        "PREFERENCE_EXTRACTOR_API_KEY", os.getenv("OPENAI_API_KEY", "EMPTY")
+                    ),
+                    "api_base": os.getenv(
+                        "PREFERENCE_EXTRACTOR_API_BASE",
+                        os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1"),
+                    ),
+                    "remove_think_prefix": True,
+                },
+            }
+        # Fallback to general_llm config (which itself falls back to OpenAI)
+        return APIConfig.get_memreader_general_llm_config()
+
     @staticmethod
     def get_activation_vllm_config() -> dict[str, Any]:
         """Get Ollama configuration."""
@@ -358,7 +459,7 @@ def get_preference_memory_config() -> dict[str, Any]:
         return {
             "backend": "pref_text",
             "config": {
-                "extractor_llm": APIConfig.get_memreader_config(),
+                "extractor_llm": APIConfig.get_preference_extractor_llm_config(),
                 "vector_db": {
                     "backend": "milvus",
                     "config": APIConfig.get_milvus_config(),
@@ -812,6 +913,10 @@ def get_product_default_config() -> dict[str, Any]:
                 "backend": reader_config["backend"],
                 "config": {
                     "llm": APIConfig.get_memreader_config(),
+                    # General LLM for non-chat/doc tasks (hallucination filter, rewrite, merge, etc.)
+                    "general_llm": APIConfig.get_memreader_general_llm_config(),
+                    # Image parser LLM (requires vision model)
+                    "image_parser_llm": APIConfig.get_image_parser_llm_config(),
                     "embedder": APIConfig.get_embedder_config(),
                     "chunker": {
                         "backend": "sentence",
@@ -934,6 +1039,10 @@ def create_user_config(user_name: str, user_id: str) -> tuple["MOSConfig", "Gene
                 "backend": reader_config["backend"],
                 "config": {
                     "llm": APIConfig.get_memreader_config(),
+                    # General LLM for non-chat/doc tasks (hallucination filter, rewrite, merge, etc.)
+                    "general_llm": APIConfig.get_memreader_general_llm_config(),
+                    # Image parser LLM (requires vision model)
+                    "image_parser_llm": APIConfig.get_image_parser_llm_config(),
                     "embedder": APIConfig.get_embedder_config(),
                     "chunker": {
                         "backend": "sentence",
diff --git a/src/memos/api/handlers/config_builders.py b/src/memos/api/handlers/config_builders.py
index 7426a60ba..5655bf1e5 100644
--- a/src/memos/api/handlers/config_builders.py
+++ b/src/memos/api/handlers/config_builders.py
@@ -201,3 +201,26 @@ def build_nli_client_config() -> dict[str, Any]:
         NLI client configuration dictionary
     """
     return APIConfig.get_nli_config()
+
+
+def build_general_llm_config() -> dict[str, Any]:
+    """
+    Build general LLM configuration for non-chat/doc tasks.
+
+    Used for: hallucination filter, memory rewrite, memory merge,
+    tool trajectory extraction, skill memory extraction.
+
+    Returns:
+        Validated general LLM configuration dictionary
+    """
+    return LLMConfigFactory.model_validate(APIConfig.get_memreader_general_llm_config())
+
+
+def build_image_parser_llm_config() -> dict[str, Any]:
+    """
+    Build image parser LLM configuration (requires vision model).
+
+    Returns:
+        Validated image parser LLM configuration dictionary
+    """
+    return LLMConfigFactory.model_validate(APIConfig.get_image_parser_llm_config())
diff --git a/src/memos/api/handlers/memory_handler.py b/src/memos/api/handlers/memory_handler.py
index 2ab8f50c7..72c6a3da8 100644
--- a/src/memos/api/handlers/memory_handler.py
+++ b/src/memos/api/handlers/memory_handler.py
@@ -320,7 +320,10 @@ def handle_delete_memories(delete_mem_req: DeleteMemoryRequest, naive_mem_cube:
     Now unified to delete from text_mem only (includes preferences).
     """
     logger.info(
-        f"[Delete memory request] writable_cube_ids: {delete_mem_req.writable_cube_ids}, memory_ids: {delete_mem_req.memory_ids}"
+        "[Delete memory request] writable_cube_ids: %s, memory_ids: %s, auto_cleanup_working: %s",
+        delete_mem_req.writable_cube_ids,
+        delete_mem_req.memory_ids,
+        getattr(delete_mem_req, "auto_cleanup_working", False),
     )
     # Validate that only one of memory_ids, file_ids, or filter is provided
     provided_params = [
@@ -335,6 +338,31 @@ def handle_delete_memories(delete_mem_req: DeleteMemoryRequest, naive_mem_cube:
         )
 
     try:
+        working_ids_to_delete: set[str] = set()
+        # When deleting by explicit memory_ids and auto_cleanup_working is enabled,
+        # collect related WorkingMemory ids from working_binding
+        if delete_mem_req.memory_ids is not None and getattr(
+            delete_mem_req, "auto_cleanup_working", False
+        ):
+            try:
+                memories = naive_mem_cube.text_mem.get_by_ids(memory_ids=delete_mem_req.memory_ids)
+            except Exception as e:
+                logger.warning("Failed to fetch memories before delete for working cleanup: %s", e)
+                memories = []
+
+            if memories:
+                import re
+
+                pattern = re.compile(r"\[working_binding:([0-9a-fA-F-]{36})\]")
+                for mem in memories:
+                    metadata = mem.get("metadata") or {}
+                    bg = metadata.get("background") or ""
+                    if not isinstance(bg, str):
+                        continue
+                    match = pattern.search(bg)
+                    if match:
+                        working_ids_to_delete.add(match.group(1))
+
         if delete_mem_req.memory_ids is not None:
             # Unified deletion from text_mem (includes preferences)
             naive_mem_cube.text_mem.delete_by_memory_ids(delete_mem_req.memory_ids)
@@ -344,6 +372,17 @@ def handle_delete_memories(delete_mem_req: DeleteMemoryRequest, naive_mem_cube:
             )
         elif delete_mem_req.filter is not None:
             naive_mem_cube.text_mem.delete_by_filter(filter=delete_mem_req.filter)
+
+        # After main deletion, optionally clean up related WorkingMemory nodes.
+        if working_ids_to_delete:
+            try:
+                logger.info(
+                    "Auto-cleanup WorkingMemory nodes after delete, count=%d",
+                    len(working_ids_to_delete),
+                )
+                naive_mem_cube.text_mem.delete_by_memory_ids(list(working_ids_to_delete))
+            except Exception as e:
+                logger.warning("Failed to auto-cleanup WorkingMemory nodes: %s, Pass", e)
     except Exception as e:
         logger.error(f"Failed to delete memories: {e}", exc_info=True)
         return DeleteMemoryResponse(
diff --git a/src/memos/api/handlers/suggestion_handler.py b/src/memos/api/handlers/suggestion_handler.py
index dce894003..a10251ec2 100644
--- a/src/memos/api/handlers/suggestion_handler.py
+++ b/src/memos/api/handlers/suggestion_handler.py
@@ -17,7 +17,7 @@
     SUGGESTION_QUERY_PROMPT_EN,
     SUGGESTION_QUERY_PROMPT_ZH,
 )
-from memos.types import MessageList
+from memos.types import MessageList, MessagesType
 
 
 logger = get_logger(__name__)
@@ -25,20 +25,29 @@
 
 def _get_further_suggestion(
     llm: Any,
-    message: MessageList,
+    message: MessageList | str,
 ) -> list[str]:
     """
     Get further suggestion based on recent dialogue.
 
     Args:
         llm: LLM instance for generating suggestions
-        message: Recent chat messages
+        message: Recent chat messages (can be a list of message dicts or a plain string)
 
     Returns:
         List of suggestion queries
     """
     try:
-        dialogue_info = "\n".join([f"{msg['role']}: {msg['content']}" for msg in message[-2:]])
+        if isinstance(message, str):
+            dialogue_info = message
+        else:
+            dialogue_info = "\n".join(
+                [
+                    f"{msg['role']}: {msg['content']}"
+                    for msg in message[-2:]
+                    if isinstance(msg, dict)
+                ]
+            )
         further_suggestion_prompt = FURTHER_SUGGESTION_PROMPT.format(dialogue=dialogue_info)
         message_list = [{"role": "system", "content": further_suggestion_prompt}]
         response = llm.generate(message_list)
@@ -53,7 +62,7 @@ def _get_further_suggestion(
 def handle_get_suggestion_queries(
     user_id: str,
     language: str,
-    message: MessageList | None,
+    message: MessagesType | None,
     llm: Any,
     naive_mem_cube: Any,
 ) -> SuggestionResponse:
diff --git a/src/memos/api/product_models.py b/src/memos/api/product_models.py
index 6f112b9a7..59f7f74c8 100644
--- a/src/memos/api/product_models.py
+++ b/src/memos/api/product_models.py
@@ -858,6 +858,13 @@ class DeleteMemoryRequest(BaseRequest):
     memory_ids: list[str] | None = Field(None, description="Memory IDs")
     file_ids: list[str] | None = Field(None, description="File IDs")
     filter: dict[str, Any] | None = Field(None, description="Filter for the memory")
+    auto_cleanup_working: bool | None = Field(
+        False,
+        description=(
+            "(Internal) Whether to automatically delete related WorkingMemory nodes "
+            "based on working_binding metadata when deleting by memory_ids."
+        ),
+    )
 
 
 class SuggestionRequest(BaseRequest):
diff --git a/src/memos/configs/mem_reader.py b/src/memos/configs/mem_reader.py
index 4bd7953c0..d4844d73f 100644
--- a/src/memos/configs/mem_reader.py
+++ b/src/memos/configs/mem_reader.py
@@ -24,7 +24,18 @@ def parse_datetime(cls, value):
             return datetime.fromisoformat(value.replace("Z", "+00:00"))
         return value
 
-    llm: LLMConfigFactory = Field(..., description="LLM configuration for the MemReader")
+    llm: LLMConfigFactory = Field(
+        ..., description="LLM configuration for chat/doc memory extraction (fine-tuned model)"
+    )
+    general_llm: LLMConfigFactory | None = Field(
+        default=None,
+        description="General LLM for non-chat/doc tasks: hallucination filter, memory rewrite, "
+        "memory merge, tool trajectory, skill memory. Falls back to main llm if not set.",
+    )
+    image_parser_llm: LLMConfigFactory | None = Field(
+        default=None,
+        description="Vision LLM for image parsing. Falls back to general_llm if not set.",
+    )
     embedder: EmbedderConfigFactory = Field(
         ..., description="Embedder configuration for the MemReader"
     )
diff --git a/src/memos/graph_dbs/polardb.py b/src/memos/graph_dbs/polardb.py
index ad75f4b65..d740ad1d2 100644
--- a/src/memos/graph_dbs/polardb.py
+++ b/src/memos/graph_dbs/polardb.py
@@ -124,7 +124,6 @@ def __init__(self, config: PolarDBGraphDBConfig):
             All node queries will enforce `user_name` in WHERE conditions and store it in metadata,
             but it will be removed automatically before returning to external consumers.
         """
-        import psycopg2
         import psycopg2.pool
 
         self.config = config
@@ -177,6 +176,7 @@ def __init__(self, config: PolarDBGraphDBConfig):
             keepalives_idle=120,  # Seconds of inactivity before sending keepalive (should be < server idle timeout)
             keepalives_interval=15,  # Seconds between keepalive retries
             keepalives_count=5,  # Number of keepalive retries before considering connection dead
+            options=f"-c search_path={self.db_name}_graph,ag_catalog,$user,public",
         )
 
         self._semaphore = threading.BoundedSemaphore(maxconn)
@@ -247,15 +247,12 @@ def _warm_up_connections_by_all(self):
 
     @contextmanager
     def _get_connection(self):
+        import psycopg2
+
         timeout = self._connection_wait_timeout
-        if timeout <= 0:
-            self._semaphore.acquire()
-        else:
-            if not self._semaphore.acquire(timeout=timeout):
-                logger.warning(f"Timeout waiting for connection slot ({timeout}s)")
-                raise RuntimeError(
-                    f"Connection pool busy: acquire a slot within {timeout}s (all connections in use)."
-                )
+        if not self._semaphore.acquire(timeout=max(timeout, 0)):
+            logger.warning(f"Timeout waiting for connection slot ({timeout}s)")
+            raise RuntimeError("Connection pool busy")
         logger.info(
             "Connection pool usage: %s/%s",
             self.connection_pool.maxconn - self._semaphore._value,
@@ -263,17 +260,26 @@ def _get_connection(self):
         )
         conn = None
         broken = False
-
         try:
             conn = self.connection_pool.getconn()
-            logger.debug(f"Acquired connection {id(conn)} from pool")
             conn.autocommit = True
+            for attempt in range(2):
+                try:
+                    with conn.cursor() as cur:
+                        cur.execute("SELECT 1")
+                    break
+                except psycopg2.Error:
+                    logger.warning("Dead connection detected, recreating (attempt %d)", attempt + 1)
+                    self.connection_pool.putconn(conn, close=True)
+                    conn = self.connection_pool.getconn()
+                    conn.autocommit = True
+            else:
+                raise RuntimeError("Cannot obtain valid DB connection after 2 attempts")
             with conn.cursor() as cur:
                 cur.execute(f'SET search_path = {self.db_name}_graph, ag_catalog, "$user", public;')
             yield conn
-        except Exception as e:
+        except Exception:
             broken = True
-            logger.exception(f"Connection failed or broken: {e}")
             raise
         finally:
             if conn:
@@ -1814,7 +1820,7 @@ def search_by_fulltext(
                         properties = row[2]  # properties column
                         item.update(self._extract_fields_from_properties(properties, return_fields))
                     output.append(item)
-            elapsed = (time.perf_counter() - start_time) * 1000
+            elapsed = (time.perf_counter() - start_time) * 1000.0
             logger.info("search_by_fulltext internal took %.1f ms", elapsed)
             return output[:top_k]
 
@@ -1945,7 +1951,7 @@ def search_by_embedding(
                         properties = row[1]  # properties column
                         item.update(self._extract_fields_from_properties(properties, return_fields))
                     output.append(item)
-            elapsed_time = time.perf_counter() - start_time
+            elapsed_time = (time.perf_counter() - start_time) * 1000.0
             logger.info(
                 "search_by_embedding query embedding completed time took %.1f ms", elapsed_time
             )
@@ -2300,48 +2306,57 @@ def export_graph(
         status: list[str] | None = None,
         **kwargs,
     ) -> dict[str, Any]:
-        """
-        Export all graph nodes and edges in a structured form.
-        Args:
-        include_embedding (bool): Whether to include the large embedding field.
-        user_name (str, optional): User name for filtering in non-multi-db mode
-        user_id (str, optional): User ID for filtering
-        page (int, optional): Page number (starts from 1). If None, exports all data without pagination.
-        page_size (int, optional): Number of items per page. If None, exports all data without pagination.
-        filter (dict, optional): Filter dictionary for metadata filtering. Supports "and", "or" logic and operators:
-            - "=": equality
-            - "in": value in list
-            - "contains": array contains value
-            - "gt", "lt", "gte", "lte": comparison operators
-            - "like": fuzzy matching
-            Example: {"and": [{"created_at": {"gte": "2025-01-01"}}, {"tags": {"contains": "AI"}}]}
-        memory_type (list[str], optional): List of memory_type values to filter by. If provided, only nodes/edges with
-            memory_type in this list will be exported. Example: ["LongTermMemory", "WorkingMemory"]
-        status (list[str], optional): List of status values to filter by. If not provided, only nodes/edges with
-            status != 'deleted' are exported. If provided, only nodes/edges with status in this list are exported.
-            Example: ["activated"] or ["activated", "archived"]
-
-        Returns:
-            {
-                "nodes": [ { "id": ..., "memory": ..., "metadata": {...} }, ... ],
-                "edges": [ { "source": ..., "target": ..., "type": ... }, ... ],
-                "total_nodes": int,  # Total number of nodes matching the filter criteria
-                "total_edges": int,   # Total number of edges matching the filter criteria
-            }
-        """
+        start_time = time.perf_counter()
         logger.info(
             f" export_graph include_embedding: {include_embedding}, user_name: {user_name}, user_id: {user_id}, page: {page}, page_size: {page_size}, filter: {filter}, memory_type: {memory_type}, status: {status}"
         )
         user_id = user_id if user_id else self._get_config_value("user_id")
 
-        # Initialize total counts
+        extracted_object_type: str | None = None
+        extracted_mem_cube_id: str | None = None
+
+        def _extract_special_filter_values(filter_obj):
+            nonlocal extracted_object_type, extracted_mem_cube_id
+
+            if isinstance(filter_obj, dict):
+                if "and" in filter_obj and isinstance(filter_obj["and"], list):
+                    cleaned_items = []
+                    for item in filter_obj["and"]:
+                        cleaned_item = _extract_special_filter_values(item)
+                        if cleaned_item not in (None, {}, []):
+                            cleaned_items.append(cleaned_item)
+                    return {"and": cleaned_items} if cleaned_items else None
+
+                if "or" in filter_obj and isinstance(filter_obj["or"], list):
+                    cleaned_items = []
+                    for item in filter_obj["or"]:
+                        cleaned_item = _extract_special_filter_values(item)
+                        if cleaned_item not in (None, {}, []):
+                            cleaned_items.append(cleaned_item)
+                    return {"or": cleaned_items} if cleaned_items else None
+
+                cleaned_dict = {}
+                for key, value in filter_obj.items():
+                    if key == "object_type" and isinstance(value, str):
+                        if extracted_object_type is None:
+                            extracted_object_type = value
+                        continue
+                    if key == "mem_cube_id" and isinstance(value, str):
+                        if extracted_mem_cube_id is None:
+                            extracted_mem_cube_id = value
+                        continue
+                    cleaned_dict[key] = value
+                return cleaned_dict if cleaned_dict else None
+
+            return filter_obj
+
+        filter_for_sql = _extract_special_filter_values(filter)
+
         total_nodes = 0
         total_edges = 0
 
-        # Determine if pagination is needed
         use_pagination = page is not None and page_size is not None
 
-        # Validate pagination parameters if pagination is enabled
         if use_pagination:
             if page < 1:
                 page = 1
@@ -2351,129 +2366,148 @@ def export_graph(
         else:
             offset = None
 
-        try:
-            with self._get_connection() as conn:
-                # Build WHERE conditions
-                where_conditions = []
-                if user_name:
-                    where_conditions.append(
-                        f"ag_catalog.agtype_access_operator(properties, '\"user_name\"'::agtype) = '\"{user_name}\"'::agtype"
-                    )
-                if user_id:
-                    where_conditions.append(
-                        f"ag_catalog.agtype_access_operator(properties, '\"user_id\"'::agtype) = '\"{user_id}\"'::agtype"
-                    )
+        where_conditions = []
+        has_object_type_filter = (
+            isinstance(extracted_object_type, str)
+            and isinstance(extracted_mem_cube_id, str)
+            and extracted_mem_cube_id.strip() != ""
+        )
 
-                # Add memory_type filter condition
-                if memory_type and isinstance(memory_type, list) and len(memory_type) > 0:
-                    # Escape memory_type values and build IN clause
-                    memory_type_values = []
-                    for mt in memory_type:
-                        # Escape single quotes in memory_type value
-                        escaped_memory_type = str(mt).replace("'", "''")
-                        memory_type_values.append(f"'\"{escaped_memory_type}\"'::agtype")
-                    memory_type_in_clause = ", ".join(memory_type_values)
-                    where_conditions.append(
-                        f"ag_catalog.agtype_access_operator(properties, '\"memory_type\"'::agtype) IN ({memory_type_in_clause})"
-                    )
+        if user_name and not has_object_type_filter:
+            where_conditions.append(
+                f"ag_catalog.agtype_access_operator(properties, '\"user_name\"'::agtype) = '\"{user_name}\"'::agtype"
+            )
 
-                # Add status filter condition: if not passed, exclude deleted; otherwise filter by IN list
-                if status is None:
-                    # Default behavior: exclude deleted entries
-                    where_conditions.append(
-                        "ag_catalog.agtype_access_operator(properties, '\"status\"'::agtype) <> '\"deleted\"'::agtype"
-                    )
-                elif isinstance(status, list) and len(status) > 0:
-                    # status IN (list)
-                    status_values = []
-                    for st in status:
-                        escaped_status = str(st).replace("'", "''")
-                        status_values.append(f"'\"{escaped_status}\"'::agtype")
-                    status_in_clause = ", ".join(status_values)
-                    where_conditions.append(
-                        f"ag_catalog.agtype_access_operator(properties, '\"status\"'::agtype) IN ({status_in_clause})"
-                    )
+        if has_object_type_filter:
+            object_type_value = extracted_object_type.strip().lower()
+            escaped_mem_cube_id = extracted_mem_cube_id.replace("'", "''")
+            if object_type_value == "user":
+                where_conditions.append(
+                    f"ag_catalog.agtype_access_operator(properties, '\"user_name\"'::agtype) <> '\"{escaped_mem_cube_id}\"'::agtype"
+                )
+            elif object_type_value == "public":
+                where_conditions.append(
+                    f"ag_catalog.agtype_access_operator(properties, '\"user_name\"'::agtype) = '\"{escaped_mem_cube_id}\"'::agtype"
+                )
 
-                # Build filter conditions using common method
-                filter_conditions = self._build_filter_conditions_sql(filter)
-                logger.info(f"[export_graph] filter_conditions: {filter_conditions}")
-                if filter_conditions:
-                    where_conditions.extend(filter_conditions)
+        if user_id:
+            where_conditions.append(
+                f"ag_catalog.agtype_access_operator(properties, '\"user_id\"'::agtype) = '\"{user_id}\"'::agtype"
+            )
 
-                where_clause = ""
-                if where_conditions:
-                    where_clause = f"WHERE {' AND '.join(where_conditions)}"
+        if memory_type and isinstance(memory_type, list) and len(memory_type) > 0:
+            memory_type_values = []
+            for mt in memory_type:
+                escaped_memory_type = str(mt).replace("'", "''")
+                memory_type_values.append(f"'\"{escaped_memory_type}\"'::agtype")
+            memory_type_in_clause = ", ".join(memory_type_values)
+            where_conditions.append(
+                f"ag_catalog.agtype_access_operator(properties, '\"memory_type\"'::agtype) IN ({memory_type_in_clause})"
+            )
 
-                # Get total count of nodes before pagination
-                count_node_query = f"""
-                    SELECT COUNT(*)
+        if status is None:
+            where_conditions.append(
+                "ag_catalog.agtype_access_operator(properties, '\"status\"'::agtype) <> '\"deleted\"'::agtype"
+            )
+        elif isinstance(status, list) and len(status) > 0:
+            status_values = []
+            for st in status:
+                escaped_status = str(st).replace("'", "''")
+                status_values.append(f"'\"{escaped_status}\"'::agtype")
+            status_in_clause = ", ".join(status_values)
+            where_conditions.append(
+                f"ag_catalog.agtype_access_operator(properties, '\"status\"'::agtype) IN ({status_in_clause})"
+            )
+
+        filter_conditions = self._build_filter_conditions_sql(filter_for_sql)
+        logger.info(f"[export_graph] filter_conditions: {filter_conditions}")
+        if filter_conditions:
+            where_conditions.extend(filter_conditions)
+
+        where_clause = ""
+        if where_conditions:
+            where_clause = f"WHERE {' AND '.join(where_conditions)}"
+
+        pagination_clause = ""
+        if use_pagination:
+            pagination_clause = f"LIMIT {page_size} OFFSET {offset}"
+
+        order_clause = """
+            ORDER BY ag_catalog.agtype_access_operator(properties, '"created_at"'::agtype) DESC NULLS LAST,id DESC
+        """
+        if include_embedding:
+            node_query = f"""
+                WITH filtered AS (
+                    SELECT id, properties, embedding
                     FROM "{self.db_name}_graph"."Memory"
                     {where_clause}
-                """
-                logger.info(f"[export_graph nodes count] Query: {count_node_query}")
-                with conn.cursor() as cursor:
-                    cursor.execute(count_node_query)
-                    total_nodes = cursor.fetchone()[0]
+                )
+                SELECT p.id, p.properties, p.embedding, c.total_count
+                FROM (SELECT COUNT(*) AS total_count FROM filtered) c
+                LEFT JOIN LATERAL (
+                    SELECT id, properties, embedding
+                    FROM filtered
+                    {order_clause}
+                    {pagination_clause}
+                ) p ON TRUE
+            """
+        else:
+            node_query = f"""
+                WITH filtered AS (
+                    SELECT id, properties
+                    FROM "{self.db_name}_graph"."Memory"
+                    {where_clause}
+                )
+                SELECT p.id, p.properties, c.total_count
+                FROM (SELECT COUNT(*) AS total_count FROM filtered) c
+                LEFT JOIN LATERAL (
+                    SELECT id, properties
+                    FROM filtered
+                    {order_clause}
+                    {pagination_clause}
+                ) p ON TRUE
+            """
+        logger.info(f"[export_graph nodes] Query: {node_query}")
 
-                # Export nodes
-                # Build pagination clause if needed
-                pagination_clause = ""
-                if use_pagination:
-                    pagination_clause = f"LIMIT {page_size} OFFSET {offset}"
+        try:
+            with self._get_connection() as conn, conn.cursor() as cursor:
+                cursor.execute(node_query)
+                node_results = cursor.fetchall()
+            nodes = []
 
+            for row in node_results:
                 if include_embedding:
-                    node_query = f"""
-                        SELECT id, properties, embedding
-                        FROM "{self.db_name}_graph"."Memory"
-                        {where_clause}
-                        ORDER BY ag_catalog.agtype_access_operator(properties, '"created_at"'::agtype) DESC NULLS LAST,
-                                 id DESC
-                        {pagination_clause}
-                    """
+                    row_id, properties_json, embedding_json, row_total_count = row
                 else:
-                    node_query = f"""
-                        SELECT id, properties
-                        FROM "{self.db_name}_graph"."Memory"
-                        {where_clause}
-                        ORDER BY ag_catalog.agtype_access_operator(properties, '"created_at"'::agtype) DESC NULLS LAST,
-                                 id DESC
-                        {pagination_clause}
-                    """
-                logger.info(f"[export_graph nodes] Query: {node_query}")
-                with conn.cursor() as cursor:
-                    cursor.execute(node_query)
-                    node_results = cursor.fetchall()
-                    nodes = []
-
-                    for row in node_results:
-                        if include_embedding:
-                            """row is (id, properties, embedding)"""
-                            _, properties_json, embedding_json = row
-                        else:
-                            """row is (id, properties)"""
-                            _, properties_json = row
-                            embedding_json = None
+                    row_id, properties_json, row_total_count = row
+                    embedding_json = None
 
-                        # Parse properties from JSONB if it's a string
-                        if isinstance(properties_json, str):
-                            try:
-                                properties = json.loads(properties_json)
-                            except json.JSONDecodeError:
-                                properties = {}
-                        else:
-                            properties = properties_json if properties_json else {}
+                if row_total_count is not None:
+                    total_nodes = int(row_total_count)
+
+                if row_id is None:
+                    continue
+
+                if isinstance(properties_json, str):
+                    try:
+                        properties = json.loads(properties_json)
+                    except json.JSONDecodeError:
+                        properties = {}
+                else:
+                    properties = properties_json if properties_json else {}
 
-                        # Remove embedding field if include_embedding is False
-                        if not include_embedding:
-                            properties.pop("embedding", None)
-                        elif include_embedding and embedding_json is not None:
-                            properties["embedding"] = embedding_json
+                if not include_embedding:
+                    properties.pop("embedding", None)
+                elif include_embedding and embedding_json is not None:
+                    properties["embedding"] = embedding_json
 
-                        nodes.append(self._parse_node(properties))
+                nodes.append(self._parse_node(properties))
 
         except Exception as e:
             logger.error(f"[EXPORT GRAPH - NODES] Exception: {e}", exc_info=True)
             raise RuntimeError(f"[EXPORT GRAPH - NODES] Exception: {e}") from e
+        elapsed = (time.perf_counter() - start_time) * 1000.0
+        logger.info("export internal took %.1f ms", elapsed)
 
         edges = []
         return {
@@ -3332,7 +3366,7 @@ def add_nodes_batch(
                             logger.warning(
                                 f"[add_nodes_batch] Failed to deallocate {prepare_name}: {dealloc_error}"
                             )
-                    elapsed_time = time.perf_counter() - batch_start_time
+                    elapsed_time = (time.perf_counter() - batch_start_time) * 1000.0
                     logger.info(
                         "add_nodes_batch batch insert completed successfully in took %.1f ms",
                         elapsed_time,
@@ -4787,7 +4821,7 @@ def delete_node_by_prams(
         """
         batch_start_time = time.time()
         logger.info(
-            f"[delete_node_by_prams] memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}, writable_cube_ids: {writable_cube_ids}"
+            f" delete_node_by_prams memory_ids: {memory_ids}, file_ids: {file_ids}, filter: {filter}, writable_cube_ids: {writable_cube_ids}"
         )
 
         # Build user_name condition from writable_cube_ids (OR relationship - match any cube_id)
@@ -4861,7 +4895,7 @@ def delete_node_by_prams(
                     DELETE FROM "{self.db_name}_graph"."Memory"
                     WHERE {where_clause}
                 """
-                logger.info(f"[delete_node_by_prams] delete_query: {delete_query}")
+                logger.info(f" delete_node_by_prams delete_query: {delete_query}")
 
                 cursor.execute(delete_query)
                 deleted_count = cursor.rowcount
@@ -4869,9 +4903,9 @@ def delete_node_by_prams(
 
                 logger.info(f"[delete_node_by_prams] Deleted {deleted_count} nodes")
 
-                elapsed_time = time.time() - batch_start_time
+                elapsed_time = (time.time() - batch_start_time) * 1000.0
                 logger.info(
-                    f"[delete_node_by_prams] Deletion completed successfully in {elapsed_time:.2f}s, total deleted {total_deleted_count} nodes"
+                    f"delete_node_by_prams Deletion completed successfully in {elapsed_time:.2f}s, total deleted {total_deleted_count} nodes"
                 )
         except Exception as e:
             logger.error(f"[delete_node_by_prams] Failed to delete nodes: {e}", exc_info=True)
diff --git a/src/memos/mem_reader/multi_modal_struct.py b/src/memos/mem_reader/multi_modal_struct.py
index 0b3e19208..4c0d4dcd0 100644
--- a/src/memos/mem_reader/multi_modal_struct.py
+++ b/src/memos/mem_reader/multi_modal_struct.py
@@ -40,6 +40,7 @@ def __init__(self, config: MultiModalStructMemReaderConfig):
             config: Configuration object for the reader
         """
         from memos.configs.mem_reader import SimpleStructMemReaderConfig
+        from memos.llms.factory import LLMFactory
 
         # Extract direct_markdown_hostnames before converting to SimpleStructMemReaderConfig
         direct_markdown_hostnames = getattr(config, "direct_markdown_hostnames", None)
@@ -57,10 +58,19 @@ def __init__(self, config: MultiModalStructMemReaderConfig):
         simple_config = SimpleStructMemReaderConfig(**config_dict)
         super().__init__(simple_config)
 
+        # Image parser LLM (requires vision model)
+        # Falls back to general_llm if not configured (general_llm itself falls back to main llm)
+        self.image_parser_llm = (
+            LLMFactory.from_config(config.image_parser_llm)
+            if config.image_parser_llm is not None
+            else self.general_llm
+        )
         # Initialize MultiModalParser for routing to different parsers
+        # Pass image_parser_llm for image parsing
         self.multi_modal_parser = MultiModalParser(
             embedder=self.embedder,
             llm=self.llm,
+            image_parser_llm=self.image_parser_llm,
             parser=None,
             direct_markdown_hostnames=direct_markdown_hostnames,
         )
@@ -344,6 +354,19 @@ def _build_window_from_items(
         if aggregated_file_ids:
             extra_kwargs["file_ids"] = aggregated_file_ids
 
+        # Propagate manager_user_id and project_id from constituent items
+        for item in items:
+            metadata = getattr(item, "metadata", None)
+            if metadata is not None:
+                if not extra_kwargs.get("manager_user_id"):
+                    mid = getattr(metadata, "manager_user_id", None)
+                    if mid:
+                        extra_kwargs["manager_user_id"] = mid
+                if not extra_kwargs.get("project_id"):
+                    pid = getattr(metadata, "project_id", None)
+                    if pid:
+                        extra_kwargs["project_id"] = pid
+
         # Extract info fields
         info_ = info.copy()
         user_id = info_.pop("user_id", "")
@@ -629,7 +652,8 @@ def _merge_memories_with_llm(
         )
 
         try:
-            response_text = self.llm.generate([{"role": "user", "content": merge_prompt}])
+            # Use general_llm for memory merge (not fine-tuned for this task)
+            response_text = self.general_llm.generate([{"role": "user", "content": merge_prompt}])
             merge_result = parse_json_result(response_text)
 
             if merge_result.get("should_merge", False):
@@ -807,7 +831,7 @@ def _process_one_item(
                     if result:
                         fine_memory_items.extend(result)
                 except Exception as e:
-                    logger.error(f"[MultiModalFine] worker error: {e}")
+                    logger.error(f"[MultiModalFine] worker error: {e} {traceback.format_exc()}")
 
         # related preceding and following rawfilememories
         fine_memory_items = self._relate_preceding_following_rawfile_memories(fine_memory_items)
@@ -871,12 +895,14 @@ def get_chunk_idx(item_with_pos) -> int:
     def _get_llm_tool_trajectory_response(self, mem_str: str) -> dict:
         """
         Generete tool trajectory experience item by llm.
+        Uses general_llm as this task is not fine-tuned for the main model.
         """
         try:
             lang = detect_lang(mem_str)
             template = TOOL_TRAJECTORY_PROMPT_ZH if lang == "zh" else TOOL_TRAJECTORY_PROMPT_EN
             prompt = template.replace("{messages}", mem_str)
-            rsp = self.llm.generate([{"role": "user", "content": prompt}])
+            # Use general_llm for tool trajectory (not fine-tuned for this task)
+            rsp = self.general_llm.generate([{"role": "user", "content": prompt}])
             rsp = rsp.replace("```json", "").replace("```", "")
             return json.loads(rsp)
         except Exception as e:
@@ -998,13 +1024,14 @@ def _process_multi_modal_data(
                 future_tool = executor.submit(
                     self._process_tool_trajectory_fine, fast_memory_items, info, **kwargs
                 )
+                # Use general_llm for skill memory extraction (not fine-tuned for this task)
                 future_skill = executor.submit(
                     process_skill_memory_fine,
                     fast_memory_items=fast_memory_items,
                     info=info,
                     searcher=self.searcher,
                     graph_db=self.graph_db,
-                    llm=self.llm,
+                    llm=self.general_llm,
                     embedder=self.embedder,
                     oss_config=self.oss_config,
                     skills_dir_config=self.skills_dir_config,
@@ -1041,6 +1068,7 @@ def _process_multi_modal_data(
                         custom_tags=custom_tags,
                         info=info,
                         lang=lang,
+                        user_context=kwargs.get("user_context"),
                     )
                     fine_memory_items.extend(items)
             return fine_memory_items
@@ -1075,12 +1103,13 @@ def _process_transfer_multi_modal_data(
             future_tool = executor.submit(
                 self._process_tool_trajectory_fine, raw_nodes, info, **kwargs
             )
+            # Use general_llm for skill memory extraction (not fine-tuned for this task)
             future_skill = executor.submit(
                 process_skill_memory_fine,
                 raw_nodes,
                 info,
                 searcher=self.searcher,
-                llm=self.llm,
+                llm=self.general_llm,
                 embedder=self.embedder,
                 graph_db=self.graph_db,
                 oss_config=self.oss_config,
@@ -1089,7 +1118,7 @@ def _process_transfer_multi_modal_data(
             )
             # Add preference memory extraction
             future_pref = executor.submit(
-                process_preference_fine, raw_nodes, info, self.llm, self.embedder, **kwargs
+                process_preference_fine, raw_nodes, info, self.general_llm, self.embedder, **kwargs
             )
 
             # Collect results
@@ -1109,7 +1138,12 @@ def _process_transfer_multi_modal_data(
             for source in sources:
                 lang = getattr(source, "lang", "en")
                 items = self.multi_modal_parser.process_transfer(
-                    source, context_items=[raw_node], info=info, custom_tags=custom_tags, lang=lang
+                    source,
+                    context_items=[raw_node],
+                    info=info,
+                    custom_tags=custom_tags,
+                    lang=lang,
+                    user_context=kwargs.get("user_context"),
                 )
                 fine_memory_items.extend(items)
         return fine_memory_items
diff --git a/src/memos/mem_reader/read_multi_modal/file_content_parser.py b/src/memos/mem_reader/read_multi_modal/file_content_parser.py
index 00e02abda..0629eda97 100644
--- a/src/memos/mem_reader/read_multi_modal/file_content_parser.py
+++ b/src/memos/mem_reader/read_multi_modal/file_content_parser.py
@@ -326,6 +326,7 @@ def __init__(
         llm: BaseLLM | None = None,
         parser: Any | None = None,
         direct_markdown_hostnames: list[str] | None = None,
+        image_parser: ImageParser | None = None,
     ):
         """
         Initialize FileContentParser.
@@ -341,7 +342,7 @@ def __init__(
         super().__init__(embedder, llm)
         self.parser = parser
         # Initialize ImageParser for processing images in markdown
-        self.image_parser = ImageParser(embedder, llm) if llm else None
+        self.image_parser = image_parser if image_parser is not None else ImageParser(embedder, llm)
 
         # Get inner markdown hostnames from config or environment
         if direct_markdown_hostnames is not None:
@@ -367,7 +368,7 @@ def create_source(
     ) -> SourceMessage:
         """Create SourceMessage from file content part."""
         if isinstance(message, dict):
-            file_info = message.get("file", {})
+            file_info = message.get("file", {}) or {}
             source_dict = {
                 "type": "file",
                 "doc_path": file_info.get("filename") or file_info.get("file_id", ""),
@@ -470,7 +471,7 @@ def parse_fast(
         file_data = file_info.get("file_data", "")
         file_id = file_info.get("file_id", "")
         filename = file_info.get("filename", "")
-        file_url_flag = False
+        file_url_flag = bool(file_info)
         # Build content string based on available information
         content_parts = []
 
@@ -651,6 +652,9 @@ def parse_fine(
         file_id = file_info.get("file_id", "")
         filename = file_info.get("filename", "")
 
+        # Whether to keep full file_info in sources
+        file_url_flag = bool(file_info)
+
         # Extract custom_tags from kwargs (for LLM extraction)
         custom_tags = kwargs.get("custom_tags")
 
@@ -683,6 +687,7 @@ def parse_fine(
                     url_str = file_data[1:] if file_data.startswith("@") else file_data
 
                     if url_str.startswith(("http://", "https://")):
+                        file_url_flag = True
                         parsed_text, temp_file_path, is_markdown = self._handle_url(
                             url_str, filename
                         )
@@ -793,6 +798,7 @@ def _make_memory_item(
                 chunk_index=chunk_idx,
                 chunk_total=total_chunks,
                 chunk_content=chunk_content,
+                file_url_flag=file_url_flag,
             )
             return TextualMemoryItem(
                 memory=value,
diff --git a/src/memos/mem_reader/read_multi_modal/image_parser.py b/src/memos/mem_reader/read_multi_modal/image_parser.py
index 0d5e8bcc2..43674a9cc 100644
--- a/src/memos/mem_reader/read_multi_modal/image_parser.py
+++ b/src/memos/mem_reader/read_multi_modal/image_parser.py
@@ -51,15 +51,23 @@ def create_source(
             if isinstance(image_url, dict):
                 url = image_url.get("url", "")
                 detail = image_url.get("detail", "auto")
+                image_info = image_url
+                return SourceMessage(
+                    type="image",
+                    content=url,
+                    url=url,
+                    detail=detail,
+                    image_info=image_info,
+                )
             else:
                 url = str(image_url)
                 detail = "auto"
-            return SourceMessage(
-                type="image",
-                content=url,
-                url=url,
-                detail=detail,
-            )
+                return SourceMessage(
+                    type="image",
+                    content=url,
+                    url=url,
+                    detail=detail,
+                )
         return SourceMessage(type="image", content=str(message))
 
     def rebuild_from_source(
@@ -74,11 +82,16 @@ def rebuild_from_source(
             or (source.content or "").replace("[image_url]: ", "")
         )
         detail = getattr(source, "detail", "auto")
+        image_id = ""
+        image_info = source.image_info
+        if image_info and isinstance(image_info, dict):
+            image_id = image_info.get("image_id")
         return {
             "type": "image_url",
             "image_url": {
                 "url": url,
                 "detail": detail,
+                "image_id": str(image_id),
             },
         }
 
diff --git a/src/memos/mem_reader/read_multi_modal/multi_modal_parser.py b/src/memos/mem_reader/read_multi_modal/multi_modal_parser.py
index 81bd25902..a08aadc0c 100644
--- a/src/memos/mem_reader/read_multi_modal/multi_modal_parser.py
+++ b/src/memos/mem_reader/read_multi_modal/multi_modal_parser.py
@@ -4,6 +4,8 @@
 in both fast and fine modes.
 """
 
+import traceback
+
 from typing import Any
 
 from memos.embedders.base import BaseEmbedder
@@ -35,6 +37,7 @@ def __init__(
         self,
         embedder: BaseEmbedder,
         llm: BaseLLM | None = None,
+        image_parser_llm: BaseLLM | None = None,
         parser: Any | None = None,
         direct_markdown_hostnames: list[str] | None = None,
     ):
@@ -43,7 +46,9 @@ def __init__(
 
         Args:
             embedder: Embedder for generating embeddings
-            llm: Optional LLM for fine mode processing
+            llm: Optional LLM for fine mode processing (chat/doc extraction)
+            image_parser_llm: Optional vision LLM for image parsing.
+                Falls back to llm if not provided.
             parser: Optional parser for parsing file contents
             direct_markdown_hostnames: List of hostnames that should return markdown directly
                 without parsing. If None, reads from FILE_PARSER_DIRECT_MARKDOWN_HOSTNAMES
@@ -51,6 +56,8 @@ def __init__(
         """
         self.embedder = embedder
         self.llm = llm
+        # Image parser LLM (requires vision model), falls back to main llm
+        self.image_parser_llm = image_parser_llm if image_parser_llm is not None else llm
         self.parser = parser
 
         # Initialize parsers for different message types
@@ -60,10 +67,15 @@ def __init__(
         self.assistant_parser = AssistantParser(embedder, llm)
         self.tool_parser = ToolParser(embedder, llm)
         self.text_content_parser = TextContentParser(embedder, llm)
+        # Use dedicated image_parser_llm for image parsing (requires vision model)
+        self.image_parser = ImageParser(embedder, self.image_parser_llm)
         self.file_content_parser = FileContentParser(
-            embedder, llm, parser, direct_markdown_hostnames=direct_markdown_hostnames
+            embedder,
+            llm,
+            parser,
+            direct_markdown_hostnames=direct_markdown_hostnames,
+            image_parser=self.image_parser,
         )
-        self.image_parser = ImageParser(embedder, llm)
         self.audio_parser = None  # future
 
         self.role_parsers = {
@@ -242,7 +254,10 @@ def process_transfer(
         try:
             message = parser.rebuild_from_source(source)
         except Exception as e:
-            logger.error(f"[MultiModalParser] Error rebuilding message from source: {e}")
+            logger.error(
+                f"[MultiModalParser] Error rebuilding message from "
+                f"source: {e} {traceback.format_exc()}"
+            )
             return []
 
         # Parse in fine mode (pass context_items and custom_tags to parse_fine)
diff --git a/src/memos/mem_reader/read_multi_modal/user_parser.py b/src/memos/mem_reader/read_multi_modal/user_parser.py
index 2e5ea6eae..a5a248e9d 100644
--- a/src/memos/mem_reader/read_multi_modal/user_parser.py
+++ b/src/memos/mem_reader/read_multi_modal/user_parser.py
@@ -114,6 +114,7 @@ def create_source(
                             chat_time=chat_time,
                             message_id=message_id,
                             image_path=image_info.get("url"),
+                            image_info=image_info,
                         )
                         source.lang = overall_lang
                         sources.append(source)
diff --git a/src/memos/mem_reader/read_multi_modal/utils.py b/src/memos/mem_reader/read_multi_modal/utils.py
index 96918589b..2e6ab1d6e 100644
--- a/src/memos/mem_reader/read_multi_modal/utils.py
+++ b/src/memos/mem_reader/read_multi_modal/utils.py
@@ -45,6 +45,10 @@
 )
 
 
+KEYS_DROP_LABEL = r"(text|type|image_url|imageurl|url|file|file_id|image_id|file_data)"
+ID_KEYS_DROP_VALUE = r"(file_id|image_id)"
+
+
 def parse_json_result(response_text: str) -> dict:
     """
     Parse JSON result from LLM response.
@@ -356,13 +360,25 @@ def detect_lang(text):
         cleaned_text = re.sub(r"\[[\d\-:\s]+\]", "", cleaned_text)
         # remove URLs to prevent the dilution of Chinese characters
         cleaned_text = re.sub(r'https?://[^\s<>"{}|\\^`\[\]]+', "", cleaned_text)
-        # remove MessageType schema keywords (multimodal JSON noise)
+        # remove common id-like tokens (uuid-ish / file_id / image_id /
+        # my_id_01 etc.)
+        # uuid
+        cleaned_text = re.sub(
+            r"\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b",
+            " ",
+            cleaned_text,
+            flags=re.IGNORECASE,
+        )
+        # key:value where key ends with _id or is id, and value is quoted or bare token
+        cleaned_text = re.sub(
+            r'(?i)\b[a-z_]*id\b\s*[:=]\s*(".*?"|\'.*?\'|[a-z0-9_\-]+)', " ", cleaned_text
+        )
         cleaned_text = re.sub(
-            r"\b(text|type|image_url|imageurl|url)\b", "", cleaned_text, flags=re.IGNORECASE
+            r'(?i)\b[a-z_]*_id\b\s*[:=]\s*(".*?"|\'.*?\'|[a-z0-9_\-]+)', " ", cleaned_text
         )
         # remove schema keywords like text / type / image_url / url
         cleaned_text = re.sub(
-            r"\b(text|type|image_url|imageurl|url|file|file_id)\b",
+            r"\b(text|type|image_url|imageurl|url|file|file_id|image_id|file_data)\b",
             "",
             cleaned_text,
             flags=re.IGNORECASE,
diff --git a/src/memos/mem_reader/simple_struct.py b/src/memos/mem_reader/simple_struct.py
index ceaf28bfa..f26be360c 100644
--- a/src/memos/mem_reader/simple_struct.py
+++ b/src/memos/mem_reader/simple_struct.py
@@ -21,6 +21,7 @@
 if TYPE_CHECKING:
     from memos.graph_dbs.base import BaseGraphDB
     from memos.memories.textual.tree_text_memory.retrieve.searcher import Searcher
+    from memos.types.general_types import UserContext
 from memos.mem_reader.read_multi_modal import coerce_scene_data, detect_lang
 from memos.mem_reader.utils import (
     count_tokens_text,
@@ -173,7 +174,15 @@ def __init__(self, config: SimpleStructMemReaderConfig):
             config: Configuration object for the reader
         """
         self.config = config
+        # Main LLM for chat/doc memory extraction (fine-tuned model)
         self.llm = LLMFactory.from_config(config.llm)
+        # General LLM for non-chat/doc tasks (hallucination filter, rewrite, merge, etc.)
+        # Falls back to main llm if not configured
+        self.general_llm = (
+            LLMFactory.from_config(config.general_llm)
+            if config.general_llm is not None
+            else self.llm
+        )
         self.embedder = EmbedderFactory.from_config(config.embedder)
         self.chunker = ChunkerFactory.from_config(config.chunker)
         self.save_rawfile = self.chunker.config.save_rawfile
@@ -332,6 +341,14 @@ def _process_chat_data(self, scene_data_info, info, **kwargs):
             "custom_tags", None
         )  # must pop here, avoid add to info, only used in sync fine mode
 
+        user_context: UserContext | None = kwargs.get("user_context")
+        ctx_kwargs: dict[str, Any] = {}
+        if user_context:
+            if user_context.manager_user_id:
+                ctx_kwargs["manager_user_id"] = user_context.manager_user_id
+            if user_context.project_id:
+                ctx_kwargs["project_id"] = user_context.project_id
+
         if mode == "fast":
             logger.debug("Using unified Fast Mode")
 
@@ -341,7 +358,12 @@ def _build_fast_node(w):
                 mem_type = "UserMemory" if roles == {"user"} else "LongTermMemory"
                 tags = ["mode:fast"]
                 return self._make_memory_item(
-                    value=text, info=info, memory_type=mem_type, tags=tags, sources=w["sources"]
+                    value=text,
+                    info=info,
+                    memory_type=mem_type,
+                    tags=tags,
+                    sources=w["sources"],
+                    **ctx_kwargs,
                 )
 
             with ContextThreadPoolExecutor(max_workers=8) as ex:
@@ -377,6 +399,7 @@ def _build_fast_node(w):
                             key=m.get("key", ""),
                             sources=w["sources"],
                             background=resp.get("summary", ""),
+                            **ctx_kwargs,
                         )
                         chat_read_nodes.append(node)
                     except Exception as e:
@@ -389,6 +412,14 @@ def _process_transfer_chat_data(
         raw_memory = raw_node.memory
         response_json = self._get_llm_response(raw_memory, custom_tags)
 
+        user_context: UserContext | None = kwargs.get("user_context")
+        ctx_kwargs: dict[str, Any] = {}
+        if user_context:
+            if user_context.manager_user_id:
+                ctx_kwargs["manager_user_id"] = user_context.manager_user_id
+            if user_context.project_id:
+                ctx_kwargs["project_id"] = user_context.project_id
+
         chat_read_nodes = []
         for memory_i_raw in response_json.get("memory list", []):
             try:
@@ -415,6 +446,7 @@ def _process_transfer_chat_data(
                     background=response_json.get("summary", ""),
                     type_="fact",
                     confidence=0.99,
+                    **ctx_kwargs,
                 )
                 chat_read_nodes.append(node_i)
             except Exception as e:
@@ -505,8 +537,9 @@ def rewrite_memories(
         prompt = template.format(**prompt_args)
 
         # Optionally run filter and parse the output
+        # Use general_llm for rewrite (not fine-tuned for this task)
         try:
-            raw = self.llm.generate([{"role": "user", "content": prompt}])
+            raw = self.general_llm.generate([{"role": "user", "content": prompt}])
             success, parsed = parse_rewritten_response(raw)
             logger.info(
                 f"[rewrite_memories] Hallucination filter parsed successfully: {success}；prompt: {prompt}"
@@ -565,8 +598,9 @@ def filter_hallucination_in_memories(
         prompt = template.format(**prompt_args)
 
         # Optionally run filter and parse the output
+        # Use general_llm for hallucination filter (not fine-tuned for this task)
         try:
-            raw = self.llm.generate([{"role": "user", "content": prompt}])
+            raw = self.general_llm.generate([{"role": "user", "content": prompt}])
             success, parsed = parse_keep_filter_response(raw)
             logger.info(
                 f"[filter_hallucination_in_memories] Hallucination filter parsed successfully: {success}；prompt: {prompt}"
diff --git a/src/memos/memories/textual/item.py b/src/memos/memories/textual/item.py
index 60af67830..a9b2c43a4 100644
--- a/src/memos/memories/textual/item.py
+++ b/src/memos/memories/textual/item.py
@@ -42,6 +42,7 @@ class SourceMessage(BaseModel):
     content: str | None = None
     doc_path: str | None = None
     file_info: dict | None = None
+    image_info: dict | None = None
     model_config = ConfigDict(extra="allow")
 
 
diff --git a/src/memos/memories/textual/tree_text_memory/organize/manager.py b/src/memos/memories/textual/tree_text_memory/organize/manager.py
index df419f0c1..96453f5a0 100644
--- a/src/memos/memories/textual/tree_text_memory/organize/manager.py
+++ b/src/memos/memories/textual/tree_text_memory/organize/manager.py
@@ -235,7 +235,6 @@ def _submit_batches(nodes: list[dict], node_kind: str) -> None:
                             exc_info=e,
                         )
 
-        _submit_batches(working_nodes, "WorkingMemory")
         _submit_batches(graph_nodes, "graph memory")
 
         if graph_node_ids and self.is_reorganize:
diff --git a/src/memos/types/openai_chat_completion_types/chat_completion_content_part_image_param.py b/src/memos/types/openai_chat_completion_types/chat_completion_content_part_image_param.py
index 6718bd91e..a5469cdc3 100644
--- a/src/memos/types/openai_chat_completion_types/chat_completion_content_part_image_param.py
+++ b/src/memos/types/openai_chat_completion_types/chat_completion_content_part_image_param.py
@@ -19,6 +19,9 @@ class ImageURL(TypedDict, total=False):
     [Vision guide](https://platform.openai.com/docs/guides/vision#low-or-high-fidelity-image-understanding).
     """
 
+    image_id: str
+    """Optional custom image id for tracking image sources."""
+
 
 class ChatCompletionContentPartImageParam(TypedDict, total=False):
     image_url: Required[ImageURL]
diff --git a/tests/mem_reader/test_project_id_propagation.py b/tests/mem_reader/test_project_id_propagation.py
new file mode 100644
index 000000000..5a17910ca
--- /dev/null
+++ b/tests/mem_reader/test_project_id_propagation.py
@@ -0,0 +1,396 @@
+"""Tests for project_id and manager_user_id propagation across memory modalities.
+
+Verifies that project_id and manager_user_id from UserContext are correctly
+carried through all extraction paths (fast/fine, multimodal, transfer) and
+into the resulting TextualMemoryItem metadata.
+"""
+
+import unittest
+
+from unittest.mock import MagicMock, patch
+
+from memos.chunkers import ChunkerFactory
+from memos.configs.mem_reader import SimpleStructMemReaderConfig
+from memos.embedders.factory import EmbedderFactory
+from memos.llms.factory import LLMFactory
+from memos.mem_reader.multi_modal_struct import MultiModalStructMemReader
+from memos.mem_reader.simple_struct import SimpleStructMemReader
+from memos.memories.textual.item import (
+    SourceMessage,
+    TextualMemoryItem,
+    TreeNodeTextualMemoryMetadata,
+)
+from memos.types.general_types import UserContext
+
+
+PROJECT_ID = "proj_42"
+MANAGER_USER_ID = "mgr_99"
+
+LLM_FINE_RESPONSE = (
+    '{"memory list": [{"key": "greeting", "memory_type": "LongTermMemory", '
+    '"value": "User greeted the assistant.", "tags": ["greeting"]}], '
+    '"summary": "User said hello."}'
+)
+
+
+def _make_user_context(
+    project_id: str = PROJECT_ID,
+    manager_user_id: str = MANAGER_USER_ID,
+) -> UserContext:
+    return UserContext(
+        user_id="u1",
+        mem_cube_id="cube1",
+        session_id="sess1",
+        manager_user_id=manager_user_id,
+        project_id=project_id,
+    )
+
+
+def _make_fast_item(
+    memory: str = "User said hello",
+    user_id: str = "u1",
+    session_id: str = "sess1",
+    manager_user_id: str | None = MANAGER_USER_ID,
+    project_id: str | None = PROJECT_ID,
+    role: str = "user",
+) -> TextualMemoryItem:
+    return TextualMemoryItem(
+        memory=memory,
+        metadata=TreeNodeTextualMemoryMetadata(
+            user_id=user_id,
+            session_id=session_id,
+            memory_type="LongTermMemory",
+            sources=[SourceMessage(type="chat", role=role, content=memory)],
+            manager_user_id=manager_user_id,
+            project_id=project_id,
+        ),
+    )
+
+
+def _assert_fields(
+    test_case, item: TextualMemoryItem, project_id=PROJECT_ID, manager_user_id=MANAGER_USER_ID
+):
+    """Assert that project_id and manager_user_id are set on the item metadata."""
+    test_case.assertEqual(
+        getattr(item.metadata, "project_id", None),
+        project_id,
+        f"project_id mismatch on item: {item.memory!r}",
+    )
+    test_case.assertEqual(
+        getattr(item.metadata, "manager_user_id", None),
+        manager_user_id,
+        f"manager_user_id mismatch on item: {item.memory!r}",
+    )
+
+
+# ---------------------------------------------------------------------------
+# SimpleStructMemReader tests
+# ---------------------------------------------------------------------------
+class TestSimpleStructProjectIdPropagation(unittest.TestCase):
+    """Verify SimpleStructMemReader propagates project_id/manager_user_id."""
+
+    def setUp(self):
+        config = MagicMock(spec=SimpleStructMemReaderConfig)
+        config.llm = MagicMock()
+        config.general_llm = None
+        config.embedder = MagicMock()
+        config.chunker = MagicMock()
+        config.remove_prompt_example = MagicMock()
+
+        with (
+            patch.object(LLMFactory, "from_config", return_value=MagicMock()),
+            patch.object(EmbedderFactory, "from_config", return_value=MagicMock()),
+            patch.object(ChunkerFactory, "from_config", return_value=MagicMock()),
+        ):
+            self.reader = SimpleStructMemReader(config)
+
+        self.reader.llm = MagicMock()
+        self.reader.general_llm = self.reader.llm
+        self.reader.embedder = MagicMock()
+        self.reader.embedder.embed.return_value = [[0.1] * 8]
+        self.reader.chunker = MagicMock()
+
+    # -- fast mode -----------------------------------------------------------
+    def test_process_chat_data_fast_with_user_context(self):
+        """Fast mode items must carry project_id and manager_user_id."""
+        scene = [
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi there"},
+        ]
+        info = {"user_id": "u1", "session_id": "sess1"}
+        ctx = _make_user_context()
+
+        result = self.reader._process_chat_data(scene, info, mode="fast", user_context=ctx)
+
+        self.assertTrue(len(result) > 0, "Expected at least one fast item")
+        for item in result:
+            _assert_fields(self, item)
+
+    def test_process_chat_data_fast_without_user_context(self):
+        """Without user_context the fields should be absent (None)."""
+        scene = [{"role": "user", "content": "Hello"}]
+        info = {"user_id": "u1", "session_id": "sess1"}
+
+        result = self.reader._process_chat_data(scene, info, mode="fast")
+
+        self.assertTrue(len(result) > 0)
+        for item in result:
+            _assert_fields(self, item, project_id=None, manager_user_id=None)
+
+    # -- fine mode -----------------------------------------------------------
+    def test_process_chat_data_fine_with_user_context(self):
+        """Fine mode items must carry project_id and manager_user_id."""
+        scene = [
+            {"role": "user", "content": "Hello"},
+            {"role": "assistant", "content": "Hi there"},
+        ]
+        info = {"user_id": "u1", "session_id": "sess1"}
+        ctx = _make_user_context()
+
+        self.reader.llm.generate.return_value = LLM_FINE_RESPONSE
+        result = self.reader._process_chat_data(scene, info, mode="fine", user_context=ctx)
+
+        self.assertTrue(len(result) > 0, "Expected at least one fine item")
+        for item in result:
+            _assert_fields(self, item)
+
+    def test_process_chat_data_fine_without_user_context(self):
+        """Fine mode without user_context should produce None fields."""
+        scene = [{"role": "user", "content": "Hello"}]
+        info = {"user_id": "u1", "session_id": "sess1"}
+
+        self.reader.llm.generate.return_value = LLM_FINE_RESPONSE
+        result = self.reader._process_chat_data(scene, info, mode="fine")
+
+        self.assertTrue(len(result) > 0)
+        for item in result:
+            _assert_fields(self, item, project_id=None, manager_user_id=None)
+
+    # -- transfer (async fine) -----------------------------------------------
+    def test_process_transfer_chat_data_with_user_context(self):
+        """Transfer path must propagate project_id and manager_user_id."""
+        raw_node = _make_fast_item()
+        ctx = _make_user_context()
+
+        self.reader.llm.generate.return_value = LLM_FINE_RESPONSE
+        result = self.reader._process_transfer_chat_data(raw_node, user_context=ctx)
+
+        self.assertTrue(len(result) > 0, "Expected at least one transfer item")
+        for item in result:
+            _assert_fields(self, item)
+
+    def test_process_transfer_chat_data_without_user_context(self):
+        """Transfer path without user_context should produce None fields."""
+        raw_node = _make_fast_item(manager_user_id=None, project_id=None)
+
+        self.reader.llm.generate.return_value = LLM_FINE_RESPONSE
+        result = self.reader._process_transfer_chat_data(raw_node)
+
+        self.assertTrue(len(result) > 0)
+        for item in result:
+            _assert_fields(self, item, project_id=None, manager_user_id=None)
+
+
+# ---------------------------------------------------------------------------
+# MultiModalStructMemReader tests
+# ---------------------------------------------------------------------------
+class TestMultiModalProjectIdPropagation(unittest.TestCase):
+    """Verify MultiModalStructMemReader propagates project_id/manager_user_id."""
+
+    def setUp(self):
+        # Bypass the heavy constructor entirely; we only need the methods
+        # under test, not a fully-wired reader.
+        with patch.object(MultiModalStructMemReader, "__init__", lambda self, *a, **kw: None):
+            self.reader = MultiModalStructMemReader.__new__(MultiModalStructMemReader)
+
+        self.reader.llm = MagicMock()
+        self.reader.general_llm = self.reader.llm
+        self.reader.embedder = MagicMock()
+        self.reader.embedder.embed.return_value = [[0.1] * 8]
+        self.reader.chunker = MagicMock()
+        self.reader.multi_modal_parser = MagicMock()
+        self.reader.config = MagicMock()
+        self.reader.chat_window_max_tokens = 4096
+        self.reader.save_rawfile = False
+        self.reader.searcher = MagicMock()
+        self.reader.graph_db = MagicMock()
+        self.reader.oss_config = None
+        self.reader.skills_dir_config = None
+
+    # -- _build_window_from_items --------------------------------------------
+    def test_build_window_propagates_project_id(self):
+        """Aggregated window items must carry project_id/manager_user_id
+        from their constituent fast items."""
+        items = [
+            _make_fast_item("Hello from user"),
+            _make_fast_item("Another message"),
+        ]
+        info = {"user_id": "u1", "session_id": "sess1"}
+
+        result = self.reader._build_window_from_items(items, info)
+
+        self.assertIsNotNone(result)
+        _assert_fields(self, result)
+
+    def test_build_window_without_project_id(self):
+        """When constituent items lack these fields, aggregated item should too."""
+        items = [
+            _make_fast_item("Hello", manager_user_id=None, project_id=None),
+        ]
+        info = {"user_id": "u1", "session_id": "sess1"}
+
+        result = self.reader._build_window_from_items(items, info)
+
+        self.assertIsNotNone(result)
+        _assert_fields(self, result, project_id=None, manager_user_id=None)
+
+    def test_build_window_picks_first_nonempty(self):
+        """If only one constituent item has the fields, they should be picked up."""
+        item_without = _make_fast_item("msg1", manager_user_id=None, project_id=None)
+        item_with = _make_fast_item("msg2")
+        info = {"user_id": "u1", "session_id": "sess1"}
+
+        result = self.reader._build_window_from_items([item_without, item_with], info)
+
+        self.assertIsNotNone(result)
+        _assert_fields(self, result)
+
+    # -- _process_string_fine ------------------------------------------------
+    def test_process_string_fine_propagates_fields(self):
+        """Fine string extraction must carry project_id/manager_user_id
+        from user_context into the resulting memory items."""
+        fast_items = [_make_fast_item("User said hello")]
+        info = {"user_id": "u1", "session_id": "sess1"}
+        ctx = _make_user_context()
+
+        self.reader.llm.generate.return_value = LLM_FINE_RESPONSE
+        # _get_maybe_merged_memory does similarity search; stub it to
+        # passthrough the extracted dict unchanged.
+        with patch.object(
+            self.reader,
+            "_get_maybe_merged_memory",
+            side_effect=lambda extracted_memory_dict, **kw: extracted_memory_dict,
+        ):
+            result = self.reader._process_string_fine(fast_items, info, user_context=ctx)
+
+        self.assertTrue(len(result) > 0, "Expected at least one fine string item")
+        for item in result:
+            _assert_fields(self, item)
+
+    def test_process_string_fine_without_user_context(self):
+        """Without user_context the fine items should lack these fields."""
+        fast_items = [_make_fast_item("Hello", manager_user_id=None, project_id=None)]
+        info = {"user_id": "u1", "session_id": "sess1"}
+
+        self.reader.llm.generate.return_value = LLM_FINE_RESPONSE
+        with patch.object(
+            self.reader,
+            "_get_maybe_merged_memory",
+            side_effect=lambda extracted_memory_dict, **kw: extracted_memory_dict,
+        ):
+            result = self.reader._process_string_fine(fast_items, info)
+
+        self.assertTrue(len(result) > 0)
+        for item in result:
+            _assert_fields(self, item, project_id=None, manager_user_id=None)
+
+    # -- _process_multi_modal_data Part B ------------------------------------
+    def test_process_multi_modal_data_passes_user_context_to_transfer(self):
+        """Part B of _process_multi_modal_data must forward user_context
+        to process_transfer so that parse_fine can use it."""
+        ctx = _make_user_context()
+        image_source = SourceMessage(type="image_url", content="http://img.png")
+        fast_item = TextualMemoryItem(
+            memory="Image context",
+            metadata=TreeNodeTextualMemoryMetadata(
+                user_id="u1",
+                session_id="sess1",
+                memory_type="LongTermMemory",
+                sources=[image_source],
+                manager_user_id=MANAGER_USER_ID,
+                project_id=PROJECT_ID,
+            ),
+        )
+
+        mock_transfer_items = [_make_fast_item("Extracted from image")]
+        self.reader.multi_modal_parser = MagicMock()
+        self.reader.multi_modal_parser.parse.return_value = [fast_item]
+        self.reader.multi_modal_parser.process_transfer.return_value = mock_transfer_items
+
+        scene = [
+            {
+                "role": "user",
+                "content": [{"type": "image_url", "image_url": {"url": "http://img.png"}}],
+            }
+        ]
+        info = {"user_id": "u1", "session_id": "sess1"}
+
+        with (
+            patch.object(self.reader, "_process_string_fine", return_value=[]),
+            patch.object(self.reader, "_process_tool_trajectory_fine", return_value=[]),
+            patch(
+                "memos.mem_reader.multi_modal_struct.process_skill_memory_fine",
+                return_value=[],
+            ),
+            patch(
+                "memos.mem_reader.multi_modal_struct.process_preference_fine",
+                return_value=[],
+            ),
+            patch.object(
+                self.reader,
+                "_concat_multi_modal_memories",
+                return_value=[fast_item],
+            ),
+        ):
+            self.reader._process_multi_modal_data(
+                scene,
+                info,
+                mode="fine",
+                user_context=ctx,
+            )
+
+        self.reader.multi_modal_parser.process_transfer.assert_called()
+        call_kwargs = self.reader.multi_modal_parser.process_transfer.call_args
+        self.assertEqual(
+            call_kwargs.kwargs.get("user_context"),
+            ctx,
+            "user_context must be forwarded to process_transfer",
+        )
+
+    # -- _process_transfer_multi_modal_data Part B ---------------------------
+    def test_process_transfer_passes_user_context(self):
+        """_process_transfer_multi_modal_data Part B must forward user_context."""
+        ctx = _make_user_context()
+        raw_node = _make_fast_item("some raw memory")
+
+        self.reader.multi_modal_parser = MagicMock()
+        self.reader.multi_modal_parser.process_transfer.return_value = []
+
+        with (
+            patch.object(self.reader, "_process_string_fine", return_value=[]),
+            patch.object(self.reader, "_process_tool_trajectory_fine", return_value=[]),
+            patch(
+                "memos.mem_reader.multi_modal_struct.process_skill_memory_fine",
+                return_value=[],
+            ),
+            patch(
+                "memos.mem_reader.multi_modal_struct.process_preference_fine",
+                return_value=[],
+            ),
+        ):
+            self.reader._process_transfer_multi_modal_data(
+                [raw_node],
+                user_context=ctx,
+            )
+
+        if self.reader.multi_modal_parser.process_transfer.called:
+            call_kwargs = self.reader.multi_modal_parser.process_transfer.call_args
+            self.assertEqual(
+                call_kwargs.kwargs.get("user_context"),
+                ctx,
+                "user_context must be forwarded in transfer path",
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/mem_reader/test_simple_structure.py b/tests/mem_reader/test_simple_structure.py
index fd07fbf41..8243cc96e 100644
--- a/tests/mem_reader/test_simple_structure.py
+++ b/tests/mem_reader/test_simple_structure.py
@@ -16,6 +16,7 @@ def setUp(self):
         # Mock config
         self.config = MagicMock(spec=SimpleStructMemReaderConfig)
         self.config.llm = MagicMock()
+        self.config.general_llm = None  # Optional, falls back to main llm
         self.config.embedder = MagicMock()
         self.config.chunker = MagicMock()
         self.config.remove_prompt_example = MagicMock()
@@ -30,6 +31,7 @@ def setUp(self):
 
         # Set up mock LLM and embedder
         self.reader.llm = MagicMock()
+        self.reader.general_llm = self.reader.llm  # Falls back to main llm
         self.reader.embedder = MagicMock()
         self.reader.chunker = MagicMock()
 
