记忆模块在Agent架构中，扮演着非常重要的角色。 它存储从环境中感知到的信息，并利用记录的记忆来促进未来的行动。记忆模块可以帮助智能体积累经验、自我进化，并以更加一致、合理、有效的方式完成任务。

概览

记忆操作

在DB-GPT智能体中，有三种主要的记忆操作:

  • 读记忆: 记忆读取的目的是从记忆中提取出有意义的信息，以加强智能体的行动。
  • 写记忆: 记忆写入的目的是感知环境信息存储在记忆中。在记忆中存储有价值的信息为将来检索信息丰富的记忆奠定基础，使智能体能够更高效、更合理地行动。
  • 记忆反思: 记忆反思模仿人类认知、情感和行为的过程的能力。应用于智能体时，目标是为智能体提供独立总结和推断更抽象、复杂和高级信息的能力。

记忆结构

在DB-GPT智能体中，有四种主要的记忆结构

  1. 感知记忆: 同人类感知一样，感知记忆是记录感知输入的，它会接收来自环境的观察结果，一些感知记忆会被转移到短期记忆中。
  2. 短期记忆: 短期记忆暂时缓冲最近的感知，它会接收一些感觉记忆，并且可以通过其他观察或者检索的记忆来增强它进入长期记忆。
  3. 长期记忆: 长期记忆存储着智能体的经验和知识，它可以接收来自短记忆的信息，并随着时间的推移巩固重要信息。
  4. 混合记忆: 混合记忆是感知记忆、短期记忆和长期记忆的结合。

DB-GPT中智能体记忆

概念说明

  • Memory: Memory是一个存储所有记忆的类，目前包含SensorMemory，ShortTermMemory, EnhancedShortTermMemory和HybridMemory
  • MemoryFragment： MemoryFragment 是一个存储记忆的抽象子类，AgentMemoryFragment是继承MemoryFragment的一个类，包含记忆的内容、记忆ID、记忆重要性以及最近的访问时间，等等。
  • GptsMemory: GptsMemory用于存储会话和计划信息，不是记忆结构的一部分。
  • AgentMemory: AgentMemory是一个包含Memory和GptsMemory的类。

创建Memory

正如先前的章节提到的，memory包括AgentMemory类中，下面是一些示意例

  1. from dbgpt.agent import AgentMemory, ShortTermMemory
  3. # Create an agent memory, default memory is ShortTermMemory
  4. memory = ShortTermMemory(buffer_size=5)
  5. agent_memory = AgentMemory(memory=memory)

顺便说一句，AgentMemory类，可以传递一个GptsMemory，在常规意义上，GptsMemory不包含在内存结构中， 它用于存储会话和计划信息。

示例如下: 

  1. from dbgpt.agent import AgentMemory, ShortTermMemory, GptsMemory
  3. # Create an agent memory, default memory is ShortTermMemory
  4. memory = ShortTermMemory(buffer_size=5)
  5. # Store the conversation and plan information
  6. gpts_memory = GptsMemory()
  7. agent_memory = AgentMemory(memory=memory, gpts_memory=gpts_memory)

在智能体中读写记忆

智能体将调用read_memories方法从记忆中读取记忆，调用write_memories方法写记忆到记忆存储中。

当智能体调用LLM时，记忆将会写到Prompt中，之后LLM返回响应时，智能体将查询和响应写入到记忆存储中。正如我们在Profile To Prompt中提到的，提示模版中有一个名为most_recent_memories的模版变量，它将被最近的记忆替换。

读记忆来构建Prompt

如下是一个读记忆来构建Prompt的示例

  1. import os
  2. import asyncio
  3. from dbgpt.agent import (
  4.     AgentContext,
  5.     ShortTermMemory,
  6.     AgentMemory,
  7.     ConversableAgent,
  8.     ProfileConfig,
  9.     LLMConfig,
  10.     BlankAction,
  11.     UserProxyAgent,
  12. )
  13. from dbgpt.model.proxy import OpenAILLMClient
  15. llm_client = OpenAILLMClient(
  16.     model_alias="gpt-4o",
  17.     api_base=os.getenv("OPENAI_API_BASE"),
  18.     api_key=os.getenv("OPENAI_API_KEY"),
  19. )
  21. context: AgentContext = AgentContext(
  22.     conv_id="test123",
  23.     language="en",
  24.     temperature=0.9,
  25.     max_new_tokens=2048,
  26.     verbose=True,  # Add verbose=True to print out the conversation history
  27. )
  29. # Create an agent memory, which contains a short-term memory
  30. memory = ShortTermMemory(buffer_size=2)
  31. agent_memory: AgentMemory = AgentMemory(memory=memory)
  33. # Custom user prompt template, which includes most recent memories and question
  34. user_prompt_template = """\
  35. {% if most_recent_memories %}\
  36. Most recent observations:
  37. {{ most_recent_memories }}
  38. {% endif %}\
  40. {% if question %}\
  41. Question: {{ question }}
  42. {% endif %}
  43. """
  45. # Custom write memory template, which includes question and thought
  46. write_memory_template = """\
  47. {% if question %}user: {{ question }} {% endif %}
  48. {% if thought %}assistant: {{ thought }} {% endif %}\
  49. """
  52. async def main():
  53.     # Create a profile with a custom user prompt template
  54.     joy_profile = ProfileConfig(
  55.         name="Joy",
  56.         role="Comedians",
  57.         user_prompt_template=user_prompt_template,
  58.         write_memory_template=write_memory_template,
  59.     )
  60.     joy = (
  61.         await ConversableAgent(profile=joy_profile)
  62.         .bind(context)
  63.         .bind(LLMConfig(llm_client=llm_client))
  64.         .bind(agent_memory)
  65.         .bind(BlankAction)
  66.         .build()
  67.     )
  68.     user_proxy = await UserProxyAgent().bind(agent_memory).bind(context).build()
  69.     await user_proxy.initiate_chat(
  70.         recipient=joy,
  71.         reviewer=user_proxy,
  72.         message="My name is bob, please tell me a joke",
  73.     )
  74.     await user_proxy.initiate_chat(
  75.         recipient=joy,
  76.         reviewer=user_proxy,
  77.         message="What's my name?",
  78.     )
  81. if __name__ == "__main__":
  82.     asyncio.run(main())

在上述示例中，我们在AgentContext中设置了verbose=True 来打印出对话历史。输出如下

  1. --------------------------------------------------------------------------------
  2. User (to Joy)-[]:
  4. "My name is bob, please tell me a joke"
  6. --------------------------------------------------------------------------------
  7. un_stream ai response: Sure thing, Bob! Here's one for you:
  9. Why don’t scientists trust atoms?
  11. Because they make up everything!
  13. --------------------------------------------------------------------------------
  14. String Prompt[verbose]: 
  15. system: You are a Comedians, named Joy, your goal is None.
  16. Please think step by step to achieve the goal. You can use the resources given below. 
  17. At the same time, please strictly abide by the constraints and specifications in IMPORTANT REMINDER.
  19. *** IMPORTANT REMINDER ***
  20. Please answer in English.
  25. human: 
  26. Question: My name is bob, please tell me a joke
  28. LLM Output[verbose]: 
  29. Sure thing, Bob! Here's one for you:
  31. Why don’t scientists trust atoms?
  33. Because they make up everything!
  34. --------------------------------------------------------------------------------
  37. --------------------------------------------------------------------------------
  38. Joy (to User)-[gpt-4o]:
  40. "Sure thing, Bob! Here's one for you:\n\nWhy don’t scientists trust atoms?\n\nBecause they make up everything!"
  41. >>>>>>>>Joy Review info: 
  42. Pass(None)
  43. >>>>>>>>Joy Action report: 
  44. execution succeeded,
  45. Sure thing, Bob! Here's one for you:
  47. Why don’t scientists trust atoms?
  49. Because they make up everything!
  51. --------------------------------------------------------------------------------
  53. --------------------------------------------------------------------------------
  54. User (to Joy)-[]:
  56. "What's my name?"
  58. --------------------------------------------------------------------------------
  59. un_stream ai response: Your name is Bob! 
  61. And here's another quick joke for you:
  63. Why don't skeletons fight each other?
  65. They don't have the guts!
  67. --------------------------------------------------------------------------------
  68. String Prompt[verbose]: 
  69. system: You are a Comedians, named Joy, your goal is None.
  70. Please think step by step to achieve the goal. You can use the resources given below. 
  71. At the same time, please strictly abide by the constraints and specifications in IMPORTANT REMINDER.
  73. *** IMPORTANT REMINDER ***
  74. Please answer in English.
  79. human: Most recent observations:
  80. user: My name is bob, please tell me a joke 
  81. assistant: Sure thing, Bob! Here's one for you:
  83. Why don’t scientists trust atoms?
  85. Because they make up everything! 
  87. Question: What's my name?
  89. LLM Output[verbose]: 
  90. Your name is Bob! 
  92. And here's another quick joke for you:
  94. Why don't skeletons fight each other?
  96. They don't have the guts!
  97. --------------------------------------------------------------------------------
  100. --------------------------------------------------------------------------------
  101. Joy (to User)-[gpt-4o]:
  103. "Your name is Bob! \n\nAnd here's another quick joke for you:\n\nWhy don't skeletons fight each other?\n\nThey don't have the guts!"
  104. >>>>>>>>Joy Review info: 
  105. Pass(None)
  106. >>>>>>>>Joy Action report: 
  107. execution succeeded,
  108. Your name is Bob! 
  110. And here's another quick joke for you:
  112. Why don't skeletons fight each other?
  114. They don't have the guts!
  116. --------------------------------------------------------------------------------

在第二轮对话中，你可以看到在Prompt中看到Most recent observations

  1. --------------------------------------------------------------------------------
  2. String Prompt[verbose]: 
  3. system: You are a Comedians, named Joy, your goal is None.
  4. Please think step by step to achieve the goal. You can use the resources given below. 
  5. At the same time, please strictly abide by the constraints and specifications in IMPORTANT REMINDER.
  7. *** IMPORTANT REMINDER ***
  8. Please answer in English.
  13. human: Most recent observations:
  14. user: My name is bob, please tell me a joke 
  15. assistant: Sure thing, Bob! Here's one for you:
  17. Why don’t scientists trust atoms?
  19. Because they make up everything! 
  21. Question: What's my name?
  23. LLM Output[verbose]: 
  24. Your name is Bob! 
  26. And here's another quick joke for you:
  28. Why don't skeletons fight each other?
  30. They don't have the guts!
  31. --------------------------------------------------------------------------------

写记忆

当智能体收到来自LLM的响应时，它将把存储和响应写入记忆。在记忆片段中，内容是字符串，因此你应该决定如何在内容中存储信息。 上述例子中，写记忆(write_memory_template)的模版如下:

  1. write_memory_template = """\
  2. {% if question %}user: {{ question }} {% endif %}
  3. {% if thought %}assistant: {{ thought }} {% endif %}\
  4. """

问题是用户查询，思考来自LLM的响应，在后续的章节中，我们将做出更多的介绍。

自定义读写

我们也可以通过继承ConversableAgent类并重写read_memories和write_memories方法来自定义记忆读写。

  1. from typing import Optional
  2. from dbgpt.agent import (
  3.     ConversableAgent,
  4.     AgentMemoryFragment,
  5.     ProfileConfig,
  6.     BlankAction,
  7.     ActionOutput,
  8. )
  10. write_memory_template = """\
  11. {% if question %}user: {{ question }} {% endif %}
  12. {% if thought %}assistant: {{ thought }} {% endif %}\
  13. """
  16. class JoyAgent(ConversableAgent):
  17.     profile: ProfileConfig = ProfileConfig(
  18.         name="Joy",
  19.         role="Comedians",
  20.         write_memory_template=write_memory_template,
  21.     )
  23.     def __init__(self, **kwargs):
  24.         super().__init__(**kwargs)
  25.         self._init_actions([BlankAction])
  27.     async def read_memories(
  28.         self,
  29.         question: str,
  30.     ) -> str:
  31.         """Read the memories from the memory."""
  32.         memories = await self.memory.read(observation=question)
  33.         recent_messages = [m.raw_observation for m in memories]
  34.         # Merge the recent messages.
  35.         return "".join(recent_messages)
  37.     async def write_memories(
  38.         self,
  39.         question: str,
  40.         ai_message: str,
  41.         action_output: Optional[ActionOutput] = None,
  42.         check_pass: bool = True,
  43.         check_fail_reason: Optional[str] = None,
  44.     ) -> None:
  45.         """Write the memories to the memory.
  47.         We suggest you to override this method to save the conversation to memory
  48.         according to your needs.
  50.         Args:
  51.             question(str): The question received.
  52.             ai_message(str): The AI message, LLM output.
  53.             action_output(ActionOutput): The action output.
  54.             check_pass(bool): Whether the check pass.
  55.             check_fail_reason(str): The check fail reason.
  56.         """
  57.         if not action_output:
  58.             raise ValueError("Action output is required to save to memory.")
  60.         mem_thoughts = action_output.thoughts or ai_message
  61.         memory_map = {
  62.             "question": question,
  63.             "thought": mem_thoughts,
  64.         }
  65.         # This is the template to write the memory.
  66.         # It configured in the agent's profile.
  67.         write_memory_template = self.write_memory_template
  68.         memory_content: str = self._render_template(write_memory_template, **memory_map)
  69.         fragment = AgentMemoryFragment(memory_content)
  70.         await self.memory.write(fragment)

在上述案例中，我们提供了read_memories来从记忆存储中读取记忆，在DB-GPT中，最近的记忆来自Prompt模版中的most_recent_memories，并重写write_memories将记忆写入到记忆存储中。

因此，你可以根据需要来自定义记忆读写。

小结

在本文档中，我们介绍了DB-GPT中智能体的记忆，以及如何使用记忆。在接下来的章节里面，我们将介绍如何使用DB-GPT智能体中的每个记忆体结构。