让AI智能体拥有像人类的持久记忆:基于LangGraph的长短期记忆管理实践指南
如何让AI智能体(Agent)像人类一样拥有持久的记忆,从而在复杂的连续任务中保持上下文感知和深度理解?这已成为构建高级智能体的核心挑战。本文将深入探讨Agent Memory的核心概念,并聚焦于LangGraph框架下的长短期记忆实现,详解短期会话与长期知识的存储、管理、语义检索等技巧。更进一步地,我们将通过一个引入MCP协议的实战案例,手把手带你构建一个真实的融合长记忆机制的Multi-Agent系统,直观展示中断、记忆与协作的融合。
基于大语言模型(LLM)的智能体(Agent)系统中,记忆机制是实现持续、连贯和个性化交互的核心基石,通过记忆,可以让Agent记住过往的交互,保持上下文的一致性,并能从反馈中学习,适应用户的偏好。
本文核心要点概述:
1.介绍Agent Memory的基本情况
2.LangGraph长短期记忆详解及案例说明:包含短期记忆实现、管理方法,长期记忆的实现方法,以及搭建了融合postgres数据库、集成Embedding服务进行语义搜索等可用于生产环境的真实案例。
3.引入MCP协议构建真实的Agent长记忆应用:搭建一个基于supervisor架构,集成中断机制、长短期记忆机制的multi-agent系统。
记忆机制介绍
Agent Memory是什么?
上图中(来源于Mem0[1]),左边是没有Memory的agent,右边是有Memory的agent,后者可以根据用户的过往信息(素食主义者、不喜欢乳制品)给出更合理的响应(不含乳制品的素食菜单),而前者的回答显然是不合适的。
简单来说,Memory是赋予Agent记忆能力的技术和架构,能够让Agent像人一样记住过去的交互、学到的知识、执行过的任务及未来的计划,是将一个LLM转变为能够执行复杂、长期任务的真正”智能体“的核心所在。
关于Agent Memory我们需要考虑什么?
如何获取记忆:通过和用户交互、环境交互...
怎么组织记忆:模型参数、模型上下文、数据库
怎么利用记忆:RAG、Few-shot...
有哪些Memory类型?
关于Memory的分类,有许多种分类体系,这里我们只讨论最常见及最易于理解的。
正如人类利用长短期记忆进行有效的交互和学习一样,Agent的记忆机制通常划分为短期记忆(short-term memory)和长期记忆(long-term memory),短期记忆决定了Agent在微观任务上的即时表现,而长期记忆则作为持久知识库,决定了Agent在宏观时间尺度上的智能深度和个性化水平,通过两者配合,Agent才能表现出连贯性、上下文感知能力,才会显得更智能。
Agent Memory如何工作?
Agent通常通过以下几步来有效地管理记忆,使得每次于用户的交互都更加精准智能:
记忆存储:通过设计一系列策略来存储重要的交互信息,这些信息可能来源于对话内容、历史数据或任务要求等等。 记忆更新:记忆会随着交互的发生,不断地进行更新,例如用户的偏好、最新的近况等等。记忆更新使得Agent能够不断优化其响应。 记忆检索:Agent根据当下的需求,去记忆中检索需要的记忆内容,从而提供更加智能的回复。
Agent Memory怎么实现?
物理外挂:即外置数据库和 RAG,需要检索当前query相关的内容,例如:Mem0、ACE。好处是即插即用,坏处是不够end-to-end Memory as Reasoning / Tool:通过训练Reasoning或Tool的方式动态更新context,例如:MemAgent、memory-R1。好处是更接近end-to-end,但不是很灵活。 参数更新:LLM本身就是一个Memory体,所有参数都是它的Memory,通过更新参数来更新记忆,这种方式是最本质的,但也是最难实现的。
LangGraph中的记忆管理
LangGraph[2]作为一款面向多智能体协作与状态管理的框架,其设计了巧妙的记忆管理系统,旨在为Agent提供在不同交互中存储、检索和利用信息的能力。它区分了两种主要的记忆类型:短期记忆和长期记忆。在实际使用中,通过这两种记忆协同,既能保障实时任务的高效执行,又支持了跨任务、跨周期的经验复用。
● short-term memory(通过Checkpointer实现):针对单个对话线程,核心价值在于保障对话的临时性,使得Agent能够跟踪会话中的多轮对话,可以在该线程内的任何时刻被回忆。
● long-term memory(通过Store实现):可以跨对话线程共享,可以在任何时间,任何线程中被回忆,而不像短期记忆局限于单个对话。
通过下表,可以更清晰的看到两者的区别:
LangGraph记忆的架构基础
要想更好的理解LangGraph中的记忆机制,首先需要理解其支持双轨记忆系统的核心概念。
Checkpointer
LangGraph有一个内置的持久化(Persistence)层,通过checkpointer实现,能够持久化存储图状态,这使得开发记忆功能和人类干预功能成为可能。
当使用检查点编译一个图时,检查点会在每个super-step保存图状态的checkpoint,这些checkpoint被保存到一个thread中,可以在图执行后访问。因为threads允许在执行后访问图的状态,所以可以实现记忆、人机协作、时间旅行、容错等多种强大的功能。
工作流程:
用户输入 → [节点 1] → 💾 保存状态 → [节点 2] → 💾 保存状态 → 输出
↓ ↓
Checkpoint 1 Checkpoint 2
Thread
为了管理多个独立的对话,LangGraph使用了thread的概念。thread_id是由checkpointer保存的每个checkpoint的唯一id,是激活和区分不同对话线程的唯一key。在调用图的invoke或stream方法时,通过configurable字典传入一个thread_id,就代表这次操作属于thread_id这个特定的对话。
Store
如上所述,图状态可以由checkpointer在每个super-step写入线程,从而实现状态的持久化。但是,如果想在多个线程之间保留一些信息的话,那么就需要用到Store。Store本质上是一个暴露给图节点和工具的键值数据库,与checkpointer的自动化快照不同,Store需要显式和主动的进行操作。
Namespace
Store中的数据通常通过更持久的标识来组织。user_id是最常见的,用于关联用户的所有信息,此外,namespace提供了一种数据隔离机制,例如,使用使用 (“memories”, user_id) 这样的元组作为命名空间,可以将用户的记忆与其他类型的数据(如用户偏好 (“preferences”, user_id))清晰地分离开来,避免数据冲突,保持知识库的整洁有序。
短期记忆详解
InMemorySaver内存会话临时存储
对于开发、原型设计和测试阶段,最简单快捷的方式是使用InMemorySaver。它将所有的对话状态存储在内存中的一个Python字典里。
1.设置记忆管理检查点
from langchain_openai import ChatOpenAI
from langchain.chat_models import init_chat_model
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.prebuilt import create_react_agent
# 初始化检查点保存器
checkpointer = InMemorySaver()
2.定义大模型并创建agent
BASE_URL=""
TOKEN=""
MODEL_NAME=""
model = init_chat_model(
model=MODEL_NAME,
model_provider="openai",
base_url=BASE_URL,
api_key=TOKEN,
temperature=0,
)
agent = create_react_agent(
model=model,
tools=[],
# 传入检查点,是将持久化能力“注入”图的关键步骤。编译后的graph对象现在具备了状态管理的能力。
checkpointer=checkpointer
)
如果是底层自定义api在图构建阶段传入检查点的代码是graph = builder.compile(checkpointer=checkpointer)。
3.短期记忆-内存后端
config = {"configurable": {"thread_id": "1"}} # 激活记忆机制的核心。如果没有提供thread_id,每次invoke调用都将是无状态的,只要使用相同的thread_id,LangGraph就会在多次调用之间维持对话状态
response = agent.invoke(
{"messages": [{"role": "user", "content": "你好,我叫ada!"}]},
config
)
print(f"thread1_bot_answer:{response['messages'][-1].content}")
response = agent.invoke(
{"messages": [{"role": "user", "content": "你好,请问你还记得我叫什么名字么?"}]},
config
)
print('------------线程1------------------')
print(f"thread1_bot_answer:{response['messages'][-1].content}")
new_config = {"configurable": {"thread_id": "2"}}
response = agent.invoke(
{"messages": [{"role": "user", "content": "你好,请问你还记得我叫什么名字么?"}]},
new_config
)
print('------------线程2------------------')
print(f"thread2_bot_answer:{response['messages'][-1].content}")
执行上面代码,可以看到输出如下:
thread1_bot_answer:你好,Ada!很高兴认识你!😊
这是一个很美的名字呢!有什么我可以帮助你的吗?无论是想聊聊天,还是有任何问题需要解答,我都很乐意为你提供帮助。
------------线程1------------------
thread1_bot_answer:当然记得!你刚才告诉我你叫 Ada~很高兴再次和你打招呼!😊
------------线程2------------------
thread2_bot_answer:你好!很抱歉,我无法记住之前对话中的个人信息,比如你的名字。这是为了保护你的隐私,所以我不会保留这类数据。你可以告诉我你的名字,或者任何你想让我称呼你的方式,我会很乐意在这次的对话中使用它!😊
短期记忆与线程相关,在对话时,需要在配置中传入thread_id。通过上面的结果我们可以看到,当我们传入相同的thread_id时,agent就可以记住用户的名字,然而当我们更换thread_id时,agent就不记得用户的名字了。
需要注意的是,InMemorySaver将所有状态都保存在内存中,一旦程序终止,那么所有对话历史都会消失。
数据库持久化存储
可以发现,上面一小节的代码在应用程序结束后再启动,记忆就又消失了。这是因为InMemorySaver仅仅是把记忆保存在内存中,应用程序结束后释放内存记忆就消失了。在生产环境中常常使用数据库支持的检查点记录器持久化保存记忆,以保证数据的可靠性和服务的连续性。
这里我们以postgres数据库为例来说明,怎么持久化地保存记忆数据。
1.首先安装以下依赖:
pip install -U "psycopg[binary,pool]" langgraph-checkpoint-postgres
2.安装postgres数据库,具体的安装方法可以参考:Linux下安装PostgreSQL_linux安装postgresql-CSDN博客。这里选择以源码的方式进行安装,安装包从官网(PostgreSQL: Downloads)下载,选择最新的postgresql-18.0.tar.gz。
3.安装数据库成功后,编码如下代码。
DB_URI是数据库连接的URL。想要自动保存在数据库中的State需要在PostgresSaver.from_conn_string(DB_URI)上下文中操作。
from langchain.chat_models import init_chat_model
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.checkpoint.postgres import PostgresSaver
BASE_URL=""
TOKEN=""
MODEL_NAME=""
model = init_chat_model(
model=MODEL_NAME,
model_provider="openai",
base_url=BASE_URL,
api_key=TOKEN,
temperature=0,
)
DB_URI = "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable"
with PostgresSaver.from_conn_string(DB_URI) as checkpointer:
checkpointer.setup() # 第一次调用时必须要setup()
def call_model(state: MessagesState):
response = model.invoke(state["messages"])
return {"messages": response}
builder = StateGraph(MessagesState)
builder.add_node(call_model)
builder.add_edge(START, "call_model")
graph = builder.compile(checkpointer=checkpointer)
config = {
"configurable": {
"thread_id": "1"
}
}
response = graph.invoke(
{"messages": [{"role": "user", "content": "你好,我叫ada!"}]},
config
)
print(response['messages'][-1].content)
response = graph.invoke(
{"messages": [{"role": "user", "content": "你好,请问你还记得我叫什么名字么?"}]},
config
)
print(response['messages'][-1].content)
运行一次上述代码后,关闭应用程序后重启,再次运行上述代码,print结果如下:
bot_answer_1:你好,Ada!很高兴再次见到你!😊
你的名字真动听!今天有什么我可以帮你解答或者想聊的话题吗?
bot_answer_2:当然记得!你告诉我你叫 **Ada**。很高兴再次和你打招呼!😊
可以看到,记忆已经被保存了。我们检查数据库可以发现,postgres数据库中出现了四个表:
上述表中,checkpoints表是”状态快照“表,每当程序执行一个step时,它就会在这张表中创建一条新记录,这条记录就是一个检查点的快照。查询该表,可以得到如下结果:
接下来,我们来分析每一列的含义:
理解了上面checkpoints表后,那么不禁会问,真正的消息内容被存到了哪里呢?真正的消息内容存储在checkpoint_writes表中,如下:
除了PostgreSQL之外,LangGraph还支持MongoDB、Redis等数据库。
子图中的记忆
当构建复杂的、由多个子图嵌套而成的应用时,需要更灵活的记忆管理策略。
● 记忆继承(默认):默认情况下,子图会继承其父图的checkpointer。这意味着整个嵌套图共享同一个对话状态,数据可以在父子图之间无缝流动。这对于将一个大型任务分解为多个模块化子任务非常有用。
● 记忆隔离:在某些场景下,例如构建多智能体系统,希望每个智能体(由一个子图表示)拥有自己独立的内存空间,互不干扰。此时,可以在编译子图时设置checkpointer=True。
如下代码,可以在子图中直接使用父图的短期记忆:
from langgraph.graph import START, StateGraph
from langgraph.checkpoint.memory import InMemorySaver
from typing import TypedDict
class State(TypedDict):
foo: str
# 子图
def subgraph_node_1(state: State):
return {"foo": state["foo"] + "bar"}
subgraph_builder = StateGraph(State)
subgraph_builder.add_node(subgraph_node_1)
subgraph_builder.add_edge(START, "subgraph_node_1")
subgraph = subgraph_builder.compile()
# 父图
builder = StateGraph(State)
builder.add_node("node_1", subgraph)
builder.add_edge(START, "node_1")
checkpointer = InMemorySaver()
graph = builder.compile(checkpointer=checkpointer)
如果子图希望使用自己的短期记忆,那么需要在编译子图时,显示传入子图的检查点:
subgraph_builder = StateGraph(...)
subgraph = subgraph_builder.compile(checkpointer=True)
工具中的记忆交互
在工具中读取状态:
LangGraph允许工具直接访问和读取当前的图状态,使其具备上下文感知能力。
核心机制:state: Annotated[CustomState, InjectedState],InjectedState的作用是在调用这个工具时,将当前的完整状态对象作为第一个参数传递到工具中,使得这个工具能根据当前状态来执行更智能的操作。
from typing import Annotated
from langchain.chat_models import init_chat_model
from langgraph.prebuilt import InjectedState, create_react_agent
from langgraph.prebuilt.chat_agent_executor import AgentState
BASE_URL=""
TOKEN=""
MODEL_NAME=""
model = init_chat_model(
model=MODEL_NAME,
model_provider="openai",
base_url=BASE_URL,
api_key=TOKEN,
temperature=0,
)
class CustomState(AgentState):
user_id: str
def get_user_info(
state: Annotated[CustomState, InjectedState]
) -> str:
"""查询用户信息"""
user_id = state["user_id"]
return"ada"if state["user_id"] == "user_ada"else"Unknown"
agent = create_react_agent(
model=model,
tools=[get_user_info],
state_schema=CustomState,
)
agent.invoke({
"messages": "查询用户信息",
"user_id": "user_ada"
})
返回结果如下:
根据查询结果,您的用户信息显示用户名为:**ada**\n\n这是您的用户信息查询结果。如果您需要了解其他信息或有其他需求,请告诉我。
在工具中写入状态:
如果要在工具执行期间修改图的记忆,那么可以直接从工具返回状态更新。这对于持久化中间结果、传递信息给后续工具等非常有用。
核心机制:工具返回Command对象。此时,LangGraph会将其返回值解释为对状态的直接修改指令。Command(update={...})中的字典定义了要更新的状态字段及其新值。这允许工具在完成其主要任务的同时,将结果写回智能体的短期记忆中,从而影响后续的决策。
from typing import Annotated
from langchain_core.tools import InjectedToolCallId
from langchain_core.runnables import RunnableConfig
from langchain_core.messages import ToolMessage
from langgraph.prebuilt import InjectedState, create_react_agent
from langgraph.prebuilt.chat_agent_executor import AgentState
from langgraph.types import Command
class CustomState(AgentState):
user_name: str
def update_user_info(
tool_call_id: Annotated[str, InjectedToolCallId],
config: RunnableConfig
) -> Command:
"""查询并更新用户信息"""
user_id = config["configurable"].get("user_id")
name = "ada"if user_id == "user_123"else"Unknown user"
return Command(update={
"user_name": name,
# 更新消息历史记录
"messages": [
ToolMessage(
"成功查询到用户信息",
tool_call_id=tool_call_id
)
]
})
def greet(
state: Annotated[CustomState, InjectedState]
) -> str:
"""找到用户信息后,使用此方式向用户问好。"""
user_name = state["user_name"]
return f"你好 {user_name}!"
agent = create_react_agent(
model=model,
tools=[update_user_info, greet],
state_schema=CustomState
)
agent.invoke(
{"messages": [{"role": "user", "content": "向用户打招呼"}]},
config={"configurable": {"user_id": "user_123"}}
)
输出结果如下:
长期记忆详解
LangGraph中的长期记忆允许系统在不同对话中保留信息,是跨对话线程共享的,可以在任何时间、任何线程中被回忆。与短期记忆不同,长期记忆保存在自定义的命名空间中,每个记忆都组织在一个自定义的namespace和一个唯一的key下。
记忆存储:LangGraph将长期记忆存储为JSON文档,使用Store进行管理,允许存储结构化和非结构化的数据。
记忆更新时机:
● 热路径(Hot Path):在应用程序逻辑运行时实时创建记忆(store.put()),优点是实时更新,但可能增加程序复杂性、延迟等问题。
● 后台(Background):作为单独的异步任务创建记忆(store.put()),优点是避免主应用延迟、逻辑分离,难点在于确定更新频率和触发时机。
记忆检索:
● store.get():根据命名空间和键精确获取记忆。
● store.search():在指定命名空间内实现灵活记忆检索,不但可以通过命名空间和标识符,更可以通过语义检索到记忆内容。通常需要Store配置一个embed来支持语义搜索。
记忆的应用:
● 语义记忆:存储事实和概念。分为以下两种情况:Profile:将关于用户、组织或代理自身的特定信息存储为一个持续更新的JSON文档,需要模型来生成新的Profile或更新已有JSON档案;Collection:将记忆存储为一组独立的文档,易于生成,但检索和更新较为复杂,且可能难以捕获记忆间的完整上下文。在应用时,可以将检索到的记忆作为上下文或系统指令的一部分传递给LLM,用于个性化响应和回答事实性问题。
● 情景记忆:存储过去的事件或行为经验。通常通过few-shot example prompt来实现,以指导模型完成任务。
● 程序记忆:存储执行任务的规则或指令。通常通过修改代码自身的prompt来实现,将其应用于LLM。
InMemoryStore
与Checkpointer类似,InMemoryStore用于快速开发和原型验证。它将所有数据存储在内存中。
from langchain.chat_models import init_chat_model
from langchain_core.runnables import RunnableConfig
from langgraph.store.memory import InMemoryStore
from langgraph.config import get_store
from langgraph.prebuilt import create_react_agent
store = InMemoryStore()
BASE_URL=""
TOKEN=""
MODEL_NAME=""
model = init_chat_model(
model=MODEL_NAME,
model_provider="openai",
base_url=BASE_URL,
api_key=TOKEN,
temperature=0,
)
store.put(
("users",), # 命名空间:元组类型,类比文件系统中的文件夹,支持分层组织结构
"user_123", # 键: 字符串,是命名空间内的唯一标识符,一般推荐使用uuid库生成唯一标识符
{
"name": "ada",
"language": "中文",
} # 值:Python字典类型,比如保存公共角色资料时可以是包含姓名、偏好等键值对的字典
)
def get_user_info(config: RunnableConfig) -> str:
"""查找用户信息的函数,可以查看长期记忆中储存的用户信息"""
store = get_store() # 获取上下文中可用的store实例
user_id = config["configurable"].get("user_id")
user_info = store.get(("users",), user_id) # 输入命名空间和键进行精确查询
return str(user_info.value) if user_info else"Unknown user"
agent = create_react_agent(
model=model,
tools=[get_user_info],
# 传入store
store=store
)
response = agent.invoke(
{"messages": [{"role": "user", "content": "帮我查找长期记忆中储存的用户信息"}]},
config={"configurable": {"user_id": "user_123"}}
)
print(response['messages'])
输出结果如下,可以看到在工具函数中成功调用store查找到了保存的用户信息:
数据库持久化存储
为了让记忆真正”长期“,生产环境必须使用数据库支持的Store,LangGraph目前主要支持PostgresStore和RedisStore。我们以PostgresStore为例来进行说明。
首先,先安装对应的包:
pip install -U "psycopg[binary,pool]" langgraph-checkpoint-postgres
Postgres数据库的安装,请参考上文。
接下来进行示例说明。整体过程与Checkpointer类似,关键区别在于Store是怎样在节点内部被访问和使用的。
import uuid
from langchain.chat_models import init_chat_model
from langchain_core.runnables import RunnableConfig
from langgraph.graph import StateGraph, MessagesState, START
from langgraph.store.base import BaseStore
from langgraph.store.postgres import PostgresStore
from langgraph.checkpoint.postgres import PostgresSaver
BASE_URL=""
TOKEN=""
MODEL_NAME=""
model = init_chat_model(
model=MODEL_NAME,
model_provider="openai",
base_url=BASE_URL,
api_key=TOKEN,
temperature=0,
)
DB_URI = "postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable"
with (
PostgresStore.from_conn_string(DB_URI) as store,
PostgresSaver.from_conn_string(DB_URI) as checkpointer,
):
store.setup() # 第一次调用时必须要setup()
#checkpointer.setup()
# 声明store参数
def call_model(
state: MessagesState,
config: RunnableConfig,
*,
store: BaseStore, # 在节点中访问store的标准方式,需要在函数签名上,加一个store
):
# 从store中读取记忆
user_id = config["configurable"]["user_id"]
namespace = ("memories", user_id)
memories = store.search(namespace, query=str(state["messages"][-1].content))
info = "\n".join([d.value["data"] for d in memories])
system_msg = f"你是一个与人类交流的小助手,用户信息: {info}"
# 向store中写入记忆
last_message = state["messages"][-1]
if"记住"in last_message.content.lower():
memory = "用户名字是ada"
store.put(namespace, str(uuid.uuid4()), {"data": memory})
response = model.invoke([{"role": "system", "content": system_msg}] + state["messages"])
return {"messages": response}
builder = StateGraph(MessagesState)
builder.add_node(call_model)
builder.add_edge(START, "call_model")
graph = builder.compile(checkpointer=checkpointer, store=store) # agent同时配备了短期记忆和长期记忆能力
# 第一次对话,告诉agent用户的名字
config = {
"configurable": {
"thread_id": "3",
"user_id": "1",
}
}
response = graph.invoke(
{"messages": [{"role": "user", "content": "你好,我叫ada!记住这个名字呦~"}]},
config
)
print(response['messages'][-1].content)
# 第二次对话,新线程,询问agent记不记得用户的名字
config = {
"configurable": {
"thread_id": "4",
"user_id": "1",
}
}
response = graph.invoke(
{"messages": [{"role": "user", "content":