LangChain 完全指南：从入门到生产级智能体构建

作者：CSDN博客
目录
引言：为什么是 LangChain？
一、LangChain 核心组件拆解
1.1 模型（Models）—— 应用的“大脑”
1.2 工具（Tools）—— 应用的“手和脚”
1.3 智能体（Agents）—— 应用的“决策者”
1.4 记忆（Memory）—— 应用的“短期记忆”
1.5 检索增强生成（RAG）—— 让模型“知道”你的数据
二、高级特性：中间件（Middleware）
三、LangGraph 进阶：从链到图的范式转移
3.1 基础示例：对话图
3.2 条件分支示例
四、2026 年 LangChain 最佳实践
4.1 工程建议
4.2 适用场景
结语：从链到图，从 Demo 到生产

---

引言：为什么是 LangChain？

2026年，大模型早已不再是稀缺资源。从 OpenAI 的 GPT 系列到本地的 Llama、Qwen，模型能力持续提升。但真正困扰开发者的，早已不是“模型够不够强”，而是 “如何让模型真正为我所用”。
你是否也遇到过这些问题？

想让模型访问公司内部数据库，却不知道从何下手
希望构建多轮对话机器人，但每次都要手动维护聊天历史
想给模型配上“工具”（查询天气、搜索网页），却发现调用逻辑越写越复杂

LangChain 的出现，正是为了解决这些问题。
它是一个开源框架，旨在简化基于大语言模型的应用程序开发。它像一座桥梁，将强大的模型与外部数据源、工具、API 连接起来，让你能够构建真正上下文感知、具备自主行动能力的 AI 应用。
一、LangChain 核心组件拆解

LangChain 之所以强大，是因为它围绕几个模块化概念构建，每个概念解决特定问题。
1.1 模型（Models）—— 应用的“大脑”

模型是 AI 应用的核心。LangChain 提供了一个统一的接口，让你可以用几乎相同的方式调用不同提供商的模型——无论是 OpenAI 的 GPT、Anthropic 的 Claude，还是本地部署的 Ollama 模型。
静态模型 vs 动态模型
LangChain 支持两种模型模式：

静态模型：最常见的用法，在创建 Agent 时固定模型，整个执行过程中保持不变。
动态模型：允许在运行时根据上下文切换模型。例如，通过 ModelFallbackMiddleware，当主模型失败时自动切换到备用模型。

1. from langchain.agents import create_agent
2. from langchain.agents.middleware import ModelFallbackMiddleware
4. agent = create_agent(
5.     model="gpt-4o",
6.     tools=[],
7.     middleware=[
8.         ModelFallbackMiddleware(
9.             "gpt-4o-mini",
10.             "claude-3-5-sonnet-20241022",
11.         ),
12.     ],
13. )

复制代码

1.2 工具（Tools）—— 应用的“手和脚”

如果说模型是大脑，那么工具就是大脑可以操控的“手和脚”。工具让 AI 能够与外部世界交互——调用 API、查询数据库、执行代码、发送邮件。
LangChain 提供了简洁的 @tool 装饰器，让你可以系统化地创建工具。

1. from langchain.tools import tool
3. @tool
4. def search_db(query: str, limit: int = 10) -> str:
5.     """搜索客户数据库中匹配查询的记录"""
6.     # 实际的数据库查询逻辑
7.     return f"找到 {limit} 条与 '{query}' 相关的结果"
9. @tool("pycharm_docs_search")
10. def pycharm_docs_search(q: str) -> str:
11.     """搜索 PyCharm 文档并返回相关内容"""
12.     # 向量检索逻辑
13.     docs = retriever.get_relevant_documents(q)
14.     return format_docs(docs)

复制代码

1.3 智能体（Agents）—— 应用的“决策者”

智能体是 LangChain 的核心抽象。它将模型和工具组合在一起，让系统能够：

推理：分析用户需求
规划：决定调用哪些工具、按什么顺序调用
执行：调用工具并分析结果
迭代：根据中间结果调整下一步行动

创建智能体的 API 极为简洁：

1. from langchain.agents import create_agent
3. agent = create_agent(
4.     "gpt-5",  # 模型
5.     tools=tools  # 工具列表
6. )

复制代码

1.4 记忆（Memory）—— 应用的“短期记忆”

默认情况下，大模型是无状态的——每次对话都是全新的开始。记忆组件让 AI 能够记住之前的交互，实现真正的多轮对话。
在新的 Runnable API 体系中，记忆不再是“隐藏参数”，而是通过检查点（checkpoint）机制实现的显式状态管理。

1. from langgraph.checkpoint.memory import InMemorySaver
3. # 使用检查点保存状态
4. checkpointer = InMemorySaver()
5. graph = graph.compile(checkpointer=checkpointer)
7. # 使用同一个 thread_id，实现跨轮次记忆
8. config = {"configurable": {"thread_id": "user-123"}}
10. # 第一轮对话
11. result1 = graph.invoke({"messages": [HumanMessage(content="你好")]}, config=config)
13. # 第二轮对话（保留上下文）
14. result2 = graph.invoke({"messages": [HumanMessage(content="我刚才说了什么")]}, config=config)

复制代码

1.5 检索增强生成（RAG）—— 让模型“知道”你的数据

RAG 是 LangChain 最具价值的应用场景之一。它通过以下流程，让模型能够基于私有数据回答问题：

文档索引：将内部文档、PDF 等分割成块，向量化后存入向量数据库
相关检索：用户提问时，从数据库中检索相关内容
增强生成：将检索到的内容注入上下文，让模型基于真实数据生成答案

1. # 示例：创建文档问答工具
2. @tool("pycharm_docs_search")
3. def pycharm_docs_search(q: str) -> str:
4.     """搜索 PyCharm 文档并返回相关内容"""
5.     # 加载向量存储
6.     vector_store = FAISS.load_local(
7.         settings.index_dir,
8.         embeddings,
9.         allow_dangerous_deserialization=True
10.     )
11.    
12.     # 检索相关文档
13.     retriever = vector_store.as_retriever(search_kwargs={"k": 4})
14.     docs = retriever.invoke(q)
15.    
16.     return format_docs(docs)

复制代码

二、高级特性：中间件（Middleware）

LangChain 2025-2026 年版本引入的中间件机制，为智能体行为定制提供了强大支持。

中间件	作用
Summarization	接近 Token 限制时自动总结对话历史
Human-in-the-loop	暂停执行，等待人工审批工具调用
Context editing	管理对话上下文，修剪或清理工具调用记录
PII detection	检测并处理个人身份信息

1. from langchain.agents.middleware import HumanInTheLoopMiddleware
3. agent = create_agent(
4.     model="gpt-4o",
5.     tools=[send_email_tool, delete_user_tool],
6.     middleware=[
7.         HumanInTheLoopMiddleware(
8.             require_approval_for=["delete_user_tool"]  # 删除用户需要人工审批
9.         )
10.     ]
11. )

复制代码

三、LangGraph 进阶：从链到图的范式转移

当业务逻辑变得复杂——多步决策、条件分支、循环执行——传统的链式结构就难以应对了。这时，LangGraph 闪亮登场。
LangGraph 是 LangChain 团队推出的图式编排框架，它让你能够：

用状态（State）表达全局任务信息
用节点（Nodes）封装具体逻辑
用边（Edges）定义流程跳转

3.1 基础示例：对话图

1. from typing import TypedDict, Annotated
2. from langgraph.graph import StateGraph, END, START
3. from langgraph.graph.message import add_messages
5. # 1. 定义全局状态
6. class ChatState(TypedDict):
7.     messages: Annotated[list, add_messages]
9. # 2. 定义节点
10. def chat_node(state: ChatState):
11.     response = llm.invoke(state["messages"])
12.     return {"messages": [response]}
14. # 3. 构建图
15. graph = StateGraph(ChatState)
16. graph.add_node("chat", chat_node)
17. graph.set_entry_point("chat")
18. graph.add_edge("chat", END)
19. graph = graph.compile()
21. # 4. 调用
22. result = graph.invoke({
23.     "messages": [HumanMessage(content="用一句话介绍什么是 LangGraph？")]
24. })
25. print(result["messages"][-1].content)

复制代码

3.2 条件分支示例

1. def router(state: AgentState) -> str:
2.     """根据用户意图路由到不同处理节点"""
3.     if "查询订单" in state["messages"][-1].content:
4.         return "order_handler"
5.     elif "咨询商品" in state["messages"][-1].content:
6.         return "product_handler"
7.     else:
8.         return "general_handler"
10. # 添加条件边
11. graph.add_conditional_edges(
12.     "intent_classifier",
13.     router,
14.     {
15.         "order_handler": "order_node",
16.         "product_handler": "product_node",
17.         "general_handler": "general_node"
18.     }
19. )

复制代码

四、2026 年 LangChain 最佳实践

4.1 工程建议

模型别贪大：7B/8B 模型是当前本地部署的性价比甜点位
Prompt 比模型更重要：本地模型对提示词非常敏感
模块化使用：Prompt/LLM/Parser/Memory 明确分层
记忆要可演进：从 InMemory → Redis → 数据库 → Checkpointer

4.2 适用场景

场景	推荐方案
多轮对话机器人	LangChain + Memory
文档问答系统	LangChain + RAG
复杂多步智能体	LangGraph
本地部署应用	LangChain + Ollama
企业级合规应用	LangGraph + Checkpoint

结语：从链到图，从 Demo 到生产

过去几年，我们讨论最多的是“该用哪个云端大模型”。而现在，越来越多开发者开始思考：“如何让 AI 真正融入我的系统？”
LangChain 给出了答案：它不是要取代任何技术，而是为开发者提供了一个真正可控、可组合、可落地的 AI 应用开发框架。
从最简单的链式调用，到带记忆的对话系统，再到复杂的图式智能体——LangChain 的演进路径，恰恰映射了 AI 应用从“玩具”走向“生产”的全过程。

原文地址：https://blog.csdn.net/m0_74263216/article/details/158392530