企业官网建设流程全解析

在构建一个能真正“理解”并“记住”交互历史的AI智能体时，开发者最常遇到的瓶颈是什么？是上下文窗口的限制，还是对话的连贯性难以维持？许多项目在初期能跑通流程，但随着交互轮次增加，智能体要么忘记关键信息，要么响应速度急剧下降，最终沦为一次性的问答机器。这背后的核心挑战，往往在于对智能体内存架构的理解和设计不够深入。

本文将系统性地拆解智能体内存架构的核心概念、类型划分与实现模式。我们将从人类记忆的类比出发，逐步深入到短期记忆、长期记忆等不同层次的技术实现，并结合主流框架（如LangChain）的实战代码，展示如何为你的智能体构建一个高效、可扩展的记忆系统。无论你是刚接触智能体开发的新手，还是希望优化现有智能体性能的进阶开发者，都能从本文中找到从理论到落地的完整路径。

1. 智能体为何需要记忆？从“反射”到“认知”的跨越

在人工智能领域，智能体（Agent）通常被定义为一个能够感知环境、进行决策并执行动作以实现特定目标的自治系统。一个最简单的智能体，例如一个基于规则的温度控制器（恒温器），它只需要根据当前传感器读数（环境温度）与设定值的比较，来执行“开启加热”或“关闭加热”的动作。这类简单反射智能体没有记忆，它的每一次决策都独立于过去，仅依赖于当前的感知输入。

然而，当我们需要智能体处理更复杂的任务，如多轮对话、个性化推荐、长期任务规划时，这种“健忘”的特性就成了致命短板。试想一个客服聊天机器人，如果它无法记住用户在本轮对话中刚刚提供的订单号或问题描述，每次回复都像初次见面，用户体验将极其糟糕。因此，记忆（Memory）成为了区分初级智能体与高级智能体的关键能力。

智能体的记忆，本质上是一个存储和回忆过往经验（包括感知、决策、动作及其结果）以改善未来决策和整体性能的系统。它使智能体能够：

1. 保持上下文连贯性：在对话或任务序列中，记住之前发生的事。
2. 进行个性化交互：学习并适应用户的偏好、习惯和历史行为。
3. 从经验中学习：通过记住成功或失败的历史，优化未来的行为策略。
4. 执行复杂规划：将长期目标分解为子任务，并记住各子任务的状态和结果。

值得注意的是，当前主流的大语言模型（LLM）本身是无状态的（Stateless）。它们拥有海量的参数化知识（训练数据），但在一次推理过程中，并不具备主动存储和调用本次会话中产生的临时信息的能力。LLM的“上下文窗口”更像是一个临时的、容量有限的“工作台”，而非记忆系统。因此，为基于LLM的智能体构建外部的、结构化的记忆组件，是开发现实可用智能体的必经之路。

2. 智能体记忆的类型：一个仿生学的视角

借鉴认知心理学对人类记忆的研究，智能体的记忆也可以被划分为多种类型，每种类型服务于不同的目的，并有相应的技术实现方式。普林斯顿大学团队在语言智能体认知架构（CoALA）的相关研究中，对此有清晰的阐述。

2.1 短期记忆（Short-Term Memory, STM）

短期记忆负责存储智能体在近期交互中产生的信息，其容量有限，保存时间较短。它的核心目标是维持当前任务或会话的上下文连贯性。

• 类比：类似于人类大脑中正在思考的当前问题或对话的上一句话。
• 典型应用：会话式AI（如ChatGPT）、即时任务执行。
• 技术实现：
  • 滚动缓冲区/对话历史：最简单的方式是维护一个最近N轮对话（User/Assistant消息对）的列表。当新消息到来时，将最旧的消息移除，以维持总长度不超过上下文窗口限制。
  • Token窗口管理：更精细的做法是基于Token数量进行管理，确保送入LLM的提示词总长度在模型限制内。
• 特点：实现简单，是大多数聊天应用的基础。但信息在会话结束后即丢失，无法用于跨会话的个性化。

2.2 长期记忆（Long-Term Memory, LTM）

长期记忆用于跨会话、长时间尺度地存储和检索信息。它是智能体实现个性化、积累知识的核心。

• 类比：人类的长时记忆，存储个人经历、学到的知识等。
• 典型应用：个性化助手、客户支持历史、用户偏好学习。
• 技术实现：
  • 向量数据库（Vector Database）：这是目前最主流和有效的方式。将文本信息通过嵌入模型（Embedding Model）转化为向量（高维数组），存储到向量数据库中。检索时，将查询问题也转化为向量，在数据库中查找最相似的向量（即最相关的历史信息）。这就是检索增强生成（RAG）技术的核心组成部分。
  • 传统数据库/知识图谱：对于高度结构化、关系型的数据（如用户档案、产品目录），可以使用SQL数据库或图数据库进行存储和关联查询。
• 特点：存储容量大，信息持久化。检索效率和质量是关键挑战。

2.3 情景记忆（Episodic Memory）

情景记忆是一种特殊的长期记忆，它专注于存储具体的、带有时间戳和上下文的事件或“情景”。它记录“在什么时间、什么地点、发生了什么事、结果如何”。

• 类比：回忆你上周三在咖啡馆和朋友见面的具体场景。
• 典型应用：基于案例的推理系统、自动驾驶汽车的行驶日志、游戏AI的决策复盘。
• 技术实现：通常以结构化的日志形式存储在数据库中，每条记录包含时间、主体、动作、环境状态、结果等字段。检索时，可以根据当前情景的特征（如类似的状态、相同的用户）来查找相关的历史事件。
• 特点：强调事件的序列性和具体性，有助于从过去的成功或失败中学习。

2.4 语义记忆（Semantic Memory）

语义记忆存储的是通用的、事实性的知识，这些知识独立于任何特定的个人经历。

• 类比：你知道“巴黎是法国的首都”，这个知识不依赖于你何时何地学到它。
• 典型应用：问答系统、法律/医疗诊断助手、企业知识库。
• 技术实现：
  • 知识库：结构化的三元组（实体-关系-实体）存储。
  • 向量化文档：将公司手册、产品文档等非结构化文本通过RAG方式存储和检索。
  • LLM的参数化知识：LLM本身在训练过程中吸收的海量事实性知识，可以看作是其内置的语义记忆。但外部语义记忆可以补充更新、更专有的知识。
• 特点：存储的是抽象的概念和事实，是智能体进行逻辑推理的基础。

2.5 程序记忆（Procedural Memory）

程序记忆存储的是“如何做”的技能和流程，使得智能体能够自动化地执行一系列复杂操作，而无需每次都进行显式的逐步推理。

• 类比：骑自行车、打字。一旦学会，身体就能自动执行。
• 典型应用：自动化工作流、机器人技能学习、重复性任务脚本。
• 技术实现：
  • 强化学习策略网络：通过训练，神经网络直接学习从状态到最优动作的映射。
  • 保存的工作流模板或脚本：将已验证成功的操作序列（如“数据抓取-清洗-分析-报告生成”）保存为可调用的模板或函数。
• 特点：提高了执行效率和可靠性，但通常需要大量的训练或编排才能形成。

理解这些记忆类型及其适用场景，是设计一个合理内存架构的第一步。一个成熟的智能体往往会组合使用多种记忆类型。

3. 环境准备与核心工具

在开始动手实现之前，我们需要搭建一个基础的开发环境。本文将使用Python作为主要语言，并依托LangChain这一流行的智能体开发框架进行演示。LangChain提供了丰富的内存组件抽象，非常适合用来理解内存架构。

3.1 基础环境

• 操作系统：Windows 10/11, macOS, 或 Linux (如 Ubuntu 20.04+)。
• Python版本：建议使用 Python 3.8 至 3.11。避免使用Python 3.12+，部分库可能兼容性不佳。
• 包管理工具：pip(Python自带) 或conda(Anaconda发行版)。

3.2 创建虚拟环境并安装依赖

强烈建议为项目创建独立的虚拟环境，以避免包冲突。

# 1. 创建项目目录并进入 mkdir ai-agent-memory-demo && cd ai-agent-memory-demo # 2. 创建虚拟环境 (以venv为例) python -m venv venv # 3. 激活虚拟环境 # Windows (cmd或PowerShell) venv\Scripts\activate # macOS / Linux source venv/bin/activate # 4. 安装核心依赖 pip install langchain langchain-openai langchain-community # langchain: 核心框架 # langchain-openai: OpenAI模型集成 # langchain-community: 社区贡献的第三方集成 # 5. 安装向量数据库客户端 (以Chroma为例，轻量级，易于上手) pip install chromadb # 6. 安装嵌入模型 (使用OpenAI的text-embedding-ada-002，需API Key) # 或者使用本地模型，如sentence-transformers pip install sentence-transformers

3.3 获取API密钥（如使用OpenAI）

如果你计划使用OpenAI的LLM（如gpt-3.5-turbo）和嵌入模型，需要准备一个有效的OpenAI API密钥。

1. 访问 OpenAI平台 并注册登录。
2. 在API Keys页面创建新的密钥。
3. 重要：将密钥保存在安全的地方，并切勿直接提交到代码仓库。推荐使用环境变量管理。

# 在终端中设置环境变量 (临时) # Windows (cmd) setx OPENAI_API_KEY "your-api-key-here" # Windows (PowerShell) $env:OPENAI_API_KEY="your-api-key-here" # macOS / Linux export OPENAI_API_KEY='your-api-key-here'

3.4 项目结构预览

我们的演示项目将包含以下几个核心文件：

ai-agent-memory-demo/ ├── requirements.txt # 项目依赖列表 ├── .env # 环境变量文件 (存储API KEY) ├── 01_short_term_memory.py ├── 02_long_term_memory_rag.py ├── 03_conversation_buffer_memory.py └── utils/ └── config.py # 配置加载工具

接下来，我们将从最简单的短期记忆开始，逐步构建更复杂的内存系统。

4. 实战：实现短期记忆（对话缓冲区）

短期记忆最直观的体现就是对话历史。我们首先实现一个能记住最近几轮对话的简单聊天智能体。

4.1 使用ConversationBufferMemory

LangChain提供了ConversationBufferMemory组件，它就像一个简单的列表，保存所有的对话历史。

# 文件：01_short_term_memory.py import os from langchain_openai import ChatOpenAI from langchain.memory import ConversationBufferMemory from langchain.chains import ConversationChain # 1. 设置OpenAI API Key (确保已设置环境变量 OPENAI_API_KEY) # 或者直接从.env文件加载 from dotenv import load_dotenv load_dotenv() # 2. 初始化大语言模型 llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7) # 3. 创建对话缓冲区内存 # 这个内存对象会保存所有的对话历史 memory = ConversationBufferMemory() # 4. 创建对话链，将LLM和Memory组合起来 conversation = ConversationChain( llm=llm, memory=memory, verbose=True # 设置为True可以看到链的思考过程 ) print("=== 简单对话缓冲区演示 ===") print("智能体: 你好！我是一个有短期记忆的助手。我们可以开始聊天了。") while True: user_input = input("\n你: ") if user_input.lower() in ['退出', 'exit', 'quit']: print("对话结束。") break # 调用对话链，它会自动从memory中读取历史，并更新memory response = conversation.predict(input=user_input) print(f"智能体: {response}") # 可选：打印当前内存中的内容 # print("\n[当前记忆内容]:") # print(memory.buffer)

运行与观察：

1. 运行python 01_short_term_memory.py。
2. 进行多轮对话，例如：
   • 你：我叫小明。
   • 智能体：你好，小明！很高兴认识你。
   • 你：我的爱好是编程。
   • 智能体：编程是个很棒的爱好，小明！它能创造很多东西。
   • 你：我刚才说我叫什么？
   • 智能体：你刚才说你叫小明。
3. 你会发现，智能体能够正确回答关于之前对话内容的问题，因为它将整个对话历史都作为上下文送给了LLM。

关键点解释：

• ConversationBufferMemory()创建了一个内存对象，其buffer属性存储了完整的对话字符串。
• ConversationChain是一个简单的链，它自动处理了格式：将memory.buffer和当前用户输入拼接成完整的提示词，发送给LLM，然后将新的输入和输出追加到memory.buffer中。
• verbose=True会在控制台打印出链的详细执行步骤，有助于调试和理解内部流程。

局限性：ConversationBufferMemory会无限制地保存所有历史，最终会导致提示词过长，超出LLM的上下文窗口限制，从而引发错误或丢失早期信息。

4.2 使用ConversationBufferWindowMemory

为了解决上述问题，我们可以使用ConversationBufferWindowMemory，它只保留最近k轮对话。

# 文件：02_conversation_buffer_window_memory.py from langchain.memory import ConversationBufferWindowMemory from langchain.chains import ConversationChain from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-3.5-turbo") # 只保留最近2轮对话 (k=2) memory = ConversationBufferWindowMemory(k=2) conversation = ConversationChain(llm=llm, memory=memory, verbose=False) print("=== 带窗口的短期记忆演示 (k=2) ===") history = [] history.append("你: 我叫小明。") response = conversation.predict(input="我叫小明。") history.append(f"智能体: {response}") print(f"智能体: {response}") history.append("你: 我的爱好是编程。") response = conversation.predict(input="我的爱好是编程。") history.append(f"智能体: {response}") print(f"智能体: {response}") history.append("你: 我还喜欢打篮球。") response = conversation.predict(input="我还喜欢打篮球。") history.append(f"智能体: {response}") print(f"智能体: {response}") # 此时，记忆窗口里只有最后两轮： # Human: 我的爱好是编程。 # AI: ... (回应) # Human: 我还喜欢打篮球。 # AI: ... (回应) # 第一轮“我叫小明”已经被移出窗口。 print("\n--- 测试记忆 ---") test_response = conversation.predict(input="我刚才说我叫什么名字？") print(f"智能体: {test_response}") print(f"(预期：由于窗口限制，它可能不记得‘小明’了)") print("\n--- 完整的对话历史 (程序记录) ---") for line in history: print(line) print("\n--- 智能体当前的内存缓冲区 ---") print(memory.buffer)

运行结果分析： 当你询问“我刚才说我叫什么名字？”时，由于窗口k=2只保留了最后两轮关于“编程”和“篮球”的对话，第一轮的“我叫小明”已被遗忘，因此智能体很可能无法正确回答。这演示了短期记忆的“有限容量”特性。

5. 实战：构建长期记忆系统（RAG + 向量数据库）

短期记忆解决了单次会话的连贯性问题，但要让智能体“认识”你，记住你的偏好，就需要长期记忆。我们将实现一个基于RAG和向量数据库Chroma的长期记忆系统。

5.1 场景设定：个性化读书助手

假设我们想要一个读书助手智能体。它能记住你读过的书、你的评价，并在后续对话中根据这些记忆提供个性化推荐或回答相关问题。

5.2 代码实现

# 文件：03_long_term_memory_rag.py import os from langchain_openai import ChatOpenAI, OpenAIEmbeddings from langchain_community.vectorstores import Chroma from langchain.memory import VectorStoreRetrieverMemory from langchain.chains import ConversationChain from langchain.prompts import PromptTemplate from dotenv import load_dotenv load_dotenv() # 1. 初始化嵌入模型和向量数据库 # 使用OpenAI的嵌入模型，也可以替换为本地模型如 `HuggingFaceEmbeddings` embeddings = OpenAIEmbeddings(model="text-embedding-ada-002") # 指定一个持久化目录 persist_directory = "./chroma_library_db" # 创建或加载向量数据库 # 首次运行，vectorstore 是空的 vectorstore = Chroma( embedding_function=embeddings, persist_directory=persist_directory ) # 2. 创建检索器，用于从向量库中查找相关记忆 # 这里设置检索最相关的3条记忆 retriever = vectorstore.as_retriever(search_kwargs=dict(k=3)) # 3. 创建基于向量检索的内存 # 这个内存会将对话中的“事实”存储到向量库，并在需要时检索回来 memory = VectorStoreRetrieverMemory(retriever=retriever) # 4. 初始化LLM llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7) # 5. 设计一个更强大的提示模板，引导智能体利用记忆 _DEFAULT_TEMPLATE = """你是一个个性化的读书助手，你拥有一个关于用户阅读历史的长期记忆库。 以下是之前对话中提及的相关信息： {history} （如果不相关，则上述内容为空） 当前对话： Human: {input} AI:""" PROMPT = PromptTemplate( input_variables=["history", "input"], template=_DEFAULT_TEMPLATE ) # 6. 创建对话链 conversation_with_memory = ConversationChain( llm=llm, prompt=PROMPT, memory=memory, verbose=True ) def save_fact_to_memory(fact: str): """将一个事实性陈述保存到长期记忆中。""" # VectorStoreRetrieverMemory 通过 `save_context` 方法存储记忆 # 它需要输入和输出。对于单纯的事实存储，我们可以将事实同时作为输入和输出。 memory.save_context({"input": fact}, {"output": f"已记录: {fact}"}) print(f"[记忆已保存] {fact}") def chat_loop(): print("=== 个性化读书助手 (长期记忆演示) ===") print("提示：你可以告诉我你读过的书和评价，我会记住。") print(" 输入 '保存: [内容]' 来主动添加一条记忆。") print(" 输入 '退出' 结束对话。\n") # 预先存入一些示例记忆 (模拟历史数据) sample_facts = [ "用户小明喜欢科幻小说。", "用户小明读完了《三体》，并给出了5星评价。", "用户小明认为《百年孤独》的叙事手法非常独特。", "用户小明最近对历史传记类书籍感兴趣。" ] for fact in sample_facts: save_fact_to_memory(fact) while True: user_input = input("\n你: ").strip() if user_input.lower() in ['退出', 'exit', 'quit']: # 持久化向量数据库到磁盘 vectorstore.persist() print("对话结束，记忆已保存。") break if user_input.startswith('保存:'): fact = user_input[3:].strip() if fact: save_fact_to_memory(fact) continue # 进行对话 response = conversation_with_memory.predict(input=user_input) print(f"助手: {response}") if __name__ == "__main__": chat_loop()

5.3 运行演示与解释

1. 首次运行：脚本会初始化一个空的Chroma向量数据库，并预存4条示例记忆。
2. 交互示例：

   你: 你好，我是小明。 助手: 你好小明！我记得你喜欢科幻小说，而且读完了《三体》并给了5星好评。最近对历史传记感兴趣吗？

   • 发生了什么？当你说“我是小明”时，ConversationChain会调用memory.load_memory_variables({})。VectorStoreRetrieverMemory会将当前的输入（“我是小明”）转化为向量，并在向量数据库中搜索与之最相关的记忆。由于示例记忆中都包含“小明”，因此相关记忆被检索出来，并插入到提示词的{history}部分。LLM基于这些记忆生成了个性化的回复。
3. 添加新记忆：

   你: 保存: 我昨天刚读了《人类简史》，觉得视角很宏大。 [记忆已保存] 我昨天刚读了《人类简史》，觉得视角很宏大。

4. 基于新记忆的对话：

   你: 能推荐一本和《人类简史》类似的书吗？ 助手: 既然你刚读完《人类简史》并欣赏其宏大的视角，我推荐你读《未来简史》，它是同一作者尤瓦尔·赫拉利的作品，同样以宏大的视角探讨人类的未来。另外，结合你对科幻和历史传记的兴趣，《银河帝国》系列或许也能满足你。

   • 分析：智能体成功检索到了你刚刚保存的关于《人类简史》的记忆，并结合之前“喜欢科幻”和“对历史传记感兴趣”的记忆，给出了综合性的推荐。

5.4 核心机制剖析

1. 存储：memory.save_context(...)被调用时，它会将输入文本通过嵌入模型转化为向量，并存储到Chroma数据库中。每条记忆都与其向量表示关联。
2. 检索：当需要加载记忆时（在predict前），内存系统会将当前的对话输入（或整个最近的上下文）作为查询文本，同样转化为向量，然后在向量数据库中进行相似性搜索，找出最相关的几条记忆。
3. 集成：检索到的相关记忆文本被格式化后，插入到预设的提示词模板中，与当前用户问题一起构成最终的提示词，送给LLM生成回复。

这就是检索增强生成（RAG）在智能体记忆中的核心应用：将外部知识（长期记忆）动态地、按需地注入到LLM的上下文中，极大地扩展了智能体的知识边界和个性化能力。

6. 组合记忆与高级模式

一个成熟的智能体通常需要混合记忆架构。例如，使用ConversationBufferWindowMemory来维持对话流畅性（短期记忆），同时使用VectorStoreRetrieverMemory来存取长期事实（长期记忆）。LangChain 提供了CombinedMemory或ConversationSummaryBufferMemory等更高级的组件来处理这种复杂性。

6.1 使用ConversationSummaryBufferMemory

这是一种折中方案：它保留完整的最近对话（短期缓冲区），但对于更早的对话，则使用LLM生成一个摘要进行存储。这样既节省了上下文空间，又保留了长期对话的要点。

# 文件：04_advanced_memory_combination.py from langchain.memory import ConversationSummaryBufferMemory from langchain_openai import ChatOpenAI from langchain.chains import ConversationChain llm = ChatOpenAI(model="gpt-3.5-turbo") # max_token_limit 控制用于存储对话历史的token上限。 # 当历史超过这个限制，最早的对话会被总结。 memory = ConversationSummaryBufferMemory( llm=llm, max_token_limit=100, # 这是一个很小的值，仅用于演示 return_messages=True # 返回消息对象列表，而非纯字符串 ) conversation = ConversationChain(llm=llm, memory=memory, verbose=True) print("进行一段较长的对话，观察记忆如何从详细记录转为摘要...") inputs = [ "我叫阿强，是一名软件工程师。", "我住在北京，喜欢爬山和摄影。", "我养了一只猫，它叫橘子。", "我的工作主要用Python和Go。" ] for inp in inputs: _ = conversation.predict(input=inp) print(f"\n--- 当前记忆 ---") # 查看内存中的消息 print(memory.load_memory_variables({}))

运行此代码，你会看到随着对话轮次增加，memory中存储的内容从完整的对话记录，逐渐变成了一个由LLM生成的摘要（如“用户介绍了自己的姓名、职业、居住地、爱好和宠物”），而最新的对话仍保持原样。这有效平衡了细节与容量。

7. 常见问题与排查思路

在实现智能体内存时，你可能会遇到以下典型问题：

8. 最佳实践与工程建议

设计生产级智能体的内存系统时，需要考虑以下几点：

1. 分层记忆设计：

   • 会话级内存：使用ConversationBufferWindowMemory，容量小（如最近10轮），保证低延迟和对话流畅。
   • 用户级长期内存：使用VectorStoreRetrieverMemory配合向量数据库，按用户ID分区存储。存储用户的关键事实、偏好和重要历史交互。
   • 全局知识内存：使用独立的RAG系统接入产品文档、知识库等，作为智能体的背景知识，不与用户个人数据混淆。

2. 记忆的存储与索引优化：

   • 分块策略：存入向量数据库的文本不宜过长或过短。通常256-512个字符是一个好的起点。可以使用RecursiveCharacterTextSplitter进行智能分块。
   • 元数据过滤：为每条记忆附加元数据，如user_id,session_id,timestamp,type（fact, preference, event）。检索时不仅可以做向量相似度搜索，还可以用元数据过滤，精度更高。
   • 混合搜索：结合向量相似度搜索和关键词（如BM25）搜索，提高检索召回率。

3. 记忆的更新与清理：

   • 记忆更新：当用户修正信息时（如“我不再喜欢科幻了”），需要有能力更新或覆盖旧记忆。这可以通过为新记忆生成新向量并关联相同memory_id，或在应用层逻辑中处理。
   • 记忆衰减与清理：并非所有记忆都需永久保存。可以设计基于时间、使用频率或重要性的清理策略。例如，标记某些记忆为“临时”，定期清理。

4. 安全与隐私：

   • 数据加密：存储在数据库（尤其是向量数据库）中的用户记忆需要进行加密处理。
   • 访问控制：严格确保记忆的检索和修改只能由对应的用户或授权系统触发。
   • 合规性：遵循数据保护法规（如GDPR），提供用户查询、导出和删除其个人记忆的接口。

5. 性能监控：

   • 监控记忆检索的延迟和成功率。
   • 记录记忆的使用频率，识别哪些记忆被频繁调用。
   • 评估记忆对最终回答质量的贡献（可通过人工评估或自动化指标）。

智能体的内存架构是其走向“智能”和“个性化”的基石。从简单的对话缓冲区到复杂的多级RAG系统，记忆组件的选择与设计直接决定了智能体的能力上限。本文从概念到实战，详细介绍了短期记忆、长期记忆等不同类型及其在LangChain中的实现方式。理解这些模式后，你可以根据具体应用场景，像搭积木一样构建适合自己智能体的记忆系统。下一步，可以探索更复杂的记忆结构，如LangGraph提供的基于图的状态管理，它能更好地处理涉及多步骤规划和工具调用的智能体工作流中的记忆问题。