LangChain的开发实战-含ChainAgentMemory

LangChain开发实战——含Chain/Agent/Memory

标签：LangChain|Chain|Agent|Memory|LCEL|大模型开发|2026最新

日期：2026年9月22日

一句话简介：从LCEL管道组合、create_agent智能体构建到短期/长期记忆管理，系统讲解LangChain1.0的三大核心

模块——每种Chain都有可复制的代码模板，每个Agent都有完整的工具定义示例，Memory的短期与长期方案逐一拆

解。

关键词/标签：LangChain实战、LCEL管道、create_agent、Agent工具调用、短期记忆、长期记忆、Checkpointer、

中间件

适用人群：大模型应用开发者、Python开发者、AI产品经理、需要构建LLM应用的工程团队、从零开始学习

LangChain的开发者

文档类型：教程攻略类

目录

第一章：LangChain1.0架构全景与版本迁移

第二章：Chain实战——LCEL管道组合

第三章：LCEL进阶——并行/分支/结构化输出

第四章：Agent实战——create_agent与工具调用

第五章：Agent中间件——上下文工程的核心机制

第六章：Memory实战——短期记忆与长期记忆

第七章：完整项目实战——智能电商客服系统

第八章：避坑指南——10个常见错误及正确做法

第九章：常见问题解答

附录：速查表

第一章：LangChain1.0架构全景与版本迁移

1.1LangChain1.0的核心变化

LangChainv1于2025年10月发布，是一个专注于构建智能体的生产就绪基础框架。官方围绕三个核心改进精简了框

架：新的标准智能体创建方式、统一的内容块、以及简化的包结构。

变化项旧版本v1.0

智能体创建create_react_agent（LangGraph）create_agent（langchain包）

AgentExecutor主要入口维护模式至2026年12月，新代码不应使用

包结构langchain包含大量传统功能精简为核心构建块，传统功能移至langchain-classic

提示词参数promptsystemPrompt

结构化输出提示词输出toolStrategy/providerStrategy

关键迁移要点：所有新的LangChain智能体都运行在LangGraph运行时之上。create_agent是v1.0中构建智能体的

标准方式，它生成的底层是一个LangGraph状态机，开箱即用地支持流式输出、持久化和可观测性。

1.2生态全景

2026年的LangChain生态已形成清晰的分层架构：

层级组件职责

核心框架LangChain1.0模型抽象、提示词、工具、RAG组件、LCEL

编排运行时LangGraph1.0将流程变为图，支持持久化、人工介入、流式

智能体入口create_agent智能体工厂+中间件

可观测平台LangSmith追踪、评测、数据集

学习顺序建议：ChatModel→Prompt→Tool→RAG→LCEL→LangGraph→create_agent。

1.3安装与环境配置

#安装LangChain1.0

pipinstall-Ulangchain

#安装模型集成包（按需选择）

pipinstalllangchain-openai

#OpenAI

pipinstalllangchain-anthropic

#AnthropicClaude

pipinstalllangchain-community

#社区集成

#安装LangGraph运行时

pipinstalllanggraph

环境变量配置（以OpenAI为例）：

importos

os.environ["OPENAI_API_KEY"]="sk-..."

#替换为实际密钥

1.4模型统一接口

LangChain1.0通过init_chat_model提供统一的模型接口，业务代码不需要知道背后是OpenAI、Anthropic还是国

产模型：

fromlangchain.chat_modelsimportinit_chat_model

#统一接口，模型标识格式：provider:model

model=init_chat_model("openai:gpt-4o")

model=init_chat_model("claude-sonnet-4-6")

model=init_chat_model("google_genai:gemini-2.5-flash-lite")

model=init_chat_model("ollama:llama3")

#三种调用方式

resp=model.invoke("LangChain是什么？")

#一次调用

forchunkinmodel.stream("讲个故事"):

#流式输出

print(chunk.content,end="")

resp=model.batch(["问题1","问题2","问题3"])

#批量调用

第二章：Chain实战——LCEL管道组合

2.1LCEL的核心逻辑

LCEL（LangChainExpressionLanguage）是LangChain1.0推荐的链组合方式，采用管道操作符|将组件串联。每个

组件（提示词、模型、解析器、检索器）都实现了Runnable接口，前一步的输出自动作为后一步的输入。

chain=prompt|model|output_parser

2.2基础Chain——单步管道

fromlangchain_mptsimportChatPromptTemplate

fromlangchain_openaiimportChatOpenAI

fromlangchain_core.output_parsersimportStrOutputParser

#1.定义提示词模板

prompt=ChatPromptTemplate.from_template(

"用一句话介绍{city}这个城市的特点。"

)

#2.初始化模型

model=ChatOpenAI(model="gpt-4o-mini",temperature=0.7)

#3.定义输出解析器

parser=StrOutputParser()

#4.用管道符组合Chain

chain=prompt|model|parser

#5.调用

result=chain.invoke({"city":"杭州"})

print(result)

执行流程：提示词模板将{city}替换为“杭州”→模型生成回答→解析器提取字符串内容。

2.3多步骤Chain——顺序流水线

多步骤Chain将多个操作串联，前一步的输出作为后一步的输入。以下示例实现“总结→翻译”两步任务：

fromlangchain_mptsimportChatPromptTemplate

fromlangchain_openaiimportChatOpenAI

model=ChatOpenAI(model="gpt-4o-mini")

#第一步：总结

summarize_prompt=ChatPromptTemplate.from_template(

"请总结以下文本的核心内容：\n\n{text}"

)

summarize_chain=summarize_prompt|model

#第二步：翻译

translate_prompt=ChatPromptTemplate.from_template(

"请将以下内容翻译成英文：\n\n{summary}"

)

translate_chain=translate_prompt|model

#组合：总结→数据映射→翻译

full_chain=(

summarize_chain

|(lambdax:{"summary":x.content})

|translate_chain

)

result=full_chain.invoke({"text":"气候变化正在导致海洋快速升温..."})

print(result.content)

关键点：(lambdax:{"summary":x.content})是数据映射步骤，将上一步的ChatMessage对象转换为下一步需

要的字典格式。

2.4RunnablePassthrough——传递原始输入

RunnablePassthrough用于在链中传递原始输入，常用于需要同时保留原始问题和检索结果的场景：

fromlangchain_core.runnablesimportRunnablePassthrough

chain=(

{"context":retriever,"question":RunnablePassthrough()}

|prompt

|model

|parser

)

这里RunnablePassthrough()将用户的原始问题原样传递给提示词模板的{question}变量。

2.5RunnableLambda——自定义处理函数

RunnableLambda允许将普通Python函数嵌入LCEL管道：

fromlangchain_core.runnablesimportRunnableLambda

defclean_text(text):

returntext.strip().lower()

defcount_words(text):

return{"text":text,"word_count":len(text.split())}

chain=(

RunnableLambda(clean_text)

|RunnableLambda(count_words)

|prompt

|model

)

2.6不带LLM的Chain

并非所有Chain都必须包含LLM。预处理和后处理流水线同样可以用LCEL构建：

defremove_extra_spaces(text):

return"".join(text.split())

defto_lowercase(text):

returntext.lower()

cleanup_chain=RunnableLambda(remove_extra_spaces)|RunnableLambda(to_lowercase)

result=cleanup_chain.invoke("Hello

World

From

LangChain")

print(result)

#"helloworldfromlangchain"

2.7LCEL与旧版LLMChain的对比

维度旧版LLMChainLCEL

组合方式类继承/参数配置管道操作符

流式支持需额外配置原生支持

并行执行不支持原生支持

类型提示弱强

异步支持有限完整

第三章：LCEL进阶——并行/分支/结构化输出

3.1并行Chain

使用RunnableParallel同时执行多个Chain，然后合并结果：

fromlangchain_core.runnablesimportRunnableParallel

#同时进行摘要和关键词提取

summarize_chain=summarize_prompt|model|parser

keywords_chain=keywords_prompt|model|parser

parallel_chain=RunnableParallel(

summary=summarize_chain,

keywords=keywords_chain,

)

result=parallel_chain.invoke({"text":"这是一篇关于AI的长文..."})

print(result["summary"])

print(result["keywords"])

3.2分支Chain

使用RunnableBranch根据输入条件选择不同的处理路径：

fromlangchain_core.runnablesimportRunnableBranch

branch=RunnableBranch(

(lambdax:"技术"inx["topic"],tech_chain),

(lambdax:"营销"inx["topic"],marketing_chain),

general_chain,

#默认路径

)

3.3结构化输出

LangChain1.0推荐使用with_structured_output替代手动拼JSON格式说明，更稳定可靠：

frompydanticimportBaseModel,Field

fromtypingimportList

classArticleInfo(BaseModel):

title:str=Field(description="文章标题")

outline:List[str]=Field(description="文章大纲")

keywords:List[str]=Field(description="3-5个关键词")

model=ChatOpenAI(model="gpt-4o-mini",temperature=0.7)

structured_model=model.with_structured_output(ArticleInfo)

prompt=ChatPromptTemplate.from_messages([

("system","你是一位资深技术博主。"),

("human","请针对「{topic}」生成文章标题、大纲和关键词。"),

])

chain={"topic":RunnablePassthrough()}|prompt|structured_model

result=chain.invoke("主流Agent框架对比")

print(f"标题：{result.title}")

print(f"大纲：{result.outline}")

print(f"关键词：{result.keywords}")

3.4回调与Token统计

使用回调机制统计Token消耗和监控链执行过程：

fromlangchain_community.callbacksimportget_openai_callback

withget_openai_callback()ascb:

result=chain.invoke({"topic":"LangChain实战"})

print(f"消耗Token：{cb.total_tokens}")

print(f"费用：${cb.total_cost:.4f}")

开发环境可以开启调试模式查看链的详细执行过程：

importlangchain

langchain.debug=True

生产环境务必关闭调试模式，避免输出敏感信息。

第四章：Agent实战——create_agent与工具调用

4.1create_agent的核心用法

create_agent是LangChain1.0中构建智能体的标准方式。它生成的底层是一个LangGraph状态机，开箱即用地支持

流式输出、持久化和可观测性。

fromlangchain.agentsimportcreate_agent

agent=create_agent(

model="claude-sonnet-4-6",

tools=[search_web,analyze_data,send_email],

system_prompt="你是一位有帮助的研究助手。"

)

result=agent.invoke({

"messages":[

{"role":"user","content":"研究AI安全趋势"}

]

})

print(result["messages"][-1].content)

4.2工具定义

使用@tool装饰器定义工具，LangChain自动将函数签名和文档字符串转换为模型可理解的工具描述：

fromlangchain_core.toolsimporttool

frompydanticimportBaseModel,Field

classSearchInput(BaseModel):

query:str=Field(description="搜索关键词")

max_results:int=Field(default=5,description="最大结果数")

@tool(args_schema=SearchInput)

defsearch_web(query:str,max_results:int=5)->str:

"""搜索互联网获取信息。当需要查询最新信息时使用此工具。"""

#实际实现：调用搜索引擎API

returnf"关于'{query}'的搜索结果（{max_results}条）"

@tool

defcalculate(expression:str)->str:

"""计算数学表达式。当需要进行数值计算时使用此工具。

参数:

expression:数学表达式，如"2+3*4"

"""

try:

result=eval(expression)

returnstr(result)

exceptExceptionase:

returnf"计算错误：{e}"

工具的文档字符串（docstring）直接影响模型是否能在正确时机调用工具。描述应清晰说明工具的功能和适用场景。

4.3Agent执行循环

create_agent基于基本的智能体循环：调用模型→让模型选择要执行的工具→执行工具→将结果返回给模型→

重复直到模型不再调用工具。

#注册多个工具

agent=create_agent(

model="gpt-4o-mini",

tools=[search_web,calculate],

system_prompt="你是一个智能助手。需要搜索信息时使用search_web，需要计算时使用calculate。"

)

#模型会自动判断是否需要调用工具

result=agent.invoke({

"messages":[

{"role":"user","content":"计算123*456等于多少？"}

]

})

#模型会调用calculate工具，然后返回计算结果

4.4ReAct模式与FunctionCall模式对比

LangChain支持两种主要的Agent推理模式：

维度ReActFunctionCall

推理方式显式“思考-行动-观察”循环模型原生工具调用

稳定性需处理格式解析高（模型原生支持）

适用场景需要显式推理过程的复杂场景大多数生产场景

推荐度复杂推理时可结合使用优先使用

建议优先使用FunctionCall模式（稳定性高），复杂推理场景可结合ReAct模式的显式思考过程。

4.5Agent状态与流式输出

Agent的执行过程可以流式获取，便于构建实时响应的应用：

foreventinagent.stream({

"messages":[{"role":"user","content":"搜索LangChain1.0新特性"}]

}):

fornode_name,node_outputinevent.items():

if"messages"innode_output:

formsginnode_output["messages"]:

ifhasattr(msg,"content")andmsg.content:

print(f"[{node_name}]{msg.content}")

节点名称在v1.0中从“agent”更名为“model”，需要注意更新相关代码。

第五章：Agent中间件——上下文工程的核心机制

5.1中间件的作用

中间件是create_agent的定义性特征，它提供了高度可定制的入口点，提升了可构建的上限。优秀的智能体需要上

下文工程：在正确的时间将正确的信息传递给模型。中间件帮助控制动态提示词、对话摘要、选择性工具访问、状态

管理和护栏。

5.2预置中间件

LangChain提供多个预置中间件覆盖常见模式：

中间件功能使用场景

PIIMiddleware在发送给模型前遮蔽敏感信息处理用户个人数据

SummarizationMiddleware对话历史过长时压缩长对话管理

HumanInTheLoopMiddleware敏感工具调用需要审批发送邮件、执行支付

fromlangchain.agentsimportcreate_agent

fromlangchain.agents.middlewareimport(

PIIMiddleware,

SummarizationMiddleware,

HumanInTheLoopMiddleware,

)

agent=create_agent(

model="claude-sonnet-4-6",

tools=[read_email,send_email],

middleware=[

PIIMiddleware("email",strategy="redact",apply_to_input=True),

PIIMiddleware(

"phone_number",

detector=r"(?:\+?\d{1,3}[\s.-]?)?(?:\(?\d{2,4}\)?[\s.-]?)?\d{3,4}[\s.-]?\d{4}",

strategy="block"

),

SummarizationMiddleware(

model="claude-sonnet-4-6",

trigger={"tokens":500}

),

HumanInTheLoopMiddleware(

interrupt_on={

"send_email":{

"allowed_decisions":["approve","edit","reject"]

}

}

),

]

)

5.3自定义中间件

通过createMiddleware函数实现自定义中间件，支持以下钩子：

钩子执行时机使用场景

beforeAgent调用智能体之前加载记忆、验证输入

beforeModel每次LLM调用之前更新提示词、裁剪消息

wrapModelCall包裹每次LLM调用拦截和修改请求/响应

afterModel每次LLM调用之后处理模型输出

wrapToolCall包裹每次工具调用工具错误处理、日志记录

5.4中间件与LCEL的关系

中间件工作在Agent层面，LCEL工作在Chain层面。两者可以结合使用：在中间件中使用LCEL构建的Chain来处理特定

的上下文工程任务。例如，SummarizationMiddleware内部就是一个LCEL链，用于将长对话压缩为摘要。

第六章：Memory实战——短期记忆与长期记忆

6.1短期记忆——线程级持久化

LangChain的智能体将短期记忆作为智能体状态的一部分进行管理。通过将这些内容存储在图的状态中，智能体可以

访问给定对话的完整上下文，同时保持不同线程之间的隔离。

核心概念：

概念说明

Thread（线程）一次会话中的多个交互，类似邮件中的一次对话

Checkpointer将状态持久化到数据库的组件

thread_id标识不同会话的唯一ID

启用短期记忆：在创建智能体时指定一个checkpointer：

fromlangchain.agentsimportcreate_agent

fromlangchain_core.toolsimporttool

fromlanggraph.checkpoint.memoryimportMemorySaver

@tool

defget_user_info()->str:

"""查询当前用户的信息。"""

return"用户档案：张先生，偏好中文回复。"

checkpointer=MemorySaver()

agent=create_agent(

model="gpt-4o-mini",

tools=[get_user_info],

checkpointer=checkpointer

)

#定义线程配置

thread_config={"configurable":{"thread_id":"session-1"}}

#第一轮对话

result=agent.invoke(

{"messages":[{"role":"user","content":"你好！我叫张先生。"}]},

thread_config

)

print(result["messages"][-1].content)

#"你好张先生！有什么可以帮你的吗？"

#第二轮对话（同一线程，模型记住了名字）

result=agent.invoke(

{"messages":[{"role":"user","content":"我叫什么名字？"}]},

thread_config

)

print(result["messages"][-1].content)

#"你叫张先生。"

生产环境Checkpointer选择：

Checkpointer存储方式适用场景

MemorySaver内存字典开发测试

SqliteSaverSQLite数据库单机生产

PostgresSaverPostgreSQL分布式生产

6.2长期记忆——跨会话存储

长期记忆让智能体在不同对话和会话之间存储和回忆信息。与短期记忆不同，长期记忆存储的是用户级别的信息，如

用户偏好、历史事实等。

fromlanggraph.store.memoryimportInMemoryStore

fromlangchain.agentsimportcreate_agent

#创建长期记忆存储

store=InMemoryStore()

agent=create_agent(

model="gpt-4o-mini",

tools=[get_user_info],

store=store,

)

#写入长期记忆

store.put(

namespace=("users","user-001"),

key="preferences",

value={"language":"中文","response_style":"简洁"}

)

#在智能体中检索长期记忆

memory=store.get(namespace=("users","user-001"),key="preferences")

print(memory.value)

#{"language":"中文","response_style":"简洁"}

6.3三层记忆架构

将短期记忆和长期记忆结合，形成完整的三层记忆架构：

层次存储内容存储方式生命周期

短期记忆当前线程的对话历史Checkpointer当前会话

长期记忆用户偏好、稳定事实Store跨会话

摘要记忆远期对话的压缩摘要SummarizationMiddleware当前会话

6.4生产环境注意事项

多用户隔离：使用thread_id区分不同用户的会话，使用namespace区分不同用户的长期记忆。确保一个用户的数据

对另一个用户不可见。

数据持久化：生产环境不要使用MemorySaver和InMemoryStore，它们仅在内存中存储数据，重启后丢失。应使用

数据库支持的Checkpointer和Store。

上下文窗口管理：长对话会超出模型的上下文窗口。使用SummarizationMiddleware在Token数超过阈值时自动压

缩对话历史。

第七章：完整项目实战——智能电商客服系统

7.1项目需求

构建一个智能电商客服系统，具备以下能力：

查询订单状态（工具调用）

查询商品库存（工具调用）

记住用户偏好和对话历史（短期+长期记忆）

敏感操作需人工审批（中间件）

7.2工具定义

fromlangchain_core.toolsimporttool

@tool

defquery_order(order_id:str)->str:

"""查询订单状态。当用户询问订单进度时使用此工具。

参数:

order_id:订单编号

"""

#实际实现：查询订单数据库

returnf"订单{order_id}：已发货，预计3天内到达。"

@tool

defcheck_inventory(product_name:str)->str:

"""查询商品库存。当用户询问商品是否有货时使用此工具。

参数:

product_name:商品名称

"""

#实际实现：查询库存系统

returnf"商品'{product_name}'：当前有货，库存充足。"

@tool

defprocess_refund(order_id:str,reason:str)->str:

"""处理退款申请。当用户要求退款时使用此工具。

参数:

order_id:订单编号

reason:退款原因

"""

returnf"订单{order_id}的退款申请已提交，原因：{reason}。"

7.3构建Agent

fromlangchain.agentsimportcreate_agent

fromlangchain.agents.middlewareimport(

SummarizationMiddleware,

HumanInTheLoopMiddleware,

)

fromlanggraph.checkpoint.sqliteimportSqliteSaver

#短期记忆

checkpointer=SqliteSaver.from_conn_string("customer_service.db")

#构建Agent

agent=create_agent(

model="gpt-4o-mini",

tools=[query_order,check_inventory,process_refund],

system_prompt="""你是一位专业的电商客服助手。

服务准则：

1.对用户保持礼貌和耐心

2.查询订单需要用户提供订单号

3.退款操作需要用户说明原因

4.如果无法解决问题，主动建议转接人工客服

请根据用户需求，选择合适的工具来解决问题。""",

checkpointer=checkpointer,

middleware=[

SummarizationMiddleware(

model="gpt-4o-mini",

trigger={"tokens":800}

),

HumanInTheLoopMiddleware(

interrupt_on={

"process_refund":{

"allowed_decisions":["approve","edit","reject"]

}

}

),

]

)

7.4调用与验证

#用户会话

thread_config={"configurable":{"thread_id":"user-zhang-001"}}

#第一轮：查询订单

result=agent.invoke(

{"messages":[{"role":"user","content":"帮我查一下订单ORD-2026-0912的状态"}]},

thread_config

)

print(result["messages"][-1].content)

#输出：订单ORD-2026-0912：已发货，预计3天内到达。

#第二轮：追问（模型记住上下文）

result=agent.invoke(

{"messages":[{"role":"user","content":"那这个订单可以退款吗？"}]},

thread_config

)

#模型理解“这个订单”指代ORD-2026-0912

print(result["messages"][-1].content)

7.5项目架构总结

层级组件实现方式

用户接口Web/APIFastAPI或Streamlit

Agent编排create_agentLangChain1.0

工具层订单/库存/退款工具@tool装饰器

短期记忆对话历史SqliteSaver

长期记忆用户偏好InMemoryStore/数据库Store

中间件摘要/人工审批SummarizationMiddleware+HumanInTheLoopMiddleware

模型LLMinit_chat_model统一接口

第八章：避坑指南——10个常见错误及正确做法

错误1：在新代码中使用AgentExecutor

错误做法：使用AgentExecutor构建新的智能体。

正确做法：使用create_agent。AgentExecutor处于维护模式至2026年12月，新代码不应使用。

错误2：拼接字符串而非使用提示词模板

错误做法：用Pythonf-string拼接提示词。

正确做法：使用ChatPromptTemplate，支持变量注入、格式校验和可复用。

错误3：忘记在LCEL中处理数据格式转换

错误做法：chain=summarize_chain|translate_chain，前一步输出ChatMessage对象，后一步期望字典格

式。

正确做法：在中间添加数据映射步骤：chain=summarize_chain|(lambdax:{"summary":x.content})|

translate_chain。

错误4：工具文档字符串描述不清

错误做法：工具函数没有docstring或描述过于笼统。

正确做法：清晰描述工具的功能、适用场景和参数含义。描述质量直接影响模型是否能正确调用工具。

错误5：生产环境使用MemorySaver

错误做法：在生产环境中使用MemorySaver作为Checkpointer。

正确做法：使用数据库支持的持久化方案（SqliteSaver/PostgresSaver），确保服务重启后会话可恢复。

错误6：不设置thread_id导致会话混淆

错误做法：多个用户共用一个线程，对话历史混乱。

正确做法：为每个用户或每个会话分配唯一的thread_id，确保不同线程之间的隔离。

错误7：不启用LangSmith追踪

错误做法：Agent运行时没有任何可观测性，出错后无法排查。

正确做法：启用LangSmith追踪，89%的生产团队使用可观测性工具。不启用的话，调试Agent行为只能靠猜。

错误8：在开发环境开启调试模式后忘记关闭

错误做法：生产环境仍保留langchain.debug=True。

正确做法：生产环境务必关闭调试模式，避免输出敏感信息。

错误9：中间件顺序错误

错误做法：将PIIMiddleware放在SummarizationMiddleware之后，敏感信息在摘要过程中泄露。

正确做法：PIIMiddleware应放在最外层，确保在发送给模型之前先完成脱敏。

错误10：忽视上下文窗口限制

错误做法：让对话无限增长，最终超出模型的上下文窗口。

正确做法：使用SummarizationMiddleware在Token数超过阈值时自动压缩对话历史。推荐阈值设为模型上下文窗

口的60%-70%。

第九章：常见问题解答

Q1：LCEL和Agent有什么区别？

LCEL是链式组合方式，适合线性流程（A→B→C）。Agent是动态决策方式，模型根据任务自主选择调用哪些工具、

以什么顺序调用。LCEL适合流程固定的场景，Agent适合需要动态决策的场景。

Q2：create_agent和create_react_agent有什么区别？

create_agent是LangChain1.0的标准方式，从langchain.agents导入。create_react_agent是旧版LangGraph

的预构建函数，从@langchain/langgraph/prebuilts导入。v1.0中推荐使用create_agent。

Q3：短期记忆和长期记忆如何选择？

短期记忆用于记住当前对话的上下文（如同一会话中的指代关系），使用Checkpointer实现。长期记忆用于记住跨会

话的用户偏好和事实，使用Store实现。大多数应用需要同时使用两者。

Q4：如何控制Agent的工具调用成本？

三种方法：第一，在系统提示词中明确工具的适用条件，减少不必要的调用；第二，使用中间件限制工具访问权限；

第三，在生产环境使用LangSmith监控Token消耗，识别高成本调用。

Q5：中间件可以叠加使用吗？

可以。多个中间件按列表顺序执行。建议的顺序是：PII脱敏（最外层）→摘要压缩→人工审批→自定义中间件。

Q6：如何处理Agent调用工具时的错误？

LangChain1.0将工具错误处理移至中间件的wrapToolCall方法中。可以自定义中间件捕获工具调用异常，返回友好

的错误信息而非中断整个Agent执行。

Q7：LangChain1.0的包结构有什么变化？

langchain包被精简为智能体核心构建块，传统功能（如旧的Chain类）移至langchain-classic包。新代码应优先

使用langchain包中的组件。

Q8：生产环境推荐什么Checkpointer？

单机部署推荐SqliteSaver，分布式部署推荐PostgresSaver。开发测试使用MemorySaver即可。

附录：速查表