veadk-python 0.2.9__tar.gz → 0.2.10__tar.gz

{veadk_python-0.2.9 → veadk_python-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veadk-python
-Version: 0.2.9
+Version: 0.2.10
 Summary: Volcengine agent development kit, integrations with Volcengine cloud services.
 Author-email: Yaozheng Fang <fangyozheng@gmail.com>, Guodong Li <cu.eric.lee@gmail.com>, Zhi Han <sliverydayday@gmail.com>, Meng Wang <mengwangwm@gmail.com>
 License:                                  Apache License
@@ -218,7 +218,7 @@ Requires-Dist: opentelemetry-exporter-otlp>=1.35.0
 Requires-Dist: opentelemetry-instrumentation-logging>=0.56b0
 Requires-Dist: wrapt>=1.17.2
 Requires-Dist: openai<1.100
-Requires-Dist: volcengine-python-sdk>=4.0.3
+Requires-Dist: volcengine-python-sdk>=4.0.18
 Requires-Dist: volcengine>=1.0.193
 Requires-Dist: agent-pilot-sdk>=0.1.2
 Requires-Dist: fastmcp>=2.11.3
@@ -235,12 +235,12 @@ Provides-Extra: extensions
 Requires-Dist: redis>=5.0; extra == "extensions"
 Requires-Dist: tos>=2.8.4; extra == "extensions"
 Requires-Dist: llama-index-vector-stores-redis>=0.6.1; extra == "extensions"
-Requires-Dist: mcp-server-vikingdb-memory; extra == "extensions"
 Provides-Extra: database
 Requires-Dist: redis>=5.0; extra == "database"
 Requires-Dist: pymysql>=1.1.1; extra == "database"
 Requires-Dist: volcengine>=1.0.193; extra == "database"
 Requires-Dist: tos>=2.8.4; extra == "database"
+Requires-Dist: mem0ai==0.1.118; extra == "database"
 Provides-Extra: eval
 Requires-Dist: prometheus-client>=0.22.1; extra == "eval"
 Requires-Dist: deepeval>=3.2.6; extra == "eval"

{veadk_python-0.2.9 → veadk_python-0.2.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "veadk-python"
-version = "0.2.9"
+version = "0.2.10"
 description = "Volcengine agent development kit, integrations with Volcengine cloud services."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -22,8 +22,8 @@ dependencies = [
     "opentelemetry-instrumentation-logging>=0.56b0",
     "wrapt>=1.17.2", # For patching built-in functions
     "openai<1.100", # For fix https://github.com/BerriAI/litellm/issues/13710
-    "volcengine-python-sdk>=4.0.3", # For Volcengine API
-    "volcengine>=1.0.193",          # For Volcengine sign
+    "volcengine-python-sdk>=4.0.18", # For Volcengine API
+    "volcengine>=1.0.193", # For Volcengine sign
     "agent-pilot-sdk>=0.1.2", # Prompt optimization by Volcengine AgentPilot/PromptPilot toolkits
     "fastmcp>=2.11.3", # For running MCP
     "cookiecutter>=2.6.0", # For cloud deploy
@@ -45,13 +45,13 @@ extensions = [
     "redis>=5.0",                 # For Redis database
     "tos>=2.8.4",                   # For TOS storage and Viking DB
     "llama-index-vector-stores-redis>=0.6.1",
-    "mcp-server-vikingdb-memory",
 ]
 database = [
     "redis>=5.0",                 # For Redis database
     "pymysql>=1.1.1",               # For MySQL database
     "volcengine>=1.0.193",          # For Viking DB
     "tos>=2.8.4",                   # For TOS storage and Viking DB
+    "mem0ai==0.1.118",              # For mem0
 ]
 eval = [
     "prometheus-client>=0.22.1",    # For exporting data to Prometheus pushgateway
@@ -91,6 +91,3 @@ exclude = [
     "veadk/integrations/ve_faas/template/*",
     "veadk/integrations/ve_faas/web_template/*"
 ]
-
-[tool.uv.sources]
-mcp-server-vikingdb-memory = { git = "https://github.com/volcengine/mcp-server", subdirectory = "server/mcp_server_vikingdb_memory" }

veadk_python-0.2.10/veadk/a2a/remote_ve_agent.py

@@ -0,0 +1,90 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 json
+from typing import Literal
+
+import httpx
+import requests
+from a2a.types import AgentCard
+from google.adk.agents.remote_a2a_agent import RemoteA2aAgent
+
+from veadk.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+AGENT_CARD_WELL_KNOWN_PATH = "/.well-known/agent-card.json"
+
+
+def _convert_agent_card_dict_to_obj(agent_card_dict: dict) -> AgentCard:
+    agent_card_json_str = json.dumps(agent_card_dict, ensure_ascii=False, indent=2)
+    agent_card_object = AgentCard.model_validate_json(str(agent_card_json_str))
+    return agent_card_object
+
+
+class RemoteVeAgent(RemoteA2aAgent):
+    """Connect to remote agent on VeFaaS platform."""
+
+    def __init__(
+        self,
+        name: str,
+        url: str,
+        auth_token: str | None = None,
+        auth_method: Literal["header", "querystring"] | None = None,
+    ):
+        if not auth_token:
+            agent_card_dict = requests.get(url + AGENT_CARD_WELL_KNOWN_PATH).json()
+            # replace agent_card_url with actual host
+            agent_card_dict["url"] = url
+
+            agent_card_object = _convert_agent_card_dict_to_obj(agent_card_dict)
+
+            logger.debug(f"Agent card of {name}: {agent_card_object}")
+            super().__init__(name=name, agent_card=agent_card_object)
+        else:
+            if auth_method == "header":
+                headers = {"Authorization": f"Bearer {auth_token}"}
+                agent_card_dict = requests.get(
+                    url + AGENT_CARD_WELL_KNOWN_PATH, headers=headers
+                ).json()
+                agent_card_dict["url"] = url
+
+                agent_card_object = _convert_agent_card_dict_to_obj(agent_card_dict)
+                httpx_client = httpx.AsyncClient(
+                    base_url=url, headers=headers, timeout=600
+                )
+
+                logger.debug(f"Agent card of {name}: {agent_card_object}")
+                super().__init__(
+                    name=name, agent_card=agent_card_object, httpx_client=httpx_client
+                )
+            elif auth_method == "querystring":
+                agent_card_dict = requests.get(
+                    url + AGENT_CARD_WELL_KNOWN_PATH + f"?token={auth_token}"
+                ).json()
+                agent_card_dict["url"] = url
+
+                agent_card_object = _convert_agent_card_dict_to_obj(agent_card_dict)
+                httpx_client = httpx.AsyncClient(
+                    base_url=url, params={"token": auth_token}, timeout=600
+                )
+
+                logger.debug(f"Agent card of {name}: {agent_card_object}")
+                super().__init__(
+                    name=name, agent_card=agent_card_object, httpx_client=httpx_client
+                )
+            else:
+                raise ValueError(
+                    f"Unsupported auth method {auth_method}, use `header` or `querystring` instead."
+                )

{veadk_python-0.2.9 → veadk_python-0.2.10}/veadk/agent.py

@@ -141,6 +141,9 @@ class Agent(LlmAgent):
         if self.long_term_memory is not None:
             from google.adk.tools import load_memory
 
+            if not load_memory.custom_metadata:
+                load_memory.custom_metadata = {}
+            load_memory.custom_metadata["backend"] = self.long_term_memory.backend
             self.tools.append(load_memory)
 
         logger.info(f"VeADK version: {VERSION}")

{veadk_python-0.2.9 → veadk_python-0.2.10}/veadk/agent_builder.py

@@ -52,9 +52,8 @@ class AgentBuilder:
         tools = []
         if agent_config.get("tools", []):
             for tool in agent_config["tools"]:
-                module_name = tool["module"]
-                func_name = tool["func"]
-
+                name = tool["name"]
+                module_name, func_name = name.rsplit(".", 1)
                 module = importlib.import_module(module_name)
                 func = getattr(module, func_name)
 

{veadk_python-0.2.9 → veadk_python-0.2.10}/veadk/cli/cli.py

@@ -18,6 +18,7 @@ import click
 from veadk.cli.cli_deploy import deploy
 from veadk.cli.cli_eval import eval
 from veadk.cli.cli_init import init
+from veadk.cli.cli_kb import kb
 from veadk.cli.cli_pipeline import pipeline
 from veadk.cli.cli_prompt import prompt
 from veadk.cli.cli_web import web
@@ -39,6 +40,7 @@ veadk.add_command(prompt)
 veadk.add_command(web)
 veadk.add_command(pipeline)
 veadk.add_command(eval)
+veadk.add_command(kb)
 
 if __name__ == "__main__":
     veadk()

veadk_python-0.2.10/veadk/cli/cli_kb.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+from pathlib import Path
+from typing import Literal
+
+import click
+
+
+@click.command()
+@click.option(
+    "--backend",
+    type=click.Choice(
+        ["local", "opensearch", "viking", "redis"],
+        case_sensitive=False,
+    ),
+    required=True,
+)
+@click.option(
+    "--app_name",
+    default="",
+    help="`app_name` for init your knowledgebase",
+)
+@click.option(
+    "--index",
+    default="",
+    help="Knowledgebase index",
+)
+@click.option(
+    "--path",
+    required=True,
+    help="Knowledge file or directory path",
+)
+def add(
+    backend: Literal["local", "opensearch", "viking", "redis"],
+    app_name: str,
+    index: str,
+    path: str,
+):
+    """Add files to knowledgebase"""
+    _path = Path(path)
+    assert _path.exists(), f"Path {path} not exists. Please check your input."
+
+    from veadk.knowledgebase import KnowledgeBase
+
+    knowledgebase = KnowledgeBase(backend=backend, app_name=app_name, index=index)
+
+    if _path.is_file():
+        knowledgebase.add_from_files(files=[path])
+    elif _path.is_dir():
+        knowledgebase.add_from_directory(directory=path)
+    else:
+        raise RuntimeError(
+            "Unsupported knowledgebase file type, only support a single file and a directory."
+        )
+
+
+@click.group()
+def kb():
+    """VeADK Knowledgebase management"""
+    pass
+
+
+kb.add_command(add)

{veadk_python-0.2.9 → veadk_python-0.2.10}/veadk/cli/cli_web.py

@@ -154,6 +154,7 @@ def web(host: str) -> None:
         eval_set_results_manager: Any,
         agents_dir: str,
         extra_plugins: Optional[list[str]] = None,
+        **kwargs: Any,
     ):
         self.agent_loader = agent_loader
         self.artifact_service = artifact_service
@@ -166,6 +167,9 @@ def web(host: str) -> None:
         self.runner_dict = {}
         self.extra_plugins = extra_plugins or []
 
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
         # parse VeADK memories
         short_term_memory, long_term_memory = _get_memory(module_path=agents_dir)
         self.session_service = short_term_memory.session_service

veadk_python-0.2.10/veadk/integrations/ve_viking_db_memory/ve_viking_db_memory.py

@@ -0,0 +1,293 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 json
+import threading
+
+from volcengine.ApiInfo import ApiInfo
+from volcengine.auth.SignerV4 import SignerV4
+from volcengine.base.Service import Service
+from volcengine.Credentials import Credentials
+from volcengine.ServiceInfo import ServiceInfo
+
+
+class VikingDBMemoryException(Exception):
+    def __init__(self, code, request_id, message=None):
+        self.code = code
+        self.request_id = request_id
+        self.message = "{}, code:{}，request_id:{}".format(
+            message, self.code, self.request_id
+        )
+
+    def __str__(self):
+        return self.message
+
+
+class VikingDBMemoryClient(Service):
+    _instance_lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(VikingDBMemoryClient, "_instance"):
+            with VikingDBMemoryClient._instance_lock:
+                if not hasattr(VikingDBMemoryClient, "_instance"):
+                    VikingDBMemoryClient._instance = object.__new__(cls)
+        return VikingDBMemoryClient._instance
+
+    def __init__(
+        self,
+        host="api-knowledgebase.mlp.cn-beijing.volces.com",
+        region="cn-beijing",
+        ak="",
+        sk="",
+        sts_token="",
+        scheme="http",
+        connection_timeout=30,
+        socket_timeout=30,
+    ):
+        self.service_info = VikingDBMemoryClient.get_service_info(
+            host, region, scheme, connection_timeout, socket_timeout
+        )
+        self.api_info = VikingDBMemoryClient.get_api_info()
+        super(VikingDBMemoryClient, self).__init__(self.service_info, self.api_info)
+        if ak:
+            self.set_ak(ak)
+        if sk:
+            self.set_sk(sk)
+        if sts_token:
+            self.set_session_token(session_token=sts_token)
+        try:
+            self.get_body("Ping", {}, json.dumps({}))
+        except Exception as e:
+            raise VikingDBMemoryException(
+                1000028, "missed", "host or region is incorrect: {}".format(str(e))
+            ) from None
+
+    def setHeader(self, header):
+        api_info = VikingDBMemoryClient.get_api_info()
+        for key in api_info:
+            for item in header:
+                api_info[key].header[item] = header[item]
+        self.api_info = api_info
+
+    @staticmethod
+    def get_service_info(host, region, scheme, connection_timeout, socket_timeout):
+        service_info = ServiceInfo(
+            host,
+            {"Host": host},
+            Credentials("", "", "air", region),
+            connection_timeout,
+            socket_timeout,
+            scheme=scheme,
+        )
+        return service_info
+
+    @staticmethod
+    def get_api_info():
+        api_info = {
+            "CreateCollection": ApiInfo(
+                "POST",
+                "/api/memory/collection/create",
+                {},
+                {},
+                {"Accept": "application/json", "Content-Type": "application/json"},
+            ),
+            "GetCollection": ApiInfo(
+                "POST",
+                "/api/memory/collection/info",
+                {},
+                {},
+                {"Accept": "application/json", "Content-Type": "application/json"},
+            ),
+            "DropCollection": ApiInfo(
+                "POST",
+                "/api/memory/collection/delete",
+                {},
+                {},
+                {"Accept": "application/json", "Content-Type": "application/json"},
+            ),
+            "UpdateCollection": ApiInfo(
+                "POST",
+                "/api/memory/collection/update",
+                {},
+                {},
+                {"Accept": "application/json", "Content-Type": "application/json"},
+            ),
+            "SearchMemory": ApiInfo(
+                "POST",
+                "/api/memory/search",
+                {},
+                {},
+                {"Accept": "application/json", "Content-Type": "application/json"},
+            ),
+            "AddMessages": ApiInfo(
+                "POST",
+                "/api/memory/messages/add",
+                {},
+                {},
+                {"Accept": "application/json", "Content-Type": "application/json"},
+            ),
+            "Ping": ApiInfo(
+                "GET",
+                "/api/memory/ping",
+                {},
+                {},
+                {"Accept": "application/json", "Content-Type": "application/json"},
+            ),
+        }
+        return api_info
+
+    def get_body(self, api, params, body):
+        if api not in self.api_info:
+            raise Exception("no such api")
+        api_info = self.api_info[api]
+        r = self.prepare_request(api_info, params)
+        r.headers["Content-Type"] = "application/json"
+        r.headers["Traffic-Source"] = "SDK"
+        r.body = body
+
+        SignerV4.sign(r, self.service_info.credentials)
+
+        url = r.build()
+        resp = self.session.get(
+            url,
+            headers=r.headers,
+            data=r.body,
+            timeout=(
+                self.service_info.connection_timeout,
+                self.service_info.socket_timeout,
+            ),
+        )
+        if resp.status_code == 200:
+            return json.dumps(resp.json())
+        else:
+            raise Exception(resp.text.encode("utf-8"))
+
+    def get_body_exception(self, api, params, body):
+        try:
+            res = self.get_body(api, params, body)
+        except Exception as e:
+            try:
+                res_json = json.loads(e.args[0].decode("utf-8"))
+            except Exception as e:
+                raise VikingDBMemoryException(
+                    1000028, "missed", "json load res error, res:{}".format(str(e))
+                ) from None
+            code = res_json.get("code", 1000028)
+            request_id = res_json.get("request_id", 1000028)
+            message = res_json.get("message", None)
+
+            raise VikingDBMemoryException(code, request_id, message)
+
+        if res == "":
+            raise VikingDBMemoryException(
+                1000028,
+                "missed",
+                "empty response due to unknown error, please contact customer service",
+            ) from None
+        return res
+
+    def get_exception(self, api, params):
+        try:
+            res = self.get(api, params)
+        except Exception as e:
+            try:
+                res_json = json.loads(e.args[0].decode("utf-8"))
+            except Exception as e:
+                raise VikingDBMemoryException(
+                    1000028, "missed", "json load res error, res:{}".format(str(e))
+                ) from None
+            code = res_json.get("code", 1000028)
+            request_id = res_json.get("request_id", 1000028)
+            message = res_json.get("message", None)
+            raise VikingDBMemoryException(code, request_id, message)
+        if res == "":
+            raise VikingDBMemoryException(
+                1000028,
+                "missed",
+                "empty response due to unknown error, please contact customer service",
+            ) from None
+        return res
+
+    def create_collection(
+        self,
+        collection_name,
+        description="",
+        custom_event_type_schemas=[],
+        custom_entity_type_schemas=[],
+        builtin_event_types=[],
+        builtin_entity_types=[],
+    ):
+        params = {
+            "CollectionName": collection_name,
+            "Description": description,
+            "CustomEventTypeSchemas": custom_event_type_schemas,
+            "CustomEntityTypeSchemas": custom_entity_type_schemas,
+            "BuiltinEventTypes": builtin_event_types,
+            "BuiltinEntityTypes": builtin_entity_types,
+        }
+        res = self.json("CreateCollection", {}, json.dumps(params))
+        return json.loads(res)
+
+    def get_collection(self, collection_name):
+        params = {"CollectionName": collection_name}
+        res = self.json("GetCollection", {}, json.dumps(params))
+        return json.loads(res)
+
+    def drop_collection(self, collection_name):
+        params = {"CollectionName": collection_name}
+        res = self.json("DropCollection", {}, json.dumps(params))
+        return json.loads(res)
+
+    def update_collection(
+        self,
+        collection_name,
+        custom_event_type_schemas=[],
+        custom_entity_type_schemas=[],
+        builtin_event_types=[],
+        builtin_entity_types=[],
+    ):
+        params = {
+            "CollectionName": collection_name,
+            "CustomEventTypeSchemas": custom_event_type_schemas,
+            "CustomEntityTypeSchemas": custom_entity_type_schemas,
+            "BuiltinEventTypes": builtin_event_types,
+            "BuiltinEntityTypes": builtin_entity_types,
+        }
+        res = self.json("UpdateCollection", {}, json.dumps(params))
+        return json.loads(res)
+
+    def search_memory(self, collection_name, query, filter, limit=10):
+        params = {
+            "collection_name": collection_name,
+            "limit": limit,
+            "filter": filter,
+        }
+        if query:
+            params["query"] = query
+        res = self.json("SearchMemory", {}, json.dumps(params))
+        return json.loads(res)
+
+    def add_messages(
+        self, collection_name, session_id, messages, metadata, entities=None
+    ):
+        params = {
+            "collection_name": collection_name,
+            "session_id": session_id,
+            "messages": messages,
+            "metadata": metadata,
+        }
+        if entities is not None:
+            params["entities"] = entities
+        res = self.json("AddMessages", {}, json.dumps(params))
+        return json.loads(res)

{veadk_python-0.2.9 → veadk_python-0.2.10}/veadk/memory/__init__.py

@@ -25,7 +25,7 @@ def __getattr__(name):
         from veadk.memory.short_term_memory import ShortTermMemory
 
         return ShortTermMemory
-    if name == "LongTeremMemory":
+    if name == "LongTermMemory":
         from veadk.memory.long_term_memory import LongTermMemory
 
         return LongTermMemory

{veadk_python-0.2.9 → veadk_python-0.2.10}/veadk/memory/long_term_memory.py

@@ -115,6 +115,14 @@ class LongTermMemory(BaseMemoryService, BaseModel):
                 f"Initialized long term memory backend {self.backend} with config. We will ignore `app_name` and `user_id` if provided."
             )
             self._backend = _get_backend_cls(self.backend)(**self.backend_config)
+            _index = self.backend_config.get("index", None)
+            if _index:
+                self._index = _index
+                logger.info(f"Long term memory index set to {self._index}.")
+            else:
+                logger.warning(
+                    "Cannot find index via backend_config, please set `index` parameter."
+                )
             return
 
         if self.app_name and self.user_id:
@@ -195,6 +203,23 @@ class LongTermMemory(BaseMemoryService, BaseModel):
     @override
     async def search_memory(self, *, app_name: str, user_id: str, query: str):
         # prevent model invoke `load_memory` before add session to this memory
+        if not self._backend and isinstance(self.backend, str):
+            self._index = build_long_term_memory_index(app_name, user_id)
+            self._backend = _get_backend_cls(self.backend)(
+                index=self._index, **self.backend_config if self.backend_config else {}
+            )
+            logger.info(
+                f"Initialize long term memory backend now, index is {self._index}"
+            )
+
+        if not self._index and self._index != build_long_term_memory_index(
+            app_name, user_id
+        ):
+            logger.warning(
+                f"The `app_name` or `user_id` is different from the initialized one. Initialized index: {self._index}, current built index: {build_long_term_memory_index(app_name, user_id)}. Search memory return empty list."
+            )
+            return SearchMemoryResponse(memories=[])
+
         if not self._backend:
             logger.error(
                 "Long term memory backend is not initialized, cannot search memory."

{veadk_python-0.2.9 → veadk_python-0.2.10}/veadk/memory/long_term_memory_backends/mem0_backend.py

@@ -46,12 +46,17 @@ class Mem0LTMBackend(BaseLongTermMemoryBackend):
 
         try:
             self._mem0_client = MemoryClient(
-                # base_url=self.mem0_config.base_url,        # mem0 endpoint
+                host=self.mem0_config.base_url,  # mem0 endpoint
                 api_key=self.mem0_config.api_key,  # mem0 API key
             )
+            logger.info(
+                f"Initialized Mem0 client for host: {self.mem0_config.base_url}"
+            )
             logger.info(f"Initialized Mem0 client for index: {self.index}")
         except Exception as e:
-            logger.error(f"Failed to initialize Mem0 client: {str(e)}")
+            logger.error(
+                f"Failed to initialize Mem0 client for host {self.mem0_config.base_url} : {str(e)}"
+            )
             raise
 
     def precheck_index_naming(self):
@@ -84,6 +89,7 @@ class Mem0LTMBackend(BaseLongTermMemoryBackend):
                     [{"role": "user", "content": event_string}],
                     user_id=user_id,
                     output_format="v1.1",
+                    async_mode=True,
                 )
                 logger.debug(f"Saved memory result: {result}")
 
@@ -116,7 +122,16 @@ class Mem0LTMBackend(BaseLongTermMemoryBackend):
                 query, user_id=user_id, output_format="v1.1", top_k=top_k
             )
 
+            logger.debug(f"return relevant memories: {memories}")
+
             memory_list = []
+            # 如果 memories 是列表，直接返回
+            if isinstance(memories, list):
+                for mem in memories:
+                    if "memory" in mem:
+                        memory_list.append(mem["memory"])
+                return memory_list
+
             if memories.get("results", []):
                 for mem in memories["results"]:
                     if "memory" in mem: