Build and run agents you can see, understand and trust.
Python agentchatbotlarge-language-modelsllmllm-agentmcpmulti-agentmulti-modalreact-agentrealtime-agentvoice-agentvoice-assistant
fix(agent): raise the CancelError when interruption happens during the tool execution (#888)
DavdGao34a8a300bde9
diff --git a/docs/tutorial/en/src/task_long_term_memory.py b/docs/tutorial/en/src/task_long_term_memory.pyindex d543c49b0..055403055 100644--- a/docs/tutorial/en/src/task_long_term_memory.py+++ b/docs/tutorial/en/src/task_long_term_memory.py@@ -147,180 +147,148 @@ asyncio.run(retrieve_preferences())## .. note:: We provide an example of using ReMe long-term memory in the GitHub repository under the ``examples/long_term_memory/reme`` directory.#--from agentscope.memory import ReMePersonalLongTermMemory--# Create ReMe personal long-term memory instance-reme_long_term_memory = ReMePersonalLongTermMemory(- agent_name="Friday",- user_name="user_123",- model=DashScopeChatModel(- model_name="qwen3-max",- api_key=os.environ.get("DASHSCOPE_API_KEY"),- stream=False,- ),- embedding_model=DashScopeTextEmbedding(- model_name="text-embedding-v4",- api_key=os.environ.get("DASHSCOPE_API_KEY"),- dimensions=1024,- ),-)--# %%+# .. code-block:: python+# :caption: Example of ReMe long-term memory setup+#+# from agentscope.memory import ReMePersonalLongTermMemory+#+# # Create ReMe personal long-term memory instance+# reme_long_term_memory = ReMePersonalLongTermMemory(+# agent_name="Friday",+# user_name="user_123",+# model=DashScopeChatModel(+# model_name="qwen3-max",+# api_key=os.environ.get("DASHSCOPE_API_KEY"),+# stream=False,+# ),+# embedding_model=DashScopeTextEmbedding(+# model_name="text-embedding-v4",+# api_key=os.environ.get("DASHSCOPE_API_KEY"),+# dimensions=1024,+# ),+# )+#+## The ``ReMePersonalLongTermMemory`` class provides four main methods for long-term memory operations.# They include ``record_to_memory`` and ``retrieve_from_memory`` for tool calls,# as well as ``record`` and ``retrieve`` for direct calls.## As an example, we use ``record_to_memory`` to record user preferences.#---async def test_record_to_memory():- """Test record_to_memory tool function interface"""- async with reme_long_term_memory:- result = await reme_long_term_memory.record_to_memory(- thinking="The user is sharing their travel preferences and habits",- content=[- "I prefer to stay in homestays when traveling to Hangzhou",- "I like to visit the West Lake in the morning",- "I enjoy drinking Longjing tea",- ],- )- # Extract result text- result_text = " ".join(- block.get("text", "")- for block in result.content- if block.get("type") == "text"- )- print(f"Recording result: {result_text}")---# %%-# output+# .. code-block:: python+# :caption: Example of recording to ReMe long-term memory+#+# async def test_record_to_memory():+# """Test record_to_memory tool function interface"""+# async with reme_long_term_memory:+# result = await reme_long_term_memory.record_to_memory(+# thinking="The user is sharing their travel preferences and habits",+# content=[+# "I prefer to stay in homestays when traveling to Hangzhou",+# "I like to visit the West Lake in the morning",+# "I enjoy drinking Longjing tea",+# ],+# )+# # Extract result text+# result_text = " ".join(+# block.get("text", "")+# for block in result.content+# if block.get("type") == "text"+# )+# print(f"Recording result: {result_text}")#-# .. code-block:: console#-# Recording result: Successfully recorded 3 memory/memories to personal memory.#---# %%# Then we use ``retrieve_from_memory`` to retrieve related memories.#---async def test_retrieve_from_memory():- """Test retrieve_from_memory tool function interface"""- async with reme_long_term_memory:- # First record some content- await reme_long_term_memory.record_to_memory(- thinking="User is sharing travel preferences",- content=[- "I prefer to stay in homestays when traveling to Hangzhou",- ],- )-- # Then retrieve- result = await reme_long_term_memory.retrieve_from_memory(- keywords=["Hangzhou travel", "tea preference"],- )- retrieved_text = " ".join(- block.get("text", "")- for block in result.content- if block.get("type") == "text"- )- print(f"Retrieved memories: {retrieved_text}")---# %%-# output-#-# .. code-block:: console+# .. code-block:: python+# :caption: Example of retrieving from ReMe long-term memory+#+# async def test_retrieve_from_memory():+# """Test retrieve_from_memory tool function interface"""+# async with reme_long_term_memory:+# # First record some content+# await reme_long_term_memory.record_to_memory(+# thinking="User is sharing travel preferences",+# content=[+# "I prefer to stay in homestays when traveling to Hangzhou",+# ],+# )+#+# # Then retrieve+# result = await reme_long_term_memory.retrieve_from_memory(+# keywords=["Hangzhou travel", "tea preference"],+# )+# retrieved_text = " ".join(+# block.get("text", "")+# for block in result.content+# if block.get("type") == "text"+# )+# print(f"Retrieved memories: {retrieved_text}")#-# Retrieved memories: Keyword 'Hangzhou travel':-# user prefers to stay in homestays when traveling to Hangzhou#-# Keyword 'tea preference':-# user prefers to stay in homestays when traveling to Hangzhou-#--# %%# Besides the tool function interface, we can also use the ``record`` method to directly record message conversations.---async def test_record_direct():- """Test record direct recording method"""- async with reme_long_term_memory:- await reme_long_term_memory.record(- msgs=[- Msg(- role="user",- content="I work as a software engineer and prefer remote work",- name="user",- ),- Msg(- role="assistant",- content="Understood! You're a software engineer who values remote work flexibility.",- name="assistant",- ),- Msg(- role="user",- content="I usually start my day at 9 AM with a cup of coffee",- name="user",- ),- ],- )- print("Successfully recorded conversation messages")---# %%-# output#-# .. code-block:: console+# .. code-block:: python+# :caption: Example of direct recording to ReMe long-term memory+#+# async def test_record_direct():+# """Test record direct recording method"""+# async with reme_long_term_memory:+# await reme_long_term_memory.record(+# msgs=[+# Msg(+# role="user",+# content="I work as a software engineer and prefer remote work",+# name="user",+# ),+# Msg(+# role="assistant",+# content="Understood! You're a software engineer who values remote work flexibility.",+# name="assistant",+# ),+# Msg(+# role="user",+# content="I usually start my day at 9 AM with a cup of coffee",+# name="user",+# ),+# ],+# )+# print("Successfully recorded conversation messages")#-# Successfully recorded conversation messages#--# %%# Similarly, we use the ``retrieve`` method to retrieve related memories.#---async def test_retrieve_direct():- """Test retrieve direct retrieval method"""- async with reme_long_term_memory:- # First record some content- await reme_long_term_memory.record(- msgs=[- Msg(- role="user",- content="I work as a software engineer and prefer remote work",- name="user",- ),- ],- )-- # Then retrieve- memories = await reme_long_term_memory.retrieve(- msg=Msg(- role="user",- content="What do you know about my work preferences?",- name="user",- ),- )- print(- f"Retrieved memories: {memories if memories else 'No memories found'}",- )---# %%-# output+# .. code-block:: python+# :caption: Example of direct retrieval from ReMe long-term memory+#+# async def test_retrieve_direct():+# """Test retrieve direct retrieval method"""+# async with reme_long_term_memory:+# # First record some content+# await reme_long_term_memory.record(+# msgs=[+# Msg(+# role="user",+# content="I work as a software engineer and prefer remote work",+# name="user",+# ),+# ],+# )+#+# # Then retrieve+# memories = await reme_long_term_memory.retrieve(+# msg=Msg(+# role="user",+# content="What do you know about my work preferences?",+# name="user",+# ),+# )+# print(+# f"Retrieved memories: {memories if memories else 'No memories found'}",+# )#-# .. code-block:: console#-# Retrieved memories: user works as a software engineer and prefers remote work--# %%# Integration with ReAct Agent# ----------------------------------------# In AgentScope, the ``ReActAgent`` class receives a ``long_term_memory``@@ -333,137 +301,97 @@ async def test_retrieve_direct():# .. note:: To achieve the best results, the ``"agent_control"`` mode may require# additional instructions in the system prompt.#---# Create ReAct agent with long-term memory (agent_control mode)-async def test_react_agent_with_reme():- """Test ReActAgent integration with ReMe personal memory"""- async with reme_long_term_memory:- agent_with_reme = ReActAgent(- name="Friday",- sys_prompt=(- "You are a helpful assistant named Friday with long-term memory capabilities. "- "\n\n## Memory Management Guidelines:\n"- "1. **Recording Memories**: When users share personal information, preferences, "- "habits, or facts about themselves, ALWAYS record them using `record_to_memory` "- "for future reference.\n"- "\n2. **Retrieving Memories**: BEFORE answering questions about the user's preferences, "- "past information, or personal details, you MUST FIRST call `retrieve_from_memory` "- "to check if you have any relevant stored information. Do NOT rely solely on the "- "current conversation context.\n"- "\n3. **When to Retrieve**: Call `retrieve_from_memory` when:\n"- " - User asks questions like 'what do I like?', 'what are my preferences?', "- "'what do you know about me?'\n"- " - User asks about their past behaviors, habits, or preferences\n"- " - User refers to information they mentioned before\n"- " - You need context about the user to provide personalized responses\n"- "\nAlways check your memory first before claiming you don't know something about the user."- ),- model=DashScopeChatModel(- model_name="qwen3-max",- api_key=os.environ.get("DASHSCOPE_API_KEY"),- stream=False,- ),- formatter=DashScopeChatFormatter(),- toolkit=Toolkit(),- memory=InMemoryMemory(),- long_term_memory=reme_long_term_memory,- long_term_memory_mode="agent_control", # Use agent_control mode- )-- # User shares preferences- msg = Msg(- role="user",- content="When I travel to Hangzhou, I prefer to stay in a homestay",- name="user",- )- response = await agent_with_reme(msg)- print(f"Agent response: {response.get_text_content()}")-- # Clear short-term memory to test long-term memory- await agent_with_reme.memory.clear()-- # Query preferences- msg2 = Msg(- role="user",- content="what preference do I have?",- name="user",- )- response2 = await agent_with_reme(msg2)- print(f"Agent response: {response2.get_text_content()}")---# %%-# output-#-# .. code-block:: console+# .. code-block:: python+# :caption: Example of ReAct agent with ReMe long-term memory+#+# # Create ReAct agent with long-term memory (agent_control mode)+# async def test_react_agent_with_reme():+# """Test ReActAgent integration with ReMe personal memory"""+# async with reme_long_term_memory:+# agent_with_reme = ReActAgent(+# name="Friday",+# sys_prompt=(+# "You are a helpful assistant named Friday with long-term memory capabilities. "+# "\n\n## Memory Management Guidelines:\n"+# "1. **Recording Memories**: When users share personal information, preferences, "+# "habits, or facts about themselves, ALWAYS record them using `record_to_memory` "+# "for future reference.\n"+# "\n2. **Retrieving Memories**: BEFORE answering questions about the user's preferences, "+# "past information, or personal details, you MUST FIRST call `retrieve_from_memory` "+# "to check if you have any relevant stored information. Do NOT rely solely on the "+# "current conversation context.\n"+# "\n3. **When to Retrieve**: Call `retrieve_from_memory` when:\n"+# " - User asks questions like 'what do I like?', 'what are my preferences?', "+# "'what do you know about me?'\n"+# " - User asks about their past behaviors, habits, or preferences\n"+# " - User refers to information they mentioned before\n"+# " - You need context about the user to provide personalized responses\n"+# "\nAlways check your memory first before claiming you don't know something about the user."+# ),+# model=DashScopeChatModel(+# model_name="qwen3-max",+# api_key=os.environ.get("DASHSCOPE_API_KEY"),+# stream=False,+# ),+# formatter=DashScopeChatFormatter(),+# toolkit=Toolkit(),+# memory=InMemoryMemory(),+# long_term_memory=reme_long_term_memory,+# long_term_memory_mode="agent_control", # Use agent_control mode+# )+#+# # User shares preferences+# msg = Msg(+# role="user",+# content="When I travel to Hangzhou, I prefer to stay in a homestay",+# name="user",+# )+# response = await agent_with_reme(msg)+# print(f"Agent response: {response.get_text_content()}")+#+# # Clear short-term memory to test long-term memory+# await agent_with_reme.memory.clear()+#+# # Query preferences+# msg2 = Msg(+# role="user",+# content="what preference do I have?",+# name="user",+# )+# response2 = await agent_with_reme(msg2)+# print(f"Agent response: {response2.get_text_content()}")#-# system: {-# "type": "tool_result",-# "id": "call_7de95a3382e241309b16cb9e",-# "name": "retrieve_from_memory",-# "output": [-# {-# "type": "text",-# "text": "Keyword 'preference':\nuser prefers to stay in a homestay when traveling to Hangzhou"-# }-# ]-# }-# Friday: Based on what I know, you prefer to stay in a homestay when traveling to Hangzhou. Let me know if there's anything else you'd like me to remember or clarify!-# Agent response: Based on what I know, you prefer to stay in a homestay when traveling to Hangzhou. Let me know if there's anything else you'd like me to remember or clarify!#--# %%# Then we clear the short-term memory and ask the agent about the user's preferences.#---async def retrieve_reme_preferences():- """Retrieve user preferences from long-term memory"""- async with reme_long_term_memory:- # Create agent (reusing for demonstration completeness)- agent_with_reme = ReActAgent(- name="Friday",- sys_prompt="You are an assistant with long-term memory capabilities.",- model=DashScopeChatModel(- api_key=os.environ.get("DASHSCOPE_API_KEY"),- model_name="qwen3-max",- stream=False,- ),- formatter=DashScopeChatFormatter(),- toolkit=Toolkit(),- memory=InMemoryMemory(),- long_term_memory=reme_long_term_memory,- long_term_memory_mode="agent_control",- )-- # Clear short-term memory- await agent_with_reme.memory.clear()- # The agent will remember previous conversations- msg2 = Msg("user", "What are my preferences? Answer briefly.", "user")- await agent_with_reme(msg2)---# %%-# output-#-# .. code-block:: console-#-# system: {-# "type": "tool_result",-# "id": "call_e7d354e450684ceca331a8d9",-# "name": "retrieve_from_memory",-# "output": [-# {-# "type": "text",-# "text": "No memories found for the given keywords."-# }-# ]-# }-# Friday: I don't have any recorded information about your preferences yet. Let me know what you like or need, and I can remember it for future reference!+# .. code-block:: python+# :caption: Example of retrieving preferences with ReAct agent and ReMe long-term memory+#+# async def retrieve_reme_preferences():+# """Retrieve user preferences from long-term memory"""+# async with reme_long_term_memory:+# # Create agent (reusing for demonstration completeness)+# agent_with_reme = ReActAgent(+# name="Friday",+# sys_prompt="You are an assistant with long-term memory capabilities.",+# model=DashScopeChatModel(+# api_key=os.environ.get("DASHSCOPE_API_KEY"),+# model_name="qwen3-max",+# stream=False,+# ),+# formatter=DashScopeChatFormatter(),+# toolkit=Toolkit(),+# memory=InMemoryMemory(),+# long_term_memory=reme_long_term_memory,+# long_term_memory_mode="agent_control",+# )+#+# # Clear short-term memory+# await agent_with_reme.memory.clear()+# # The agent will remember previous conversations+# msg2 = Msg("user", "What are my preferences? Answer briefly.", "user")+# await agent_with_reme(msg2)#--# %%# Customizing Long-Term Memory# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~# AgentScope provides the ``LongTermMemoryBase`` base class, which defines the basicdiff --git a/docs/tutorial/zh_CN/src/task_long_term_memory.py b/docs/tutorial/zh_CN/src/task_long_term_memory.pyindex e6040de37..dedf7beca 100644--- a/docs/tutorial/zh_CN/src/task_long_term_memory.py+++ b/docs/tutorial/zh_CN/src/task_long_term_memory.py@@ -135,177 +135,143 @@ asyncio.run(retrieve_preferences())## .. note:: 在 GitHub 仓库的 ``examples/long_term_memory/reme`` 目录下我们提供了 ReMe 长期记忆的使用示例。#--from agentscope.memory import ReMePersonalLongTermMemory--# 创建 ReMe 个人长期记忆实例-reme_long_term_memory = ReMePersonalLongTermMemory(- agent_name="Friday",- user_name="user_123",- model=DashScopeChatModel(- model_name="qwen3-max",- api_key=os.environ.get("DASHSCOPE_API_KEY"),- stream=False,- ),- embedding_model=DashScopeTextEmbedding(- model_name="text-embedding-v4",- api_key=os.environ.get("DASHSCOPE_API_KEY"),- dimensions=1024,- ),-)--# %%+# .. code-block:: python+# :caption: 安装 ReMe 依赖+#+# from agentscope.memory import ReMePersonalLongTermMemory+#+# # 创建 ReMe 个人长期记忆实例+# reme_long_term_memory = ReMePersonalLongTermMemory(+# agent_name="Friday",+# user_name="user_123",+# model=DashScopeChatModel(+# model_name="qwen3-max",+# api_key=os.environ.get("DASHSCOPE_API_KEY"),+# stream=False,+# ),+# embedding_model=DashScopeTextEmbedding(+# model_name="text-embedding-v4",+# api_key=os.environ.get("DASHSCOPE_API_KEY"),+# dimensions=1024,+# ),+# )+#+## ``ReMePersonalLongTermMemory`` 类提供了四个操作长期记忆的方法。# 它们分别是用于工具调用的 ``record_to_memory`` 和 ``retrieve_from_memory``,# 以及用于直接调用的 ``record`` 和 ``retrieve``。## 例如下面的例子中,我们使用 ``record_to_memory`` 记录用户偏好。#---async def test_record_to_memory():- """测试 record_to_memory 工具函数接口"""- async with reme_long_term_memory:- result = await reme_long_term_memory.record_to_memory(- thinking="用户正在分享他们的旅行偏好和习惯",- content=[- "我去杭州旅行时喜欢住民宿",- "我喜欢早上去西湖游玩",- "我喜欢喝龙井茶",- ],- )- # 提取结果文本- result_text = " ".join(- block.get("text", "")- for block in result.content- if block.get("type") == "text"- )- print(f"记录结果: {result_text}")---# %%-# 输出-#-# .. code-block:: console+# .. code-block:: python+# :caption: 创建 ReMe 个人长期记忆实例+#+# async def test_record_to_memory():+# """测试 record_to_memory 工具函数接口"""+# async with reme_long_term_memory:+# result = await reme_long_term_memory.record_to_memory(+# thinking="用户正在分享他们的旅行偏好和习惯",+# content=[+# "我去杭州旅行时喜欢住民宿",+# "我喜欢早上去西湖游玩",+# "我喜欢喝龙井茶",+# ],+# )+# # 提取结果文本+# result_text = " ".join(+# block.get("text", "")+# for block in result.content+# if block.get("type") == "text"+# )+# print(f"记录结果: {result_text}")#-# 记录结果: Successfully recorded 3 memory/memories to personal memory.#---# %%# 然后我们使用 ``retrieve_from_memory`` 检索相关记忆。#---async def test_retrieve_from_memory():- """测试 retrieve_from_memory 工具函数接口"""- async with reme_long_term_memory:- # 先记录一些内容- await reme_long_term_memory.record_to_memory(- thinking="用户正在分享旅行偏好",- content=["我去杭州旅行时喜欢住民宿"],- )-- # 然后检索- result = await reme_long_term_memory.retrieve_from_memory(- keywords=["杭州旅行", "茶偏好"],- )- retrieved_text = " ".join(- block.get("text", "")- for block in result.content- if block.get("type") == "text"- )- print(f"检索到的记忆: {retrieved_text}")---# %%-# 输出-#-# .. code-block:: console+# .. code-block:: python+# :caption: 使用 retrieve_from_memory 检索记忆+#+# async def test_retrieve_from_memory():+# """测试 retrieve_from_memory 工具函数接口"""+# async with reme_long_term_memory:+# # 先记录一些内容+# await reme_long_term_memory.record_to_memory(+# thinking="用户正在分享旅行偏好",+# content=["我去杭州旅行时喜欢住民宿"],+# )+#+# # 然后检索+# result = await reme_long_term_memory.retrieve_from_memory(+# keywords=["杭州旅行", "茶偏好"],+# )+# retrieved_text = " ".join(+# block.get("text", "")+# for block in result.content+# if block.get("type") == "text"+# )+# print(f"检索到的记忆: {retrieved_text}")#-# 检索到的记忆: Keyword 'Hangzhou travel':-# user prefers to stay in homestays when traveling to Hangzhou#-# Keyword 'tea preference':-# user prefers to stay in homestays when traveling to Hangzhou-#--# %%# 除了工具函数接口,我们也可以使用 ``record`` 方法直接记录消息对话。#---async def test_record_direct():- """测试 record 直接记录方法"""- async with reme_long_term_memory:- await reme_long_term_memory.record(- msgs=[- Msg(- role="user",- content="我是一名软件工程师,喜欢远程工作",- name="user",- ),- Msg(- role="assistant",- content="明白了!您是一名重视远程工作灵活性的软件工程师。",- name="assistant",- ),- Msg(- role="user",- content="我通常早上9点开始工作,会先喝一杯咖啡",- name="user",- ),- ],- )- print("成功记录了对话消息")---# %%-# 输出-#-# .. code-block:: console+# .. code-block:: python+# :caption: 使用 record 直接记录消息+#+# async def test_record_direct():+# """测试 record 直接记录方法"""+# async with reme_long_term_memory:+# await reme_long_term_memory.record(+# msgs=[+# Msg(+# role="user",+# content="我是一名软件工程师,喜欢远程工作",+# name="user",+# ),+# Msg(+# role="assistant",+# content="明白了!您是一名重视远程工作灵活性的软件工程师。",+# name="assistant",+# ),+# Msg(+# role="user",+# content="我通常早上9点开始工作,会先喝一杯咖啡",+# name="user",+# ),+# ],+# )+# print("成功记录了对话消息")#-# 成功记录了对话消息#--# %%# 类似地,我们使用 ``retrieve`` 方法检索相关记忆。#---async def test_retrieve_direct():- """测试 retrieve 直接检索方法"""- async with reme_long_term_memory:- # 先记录一些内容- await reme_long_term_memory.record(- msgs=[- Msg(- role="user",- content="我是一名软件工程师,喜欢远程工作",- name="user",- ),- ],- )-- # 然后检索- memories = await reme_long_term_memory.retrieve(- msg=Msg(- role="user",- content="你知道我的工作偏好吗?",- name="user",- ),- )- print(f"检索到的记忆: {memories if memories else '未找到相关记忆'}")---# %%-# 输出+# .. code-block:: python+# :caption: 使用 retrieve 直接检索消息+#+# async def test_retrieve_direct():+# """测试 retrieve 直接检索方法"""+# async with reme_long_term_memory:+# # 先记录一些内容+# await reme_long_term_memory.record(+# msgs=[+# Msg(+# role="user",+# content="我是一名软件工程师,喜欢远程工作",+# name="user",+# ),+# ],+# )+#+# # 然后检索+# memories = await reme_long_term_memory.retrieve(+# msg=Msg(+# role="user",+# content="你知道我的工作偏好吗?",+# name="user",+# ),+# )+# print(f"检索到的记忆: {memories if memories else '未找到相关记忆'}")#-# .. code-block:: console#-# 检索到的记忆: user works as a software engineer and prefers remote work--# %%# 与 ReAct 智能体集成# ----------------------------------------# AgentScope 中的 ``ReActAgent`` 在构造函数中包含 ``long_term_memory`` 和 ``long_term_memory_mode`` 两个参数。@@ -315,132 +281,93 @@ async def test_retrieve_direct():## .. note:: 为了达到最好的效果,``"agent_control"`` 模式可能还需要在系统提示(system prompt)中添加相应的说明。#---# 创建带有长期记忆的 ReAct 智能体(agent_control 模式)-async def test_react_agent_with_reme():- """测试 ReActAgent 与 ReMe 个人记忆的集成"""- async with reme_long_term_memory:- agent_with_reme = ReActAgent(- name="Friday",- sys_prompt=(- "你是一个名为 Friday 的助手,具有长期记忆能力。"- "\n\n## 记忆管理指南:\n"- "1. **记录记忆**:当用户分享个人信息、偏好、习惯或关于自己的事实时,"- "始终使用 `record_to_memory` 记录这些信息以供将来参考。\n"- "\n2. **检索记忆**:在回答关于用户偏好、过去信息或个人详细信息的问题之前,"- "你必须首先调用 `retrieve_from_memory` 来检查是否有任何相关的存储信息。"- "不要仅依赖当前对话上下文。\n"- "\n3. **何时检索**:在以下情况下调用 `retrieve_from_memory`:\n"- " - 用户问类似'我喜欢什么?'、'我的偏好是什么?'、"- "'你对我了解多少?'的问题\n"- " - 用户询问他们过去的行为、习惯或偏好\n"- " - 用户提到他们之前提到的信息\n"- " - 你需要关于用户的上下文来提供个性化的响应\n"- "\n在声称不了解用户的某些信息之前,始终先检查你的记忆。"- ),- model=DashScopeChatModel(- model_name="qwen3-max",- api_key=os.environ.get("DASHSCOPE_API_KEY"),- stream=False,- ),- formatter=DashScopeChatFormatter(),- toolkit=Toolkit(),- memory=InMemoryMemory(),- long_term_memory=reme_long_term_memory,- long_term_memory_mode="agent_control", # 使用 agent_control 模式- )-- # 用户分享偏好- msg = Msg(- role="user",- content="我去杭州旅行时,喜欢住民宿",- name="user",- )- response = await agent_with_reme(msg)- print(f"智能体响应: {response.get_text_content()}")-- # 清空短期记忆以测试长期记忆- await agent_with_reme.memory.clear()-- # 查询偏好- msg2 = Msg(role="user", content="我有什么偏好?", name="user")- response2 = await agent_with_reme(msg2)- print(f"智能体响应: {response2.get_text_content()}")---# %%-# 输出-#-# .. code-block:: console+# .. code-block:: python+# :caption: 创建带有长期记忆的 ReAct 智能体+#+# # 创建带有长期记忆的 ReAct 智能体(agent_control 模式)+# async def test_react_agent_with_reme():+# """测试 ReActAgent 与 ReMe 个人记忆的集成"""+# async with reme_long_term_memory:+# agent_with_reme = ReActAgent(+# name="Friday",+# sys_prompt=(+# "你是一个名为 Friday 的助手,具有长期记忆能力。"+# "\n\n## 记忆管理指南:\n"+# "1. **记录记忆**:当用户分享个人信息、偏好、习惯或关于自己的事实时,"+# "始终使用 `record_to_memory` 记录这些信息以供将来参考。\n"+# "\n2. **检索记忆**:在回答关于用户偏好、过去信息或个人详细信息的问题之前,"+# "你必须首先调用 `retrieve_from_memory` 来检查是否有任何相关的存储信息。"+# "不要仅依赖当前对话上下文。\n"+# "\n3. **何时检索**:在以下情况下调用 `retrieve_from_memory`:\n"+# " - 用户问类似'我喜欢什么?'、'我的偏好是什么?'、"+# "'你对我了解多少?'的问题\n"+# " - 用户询问他们过去的行为、习惯或偏好\n"+# " - 用户提到他们之前提到的信息\n"+# " - 你需要关于用户的上下文来提供个性化的响应\n"+# "\n在声称不了解用户的某些信息之前,始终先检查你的记忆。"+# ),+# model=DashScopeChatModel(+# model_name="qwen3-max",+# api_key=os.environ.get("DASHSCOPE_API_KEY"),+# stream=False,+# ),+# formatter=DashScopeChatFormatter(),+# toolkit=Toolkit(),+# memory=InMemoryMemory(),+# long_term_memory=reme_long_term_memory,+# long_term_memory_mode="agent_control", # 使用 agent_control 模式+# )+#+# # 用户分享偏好+# msg = Msg(+# role="user",+# content="我去杭州旅行时,喜欢住民宿",+# name="user",+# )+# response = await agent_with_reme(msg)+# print(f"智能体响应: {response.get_text_content()}")+#+# # 清空短期记忆以测试长期记忆+# await agent_with_reme.memory.clear()+#+# # 查询偏好+# msg2 = Msg(role="user", content="我有什么偏好?", name="user")+# response2 = await agent_with_reme(msg2)+# print(f"智能体响应: {response2.get_text_content()}")#-# system: {-# "type": "tool_result",-# "id": "call_7de95a3382e241309b16cb9e",-# "name": "retrieve_from_memory",-# "output": [-# {-# "type": "text",-# "text": "Keyword 'preference':\nuser prefers to stay in a homestay when traveling to Hangzhou"-# }-# ]-# }-# Friday: Based on what I know, you prefer to stay in a homestay when traveling to Hangzhou. Let me know if there's anything else you'd like me to remember or clarify!-# Agent response: Based on what I know, you prefer to stay in a homestay when traveling to Hangzhou. Let me know if there's anything else you'd like me to remember or clarify!#--# %%# 然后我们清空智能体的短期记忆,以避免造成干扰,并测试智能体是否会记住之前的对话。#---async def retrieve_reme_preferences():- """从长期记忆中检索用户偏好"""- async with reme_long_term_memory:- # 创建智能体(这里可以复用之前创建的智能体,为了示例完整性重新创建)- agent_with_reme = ReActAgent(- name="Friday",- sys_prompt="你是一个具有长期记忆功能的助手。",- model=DashScopeChatModel(- api_key=os.environ.get("DASHSCOPE_API_KEY"),- model_name="qwen3-max",- stream=False,- ),- formatter=DashScopeChatFormatter(),- toolkit=Toolkit(),- memory=InMemoryMemory(),- long_term_memory=reme_long_term_memory,- long_term_memory_mode="agent_control",- )-- # 我们清空智能体的短期记忆,以避免造成干扰- await agent_with_reme.memory.clear()-- # 测试智能体是否会记住之前的对话- msg2 = Msg("user", "我有什么偏好?简要的回答我", "user")- await agent_with_reme(msg2)---# %%-# 输出-#-# .. code-block:: console+# .. code-block:: python+# :caption: 测试 ReAct 智能体是否记住偏好+#+# async def retrieve_reme_preferences():+# """从长期记忆中检索用户偏好"""+# async with reme_long_term_memory:+# # 创建智能体(这里可以复用之前创建的智能体,为了示例完整性重新创建)+# agent_with_reme = ReActAgent(+# name="Friday",+# sys_prompt="你是一个具有长期记忆功能的助手。",+# model=DashScopeChatModel(+# api_key=os.environ.get("DASHSCOPE_API_KEY"),+# model_name="qwen3-max",+# stream=False,+# ),+# formatter=DashScopeChatFormatter(),+# toolkit=Toolkit(),+# memory=InMemoryMemory(),+# long_term_memory=reme_long_term_memory,+# long_term_memory_mode="agent_control",+# )+#+# # 我们清空智能体的短期记忆,以避免造成干扰+# await agent_with_reme.memory.clear()+#+# # 测试智能体是否会记住之前的对话+# msg2 = Msg("user", "我有什么偏好?简要的回答我", "user")+# await agent_with_reme(msg2)#-# system: {-# "type": "tool_result",-# "id": "call_e7d354e450684ceca331a8d9",-# "name": "retrieve_from_memory",-# "output": [-# {-# "type": "text",-# "text": "No memories found for the given keywords."-# }-# ]-# }-# Friday: I don't have any recorded information about your preferences yet. Let me know what you like or need, and I can remember it for future reference!#--# %%# 自定义长期记忆# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~# AgentScope 提供了 ``LongTermMemoryBase`` 基类,它定义了长期记忆的基本接口。diff --git a/src/agentscope/agent/_react_agent.py b/src/agentscope/agent/_react_agent.pyindex 39d8831f7..f221b1f2a 100644--- a/src/agentscope/agent/_react_agent.py+++ b/src/agentscope/agent/_react_agent.py@@ -488,6 +488,11 @@ class ReActAgent(ReActAgentBase):):await self.print(tool_res_msg, chunk.is_last)+ # Raise the CancelledError to handle the interruption in the+ # handle_interrupt function+ if chunk.is_interrupted:+ raise asyncio.CancelledError()+# Return message if generate_response is called successfullyif (tool_call["name"] == self.finish_function_name@@ -562,7 +567,10 @@ class ReActAgent(ReActAgentBase):"I noticed that you have interrupted me. What can I ""do for you?","assistant",- metadata={},+ metadata={+ # Expose this field to indicate the interruption+ "is_interrupted": True,+ },)await self.print(response_msg, True)