alpha-avatar-plugins-memory 0.5.2__tar.gz → 0.5.3__tar.gz

{alpha_avatar_plugins_memory-0.5.2 → alpha_avatar_plugins_memory-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpha-avatar-plugins-memory
-Version: 0.5.2
+Version: 0.5.3
 Summary: AlphaAvatar Framework plugin for memory service
 Project-URL: Source, https://github.com/AlphaAvatar/AlphaAvatar
 License-Expression: Apache-2.0
@@ -17,6 +17,7 @@ Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
+Requires-Dist: lancedb
 Requires-Dist: langchain-community
 Requires-Dist: langchain-core
 Requires-Dist: langchain-openai

{alpha_avatar_plugins_memory-0.5.2 → alpha_avatar_plugins_memory-0.5.3}/alphaavatar/plugins/memory/__init__.py

@@ -11,13 +11,14 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import os
+
 from livekit.agents.inference_runner import _InferenceRunner
 
 from alphaavatar.agents import AvatarModule, AvatarPlugin
 
 from .log import logger
 from .memory_langchain import MemoryLangchain
-from .runner import QdrantRunner
 from .version import __version__
 
 __all__ = [
@@ -33,6 +34,7 @@ class MemoryLangchainPlugin(AvatarPlugin):
 
     def get_plugin(
         self,
+        working_dir: str,
         memory_search_context: int,
         memory_recall_num: int,
         maximum_memory_num: int,
@@ -42,20 +44,32 @@ class MemoryLangchainPlugin(AvatarPlugin):
     ) -> MemoryLangchain:
         try:
             return MemoryLangchain(
+                working_dir=working_dir,
                 memory_search_context=memory_search_context,
                 memory_recall_num=memory_recall_num,
                 maximum_memory_num=maximum_memory_num,
                 memory_init_config=memory_init_config,
             )
-        except Exception:
-            raise ImportError(
-                "The 'langchain[default]' Memory plugin is required but is not installed.\n"
-                "To fix this, install the optional dependency: `pip install alphaavatar-plugins-memory`"
-            )
+        except Exception as e:
+            raise ImportError(f"Failed to initialize MemoryLangchain plugin: {e}")
 
 
 # plugin init
 AvatarPlugin.register_avatar_plugin(AvatarModule.MEMORY, "default", MemoryLangchainPlugin())
 
 # runner init
-_InferenceRunner.register_runner(QdrantRunner)
+memory_vdb_type = os.getenv("MEMORY_VDB_TYPE", None)
+match memory_vdb_type:
+    case "qdrant":
+        from . import memory_langchain
+        from .runner import QdrantRunner
+
+        memory_langchain.MEMORY_INFERENCE_METHOD = QdrantRunner.INFERENCE_METHOD
+        _InferenceRunner.register_runner(QdrantRunner)
+
+    case "lancedb":
+        from . import memory_langchain
+        from .runner import LanceDBRunner
+
+        memory_langchain.MEMORY_INFERENCE_METHOD = LanceDBRunner.INFERENCE_METHOD
+        _InferenceRunner.register_runner(LanceDBRunner)

{alpha_avatar_plugins_memory-0.5.2 → alpha_avatar_plugins_memory-0.5.3}/alphaavatar/plugins/memory/memory_langchain.py

@@ -14,6 +14,7 @@
 import asyncio
 import hashlib
 import json
+import pathlib
 import re
 from typing import Any
 
@@ -34,32 +35,63 @@ from alphaavatar.agents.memory import (
 from alphaavatar.agents.utils import format_current_time
 
 from .log import logger
+from .memory_markdown import save_memory_items_to_markdown
 from .memory_op import MemoryDelta, PatchOp, flatten_items, norm_token, rebuild_from_items
-from .memory_prompts import MEMORY_EXTRACT_PROMPT
-from .runner import QdrantRunner
+from .memory_prompts import (
+    CONVERSATION_MEMORY_EXTRACT_PROMPT,
+    TOOL_MEMORY_EXTRACT_PROMPT,
+)
+
+CONVERSATION_DELTA_PROMPT = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            CONVERSATION_MEMORY_EXTRACT_PROMPT,
+        ),
+        (
+            "human",
+            "NEW TURN TYPE: {type}\n"
+            "NEW TURN CONTENT:\n```{message_content}```\n\n"
+            "Output only `MemoryDelta`.\n\n"
+            "### WRITING RULES\n"
+            "- Each user_or_tool_memory_entries PatchOp.value MUST be exactly one [MEMORY]...[/MEMORY] card for conversation memory.\n"
+            "- Each assistant_memory_entries PatchOp.value MUST be exactly one [MEMORY]...[/MEMORY] card for avatar memory.\n"
+            "- summary must preserve user intent, assistant response, and any continuing context.\n"
+            "- Do NOT write raw tool logs, request IDs, file paths, actions, or next_steps unless absolutely necessary.\n"
+            "- If tools were used, describe only the user-facing result at a high level.\n"
+            "- entities must include high-signal nouns.\n"
+            "- topic must be a stable short label.\n"
+            "- Avoid duplication: only record new conversational facts or new details in this turn.\n"
+            "- Do not invent details not supported by the content.\n",
+        ),
+    ]
+)
 
-DELTA_PROMPT = ChatPromptTemplate.from_messages(
+TOOL_DELTA_PROMPT = ChatPromptTemplate.from_messages(
     [
         (
             "system",
-            MEMORY_EXTRACT_PROMPT,
+            TOOL_MEMORY_EXTRACT_PROMPT,
         ),
         (
             "human",
             "NEW TURN TYPE: {type}\n"
             "NEW TURN CONTENT:\n```{message_content}```\n\n"
-            "Output only MemoryDelta.\n\n"
+            "Output only `MemoryDelta`.\n\n"
             "### WRITING RULES\n"
-            "- Each PatchOp.value MUST be exactly one [EVENT]...[/EVENT] card described in the system prompt.\n"
-            "- Do NOT write vague summaries. Include tool/component, operation, outcome, and evidence IDs when available.\n"
-            "- entities must include high-signal nouns (tool names, ops, error codes, env cues).\n"
-            "- topic must be a stable short label (e.g., 'rag indexing', 'web search', 'file storage', 'tool error').\n"
-            "- Avoid duplication: only record new events or new details in this turn.\n"
+            "- Each user_or_tool_memory_entries PatchOp.value MUST be exactly one [EVENT]...[/EVENT] card for tool memory.\n"
+            "- Each assistant_memory_entries PatchOp.value MUST be exactly one [EVENT]...[/EVENT] card for avatar memory derived from tool events.\n"
+            "- Include concrete tool/component, operation, outcome, and relevant sanitized details.\n"
+            "- Include evidence IDs only when actually present.\n"
+            "- entities must include high-signal nouns such as tool names, operations, error identifiers, or artifact types.\n"
+            "- topic must be a stable short label.\n"
+            "- Avoid duplication: only record new tool events or new details in this turn.\n"
             "- Do not invent details not supported by the content.\n",
         ),
     ]
 )
 
+MEMORY_INFERENCE_METHOD = None
 
 # ===============================
 # For Memory Normalization and Dedupe
@@ -104,6 +136,14 @@ EVENT_TYPE_RE = re.compile(r"(?im)^\s*type:\s*([a-zA-Z_]+)\s*$")
 OUTCOME_RE = re.compile(r"(?im)^\s*outcome:\s*([a-zA-Z_]+)\s*$")
 TOPIC_RE = re.compile(r"(?im)^\s*topic:\s*(.+?)\s*$")
 ERROR_RE = re.compile(r"(?im)^\s*error:\s*(.+?)\s*$")
+KIND_RE = re.compile(r"(?im)^\s*kind:\s*([a-zA-Z_]+)\s*$")
+SUMMARY_RE = re.compile(r"(?ims)^\s*summary:\s*(.+?)\s*$")
+CONTEXT_RE = re.compile(r"(?ims)^\s*context:\s*(.+?)\s*$")
+
+
+def _memory_field(value: str, regex: re.Pattern[str]) -> str | None:
+    m = regex.search(value or "")
+    return m.group(1).strip() if m else None
 
 
 def _event_field(value: str, regex: re.Pattern[str]) -> str | None:
@@ -114,13 +154,16 @@ def _event_field(value: str, regex: re.Pattern[str]) -> str | None:
 def _memory_priority(item: "MemoryItem") -> int:
     """
     Higher is more important.
-    Works even if value is not an event card (but your prompt aims to always produce one).
+    Supports both:
+    - [EVENT] cards for tool memory
+    - [MEMORY] cards for conversation/avatar memory
     """
     v = (item.value or "").lower()
     t = (item.topic or "").lower()
 
     etype = _event_field(item.value, EVENT_TYPE_RE) or ""
     outcome = _event_field(item.value, OUTCOME_RE) or ""
+    kind = (_memory_field(item.value, KIND_RE) or "").strip().lower()
 
     # 1) Hard signals: failures/incidents
     if "outcome: failed" in v or outcome == "failed":
@@ -132,28 +175,67 @@ def _memory_priority(item: "MemoryItem") -> int:
     if "error:" in v or _event_field(item.value, ERROR_RE):
         return 92
 
-    # 2) High-value operational memories
-    if etype in ("decision", "config_change"):
-        return 88
-    if etype in ("indexing", "retrieval"):
-        return 85
-    if t in (
-        "rag indexing",
-        "tool error",
-        "qdrant memory",
-        "async debugging",
-        "dependency install",
-        "gpu detection",
-    ):
-        return 82
-
-    # 3) Medium: user intent / tasks / important interactions
-    if etype in ("interaction", "file_storage", "web_search", "tool_run"):
-        return 60
-
-    # 4) Social context: keep but lower priority
+    # 2) Avatar memory is usually high-value global memory
+    if item.memory_type == MemoryType.Avatar:
+        if kind == "avatar":
+            return 90
+        if etype in ("decision", "config_change"):
+            return 88
+        return 86
+
+    # 3) Tool-side operational memories
+    if item.memory_type == MemoryType.TOOLS:
+        if etype in ("decision", "config_change"):
+            return 88
+        if etype in ("indexing", "retrieval", "web_search", "tool_run", "artifact_generation"):
+            return 82
+        if t in (
+            "rag indexing",
+            "tool error",
+            "qdrant memory",
+            "async debugging",
+            "dependency install",
+            "gpu detection",
+            "memory prompt inspection",
+            "tool memory policy",
+        ):
+            return 80
+        return 70
+
+    # 4) Conversation memories
+    if item.memory_type == MemoryType.CONVERSATION:
+        if kind == "conversation":
+            if t in (
+                "response preference",
+                "user response preference",
+                "memory prompt design",
+                "alphaavatar architecture",
+                "social context",
+            ):
+                return 72
+
+            # If it contains explicit preference/emotion/project context, slightly higher
+            if any(
+                k in v
+                for k in [
+                    "prefers",
+                    "preference",
+                    "short and direct",
+                    "concise",
+                    "building",
+                    "redesigning",
+                    "stressed",
+                    "tired",
+                    "excited",
+                    "frustrated",
+                ]
+            ):
+                return 68
+
+            return 60
+
+    # 5) Fallbacks
     if t in ("social context", "small talk", "chitchat", "chat"):
-        # if contains emotion keywords, slightly higher
         if any(
             k in v
             for k in ["tired", "exhausted", "stressed", "anxious", "happy", "excited", "frustrated"]
@@ -218,7 +300,7 @@ def _select_by_priority(
     return picked
 
 
-class MemmoryInitConfig(BaseModel):
+class MemoryInitConfig(BaseModel):
     chat_model: str = Field(default="gpt-4o-mini")
     temperature: float = Field(default=0.0)
 
@@ -227,19 +309,21 @@ class MemoryLangchain(MemoryBase):
     def __init__(
         self,
         *,
+        working_dir: pathlib.Path,
         memory_search_context: int = 3,
         memory_recall_num: int = 10,
         maximum_memory_num: int = 24,
         memory_init_config: dict[str, Any] | None = None,
     ) -> None:
         super().__init__(
+            working_dir=working_dir,
             memory_search_context=memory_search_context,
             memory_recall_num=memory_recall_num,
             maximum_memory_num=maximum_memory_num,
         )
 
         self._memory_init_config = (
-            MemmoryInitConfig(**memory_init_config) if memory_init_config else MemmoryInitConfig()
+            MemoryInitConfig(**memory_init_config) if memory_init_config else MemoryInitConfig()
         )
 
         llm = ChatOpenAI(
@@ -248,41 +332,66 @@ class MemoryLangchain(MemoryBase):
         )  # type: ignore
 
         self._delta_llm = llm.with_structured_output(MemoryDelta)
-        self._delta_chain = DELTA_PROMPT | self._delta_llm  # ✅ build once
+        self._conversation_delta_chain = CONVERSATION_DELTA_PROMPT | self._delta_llm
+        self._tool_delta_chain = TOOL_DELTA_PROMPT | self._delta_llm
         self._executor = get_job_context().inference_executor
 
     @property
-    def memory_init_config(self) -> MemmoryInitConfig:
+    def memory_init_config(self) -> MemoryInitConfig:
         return self._memory_init_config
 
-    async def _safe_ainvoke_delta(
+    async def _safe_ainvoke_conversation_delta(
+        self,
+        *,
+        message_content: str,
+        timeout: float = 12.0,
+    ) -> MemoryDelta:
+        payload = {
+            "type": MemoryType.CONVERSATION,
+            "message_content": message_content,
+        }
+        try:
+            return await asyncio.wait_for(
+                self._conversation_delta_chain.ainvoke(payload), timeout=timeout
+            )  # type: ignore
+        except asyncio.TimeoutError:
+            logger.warning("[Memory] conversation delta extraction timeout")
+            return MemoryDelta()
+        except Exception:
+            logger.exception("[Memory] conversation delta extraction failed")
+            return MemoryDelta()
+
+    async def _safe_ainvoke_tool_delta(
         self,
         *,
-        memory_type: MemoryType,
         message_content: str,
         timeout: float = 12.0,
     ) -> MemoryDelta:
-        """Robust delta extraction with timeout and fallback."""
         payload = {
-            "type": memory_type,
+            "type": MemoryType.TOOLS,
             "message_content": message_content,
         }
         try:
-            return await asyncio.wait_for(self._delta_chain.ainvoke(payload), timeout=timeout)  # type: ignore
+            return await asyncio.wait_for(self._tool_delta_chain.ainvoke(payload), timeout=timeout)  # type: ignore
         except asyncio.TimeoutError:
-            logger.warning(f"[Memory] delta extraction timeout (type={memory_type})")
+            logger.warning("[Memory] tool delta extraction timeout")
             return MemoryDelta()
         except Exception:
-            logger.exception(f"[Memory] delta extraction failed (type={memory_type})")
+            logger.exception("[Memory] tool delta extraction failed")
             return MemoryDelta()
 
-    def _apply_delta(self, avatar_id: str, delta: MemoryDelta, memory_cache: MemoryCache):
+    def _apply_delta_to_bucket(
+        self,
+        *,
+        avatar_id: str,
+        delta: MemoryDelta,
+        memory_cache: MemoryCache,
+        user_or_tool_memory_type: MemoryType,
+    ):
         updated_time = format_current_time().time_str
         assistant_memories: list[MemoryItem] = []
-        user_memories: list[MemoryItem] = []
-        tool_memories: list[MemoryItem] = []
+        target_memories: list[MemoryItem] = []
 
-        # local dedupe per update call
         seen_keys: set[str] = set()
 
         def _maybe_add(
@@ -292,7 +401,6 @@ class MemoryLangchain(MemoryBase):
             mem_type: MemoryType,
             item: PatchOp,
         ):
-            # normalize
             item.topic = _norm_topic(item.topic)
             item.entities = _norm_entities(item.entities)
 
@@ -317,7 +425,6 @@ class MemoryLangchain(MemoryBase):
                 )
             )
 
-        # assistant memory
         for item in delta.assistant_memory_entries:
             _maybe_add(
                 bucket=assistant_memories,
@@ -326,25 +433,15 @@ class MemoryLangchain(MemoryBase):
                 item=item,
             )
 
-        # user or tool memory
-        if memory_cache.type == MemoryType.CONVERSATION:
-            for item in delta.user_or_tool_memory_entries:
-                _maybe_add(
-                    bucket=user_memories,
-                    object_id=memory_cache.user_or_tool_id,
-                    mem_type=MemoryType.CONVERSATION,
-                    item=item,
-                )
-        else:
-            for item in delta.user_or_tool_memory_entries:
-                _maybe_add(
-                    bucket=tool_memories,
-                    object_id=memory_cache.user_or_tool_id,
-                    mem_type=MemoryType.TOOLS,
-                    item=item,
-                )
+        for item in delta.user_or_tool_memory_entries:
+            _maybe_add(
+                bucket=target_memories,
+                object_id=memory_cache.user_or_tool_id,
+                mem_type=user_or_tool_memory_type,
+                item=item,
+            )
 
-        return assistant_memories, user_memories, tool_memories
+        return assistant_memories, target_memories
 
     async def search_by_context(
         self, *, avatar_id: str, session_id: str, chat_context: list[ChatItem], timeout: float = 3
@@ -357,23 +454,19 @@ class MemoryLangchain(MemoryBase):
         if not context_str:
             return
 
-        if self.memory_cache[session_id].type == MemoryType.CONVERSATION:
-            json_data = {
-                "op": VectorRunnerOP.search_by_context,
-                "param": {
-                    "context_str": context_str,
-                    "avatar_id": avatar_id,
-                    "user_id": self.memory_cache[session_id].user_or_tool_id,
-                    "top_k": self.memory_recall_num,
-                },
-            }
-            json_data = json.dumps(json_data).encode()
-        else:
-            # TODO: we will implement the part in the future
-            raise NotImplementedError
+        json_data = {
+            "op": VectorRunnerOP.search_by_context,
+            "param": {
+                "context_str": context_str,
+                "avatar_id": avatar_id,
+                "user_or_tool_id": self.memory_cache[session_id].user_or_tool_id,
+                "top_k": self.memory_recall_num,
+            },
+        }
+        json_data = json.dumps(json_data).encode()
 
         result = await asyncio.wait_for(
-            self._executor.do_inference(QdrantRunner.INFERENCE_METHOD, json_data),
+            self._executor.do_inference(MEMORY_INFERENCE_METHOD, json_data),
             timeout=timeout,
         )
 
@@ -383,19 +476,19 @@ class MemoryLangchain(MemoryBase):
 
         data: dict[str, Any] = json.loads(result.decode())
 
-        # Avatar Memory
-        if data.get("avatar_memory_items", None):
-            self.avatar_memory = rebuild_from_items(data["avatar_memory_items"])
-
-        # User Memory
-        if data.get("user_rmemory_items", None):
-            self.user_memory = rebuild_from_items(data["user_rmemory_items"])
+        # Update Current Memory
+        if data.get("memory_items", None):
+            memory_items = rebuild_from_items(data["memory_items"])
+            self.avatar_memory = [it for it in memory_items if it.memory_type == MemoryType.Avatar]
+            self.user_memory = [
+                it for it in memory_items if it.memory_type == MemoryType.CONVERSATION
+            ]
+            self.tool_memory = [it for it in memory_items if it.memory_type == MemoryType.TOOLS]
 
         if data.get("error", None):
             logger.warning(f"Memory [search_by_context] err: {data['error']}")
 
     async def update(self, *, avatar_id: str, session_id: str | None = None):
-        """Update the memory database with the cached messages."""
         if session_id is not None and session_id not in self.memory_cache:
             raise ValueError(
                 f"Session ID {session_id} not found in memory cache. You need to call 'init_cache' first."
@@ -407,7 +500,6 @@ class MemoryLangchain(MemoryBase):
             else [(session_id, self.memory_cache[session_id])]
         )
 
-        # ✅ accumulate instead of overwrite
         all_assistant: list[MemoryItem] = []
         all_user: list[MemoryItem] = []
         all_tool: list[MemoryItem] = []
@@ -415,49 +507,82 @@ class MemoryLangchain(MemoryBase):
         for _sid, cache in memory_tuple:
             chat_context = cache.messages
             if not chat_context:
-                logger.info(f"[sid: {_sid}] Memory message is empty, UPDATE skip!")
-                continue  # ✅ important
+                logger.warning(f"[sid: {_sid}] Memory message is empty, UPDATE skip!")
+                continue
 
             message_content: str = MemoryPluginsTemplate.apply_update_template(
                 chat_context, cache.type
             )
 
-            delta: MemoryDelta = await self._safe_ainvoke_delta(
-                memory_type=cache.type,
-                message_content=message_content,
-                timeout=12.0,
-            )
+            if cache.type == MemoryType.CONVERSATION:
+                conversation_delta, tool_delta = await asyncio.gather(
+                    self._safe_ainvoke_conversation_delta(
+                        message_content=message_content,
+                        timeout=30.0,
+                    ),
+                    self._safe_ainvoke_tool_delta(
+                        message_content=message_content,
+                        timeout=30.0,
+                    ),
+                )
 
-            assistant_memories, user_memories, tool_memories = self._apply_delta(
-                avatar_id, delta, cache
-            )
+                conv_avatar, conv_user = self._apply_delta_to_bucket(
+                    avatar_id=avatar_id,
+                    delta=conversation_delta,
+                    memory_cache=cache,
+                    user_or_tool_memory_type=MemoryType.CONVERSATION,
+                )
+
+                tool_avatar, tool_memories = self._apply_delta_to_bucket(
+                    avatar_id=avatar_id,
+                    delta=tool_delta,
+                    memory_cache=cache,
+                    user_or_tool_memory_type=MemoryType.TOOLS,
+                )
 
-            all_assistant.extend(assistant_memories)
-            all_user.extend(user_memories)
-            all_tool.extend(tool_memories)
+                all_assistant.extend(conv_avatar)
+                all_assistant.extend(tool_avatar)
+                all_user.extend(conv_user)
+                all_tool.extend(tool_memories)
+
+            else:
+                tool_delta = await self._safe_ainvoke_tool_delta(
+                    message_content=message_content,
+                    timeout=30.0,
+                )
+
+                tool_avatar, tool_memories = self._apply_delta_to_bucket(
+                    avatar_id=avatar_id,
+                    delta=tool_delta,
+                    memory_cache=cache,
+                    user_or_tool_memory_type=MemoryType.TOOLS,
+                )
+
+                all_assistant.extend(tool_avatar)
+                all_tool.extend(tool_memories)
 
         self.avatar_memory = all_assistant
         self.user_memory = all_user
         self.tool_memory = all_tool
 
     async def save(self, timeout: float = 3):
-        # 1) Collect updated MemoryItem objects (not dict yet)
+        # 1. Collect updated MemoryItem objects (not dict yet)
         updated_items: list[MemoryItem] = [item for item in self.memory_items if item.updated]
 
         if not updated_items:
             logger.info("Avatar Memory SAVE skip!")
             return
 
-        # 2) Split buckets by memory_type (optional but recommended)
+        # 2. Split buckets by memory_type (optional but recommended)
         avatar_items = [x for x in updated_items if x.memory_type == MemoryType.Avatar]
         user_items = [x for x in updated_items if x.memory_type == MemoryType.CONVERSATION]
         tool_items = [x for x in updated_items if x.memory_type == MemoryType.TOOLS]
 
-        # 3) Apply priority selection with quotas
-        # You can tune these numbers; idea: keep incidents/decisions, allow small amount of social.
+        # 3. Apply priority selection with quotas
+        ## 3.1 You can tune these numbers; idea: keep incidents/decisions, allow small amount of social.
         max_total = getattr(self, "maximum_memory_num", 24)
 
-        # Per bucket limits (sum can exceed max_total; we'll cap again later)
+        ## 3.2 Per bucket limits (sum can exceed max_total; we'll cap again later)
         avatar_selected = _select_by_priority(
             avatar_items, limit=min(10, max_total), social_limit=1
         )
@@ -466,17 +591,29 @@ class MemoryLangchain(MemoryBase):
 
         selected = avatar_selected + user_selected + tool_selected
 
-        # 4) Global cap (final)
+        # 4. Global cap (final)
         selected.sort(key=lambda x: _memory_priority(x), reverse=True)
         selected = selected[:max_total]
 
-        # 5) Convert to dict for storage
+        # 5. Convert to dict for storage
         memory_items: list[dict] = flatten_items(selected)
 
         if not memory_items:
             logger.info("Memory SAVE skip after priority filtering (no items selected).")
             return
 
+        ## 5.1 Save to local .md file for backup/debug
+        try:
+            md_result = save_memory_items_to_markdown(
+                avatar_memory_path=self._avatar_memory_path,
+                session_memory_path=self._session_memory_path,
+                memory_items=memory_items,
+            )
+            logger.info(f"Memory local markdown backup success: {md_result}")
+        except Exception as e:
+            logger.warning(f"Memory local markdown backup failed: {e}")
+
+        ## 5.2 Save to VDB via runner
         json_data = {
             "op": VectorRunnerOP.save,
             "param": {"memory_items": memory_items},
@@ -485,7 +622,7 @@ class MemoryLangchain(MemoryBase):
         try:
             result = await asyncio.wait_for(
                 self._executor.do_inference(
-                    QdrantRunner.INFERENCE_METHOD, json.dumps(json_data).encode()
+                    MEMORY_INFERENCE_METHOD, json.dumps(json_data).encode()
                 ),
                 timeout=timeout,
             )