LangChain 的 create_agent 底层运行在 LangGraph Runtime 之上。Runtime 可以理解为 Agent 每次执行时拿到的“运行环境”,其中与数据管理最相关的三个部分是:
-
Context:本次调用需要的静态身份和依赖。 -
State:执行过程中不断变化的短期状态。 -
Store:跨会话保存的长期数据。
1.认识Runtime
| 概念 | 作用 | 读写 | 典型生命周期 | 典型内容 | 访问方式 |
|---|---|---|---|---|---|
| Context | 注入本次运行所需的身份、配置和依赖 | 只读 | 单次调用 | user_id、tenant_id、权限、数据库连接 |
|
| State | 保存 Agent 执行中产生的动态数据 | 可读写 | 同一会话:同一thread_id的多次调用 | 消息、步骤结果、计数器、业务流程状态 |
|
| Store | 保存跨会话需要复用的数据 | 可读写 | 跨会话; | 用户偏好、长期记忆、历史资料 |
|
判断数据放在哪里,可以连续问两个问题:
-
这份数据在执行过程中会不会变化?不变化,优先考虑 Context。
-
如果会变化,下一次会话还要不要使用?只在当前会话使用调用 State,跨会话复用调用 Store。
更多Runtime信息可以查看官方文档:Runtime - Docs by LangChain
2.Context(运行上下文)
Runtime Context 是一种依赖注入机制:调用者在运行开始时把用户身份、租户信息、权限或外部服务连接传给 Agent,节点、中间件和工具在执行时再从 Runtime 读取。
它解决的是三个工程问题:
-
避免把用户 ID、数据库连接等信息硬编码进工具。
-
同一个 Agent 可以安全地服务不同用户和租户。
-
工具的业务参数只保留真正需要模型填写的内容。
Context 中的数据默认不会自动发给大模型;只有代码主动读取并把内容加入提示词或工具结果时,模型才会看到它。
例如,在系统中用户通常会先登录,然后访问agent,我们就可以把登录用户信息存入Context,在Agent内部的Middleware或Tool旧能很方便的通过runtime.context获取用户信息。而这个用户信息并不会让模型看到,也不需要作为参数让模型传递,纯粹是Agent内部信息。
2.1准备数据
下面,我们就以一个多租户的在线教育Agent系统为例,来演示Context的用法。
我们先准备一个字典,模拟一个多租户的在线教育项目数据库,其中的租户就是学校,user就是学员:
USER_DATABASE = {
"school1":{"id_01":{"name":"张三","course" :"java实践"},
"id_02":{"name":"李四","course" :"python实践"}
},
"school2":{"id_01":{"name":"王五","course" :"c++实践"},
"id_02":{"name":"赵六","course" :"go实践"}
}
}
下面用“查询当前用户资料”演示 Context。模型只负责决定何时调用工具,不负责填写 user_id 和school_id;工具从 Runtime Context 中读取它们。
2.2定义Context Schema
我们在定义类的时候可以使用@dataclass装饰器,dataclass是Python3.7引入的一个装饰器,用于简化类的定义,自动生成一些常用方法,如__init__()、__repr__()、__eq__()等。frozen=True表示该数据类是不可变的,一旦创建实例后,其属性值不能被修改。
@dataclass(frozen=True) #定义用户内容数据类,
class USERCONTEXT():
"""agent的用户内容数据类"""
user_id: str
school_id: str
定义USERCONTEXT类就是一个context_schema ,作用是给 Context 提供明确的数据结构。frozen=True不是 LangChain 的硬性要求,但能表达“运行内不可修改”的设计意图。
2.3Tool中使用Context
在tool中,我们可以添加runtime参数,然后利用runtime.context来访问Context:
@tool
#运行时工具,tool是langchain中的一个装饰器,用于将一个函数包装成一个工具,使其可以在agent中被调用,但是agent不能调用它也不会看到它,它是由langchain运行时来调用的。
def get_user_profile(runtime : ToolRuntime[USERCONTEXT]):
"""
通过用户ID和学校ID获取用户的个人信息
:param runtime: 工具运行时对象
:return: 用户的个人信息
"""
cnt = runtime.context #获取上下文中的用户内容数据类实例
if cnt is None:
raise ValueError("上下文数据类实例为空")
profile = USER_DATABASE.get(cnt.school_id).get(cnt.user_id)
if profile is None:
raise ValueError(f"未找到用户信息,school_id: {cnt.school_id}, user_id: {cnt.user_id}")
return {
"name": profile["name"],
"course": profile["course"]
}
2.4给Agent添加Context
在定义Agent时,需要指定我们创建好的Context。
context_schema=USERCONTEXT表示上下文数据类为USERCONTEXT,agent在调用工具时会将上下文数据类实例传入工具的runtime中。并且在调用中,需要写入context的信息。
model = init_chat_model(
model = "deepseek-flash",
extra_body = {
"thinking": {"type": "disabled"} #控制模型思考开关
}
)
agent = create_agent(model = model, tools=[get_user_profile],context_schema=USERCONTEXT)
2.5调用agent
context 属于本次 agent 运行的配置信息,不会发给大模型; 如果工具需要用到用户身份标识(user_id、school_id),就把它放到 context 里注入给工具; 不是调用模型就一定要传,只有后续要调用依赖这个上下文的工具时,才需要传。这个 context 是run 级别的上下文,不会自动跨轮次保存,多轮对话每一次 invoke 都要继续带上 context=。
response = agent.invoke(
{"messages": [HumanMessage("帮我查询正在处理的课程")]},
context=USERCONTEXT(user_id="id_01", school_id="school1") , #传入上下文数据类实例
)
for message in response["messages"]:
message.pretty_print()
打印结果:
D:\python\python.exe D:\pythonProject\langchain\进阶\01.context的使用.py
================================ Human Message =================================
帮我查询正在处理的课程
================================== Ai Message ==================================
我来帮您查询。不过,要获取您的个人信息(包括正在处理的课程),我需要先调用工具获取您的用户资料。
Tool Calls:
get_user_profile (call_00_JZWI8rQ3zMYT6FHHaG585857)
Call ID: call_00_JZWI8rQ3zMYT6FHHaG585857
Args:
================================= Tool Message =================================
Name: get_user_profile
{"name": "张三", "course": "java实践"}
================================== Ai Message ==================================
您好,张三!根据您的用户资料,您目前正在处理的课程是:
Java实践
祝您学习顺利!如需查询其他信息,随时告诉我。
进程已结束,退出代码为 0
- 用户消息:
帮我查询正在处理的课程(这部分是给 LLM 看的) - LLM 判断需要调用工具
get_user_profile - 框架自动从你传入的
context=USERCONTEXT(...)给到ToolRuntime,工具拿到runtime.context里面的user_id、school_id,模型全程看不到这两个 id,也不需要生成这两个参数 - 工具查到数据返回:
{"name": "张三", "course": "java实践"} - LLM 基于工具返回结果整理自然语言回答输出
完整代码:
from dataclasses import dataclass
from langchain.tools import tool
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_core.messages import HumanMessage
from langgraph.prebuilt import ToolRuntime
from langchain.agents import create_agent
load_dotenv(encoding="utf-8")
USER_DATABASE = {
"school1":{"id_01":{"name":"张三","course" :"java实践"},
"id_02":{"name":"李四","course" :"python实践"}
},
"school2":{"id_01":{"name":"王五","course" :"c++实践"},
"id_02":{"name":"赵六","course" :"go实践"}
}
}
@dataclass(frozen=True)
class USERCONTEXT():
"""agent的用户内容数据类"""
user_id: str
school_id: str
#定义获取信息工具
@tool
def get_user_profile(runtime : ToolRuntime[USERCONTEXT]):
"""
通过用户ID和学校ID获取用户的个人信息
:param runtime: 工具运行时对象
:return: 用户的个人信息
"""
cnt = runtime.context #获取上下文中的用户内容数据类实例
if cnt is None:
raise ValueError("上下文数据类实例为空")
profile = USER_DATABASE.get(cnt.school_id).get(cnt.user_id)
if profile is None:
raise ValueError(f"未找到用户信息,school_id: {cnt.school_id}, user_id: {cnt.user_id}")
return {
"name": profile["name"],
"course": profile["course"]
}
model = init_chat_model(
model = "deepseek-flash",
extra_body = {
"thinking": {"type": "disabled"} #控制模型开关
}
)
agent = create_agent(model = model,
tools=[get_user_profile],
context_schema=USERCONTEXT,
system_prompt="你是课程平台助手。需要用户资料时调用工具。")
"""
context_schema=USERCONTEXT表示上下文数据类为USERCONTEXT,agent在调用工具时会将上下文数据类实例传入工具的runtime中。
"""
##流式输出
response = agent.stream_events(
{"messages": [HumanMessage("帮我查询正在处理的课程")]},
context=USERCONTEXT(user_id="id_01", school_id="school1") , #传入上下文数据类实例
version = "v3"
)
for message in response.messages:
for delta in message.text:
print(delta, end="", flush=True)
response = agent.invoke(
{"messages": [HumanMessage("帮我查询正在处理的课程")]},
context=USERCONTEXT(user_id="id_01", school_id="school1") , #传入上下文数据类实例
)
for message in response["messages"]:
message.pretty_print()
3.State(短期记忆)
State它是Agent的短期记忆,存储当前会话的历史消息、任务状态等信息。
我们之前所说的短期记忆时使用的是默认的AgentState,其中只包含会话的历史消息(messages),本节开始我们学习如何自定义AgentState,记录除了历史消息以外的其他信息。
3.1自定义State
要自定义AgentState,其实就是定义一个类,然后继承AgentState,在其中添加想要记录的属性信息即可。
例如,我们要实现统计用户的模型调用次数、调用时间的功能,可以这样定义state:
# 定义自定义State结构
class State(AgentState):
chat_count : int # 模型对话次数
由于在AgentState中已经具备messages属性,也就是历史消息列表,因此我们的CustomState继承了AgentState以后,不仅可以记录会话的历史消息,也能记录Agent运行的任务状态信息了。
标题一那么,我们该如何操作state中的自定义属性呢?
Lang Chain中通常有两个地方可以操作state:
-
Tool -
Middleware
由于Middleware还没有接触,我们先来看在Tool中访问state
3.2使用工具访问state
在 Tool 中访问 State,靠的是工具函数里的 runtime 参数。只要给工具声明 runtime: ToolRuntime,LangGraph 在调用这个工具时就会把当前运行环境注入进来,我们通过 runtime.state 就能读到当前会话的 State。
需要注意两点:
-
runtime.state是只读的,直接修改它不会生效,必须通过返回值把更新提交给框架。 -
工具要更新 State,需要返回一个
Command对象,把要写入的字段放在update字典里。
下面这个工具的作用是:每次被调用时,把 State 中的 chat_count 加 1,并返回一条工具消息,告诉模型这次更新已经完成。
@tool
def get_increse_chat_count(runtime: ToolRuntime):
"""
在每一次调用模型的时候,都会调用这个工具来增加聊天计数器的值
:param runtime: 工具运行时对象
:return: 一个State对象,表示当前的聊天计数器值 ,但是因为AgentState类继承的是TypeDict,所以返回的State对象会被自动转换为字典类型
"""
state = runtime.state.get("chat_count",0) #获取当前的聊天计数器值,如果没有则默认为0
new_count = state + 1
update = {
"messages" :[
ToolMessage(content="Successfully updated agent state",tool_call_id = runtime.tool_call_id)
],
"chat_count": new_count
}
return Command(update = update)
这段代码里有几个关键点值得展开说明:
-
runtime.state.get("chat_count", 0):从当前 State 中读取计数器,第一次运行时该字段还不存在,所以用0作为默认值,避免KeyError。 -
runtime.tool_call_id:本次工具调用的唯一标识。返回ToolMessage时必须带上它,框架才能把这条工具结果和模型发起的那次工具调用对应起来。 -
Command(update=update):这是向 State 写数据的标准方式。update中的messages会被追加到历史消息列表,chat_count则会覆盖 State 中同名字段。
还有一点容易踩坑:工具必须真的被调用,State 才会更新。如果模型判断不需要调用工具,那么 chat_count 就不会变化。因此这类计数逻辑通常配合系统提示词使用,明确告诉模型在什么场景下应该调用该工具。
3.3设置state schema
把工具注册到 Agent 时,还需要把自定义的 State 通过 state_schema 传给 create_agent,否则框架仍然使用默认的 AgentState,chat_count 这个字段不会被保存,state_schema=State表示状态数据类为State,agent在调用工具时会将状态数据类实例传入工具的runtime中。
agent = create_agent(model,
tools=[get_increse_chat_count],
state_schema=State,
checkpointer= InMemorySaver())
调用之后,可以在返回结果的 State 中看到累加后的计数:
config = {"configurable":{"thread_id":"1"}}
print("-------第一轮--------")
response = agent.invoke({"messages":"你好,我是张扬,我喜欢薛之谦的歌,我想和你聊聊薛之谦的歌。"},config )
print(response)
agent.get_state(config)
print("-------第二轮--------")
response =agent.invoke({"messages":"你知道演员这首歌曲吗?"}, config)
print(response)
agent.get_state(config)
print("-------第三轮--------")
response = agent.invoke({"messages":"你知道我和你已经聊了多少次了吗?"}, config)
print(response)
agent.get_state(config)
config2 = {"configurable":{"thread_id":"2"}}
print("-------第四轮--------")
response = agent.invoke({"messages":"你知道我和你已经聊了多少次了吗?"}, config2)
print(response)
agent.get_state(config2)
这里 thread_id 是 State 的生命周期边界:同一个 thread_id 的多次调用共享同一份 State,chat_count 会持续累加;换一个 thread_id 就是一段全新的会话,计数会从 0 重新开始。这也正好呼应了前面表格里 State 的定位——只在当前会话内有效,不会跨会话保存。
运行结果如下,可以看出前三次的运行,它的chat_count字段是1,2,3;但是到了第四次,我将thread_id设置为2,它的chat_count字段变成了,这也说明state是在同一会话,同一thread_id的多次调用
D:\python\python.exe D:\pythonProject\langchain\进阶\02.state的使用.py
-------第一轮--------
{'messages': [HumanMessage(content='你好,我是张三,我喜欢薛之谦的歌,我想和你聊聊薛之谦的歌。', additional_kwargs={}, response_metadata={}, id='7ce39e1d-08e6-4e5f-af49-fdd3c83c7417'), AIMessage(content='', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 26, 'prompt_tokens': 327, 'total_tokens': 353, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 128, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 128, 'prompt_cache_miss_tokens': 199}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': 'c81c4674-b1c4-4b81-9be1-f9826c577a8b', 'finish_reason': 'tool_calls', 'logprobs': None}, id='lc_run--01a1e879-14a5-7962-a640-68fbecc54068-0', tool_calls=[{'name': 'get_increse_chat_count', 'args': {}, 'id': 'call_00_twvU5KWVIc7Oc8THi3wl4841', 'type': 'tool_call'}], invalid_tool_calls=[], usage_metadata={'input_tokens': 327, 'output_tokens': 26, 'total_tokens': 353, 'input_token_details': {'cache_read': 128}, 'output_token_details': {}}), ToolMessage(content='Successfully updated agent state', name='get_increse_chat_count', id='11a08cac-f85e-4c13-94e3-21e039df7f50', tool_call_id='call_00_twvU5KWVIc7Oc8THi3wl4841'), AIMessage(content='你好,张三!很高兴认识你 😊 薛之谦的歌确实很有辨识度——旋律抓耳、歌词常常带着故事感和一点“自嘲式”的深情,很多人听着会很有共鸣。\n\n我们可以从几个角度聊:\n\n1. **你最喜欢的薛之谦歌曲是哪一首?** 是《演员》《丑八怪》《认真的雪》这类大热歌,还是偏冷门一点的?\n2. **你更喜欢他的“苦情歌”还是“幽默/反差感”强的作品?**\n3. **有没有哪句歌词特别戳你?** 比如《演员》里那种“感情里的表演感”,或者《刚刚好》里的克制与遗憾。\n\n你可以先说说你最近循环的是哪首、为什么喜欢,我可以陪你一起拆歌词、聊旋律,也可以帮你推荐同类型的歌。', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 171, 'prompt_tokens': 370, 'total_tokens': 541, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 128, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 128, 'prompt_cache_miss_tokens': 242}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': '12aa1dbe-215b-4b0b-9898-c38d116051bb', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--01a1e879-1795-7633-9a78-bcbe560868b2-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 370, 'output_tokens': 171, 'total_tokens': 541, 'input_token_details': {'cache_read': 128}, 'output_token_details': {}})], 'chat_count': 1}
-------第二轮--------
{'messages': [HumanMessage(content='你好,我是张三,我喜欢薛之谦的歌,我想和你聊聊薛之谦的歌。', additional_kwargs={}, response_metadata={}, id='7ce39e1d-08e6-4e5f-af49-fdd3c83c7417'), AIMessage(content='', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 26, 'prompt_tokens': 327, 'total_tokens': 353, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 128, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 128, 'prompt_cache_miss_tokens': 199}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': 'c81c4674-b1c4-4b81-9be1-f9826c577a8b', 'finish_reason': 'tool_calls', 'logprobs': None}, id='lc_run--01a1e879-14a5-7962-a640-68fbecc54068-0', tool_calls=[{'name': 'get_increse_chat_count', 'args': {}, 'id': 'call_00_twvU5KWVIc7Oc8THi3wl4841', 'type': 'tool_call'}], invalid_tool_calls=[], usage_metadata={'input_tokens': 327, 'output_tokens': 26, 'total_tokens': 353, 'input_token_details': {'cache_read': 128}, 'output_token_details': {}}), ToolMessage(content='Successfully updated agent state', name='get_increse_chat_count', id='11a08cac-f85e-4c13-94e3-21e039df7f50', tool_call_id='call_00_twvU5KWVIc7Oc8THi3wl4841'), AIMessage(content='你好,张三!很高兴认识你 😊 薛之谦的歌确实很有辨识度——旋律抓耳、歌词常常带着故事感和一点“自嘲式”的深情,很多人听着会很有共鸣。\n\n我们可以从几个角度聊:\n\n1. **你最喜欢的薛之谦歌曲是哪一首?** 是《演员》《丑八怪》《认真的雪》这类大热歌,还是偏冷门一点的?\n2. **你更喜欢他的“苦情歌”还是“幽默/反差感”强的作品?**\n3. **有没有哪句歌词特别戳你?** 比如《演员》里那种“感情里的表演感”,或者《刚刚好》里的克制与遗憾。\n\n你可以先说说你最近循环的是哪首、为什么喜欢,我可以陪你一起拆歌词、聊旋律,也可以帮你推荐同类型的歌。', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 171, 'prompt_tokens': 370, 'total_tokens': 541, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 128, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 128, 'prompt_cache_miss_tokens': 242}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': '12aa1dbe-215b-4b0b-9898-c38d116051bb', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--01a1e879-1795-7633-9a78-bcbe560868b2-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 370, 'output_tokens': 171, 'total_tokens': 541, 'input_token_details': {'cache_read': 128}, 'output_token_details': {}}), HumanMessage(content='你知道演员这首歌曲吗?', additional_kwargs={}, response_metadata={}, id='4f242c4e-6c86-4c7d-b298-34d0bbf58d67'), AIMessage(content='', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 26, 'prompt_tokens': 551, 'total_tokens': 577, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 384, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 384, 'prompt_cache_miss_tokens': 167}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': 'e4c265e5-1871-45c3-af40-6284844cafb0', 'finish_reason': 'tool_calls', 'logprobs': None}, id='lc_run--01a1e879-1ff1-7a21-b014-e078fa7479b5-0', tool_calls=[{'name': 'get_increse_chat_count', 'args': {}, 'id': 'call_00_edeXLEVjOAVR7pcBRBHj4021', 'type': 'tool_call'}], invalid_tool_calls=[], usage_metadata={'input_tokens': 551, 'output_tokens': 26, 'total_tokens': 577, 'input_token_details': {'cache_read': 384}, 'output_token_details': {}}), ToolMessage(content='Successfully updated agent state', name='get_increse_chat_count', id='90cde541-689c-4212-b4fb-7ecab7c214d6', tool_call_id='call_00_edeXLEVjOAVR7pcBRBHj4021'), AIMessage(content='当然知道,《演员》算是薛之谦最有代表性的作品之一了 🎵\n\n简单说几句我对这首歌的理解:\n\n- **发行背景**:收录在薛之谦 2015 年的专辑《绅士》里,也是他“第二次走红”后传唱度极高的一首歌,KTV 点唱率常年居高。\n- **核心主题**:用“演戏”来比喻一段已经变质的感情——一方在感情里“演”,一方明知却配合着“演”。“其实台下的观众就我一个”这句就很有画面感,把两个人的关系写成了独角戏。\n- **歌词亮点**:\n - “简单点,说话的方式简单点”——直白地要求对方别再绕弯子、别再演。\n - “你难过的太表面,像没天赋的演员”——又心疼又讽刺,情绪很复杂。\n - 整首歌其实是“看穿却不说破”的委屈感。\n- **旋律/编曲**:主歌压抑克制,副歌情绪释放,薛之谦那种带点沙哑、略带鼻音的唱腔把“隐忍的爆发”处理得很有味道。\n\n张三,你听《演员》的时候,最戳你的是哪一句?是“简单点”的那种直接,还是“台下的观众就我一个”的那种孤独感?我可以顺着你喜欢的点,再帮你聊聊他的其他歌 😊', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 290, 'prompt_tokens': 594, 'total_tokens': 884, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 384, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 384, 'prompt_cache_miss_tokens': 210}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': '7849fbd9-1ac4-467a-bc57-f5d395185b1c', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--01a1e879-225a-7cd1-be01-2310d84f1326-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 594, 'output_tokens': 290, 'total_tokens': 884, 'input_token_details': {'cache_read': 384}, 'output_token_details': {}})], 'chat_count': 2}
-------第三轮--------
{'messages': [HumanMessage(content='你好,我是张三,我喜欢薛之谦的歌,我想和你聊聊薛之谦的歌。', additional_kwargs={}, response_metadata={}, id='7ce39e1d-08e6-4e5f-af49-fdd3c83c7417'), AIMessage(content='', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 26, 'prompt_tokens': 327, 'total_tokens': 353, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 128, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 128, 'prompt_cache_miss_tokens': 199}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': 'c81c4674-b1c4-4b81-9be1-f9826c577a8b', 'finish_reason': 'tool_calls', 'logprobs': None}, id='lc_run--01a1e879-14a5-7962-a640-68fbecc54068-0', tool_calls=[{'name': 'get_increse_chat_count', 'args': {}, 'id': 'call_00_twvU5KWVIc7Oc8THi3wl4841', 'type': 'tool_call'}], invalid_tool_calls=[], usage_metadata={'input_tokens': 327, 'output_tokens': 26, 'total_tokens': 353, 'input_token_details': {'cache_read': 128}, 'output_token_details': {}}), ToolMessage(content='Successfully updated agent state', name='get_increse_chat_count', id='11a08cac-f85e-4c13-94e3-21e039df7f50', tool_call_id='call_00_twvU5KWVIc7Oc8THi3wl4841'), AIMessage(content='你好,张三!很高兴认识你 😊 薛之谦的歌确实很有辨识度——旋律抓耳、歌词常常带着故事感和一点“自嘲式”的深情,很多人听着会很有共鸣。\n\n我们可以从几个角度聊:\n\n1. **你最喜欢的薛之谦歌曲是哪一首?** 是《演员》《丑八怪》《认真的雪》这类大热歌,还是偏冷门一点的?\n2. **你更喜欢他的“苦情歌”还是“幽默/反差感”强的作品?**\n3. **有没有哪句歌词特别戳你?** 比如《演员》里那种“感情里的表演感”,或者《刚刚好》里的克制与遗憾。\n\n你可以先说说你最近循环的是哪首、为什么喜欢,我可以陪你一起拆歌词、聊旋律,也可以帮你推荐同类型的歌。', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 171, 'prompt_tokens': 370, 'total_tokens': 541, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 128, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 128, 'prompt_cache_miss_tokens': 242}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': '12aa1dbe-215b-4b0b-9898-c38d116051bb', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--01a1e879-1795-7633-9a78-bcbe560868b2-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 370, 'output_tokens': 171, 'total_tokens': 541, 'input_token_details': {'cache_read': 128}, 'output_token_details': {}}), HumanMessage(content='你知道演员这首歌曲吗?', additional_kwargs={}, response_metadata={}, id='4f242c4e-6c86-4c7d-b298-34d0bbf58d67'), AIMessage(content='', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 26, 'prompt_tokens': 551, 'total_tokens': 577, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 384, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 384, 'prompt_cache_miss_tokens': 167}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': 'e4c265e5-1871-45c3-af40-6284844cafb0', 'finish_reason': 'tool_calls', 'logprobs': None}, id='lc_run--01a1e879-1ff1-7a21-b014-e078fa7479b5-0', tool_calls=[{'name': 'get_increse_chat_count', 'args': {}, 'id': 'call_00_edeXLEVjOAVR7pcBRBHj4021', 'type': 'tool_call'}], invalid_tool_calls=[], usage_metadata={'input_tokens': 551, 'output_tokens': 26, 'total_tokens': 577, 'input_token_details': {'cache_read': 384}, 'output_token_details': {}}), ToolMessage(content='Successfully updated agent state', name='get_increse_chat_count', id='90cde541-689c-4212-b4fb-7ecab7c214d6', tool_call_id='call_00_edeXLEVjOAVR7pcBRBHj4021'), AIMessage(content='当然知道,《演员》算是薛之谦最有代表性的作品之一了 🎵\n\n简单说几句我对这首歌的理解:\n\n- **发行背景**:收录在薛之谦 2015 年的专辑《绅士》里,也是他“第二次走红”后传唱度极高的一首歌,KTV 点唱率常年居高。\n- **核心主题**:用“演戏”来比喻一段已经变质的感情——一方在感情里“演”,一方明知却配合着“演”。“其实台下的观众就我一个”这句就很有画面感,把两个人的关系写成了独角戏。\n- **歌词亮点**:\n - “简单点,说话的方式简单点”——直白地要求对方别再绕弯子、别再演。\n - “你难过的太表面,像没天赋的演员”——又心疼又讽刺,情绪很复杂。\n - 整首歌其实是“看穿却不说破”的委屈感。\n- **旋律/编曲**:主歌压抑克制,副歌情绪释放,薛之谦那种带点沙哑、略带鼻音的唱腔把“隐忍的爆发”处理得很有味道。\n\n张三,你听《演员》的时候,最戳你的是哪一句?是“简单点”的那种直接,还是“台下的观众就我一个”的那种孤独感?我可以顺着你喜欢的点,再帮你聊聊他的其他歌 😊', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 290, 'prompt_tokens': 594, 'total_tokens': 884, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 384, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 384, 'prompt_cache_miss_tokens': 210}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': '7849fbd9-1ac4-467a-bc57-f5d395185b1c', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--01a1e879-225a-7cd1-be01-2310d84f1326-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 594, 'output_tokens': 290, 'total_tokens': 884, 'input_token_details': {'cache_read': 384}, 'output_token_details': {}}), HumanMessage(content='你知道我和你已经聊了多少次了吗?', additional_kwargs={}, response_metadata={}, id='a7cf961c-387f-4433-ae45-40c73946677a'), AIMessage(content='', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 26, 'prompt_tokens': 896, 'total_tokens': 922, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 640, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 640, 'prompt_cache_miss_tokens': 256}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': '64732ff0-28e3-4c69-8e19-84eddb22e1af', 'finish_reason': 'tool_calls', 'logprobs': None}, id='lc_run--01a1e879-2dc2-7e43-b033-a75f7cb51f02-0', tool_calls=[{'name': 'get_increse_chat_count', 'args': {}, 'id': 'call_00_ilSJvgexmKxPeJ0ZwYVn6770', 'type': 'tool_call'}], invalid_tool_calls=[], usage_metadata={'input_tokens': 896, 'output_tokens': 26, 'total_tokens': 922, 'input_token_details': {'cache_read': 640}, 'output_token_details': {}}), ToolMessage(content='Successfully updated agent state', name='get_increse_chat_count', id='31411b56-2ae8-4275-8097-b8228d83cb7b', tool_call_id='call_00_ilSJvgexmKxPeJ0ZwYVn6770'), AIMessage(content='从我这边的记录来看,咱们目前一共聊了 **3 次** 啦 😊\n\n- 第 1 次:你自我介绍,说喜欢薛之谦的歌\n- 第 2 次:你问我知不知道《演员》\n- 第 3 次:就是现在这次~\n\n不过我要说明一下:我是通过一个聊天计数工具来记录轮次的,所以这个“3 次”是从我这边统计到的次数。如果你指的是别的东西(比如某个平台的记录),那我可能就不一定对得上啦。\n\n聊薛之谦聊得还开心吗?要不要继续聊聊《演员》,或者换一首他的歌? 🎶', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 138, 'prompt_tokens': 939, 'total_tokens': 1077, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 768, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 768, 'prompt_cache_miss_tokens': 171}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': '43ccb997-4a08-4eae-8543-4fc1d8c5caa2', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--01a1e879-30be-73f1-bde1-2056d411117a-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 939, 'output_tokens': 138, 'total_tokens': 1077, 'input_token_details': {'cache_read': 768}, 'output_token_details': {}})], 'chat_count': 3}
-------第四轮--------
{'messages': [HumanMessage(content='你知道我和你已经聊了多少次了吗?', additional_kwargs={}, response_metadata={}, id='5122cbc1-75d7-4452-bd17-ab96f1537028'), AIMessage(content='', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 26, 'prompt_tokens': 316, 'total_tokens': 342, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 128, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 128, 'prompt_cache_miss_tokens': 188}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': 'c12df79b-f35d-4547-9e3c-b3aa62289eaf', 'finish_reason': 'tool_calls', 'logprobs': None}, id='lc_run--01a1e879-35bc-7650-83fc-3bdfdd1cc3c1-0', tool_calls=[{'name': 'get_increse_chat_count', 'args': {}, 'id': 'call_00_bsBEJunWdJX2wn4pYmo28282', 'type': 'tool_call'}], invalid_tool_calls=[], usage_metadata={'input_tokens': 316, 'output_tokens': 26, 'total_tokens': 342, 'input_token_details': {'cache_read': 128}, 'output_token_details': {}}), ToolMessage(content='Successfully updated agent state', name='get_increse_chat_count', id='53199b8d-c271-4526-82ac-161440317e1e', tool_call_id='call_00_bsBEJunWdJX2wn4pYmo28282'), AIMessage(content='我刚刚查了一下计数器——不过这个工具只返回了“状态已更新”的确认信息,并没有把具体的计数数字传回来,所以我这边看不到确切的次数。\n\n如果你希望我知道准确数字,可以告诉我,或者让我用别的方式帮你记录/查询聊天次数~', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 57, 'prompt_tokens': 359, 'total_tokens': 416, 'completion_tokens_details': None, 'prompt_tokens_details': {'audio_tokens': None, 'cache_write_tokens': None, 'cached_tokens': 128, 'image_tokens': None, 'text_tokens': None}, 'prompt_cache_hit_tokens': 128, 'prompt_cache_miss_tokens': 231}, 'model_provider': 'deepseek', 'model_name': 'deepseek-flash', 'system_fingerprint': 'bc19ba97cbe016479903222bb1578db6', 'id': '3cf7c28b-22c4-404b-b01e-9109001bbbbb', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--01a1e879-37d1-7e41-985e-df586bda8582-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 359, 'output_tokens': 57, 'total_tokens': 416, 'input_token_details': {'cache_read': 128}, 'output_token_details': {}})], 'chat_count': 1}
进程已结束,退出代码为 0
完整代码:
import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain.agents import AgentState
from langchain_core.messages import ToolMessage
from langgraph.prebuilt import ToolRuntime
from langchain.tools import tool
from langchain.agents import create_agent
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.types import Command
load_dotenv(encoding="utf-8")
#初始化模型
model = init_chat_model(model = "deepseek-flash",extra_body = {"thinking": {"type": "disabled"}})
#自定义State
class State(AgentState):
chat_count : int
#通过工具调用,增加模型计数
@tool
def get_increse_chat_count(runtime: ToolRuntime):
"""
在每一次调用模型的时候,都会调用这个工具来增加聊天计数器的值
:param runtime: 工具运行时对象
:return: 一个State对象,表示当前的聊天计数器值 ,但是因为AgentState类继承的是TypeDict,所以返回的State对象会被自动转换为字典类型
"""
state = runtime.state.get("chat_count",0) #获取当前的聊天计数器值,如果没有则默认为0
new_count = state + 1
update = {
"messages" :[
ToolMessage(content="Successfully updated agent state",tool_call_id = runtime.tool_call_id)
],
"chat_count": new_count
}
return Command(update = update)
#创建agent
agent = create_agent(model,
tools=[get_increse_chat_count],
state_schema=State,
checkpointer= InMemorySaver())
#state_schema=State表示状态数据类为State,agent在调用工具时会将状态数据类实例传入工具的runtime中。
#会话标识
config = {"configurable":{"thread_id":"1"}}
#模型调用
print("-------第一轮--------")
response = agent.invoke({"messages":"你好,我是张三,我喜欢薛之谦的歌,我想和你聊聊薛之谦的歌。"},
config )
print(response)
agent.get_state(config)
print("-------第二轮--------")
response =agent.invoke({"messages":"你知道演员这首歌曲吗?"}, config)
print(response)
agent.get_state(config)
print("-------第三轮--------")
response = agent.invoke({"messages":"你知道我和你已经聊了多少次了吗?"}, config)
print(response)
agent.get_state(config)
config2 = {"configurable":{"thread_id":"2"}}
print("-------第四轮--------")
response = agent.invoke({"messages":"你知道我和你已经聊了多少次了吗?"}, config2)
print(response)
agent.get_state(config2)
4.Store(长期记忆)
store是LangChain提供的长期记忆机制,用于在不同会话间共享数据。例如:模型以外的数据、用户偏好等。
例如,同一位用户可能先在 thread-a 中告诉 Agent“我喜欢代码示例优先”,几天后又在 thread-b 中开始新的课程咨询。
如果这条偏好只放在 State 中,新 thread 无法自动读取;把它写入 Store 后,两个 thread 都可以访问。
LangChain提供了多种Store的实现方式,例如:
-
InMemoryStore
-
PostgresStore
-
RedisStore
-
...
课程中我们以InMemoryStore为例来学习。
4.1Store的数据结构
Store的数据格式是JSON文档,JSON文档采用分级管理:
-
Namespace(命名空间):可以理解为一个文件夹
-
Key(键):可以理解为文件名,必须唯一
-
Value(值):要存储的JSON文档
-
所以,定位Store中的一条数据,需要两部分信息:namespace + key,其中namespace是一个元组,而key则是普通字符串。
例如,在多租户的在线教育Agent,我们要记录每个用户的学习偏好,namespace和key分别可以采用下面的组织方式。
| namespace | key | value |
|---|---|---|
|
| "learning_preferences" | {"内容顺序":"先写代码,再解释原理"} |
| "coding_preferences" | {"代码风格":"简洁但要有注释"} | |
|
| "learning_preferences" | {"...":"..."} |
| "coding_preferences" | {"...":"..."} |
USER_DATABASE = {
"school1":{"id_01":{"name":"张三","course" :"java实践"},
"id_02":{"name":"李四","course" :"python实践"}
},
"school2":{"id_01":{"name":"王五","course" :"c++实践"},
"id_02":{"name":"赵六","course" :"go实践"}
}
}
@dataclass(frozen=True) #定义用户内容数据类
class USERCONTEXT():
"""agent的用户内容数据类"""
school_id: str
user_id: str
Store 的设计是三层结构,但是它存储方式是可以有多种的。
一种是一条记录 → 唯一绑定一个 value。
优点:
- 可以单独增、删、改某一条记忆,互不影响
- 适合零散、独立的记忆片段(比如知识库片段、多条用户事实)
缺点:
- 想要一次性拿到全部记忆,必须提前知道所有 key 的名字,不方便
- 管理大量记忆时,key 会越来越多
namespace = ("school_a", "u001")
├─ key = "fav_singer" → value = "薛之谦"
├─ key = "fav_song" → value = "骆驼"
└─ key = "hobby" → value = "打篮球"

实现代码:
#写入工具代码
@tool
def save_memory_separate(
memory_key: str,
memory_value: str,
runtime: ToolRuntime[USERCONTEXT]
):
"""方案A:每条记忆单独作为store的一个key"""
namespace = get_user_id(runtime.context) # ("school_a", "u001")
# 直接用记忆名称作为store的key
runtime.store.put(namespace, memory_key, memory_value)
return f"保存成功:{memory_key} = {memory_value}"
#读取代码
@tool
def get_all_memory_separate(runtime: ToolRuntime[USERCONTEXT]):
namespace = get_user_id(runtime.context)
# get第二个参数是key列表,批量读取多条独立记录
items = runtime.store.get(namespace, ["fav_singer", "fav_song", "hobby"])
res = {}
for item in items:
res[item.key] = item.value
return f"用户记忆:{res}"
直接删除一条,不影响别的记忆
runtime.store.delete(namespace, "hobby")
另外一种方法是单个 Store Key,value 包一个字典
优点:
- 读取超级方便,一次 get 拿到用户全部偏好,适合用户画像、偏好配置
- 不用维护一堆零散的 store key
缺点:
- 修改、删除单条偏好,必须全量读出字典、改完再整体写回
- 并发场景下容易出现覆盖丢失(多人同时修改同一份字典)
namespace = ("school_a", "u001")
└─ key = "user_preference" → value = {
"fav_singer": "薛之谦",
"fav_song": "演员",
"hobby": "打游戏"
}

写入工具代码
@tool
def save_memory_in_dict(
pref_name: str,
pref_value: str,
runtime: ToolRuntime[USERCONTEXT]
):
"""方案B:全部偏好放在同一个store-key的字典里面"""
namespace = get_user_id(runtime.context)
STORE_KEY = "user_preference" # store层面固定唯一key
# 读取这个key对应的字典
items = runtime.store.get(namespace, [STORE_KEY])
if items:
pref_dict = items[0].value
else:
pref_dict = {}
在字典内部新增/修改字段
pref_dict[pref_name] = pref_value
把整个字典重新写回store(覆盖旧value)
runtime.store.put(namespace, STORE_KEY, pref_dict)
return f"已保存偏好:{pref_name}={pref_value},当前全部偏好:{pref_dict}"
#d读取代码
@tool
def get_all_memory_in_dict(runtime: ToolRuntime[USERCONTEXT]):
namespace = get_user_id(runtime.context)
STORE_KEY = "user_preference"
items = runtime.store.get(namespace, [STORE_KEY])
if items:
return f"用户偏好:{items[0].value}"
return "暂无偏好记忆"
#删除代码,不能直接删 store 里的一条 key,要先读字典 → 删除字典内字段 → 整字典写回去
namespace = get_user_id(runtime.context)
STORE_KEY = "user_preference"
items = runtime.store.get(namespace, [STORE_KEY])
pref_dict = items[0].value
del pref_dict["hobby"] # 在字典里面删掉这个子key
runtime.store.put(namespace, STORE_KEY, pref_dict) # 整体覆盖保存
下面我使用第二种方式进行演示。
4.2初始化Store
首先我们需要初始化Store
model = init_chat_model(model = "deepseek-flash",extra_body = {"thinking": {"type": "disabled"}})
store = InMemoryStore()
checkpointer = InMemorySaver()
store中有两个方法,分别用来读取和写入Store:
-
store.get(namespace, key):读取Store -
store.put(namespace, key, value):存入Store,这里的value必须是dict[str,Any]结构,而且dict中的值必须是可以转JSON的,LangChain会将其转JSON存储
4.3在tool中访问store
与 State 类似,访问 Store 也有两种场景:Tool 和中间件。这里先看 Tool,同样是通过 runtime 拿到 runtime.store。
在 Tool 中访问 Store 的要点:
-
runtime.store提供get/put/delete三个方法。 -
namespace是元组,通常由runtime.context中的school_id、user_id拼出来,实现按用户隔离。 -
put的 value 必须是可转 JSON 的dict。
下面这个工具把用户偏好写入 Store:
1.首先需要获取namespace
2.读取这个key对应的字典
3.更新字典中的字段
4.将字典重新写入Store中
@tool
def save_long_memory(
pref_name: str,
pref_value: str,
runtime: ToolRuntime[USERCONTEXT]
):
"""
保存长期记忆
:param pref_name: 偏好名称
:param pref_value: 偏好值
:param runtime: 工具运行时对象
:return: 保存成功的内容
"""
"""方案B:全部偏好放在同一个store-key的字典里面"""
namespace = get_user_id(runtime.context)
# 读取这个key对应的字典
items = runtime.store.get(namespace, STORE_KEY)
if items:
pref_dict = items.value
else:
pref_dict = {}
# 在字典内部新增/修改字段
pref_dict[pref_name] = pref_value
# 把整个字典重新写回store(覆盖旧value)
runtime.store.put(namespace, STORE_KEY, pref_dict)
return f"已保存偏好:{pref_name}={pref_value},当前全部偏好:{pref_dict}"
获取长期记忆:
获取长期记忆:
@tool
def get_long_memory(runtime: ToolRuntime[USERCONTEXT]):
"""
获取长期记忆
:param runtime: 工具运行时对象
:return: 长期记忆
"""
namespace = get_user_id(runtime.context) # 获通过上下文中的用户内容数据类实例获取或者构建命名空间
#通过namespace和key获取用户的长期记忆,返回结果是一个字典类型,如果没有则返回None
item = runtime.store.get(namespace, STORE_KEY)
preference = item.value if item else {}
return f"当前偏好列表为:{preference}"
4.4创建agent并测试
创建 Agent:调用 create_agent,把模型、工具、context_schema、checkpointer、store 和 system_prompt 一次性注册进去。
准备运行参数:构造 context,以及两个不同 thread_id 的 config,用来模拟同一会话和新会话。
前三轮写入记忆:在 thread_id=1 的会话里连续告诉 Agent 三条学习偏好,模型判断需要保存时调用 save_long_memory,把偏好写进 Store。
第四轮跨会话读取:换到 thread_id=2 这个全新会话,问“我的学习习惯是什么?”,模型调用 get_long_memory 从 Store 中读出之前保存的偏好,验证长期记忆跨会话可用。
第五轮综合应用:继续在新会话里让 Agent 讲解二分查找,观察它是否会结合 Store 中的偏好(先看代码、通俗易懂、结合代码)来组织回答。
agent = create_agent(
model = model,
tools=[get_user_profile,save_long_memory,get_long_memory],
context_schema=USERCONTEXT,
checkpointer = checkpointer,
store = store,
system_prompt= "你是课程帮助助手,在需要用户资料室调用资料工具,涉及长期学习偏好或者代码解释时调用长期记忆工具。"
)
context = USERCONTEXT(user_id="id_02", school_id="school1")
config1 = {"configurable":{"thread_id":"1"}}
config2 = {"configurable":{"thread_id":"2"}}
print("-------第一轮--------")
response = agent.invoke(
{
"messages" : [HumanMessage("我喜欢先看代码再看原理")]
},
config = config1,
context = context
)
for message in response["messages"]:
message.pretty_print()
print("-------第二轮--------")
response = agent.invoke(
{
"messages" : [HumanMessage("我喜欢讲解原理能够通俗易懂些")]
},
config = config1,
context = context
)
for message in response["messages"]:
message.pretty_print()
print("-------第三轮--------")
response = agent.invoke(
{
"messages" : [HumanMessage("我喜欢讲解原理能够结合代码")]
},
config = config1,
context = context
)
for message in response["messages"]:
message.pretty_print()
print("-------第四轮--------")
response = agent.invoke(
{
"messages" : [HumanMessage("我的学习习惯是什么?")]
},
config = config2,
context = context
)
for message in response["messages"]:
message.pretty_print()
print("-------第五轮--------")
response = agent.invoke(
{"messages" : [HumanMessage("给我讲解一下二分查找算法的原理和代码实现")]} ,
config = config2,
context = context
)
通过第四轮的对话就可以看出,我们的模型具有了跨对话的能力,也就具备长期记忆的功能。
================================ Human Message =================================
我的学习习惯是什么?
================================== Ai Message ==================================
Tool Calls:
get_long_memory (call_00_L4UpIP4sW73Nj7GnMLzP9493)
Call ID: call_00_L4UpIP4sW73Nj7GnMLzP9493
Args:
================================= Tool Message =================================
Name: get_long_memory
当前偏好列表为:{'学习顺序偏好': '喜欢先看代码再看原理(代码优先,然后讲解背后的原理)', '原理讲解风格偏好': '希望原理讲解通俗易懂:多用生活化类比、少用抽象术语堆砌,先讲直观理解再讲精确表述;且原理必须结合代码来讲(用代码片段/运行结果印证原理,避免纯理论空讲)'}
================================== Ai Message ==================================
根据长期记忆,你的学习习惯有两条:
1. 学习顺序:代码优先
> 喜欢先看代码,再看原理。也就是先拿到能跑的东西,再回头理解它为什么这么工作。
2. 原理讲解风格:通俗 + 结合代码
> - 通俗易懂:多用生活化类比,少堆抽象术语,先讲直观理解再给精确表述
> - 原理必须结合代码印证:用代码片段和运行结果来说明原理,不接受纯理论空讲
合起来就是你的理想讲解节奏:代码示例 → 类比讲清机制 → 每一点都回扣到代码 → 最后严谨补充。
要不要我按这个节奏给你讲一个具体主题?
完整代码:
from dataclasses import dataclass
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain.tools import tool
from langgraph.store.memory import InMemoryStore
from langgraph.prebuilt import ToolRuntime
from langgraph.checkpoint.memory import InMemorySaver
from langchain.agents import create_agent
from langchain_core.messages import SystemMessage, HumanMessage,AIMessage,ToolMessage
load_dotenv(encoding="utf-8")
model = init_chat_model(model = "deepseek-flash",extra_body = {"thinking": {"type": "disabled"}})
store = InMemoryStore()
checkpointer = InMemorySaver()
USER_DATABASE = {
"school1":{"id_01":{"name":"张三","course" :"java实践"},
"id_02":{"name":"李四","course" :"python实践"}
},
"school2":{"id_01":{"name":"王五","course" :"c++实践"},
"id_02":{"name":"赵六","course" :"go实践"}
}
}
@dataclass(frozen=True) #定义用户内容数据类
class USERCONTEXT():
"""agent的用户内容数据类"""
school_id: str
user_id: str
#根据context中的user_id和school_id获取用户的个人信息
def get_user_id(ctx: USERCONTEXT):
return (ctx.school_id, ctx.user_id)
STORE_KEY = "user_preference" # store层面固定唯一key
@tool
def get_user_profile(runtime : ToolRuntime[USERCONTEXT]):
"""
通过用户ID和学校ID获取用户的个人信息
:param runtime: 工具运行时对象
:return: 用户的个人信息
"""
cnt = runtime.context #获取上下文中的用户内容数据类实例
profile = USER_DATABASE.get(cnt.school_id).get(cnt.user_id)
return {
f"name: {profile["name"]}",
f"course: {profile["course"]}"
}
@tool
def save_long_memory(
pref_name: str,
pref_value: str,
runtime: ToolRuntime[USERCONTEXT]
):
"""
保存长期记忆
:param pref_name: 偏好名称
:param pref_value: 偏好值
:param runtime: 工具运行时对象
:return: 保存成功的内容
"""
"""方案B:全部偏好放在同一个store-key的字典里面"""
namespace = get_user_id(runtime.context)
# 读取这个key对应的字典
items = runtime.store.get(namespace, STORE_KEY)
if items:
pref_dict = items.value
else:
pref_dict = {}
# 在字典内部新增/修改字段
pref_dict[pref_name] = pref_value
# 把整个字典重新写回store(覆盖旧value)
runtime.store.put(namespace, STORE_KEY, pref_dict)
return f"已保存偏好:{pref_name}={pref_value},当前全部偏好:{pref_dict}"
@tool
def get_long_memory(runtime: ToolRuntime[USERCONTEXT]):
"""
获取长期记忆
:param runtime: 工具运行时对象
:return: 长期记忆
"""
namespace = get_user_id(runtime.context) # 获通过上下文中的用户内容数据类实例获取或者构建命名空间
#通过namespace和key获取用户的长期记忆,返回结果是一个字典类型,如果没有则返回None
item = runtime.store.get(namespace, STORE_KEY)
preference = item.value if item else {}
return f"当前偏好列表为:{preference}"
agent = create_agent(
model = model,
tools=[get_user_profile,save_long_memory,get_long_memory],
context_schema=USERCONTEXT,
checkpointer = checkpointer,
store = store,
system_prompt= "你是课程帮助助手,在需要用户资料室调用资料工具,涉及长期学习偏好或者代码解释时调用长期记忆工具。"
)
context = USERCONTEXT(user_id="id_02", school_id="school1")
config1 = {"configurable":{"thread_id":"1"}}
config2 = {"configurable":{"thread_id":"2"}}
print("-------第一轮--------")
response = agent.invoke(
{
"messages" : [HumanMessage("我喜欢先看代码再看原理")]
},
config = config1,
context = context
)
for message in response["messages"]:
message.pretty_print()
print("-------第二轮--------")
response = agent.invoke(
{
"messages" : [HumanMessage("我喜欢讲解原理能够通俗易懂些")]
},
config = config1,
context = context
)
for message in response["messages"]:
message.pretty_print()
print("-------第三轮--------")
response = agent.invoke(
{
"messages" : [HumanMessage("我喜欢讲解原理能够结合代码")]
},
config = config1,
context = context
)
for message in response["messages"]:
message.pretty_print()
print("-------第四轮--------")
response = agent.invoke(
{
"messages" : [HumanMessage("我的学习习惯是什么?")]
},
config = config2,
context = context
)
for message in response["messages"]:
message.pretty_print()
print("-------第五轮--------")
response = agent.invoke(
{"messages" : [HumanMessage("给我讲解一下二分查找算法的原理和代码实现")]} ,
config = config2,
context = context
)
for message in response["messages"]:
message.pretty_print()
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/2501_92746740/article/details/170919666



