LangChain 1.0 Agent开发流程

课程说明：

体验课内容节选自《2025大模型Agent智能体开发实战》(秋季班) 完整版付费课程

体验课时间有限，若想深度学习大模型技术，欢迎大家报名由我主讲的《2025大模型Agent智能体开发实战》(秋季班)

《2025大模型Agent智能体开发实战》(秋招冲刺班) 为【100+小时】体系大课，总共20大模块精讲精析，零基础直达大模型企业级应用！

课程完整介绍

秋季班重磅新增14项实战案例

部分课程成果演示

from IPython.display import Video

Dify+DeepSeek搭建智能微信语音客服

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/2f1b47f42c65fd59e8d3a83e6cb9f13b_raw.mp4", width=800, height=400)

Coze自动图文视频创作流程

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/Coze%E5%8A%A8%E6%80%81%E8%A7%86%E9%A2%91%E7%94%9F%E6%88%90%E5%AE%9E%E4%BE%8B.mp4", width=800, height=400)

可视化数据分析Multi-Agent

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/%E5%8F%AF%E8%A7%86%E5%8C%96%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90Multi-Agent%E6%95%88%E6%9E%9C%E6%BC%94%E7%A4%BA%E6%95%88%E6%9E%9C.mp4", width=800, height=400)

高效微调全自动数据集创建

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/easy_daset_yanshi.mp4", width=800, height=400)

MateGen Pro 项目功能演示

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/MG%E6%BC%94%E7%A4%BA%E8%A7%86%E9%A2%91.mp4", width=800, height=400)

智能客服项目展示

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/%E6%99%BA%E8%83%BD%E5%AE%A2%E6%9C%8D%E6%A1%88%E4%BE%8B%E8%A7%86%E9%A2%91.mp4", width=800, height=400)

GraphRAG+多模态文档检索

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/7%E6%9C%8817%E6%97%A5%281%29%20%E8%BF%9B%E5%BA%A6%E6%9D%A1.mp4", width=800, height=400)

此外，若是对大模型底层原理感兴趣，也欢迎报名由我和菜菜老师共同主讲的《2025大模型原理与实战课程》(秋季班)

详细信息扫码添加助教，回复“大模型”，即可领取课程大纲&查看课程详情👇

LangChain 1.0入门实战

Part 4.LangChain 1.0 Agent开发流程

1. LangChain 1.0最大更新：全新Agent框架介绍

import os
from dotenv import load_dotenv 
load_dotenv(override=True)

在 LangChain 1.0 中，最大的变化肯定是推出了全新的Agent API：create_agent。至此，LangChain Agent就已经不再是早期那种“带点魔法味的模型调用器”，它正式被定义为：一个可感知上下文、具备行动能力、可扩展、可插拔的智能运行体（Intelligent Runtime Unit）。简单来说，Agent 不再只是“用大模型回答问题”，而是能根据任务动态调用工具、推理决策、规划步骤，并与外部世界进行交互的 自治式执行体。

LangChain Agent API大一统

LangChain 在 1.0 版本中，将所有 Agent 的创建方式统一为了一个入口——create_agent()。它取代了旧版本中的 create_react_agent、create_json_agent、create_tool_calling_agent 等多种分支函数，真正让开发者用一行代码即可创建任何类型的智能体。

在 LangChain 0.x 时代，框架内的 Agent 系统经历了“碎片化”阶段。当时的设计理念是 “针对场景设计特定 Agent”——如果你要实现思维链推理（ReAct），就用 create_react_agent；如果需要结构化输出，就用 create_structured_chat_agent；要工具调用，则用 create_tool_calling_agent。这种方式灵活，但也带来了三个明显问题：

心智负担高——每种 Agent 都要单独记忆 API 与参数；
可组合性差——多个 Agent 之间无法统一调度；
生态碎片化——不同模块难以复用或协同演化。

而进入 LangChain 1.0 后，团队做出了彻底重构：将所有 Agent 的创建入口合并为 create_agent()，同时在底层通过“中间件机制（Middleware）”和“标准模型接口（invoke / stream）”实现全局统一。这让框架更轻、更稳，也更易于被集成到其他 Agent 平台中。

create_agent API极简调用流程

而LangChain 1.0中的create_agent API的实际调用过程也非常简单，从代码层面来看，我们只需要将模型和工具拼接到一起，即可完成Agent创建：

# 1.导入相关库
from langchain.agents import create_agent
from langchain_deepseek import ChatDeepSeek
from langchain_community.tools.tavily_search import TavilySearchResults

# 2.导入模型和工具
web_search = TavilySearchResults(max_results=2)
model = ChatDeepSeek(model="deepseek-chat")

# 3.创建Agent
agent = create_agent(
    model=model,
    tools=[web_search],
    system_prompt="你是一名多才多艺的智能助手，可以调用工具帮助用户解决问题。"
)

# 4.运行Agent获得结果
result = agent.invoke(
    {"messages": [{"role": "user", "content": "请帮我查询2024年诺贝尔物理学奖得主是谁？"}]}
)

result['messages'][-1].content

create_agent API底层LangGraph架构

而从底层架构来看，从 LangChain 1.0 开始，官方对框架的整体架构进行了根本性的角色重置：LangGraph 被正式确立为 LangChain 的底层运行框架（Runtime Foundation），而非附属扩展。在 0.x 时代，LangGraph 还被视作 LangChain 的“高层封装”——它是开发者在 LangChain 基础上进一步实现复杂 Agent 编排、状态流转与多节点控制的可选工具；换言之，那时 LangChain 是核心、LangGraph 是外挂。而进入 1.0 之后，情况彻底反转：LangGraph 被下沉为 LangChain 的底层执行引擎，一切新的高级 API（包括统一的 create_agent()、中间件系统、状态管理机制、流式回调与事件调度等）都直接运行在 LangGraph 架构之上。这样一来，LangChain 不再只是一个“Prompt 组织与调用库”，而是一个基于图结构的智能体运行时系统：每个 Agent 的生命周期、每次模型调用、每个工具执行，都是图中一个节点或边的执行过程。LangGraph 提供了稳定的调度、状态传递与事件流控制，而 LangChain 则提供了上层接口与开发体验。也就是说，上述Agent的实际运行逻辑，如果用LangGraph的语言来描述就是：

这种统一架构并以LangGraph为底层框架带来的优势如下：

接口统一，降低心智负担
- 无论是工具型、规划型还是对话型 Agent，都用同一个入口创建。
- 开发者不再需要区分不同 Agent 的实现逻辑。
跨生态兼容性增强
- LangChain 1.0 的 Agent 架构与 LangGraph、LangServe、甚至 OpenAI Responses API 都完全兼容。
- 这意味着同一个 Agent 可以同时运行在命令行、Web UI、LangGraph 节点或云端推理环境中。
中间件机制的加入
- 新版本允许通过装饰器或中间件在 Agent 生命周期中插入逻辑：如日志、速率限制、记忆压缩、PII 审查、内容重写等。
- 这使得 Agent 更像一个“微型操作系统进程”，具备可观察性与可管理性。
可扩展性与定制性更强
- 统一 API 底层基于标准化状态流（State Graph），这意味着用户可以自由地扩展 Agent 行为而不破坏核心逻辑。

create_agent API与Agents SDK、ADK对比

并且，LangChain 1.0 的 create_agent() 与 OpenAI 的 client.agents.create()、Google ADK 的 Agent.create() 在形式上极为相似：都是 “传入模型 + 工具 + 说明 → 获得一个可交互 Agent 实例”。但 LangChain 的优势在于——它不仅是一个调用层 SDK，而是一个 完备的 Agent Runtime 框架。

维度	LangChain 1.0	OpenAI Agents SDK	Google ADK
定位	完整 Agent Runtime（含状态流、中间件、LangGraph）	平台级 SDK	研究级 Agent 构建工具
创建方式	`create_agent(model, tools, system_prompt)`	`client.agents.create(...)`	`Agent.create(tools, model, config)`
状态管理	AgentState + Graph	隐式	Context Graph
中间件支持	✅ 丰富的 before/after hooks	❌（需手动实现）	✅ 部分支持
生态完备性	🟢 极高（内置工具库、RAG模块、Serve接口）	中等	中等

因此我们可以说：LangChain 1.0 的 Agent 系统兼具 OpenAI SDK 的易用性 + Google ADK 的可扩展性 + 自身生态的完整性。 它不只是“能用”，更是“能跑得久、能部署、能运维”的生产级智能体框架。

Agent Runtime框架：create_agent

而从官方的角度进行解释，LangChain 1.0中的Agent系统是一个Agent Runtime框架。在计算机领域中，Runtime 通常指的是一段代码运行所依赖的执行环境，它负责管理：

程序的生命周期（从初始化 → 执行 → 结束）；
内部状态的维护；
与外部资源的交互（输入、输出、网络、文件等）；
异常处理、事件调度、中断恢复等底层细节。

而Agent Runtime 框架 = 让智能体能够持续运行、思考、决策、调用工具、保持状态的底层执行系统。它不是一个“函数库”，而是一整套管理 Agent 生命周期与执行流程的框架。当然其中主要得益于LangChain 1.0 Agent框架继承了此前LangGraph的全套开发框架、并在此基础上增加了中间件Middleware，使得Agent开发和运行过程更加可控。

2. create_agent API模型接入方法

在 LangChain 1.0 中，Agent（智能体）不再只是调用模型的脚本，而是一个能理解任务、推理路径、调用工具并自主完成目标的系统。每个 Agent 都包含一个循环结构（Agent Loop）：模型会根据当前输入进行推理，决定是否调用工具、如何解析观察结果，并不断迭代，直到满足“停止条件”（Stop Condition），也就是模型生成最终答案，或达到设定的迭代次数上限。

LangChain 1.0 提供了全新的 create_agent() 接口，这是一个可用于生产环境的标准化智能体构造函数。通过它，你可以用极简的方式创建一个完整的、可运行的智能体系统。create_agent 会在内部使用 LangGraph 构建一个基于图结构的 Agent Runtime，它以节点（Node）和边（Edge）的形式定义整个推理流程：

节点（Node）：代表执行步骤，例如模型调用节点、工具执行节点或中间件节点；
边（Edge）：代表执行流程与状态流转；
图（Graph）：定义了 Agent 如何在这些节点之间流动、推理和决策。

换而言之，LangChain 的每个 Agent 都是一张有向图，语言模型是推理引擎，工具是行动节点，而底层则是通过LangGrph进行的编写和实现。

在 create_agent() 的底层运行机制中，最重要的三个组件分别是：

模型（Model）

模型是 Agent 的“大脑”，负责理解任务与决策推理。它既可以是静态模型（固定不变），也可以是动态模型（根据上下文切换）。

工具（Tools）

工具是 Agent 的“手脚”。模型可以选择调用不同工具来实现特定子任务，例如：

web_search() → 进行联网搜索
calculate() → 计算公式
database_query() → 查询数据源

中间件（Middleware）

中间件类似于“神经系统”，它可以在模型调用前后拦截请求、修改参数、或动态调整模型选择逻辑，是 LangChain 1.0 的强大扩展机制。

create_agent支持两种模型使用模式：静态模型（Static Model）与动态模型（Dynamic Model）。其中静态模型在创建 Agent 时配置一次，并在整个执行过程中保持固定。这种方式简单稳定，适合实验和一般生产场景。例如 FENCE0

此时LangChain 会自动识别 "deepseek-chat" 并推断其完整标识 "deepseek:deepseek-chat"。这种方式适合快速构建 Demo 或标准化模型调用。

完整静态模型字符串映射详见：https://reference.langchain.com/python/langchain/models/?_gl=1*125pi5n*_gcl_au*MTI5ODI4NTA5Ny4xNzYxMjA1ODI2*_ga*MTc2OTg3MTQ2OS4xNzYxMzc5MDEw*_ga_47WX3HKKY2*czE3NjE2MzMwNDQkbzYkZzEkdDE3NjE2MzczMzUkajYwJGwwJGgw#langchain.chat_models.init_chat_model(model_provider)

另外，在静态模型调用过程中，也可以类似此前的示例中展示的调用过程，先实例化模型，然后再将实例化后的模型带入create_agent中创建Agent，此时我们就可以在创建模型的环节进行更多的参数设置，例如：

FENCE0

而除此之外，LangChain 1.0的create_agent API还提供了动态模型的方式，这是一种更高级的机制，它允许 Agent 在运行时根据任务上下文自动切换模型，实现智能的模型路由与成本优化。例如对话初期使用轻量模型（如 gpt-4o-mini）以节省成本；当上下文变复杂或任务难度提升时，自动切换到更强模型（如 gpt-4o）。而此时就需要使用到中间件的@wrap_model_call装饰器，这部分内容我们将放在下一小节进行介绍。

3. create_agent接入内置工具与Agent创建流程

当然，只有接入了一些工具，才能使用create_agent完成Agent创建（如果只是进行模型调用，可以采用上一小节介绍的model.invoke进行调用）。

这里我们首先介绍一个最基本的LangChain接入工具流程——接入LangChain内置的工具集。其实在MCP爆火之前，LangChian生态中就已经内置集成了非常多的实用工具，开发者可以快速调用这些工具完成更加复杂工作流的开发。

LangChain内置工具列表：https://python.langchain.com/docs/integrations/tools/

其中典型的工具如下：

领域	工具名称	功能说明
搜索引擎与信息检索	🔹 DuckDuckGo Search	免费搜索引擎，返回网页标题、摘要与链接，常用于联网问答。
	🔹 Brave Search API	提供隐私友好的网页搜索结果，可配置输出深度与过滤。
	🔹 Bing Search Tool	微软 Bing 搜索接口，支持精确检索与多语言查询。
网页浏览与内容提取	🔹 Playwright Browser Toolkit	提供浏览器自动化访问、网页截图与文本抓取功能。
	🔹 Selenium Toolkit	类似于 Playwright，但偏向传统网页 DOM 操控。
生产力工具集成	🔹 Slack Toolkit	允许 Agent 在 Slack 中发送、读取或总结消息。
	🔹 Jira Toolkit	用于查询、创建或更新 Jira 项目工单。
	🔹 Google Drive / Docs Toolkit	操作 Google 文档、表格与文件搜索。
数据库与数据操作	🔹 SQLDatabase Toolkit	连接 SQL 数据库，自动生成并执行 SQL 查询。
	🔹 Faiss / Chroma / Milvus VectorStore Tools	进行向量相似度搜索，用于 RAG 检索。
代码与终端执行	🔹 Python REPL Tool	执行 Python 代码片段并返回结果（沙盒环境）。
	🔹 Shell Tool (Bash)	允许执行 Shell 命令（需安全限制）。
	🔹 Requests Wrapper Tool	发起 HTTP 请求、API 调用，用于外部数据交互。
多模态工具	🔹 DALL-E Tool	生成图像，可结合文本描述创作内容。
	🔹 SerpAPI Image Search	图片搜索引擎，可返回图片 URL 与元信息。
	🔹 OpenAI Whisper Tool	音频转录工具，将语音文件转换为文本。
知识问答与嵌入检索	🔹 VectorStoreRetrieverTool	基于嵌入模型检索文档片段，用于 RAG 问答。
	🔹 MultiQueryRetrieverTool	生成多种查询变体以提升检索覆盖率。
云与AI服务	🔹 OpenAI Functions / Azure Functions Tool	让 Agent 调用 OpenAI 或 Azure 定义的函数。
	🔹 Anthropic ToolKit	集成 Claude 模型工具调用能力。
文件系统与数据处理	🔹 CSV Toolkit	读取、过滤与分析 CSV 文件数据。
	🔹 Pandas DataFrame Agent Tool	直接在 DataFrame 上执行查询与统计任务。

我们就以其中网络搜索工具为例，来介绍如何将内置工具接入create_agent中。

# !pip install -qU langchain-community langchain-experimental pandas -i https://pypi.tuna.tsinghua.edu.cn/simple

LangChain中内置了TavilySearchResults搜索工具，可以借助Tavily进行网络搜索和信息爬取。这里我们需要先在tavily官网注册并获得API-KEY（每月有免费额度）：https://www.tavily.com/

然后将API-KEY写到本地.env中的TAVILY_API_KEY变量中。然后即可进行调用了。

from langchain_community.tools.tavily_search import TavilySearchResults
web_search = TavilySearchResults(max_results=2)

web_search?

这是一个高度封装的网络搜索工具，可以直接调用：

web_search.invoke("请问截至目前，2025年诺贝尔奖颁发了几个？")

也可以直接带入create_agent中作为外部工具。

# 1.导入相关库
from langchain.agents import create_agent
from langchain_deepseek import ChatDeepSeek
from langchain_community.tools.tavily_search import TavilySearchResults

# 2.导入模型和工具
web_search = TavilySearchResults(max_results=2)
model = ChatDeepSeek(model="deepseek-chat")

# 3.创建Agent
agent = create_agent(
    model=model,
    tools=[web_search],
    system_prompt="你是一名多才多艺的智能助手，可以调用工具帮助用户解决问题。"
)

# 4.运行Agent获得结果
result = agent.invoke(
    {"messages": [{"role": "user", "content": "请帮我查询2024年诺贝尔物理学奖得主是谁？"}]}
)

result['messages'][-1].content

而如果仔细观察本次运行过程，本次工具调用仍然是一次典型的Function calling执行流程，包括用户首次发起消息在内，总共创建了4条消息，分别是user message、function call message、function response message以及final responses：

result['messages']

len(result['messages'])

result['messages'][0]

result['messages'][1]

result['messages'][2]

result['messages'][3]

一次完整的Function calling执行流程如下：

更多大模型底层调用工具原理、流程、Fucntion calling原理介绍，对更深度内容感兴趣的同学欢迎报名《2025大模型Agent智能体开发实战》(秋季班) 付费课程进行学习。

4. create_agent接入自定义工具与React循环介绍

我们都知道，能调用外部工具，是大模型进化为智能体Agent的关键，如果不能使用外部工具，大模型就只能是个简单的聊天机器人，甚至连查询天气都做不到。由于底层技术限制，大模型本身是无法和外部工具直接通信的，因此Function calling的思路，就是创建一个外部函数（function）作为中介，一边传递大模型的请求，另一边调用外部工具，最终让大模型能够间接的调用外部工具。

例如，当我们要查询当前天气时，让大模型调用外部工具的function calling的过程就如图所示：

因此所谓的接入自定义外部工具，核心我们需要创建的就是这个能够调用外部工具API的外部函数。一个典型的能够查询实时天气信息的外部函数如下：

这里需要先登录openweather官网获取API-KEY：https://home.openweathermap.org/ ，然后将其写入.env中的OPENWEATHER_API_KEY变量中。

import os
from dotenv import load_dotenv 
load_dotenv(override=True)

OPENWEATHER_API_KEY = os.getenv("OPENWEATHER_API_KEY")

import requests,json

def get_weather(loc):
    """
    查询即时天气函数
    :param loc: 必要参数，字符串类型，用于表示查询天气的具体城市名称，\
    注意，中国的城市需要用对应城市的英文名称代替，例如如果需要查询北京市天气，则loc参数需要输入'Beijing'；
    :return：OpenWeather API查询即时天气的结果，具体URL请求地址为：https://api.openweathermap.org/data/2.5/weather\
    返回结果对象类型为解析之后的JSON格式对象，并用字符串形式进行表示，其中包含了全部重要的天气信息
    """
    # Step 1.构建请求
    url = "https://api.openweathermap.org/data/2.5/weather"

    # Step 2.设置查询参数
    params = {
        "q": loc,               
        "appid": os.getenv("OPENWEATHER_API_KEY"),    # 输入API key
        "units": "metric",            # 使用摄氏度而不是华氏度
        "lang":"zh_cn"                # 输出语言为简体中文
    }

    # Step 3.发送GET请求
    response = requests.get(url, params=params)
    
    # Step 4.解析响应
    data = response.json()
    return json.dumps(data)

get_weather("Beijing")

紧接着将其封装为LangChain能够识别的外部函数：

from langchain.tools import tool

@tool
def get_weather(loc):
    """
    查询即时天气函数
    :param loc: 必要参数，字符串类型，用于表示查询天气的具体城市名称，\
    注意，中国的城市需要用对应城市的英文名称代替，例如如果需要查询北京市天气，则loc参数需要输入'Beijing'；
    :return：OpenWeather API查询即时天气的结果，具体URL请求地址为：https://api.openweathermap.org/data/2.5/weather\
    返回结果对象类型为解析之后的JSON格式对象，并用字符串形式进行表示，其中包含了全部重要的天气信息
    """
    # Step 1.构建请求
    url = "https://api.openweathermap.org/data/2.5/weather"

    # Step 2.设置查询参数
    params = {
        "q": loc,               
        "appid": os.getenv("OPENWEATHER_API_KEY"),    # 输入API key
        "units": "metric",            # 使用摄氏度而不是华氏度
        "lang":"zh_cn"                # 输出语言为简体中文
    }

    # Step 3.发送GET请求
    response = requests.get(url, params=params)
    
    # Step 4.解析响应
    data = response.json()
    return json.dumps(data)

print(get_weather.name)
print(get_weather.description)
print(get_weather.args)

然后即可直接带入到create_agent中，创建一个简易的天气查询Agent：

# 1.导入相关库
from langchain.agents import create_agent
from langchain_deepseek import ChatDeepSeek
from langchain_community.tools.tavily_search import TavilySearchResults

# 2.导入模型
model = ChatDeepSeek(model="deepseek-chat")

# 3.创建Agent
agent = create_agent(
    model=model,
    tools=[get_weather],
    system_prompt="你是一名多才多艺的智能助手，可以调用工具帮助用户解决问题。"
)

# 4.运行Agent获得结果
result = agent.invoke(
    {"messages": [{"role": "user", "content": "请问北京今天天气如何？"}]}
)

result['messages'][-1].content

而同样，这也是一个典型的Fucntion calling流程。

len(result['messages'])

而对于create_agent API来说，其工具调用的核心逻辑也是React循环工具调用，即可以在简短的推理步骤和有针对性的工具调用之间交替，并将得到的观察结果反馈到后续决策中，直到他们能够给出最终答案。并且具备如下特性：

按顺序调用多个工具（由单个提示触发）
适当时并行调用工具
根据先前结果进行动态工具选择
工具重试逻辑和错误处理
跨工具调用的状态持久性

例如：

result = agent.invoke(
    {"messages": [{"role": "user", "content": "请问今天杭州和南昌哪里更冷？"}]}
)

result['messages'][-1].content

此时Agent进行了多工具的并发调用。

result

接下来继续尝试进行工具的多步调用：

import os
from datetime import datetime

@tool
def write_file(content: str) -> str:
    """
    将指定内容写入本地文件。
    :param content: 必要参数，字符串类型，用于表示需要写入文档的具体内容。
    :return: 写入结果提示信息。
    """
    try:
        # ✅ 始终先定义文件名（防止未绑定变量）
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"output_{timestamp}.txt"

        # 写入文件
        with open(filename, "w", encoding="utf-8") as f:
            f.write(content)

        abs_path = os.path.abspath(filename)
        return f"✅ 已成功写入本地文件：{abs_path}"

    except Exception as e:
        return f"❌ 文件写入失败：{str(e)}"

agent = create_agent(
    model=model,
    tools=[get_weather, write_file],
    system_prompt="你是一名多才多艺的智能助手，可以调用工具帮助用户解决问题。"
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "请帮我查询天津、石家庄、上海等地天气，并写入本地文件。"}]}
)

result['messages'][-1].content

而此时就经历了两轮Function calling，也就是先查询天气、然后写入到本地文件中。

len(result['messages'])

而如果出现调用工具报错，则一般会尝试2-3次之后停止尝试。此外，关于调用工具报错信息的输出格式、以及控制报错响应流程，都可以使用稍后介绍的中间件来完成。

result['messages']

5.create_agent记忆管理

在实际进行Agent开发时，还有一项工作至关重要，那就是需要管理智能体的记忆。

from langgraph.checkpoint.memory import InMemorySaver

checkpointer = InMemorySaver()

tools = [get_weather]

agent = create_agent(model=model, 
                     tools=tools,
                     checkpointer=checkpointer)

config = {
    "configurable": {
        "thread_id": "1"  
    }
}

response = agent.invoke(
    {"messages": [{"role": "user", "content": "你好，我叫陈明，好久不见！"}]},
    config
)

response['messages']

response['messages'][-1].content

此时记忆就自动保存在当前Agent和线程中：

latest = agent.get_state(config)

latest

当我们再次进行对话时，直接带入线程ID，即可带入此前对话记忆：

response = agent.invoke(
    {"messages": [{"role": "user", "content": "你好，请问你还记得我叫什么名字么？"}]},
    config
)

response['messages']

response['messages'][-1].content

latest = agent.get_state(config)
latest

而如果更新线程ID，则会重新开启对话：

config2 = {
    "configurable": {
        "thread_id": "2"  
    }
}

response2 = agent.invoke(
    {"messages": [{"role": "user", "content": "你好，你还记得我叫什么名字么？"}]},
    config2
)

response2['messages']

此外，关于记忆的管理，往往还涉及记忆持久化存储、跨线程记忆管理、修建&总结历史记录、设置用户偏好记忆、记忆修改、语义搜索、数据加密、快照回复、人机交互（Human in loop）等功能，受限于公开课时间，无法具体展开介绍，感兴趣的同学可以参与付费课程进行更深入的学习，欢迎大家报名由我主讲的《2025大模型Agent智能体开发实战》(秋季班) ，下图扫码即可咨询。

课程说明：​

课程完整介绍​

秋季班重磅新增14项实战案例​

部分课程成果演示​

LangChain 1.0入门实战

Part 4.LangChain 1.0 Agent开发流程​

1. LangChain 1.0最大更新：全新Agent框架介绍​

2. create_agent API模型接入方法​

3. create_agent接入内置工具与Agent创建流程​

4. create_agent接入自定义工具与React循环介绍​

5.create_agent记忆管理​