第01章：LangChain v1 全景概览

版本：LangChain v1.3.7 | 讲师：汤姆小白

1. 介绍 LangChain

1.1 什么是 LangChain

LangChain 是 2022 年 10 月，由哈佛大学的 Harrison Chase（哈里森·蔡斯） 发起研发的一个开源框架，用于开发由大语言模型（LLMs）驱动的应用程序。

比如，搭建"智能体"（Agent）、问答系统（QA）、对话机器人、文档搜索系统、企业私有知识库等。

GitHub 地址：https://github.com/langchain-ai/langchain

简单概括：

  • LangChain ≠ LLMs
  • LangChain 之于 LLMs，类似 Spring 之于 Java
  • LangChain 之于 LLMs，类似 Django、Flask 之于 Python

顾名思义，LangChain 中的 “Lang” 是指 language，即大语言模型，“Chain” 即"链"，也就是将大模型与外部数据&各种组件连接成链，以此构建 AI 应用程序。

应用开发是大模型最值得关注的方向：应用为王！学习 LangChain 框架，高效开发大模型应用。

1.2 有哪些大模型应用开发框架呢？

截止到 2026 年 6 月，GitHub 统计数据：

框架 特点
LangChain 出现最早、最成熟，聚焦 LCEL 管道式组合 + LangGraph 编排 + Deep Agents 高级智能体
LlamaIndex 专注于高效的索引和检索，适合 RAG 场景（注意不是 Meta 开发的）
LangChain4J Java / JavaScript（LangChain.js）双语言版本，功能略少于 LangChain，但核心功能都有
SpringAI / SpringAI Alibaba 有待进一步成熟，仅对部分接口进行了封装
SemanticKernel (sk) 微软推出，对 C# 同学来说是 5 颗星

1.3 为什么需要 LangChain？

问题1：LLMs 用的好好的，干嘛还需要 LangChain？

在大语言模型如 ChatGPT、Claude、DeepSeek 等快速发展的今天，开发者不仅希望能"使用"这些模型，还希望能将它们灵活集成到自己的应用中，实现更强大的对话能力、检索增强生成（RAG）、工具调用（Tool Calling）、多轮推理等功能。

LangChain 为更方便解决这些问题而生。比如：大模型默认不能联网，如果需要联网，用 LangChain。

问题2：可以使用 GPT 或 GLM4 等模型的 API 进行开发，为何需要 LangChain？

不使用 LangChain，确实可以用 GPT 或 GLM4 等模型的 API 进行开发。但使用 LangChain 的好处：

  • 简化开发难度：更简单、更高效、效果更好
  • 学习成本更低：不同模型的 API 不同，调用方式也有区别，切换模型时学习成本高。使用 LangChain，可以以统一、规范的方式进行调用，有更好的移植性
  • 现成的管道式组装：LangChain 提供 LCEL（LangChain Expression Language）管道式组合方式，让复杂的逻辑变得结构化、易组合、易扩展

问题3：LangChain 提供了哪些功能呢？

LangChain 是一个帮助你构建 LLM 应用的全套工具集。涉及 prompt 构建、LLM 接入、工具调用、RAG、智能体开发、可观测性等模块。

学习 LangChain 最好的方式就是做项目。

1.4 LangChain 的使用场景

学完 LangChain，如下类型的项目都可以实现：

项目名称 技术点 难度
文档问答助手 Prompt + Embedding + LCEL RAG ⭐⭐
智能日程规划助手 create_agent + Tool + LangGraph Memory ⭐⭐⭐
LLM+数据库问答 SQLDatabaseToolkit + create_agent ⭐⭐⭐⭐
多模型路由对话系统 LCEL RunnableBranch + 多 LLM ⭐⭐⭐⭐
互联网智能客服 LCEL Chain + RAG + create_agent ⭐⭐⭐⭐⭐
企业知识库助手 VectorDB + LLM + Streamlit ⭐⭐⭐⭐⭐
Deep Agent 自动化任务 Deep Agents + 子代理 + 文件系统 ⭐⭐⭐⭐⭐

1.5 LangChain 资料介绍

资源 地址
官网地址 https://www.langchain.com/langchain
官方文档 https://docs.langchain.com/oss/python/langchain/overview
LangGraph 文档 https://langchain-ai.github.io/langgraph/
Deep Agents 文档 https://docs.langchain.com/oss/python/deepagents/overview
API 参考 https://reference.langchain.com/python/langchain/
GitHub 地址 https://github.com/langchain-ai/langchain

2. 架构设计

2.1 核心包结构

LangChain v1 采用模块化包架构，按需安装：

┌─────────────────────────────────────────────┐
│  langchain       核心：LCEL + create_agent + RAG  │
│  langchain-core  基础抽象：Runnable 接口、消息类型  │
│  langgraph       编排运行时：状态图、持久化、人机协同  │
│  langchain-openai / langchain-anthropic 等       │
│                   独立提供商包，按需安装              │
│  langchain-text-splitters  文本分割器              │
│  deepagents      高级智能体套件（需要时安装）          │
│  langchain-classic  兼容层（不再推荐新项目使用）        │
└─────────────────────────────────────────────┘
包名 职责 安装命令
langchain LCEL 管道、Agent 创建、RAG 构建 pip install langchain
langchain-core Runnable 接口、消息类型、Prompt 模板、工具定义 随 langchain 自动安装
langgraph 状态图编排、持久化、人机协同、Memory pip install langgraph
langchain-openai OpenAI 模型与工具集成 pip install langchain-openai
langchain-anthropic Anthropic Claude 集成 pip install langchain-anthropic
langchain-text-splitters 文本分割器 pip install langchain-text-splitters
deepagents Deep Agents 高级智能体 pip install deepagents
langchain-classic Chains/Memory 兼容层（新项目不建议用） pip install langchain-classic

核心原则：LCEL 管道式组合是推荐的组件组合方式。使用 chain = prompt | llm | parser，管道化串联。

2.2 三层产品架构

LangChain 生态系统分为三个层次：

┌──────────────────────────────────────────────────────────┐
│              Deep Agents（智能体套件）                      │
│   内置：任务规划 · 子代理 · 文件系统 · 上下文工程 · 人机协同    │
│                 pip install deepagents                    │
├──────────────────────────────────────────────────────────┤
│              LangGraph（编排运行时）                        │
│   能力：状态图 · 持久化 · 断点恢复 · 人机协同 · 流式输出 · 记忆  │
│                 pip install langgraph                     │
├──────────────────────────────────────────────────────────┤
│              LangChain（基础构建块）                        │
│   核心：LCEL 管道 · Models · Tools · RAG · Callbacks       │
│                  pip install langchain                    │
└──────────────────────────────────────────────────────────┘
层次1：LangChain（基础构建块）—— 打好地基
子包 职责
langchain-core 基础抽象：Runnable 接口、消息类型、Prompt 模板、Output Parser、工具定义
langchain 高级认知架构：create_agent、RAG 构建（LCEL 管道 + @tool 检索工具）、工具管理
langchain-openai / langchain-anthropic 等 各提供商的独立集成包，按需安装

各提供商使用独立集成包。例如聊天模型用 langchain_openai，文档加载器用 langchain_community。

层次2：LangGraph（编排运行时）—— Agent 的引擎

LangGraph 是 LangChain 生态的核心运行时引擎：

能力 说明
StateGraph 声明式定义节点和边的有向图工作流
持久化 (Checkpointer) Agent 运行中崩溃，从断点恢复继续执行
人机协同 (interrupt) 关键节点（如删除数据）暂停等待人工审批
Memory Store 跨会话长期记忆存储
流式输出 逐事件流式返回 Agent 的每一步执行结果
条件路由 基于运行时状态动态决定下一步

create_agent 底层就是基于 LangGraph 构建的，学 Agent 之前先了解 LangGraph 会事半功倍。

层次3：Deep Agents（智能体套件）—— 开箱即用的最强 Agent

内置了 14 项高级能力：

能力 说明
任务规划 内置 write_todos 工具，自动分解任务、跟踪进度
子代理生成 task 工具自动派生独立子代理处理子任务
上下文工程 自动摘要对话历史、压缩上下文、大结果卸载到虚拟文件
文件系统 可插拔后端（内存 / 本地磁盘 / LangGraph Store）
长期记忆 基于 LangGraph Memory Store 的跨会话记忆
沙箱执行 代码在隔离环境中运行，安全可控
人机协同 敏感操作配置人工审批流程

选用建议：简单任务用 create_agent，中等复杂用 LangGraph 自定义工作流，最复杂场景用 Deep Agents 开箱即用。

结构4：LangSmith（可观测性平台）

  • 地址：https://docs.smith.langchain.com/
  • 链路追踪与可观测性平台，提供：Debugging、Playground、Prompt Management、Testing、Monitoring、Evaluation
  • 与 LangChain 无缝集成，帮助开发者从原型阶段过渡到生产阶段

LangSmith 使 LangChain 的"企业级可观测性"成为现实，否则仅靠 API 组合支撑不住生产级 Agent 的热度。

结构5：LangServe

将 LangChain 的可运行项和链部署为 REST API，使它们可以通过网络进行调用。

总结：LangChain 生态中三个最值得深入学习的方向：

方向 定位 为什么重要
LangGraph 编排运行时 Agent 的发动机，所有复杂工作流的基础
Deep Agents 高级智能体 开箱即用的最强 Agent，1.3.x 的第一方产品
LangSmith 可观测性 生产环境部署与监控的必备工具

3. 开发前的准备工作

3.1 前置知识

1. Python 基础语法

  • 变量、函数、类、装饰器、上下文管理器
  • 模块导入、包管理（推荐用 pip 或 conda）

2. 大语言模型基础

  • 了解什么是 LLM、Token、Prompt、Embedding
  • OpenAI API 或其他模型提供商，如 Anthropic、阿里云百炼、DeepSeek 等
  • 通过浏览器或 App 使用过大模型（比如：豆包、DeepSeek 等）

3.2 环境安装

1. 安装 Python

LangChain v1.3.7 基于 Python 开发，最低要求 Python 3.10。

  • 方式1：直接下载 Python 安装包（https://www.python.org/）
  • 方式2：使用 Anaconda 创建和管理虚拟环境

具体操作见《conda使用指南.md》

2. 创建虚拟环境
# 创建 Python 3.10+ 虚拟环境
conda create -n langchain_v1 python=3.12

# 激活环境
conda activate langchain_v1

# 验证版本
python --version
3. 安装 LangChain v1.3.7
# 核心包
pip install langchain==1.3.7

# 常用提供商包（按需安装）
pip install langchain-openai
pip install langchain-anthropic

# LangGraph 编排运行时
pip install langgraph

# Deep Agents（高级智能体，可选）
pip install deepagents

# 如需兼容层
pip install langchain-classic

# 文本分割器
pip install langchain-text-splitters

一个极简启动命令（覆盖多数入门需求）：pip install langchain langchain-openai langgraph

4. 验证安装
import langchain
print(langchain.__version__)  # 1.3.7

import sys
print(sys.version)  # 3.12.x (确保 >= 3.10)
5. pip 常用操作
# 安装指定版本
pip install langchain==1.3.7

# 升级
pip install --upgrade langchain

# 卸载
pip uninstall langchain

# 查看已安装
pip list | grep langchain

# 国内镜像加速
pip install -i https://mirrors.aliyun.com/pypi/simple/ langchain

建议：conda 和 pip 不要混用，推荐先 conda 装基础环境，后 pip 补充 Python 包。

4. 大模型应用开发

大模型应用技术特点：门槛低，天花板高。

4.1 基于 RAG 架构的开发

背景：

  • 大模型的知识冻结
  • 大模型幻觉

RAG 可以非常精准地解决这两个问题。

何为 RAG？

Retrieval-Augmented Generation（检索增强生成）

RAG 流程：

本地文件 → 非结构化数据加载器 → 文本分割 → 转换为向量嵌入
                                              ↓
                                         向量数据库（存储与索引）
                                              ↓
用户提问 → 向量嵌入 → 相似度搜索 → 相似向量作为上下文
                                              ↓
          提示词模板（Prompt = Context + User Query）
                                              ↓
                              LLM → 回答 → 发送给用户

三个涉及大模型使用的位置：

  1. 向量化时使用 Embedding Models
  2. 重排序时使用 Rerank Models
  3. 生成答案时使用 LLM

4.2 基于 Agent 架构的开发

充分利用 LLM 的推理决策能力，通过增加规划、记忆和工具调用的能力，构造一个能够独立思考、逐步完成给定目标的智能体。

Agent = LLM + Memory + Tools + Planning + Action

比如：打车到西藏玩。

  • 大脑中枢：规划行程的你
  • 规划：步骤1——查路线；步骤2——订酒店……
  • 调用工具：滴滴打车、携程、美团
  • 记忆能力：沟通时要知道上下文，不能聊着聊着忘了最初的目的
  • 行动：说走就走，执行操作

Agent 开发的三个层次：

层次 适用场景 使用方式
create_agent 快速原型、简单的工具调用 from langchain.agents import create_agent
LangGraph 自定义 复杂工作流、人机协同、持久化 from langgraph.graph import StateGraph
Deep Agents 最复杂的多步自主任务 from deepagents.graph import create_deep_agent

4.3 大模型应用开发的 4 个场景

场景 描述 举例
纯 Prompt 直接对话，你问 ta 答 直接与 ChatGPT 对话
Agent + Tool Calling AI 主动要求调用工具，收集信息后决策 “明天杭州出差带伞吗？” → AI 查天气后答复
RAG 补充领域知识，检索-增强-生成 在知识库中找相关内容，结合题目组成答案
Fine-tuning（精调） 在特定领域数据上微调模型 垂直领域模型训练

如何选择：

提示词工程 → RAG → Agent → Fine-tuning
（逐步升级，越往后成本越高）

注意：其中最容易被忽略的，是准备测试数据。

5. LangChain 核心组件

5.1 核心组件总览

LangChain v1 的核心组件如下：

组件 职责 说明
Models 模型调用与结构化输出 统一接口调用各提供商模型，支持 Structured Output、Multimodal、流式等
LCEL 管道式组件组合 prompt | llm | parser 管道串联，支持 invoke/stream/batch
Agents 智能体决策与工具调用 create_agent 统一 API，底层基于 LangGraph
Tools 外部能力扩展 @tool 自定义工具、MCP 协议、bind_tools() 绑定
Retrieval 检索增强生成 (RAG) create_agent + LCEL RAG 管道 / @tool 检索工具
Callbacks 可观测性与钩子 融入 Middleware 体系，与 LangSmith 集成

5.2 核心组件说明

组件1：Models（模型）

标准化各模型的输入输出。核心流程不变：Format → Predict → Parse。

主要能力：

  • init_chat_model() 统一初始化任何提供商的模型
  • Structured Output（Pydantic / TypedDict / JSON Schema 三种方案）
  • Multimodal（图片、音频、视频输入）
  • Model Profiles（模型能力自动探查）
  • Rate Limiter（内置速率限制）
  • Prompt Caching（提示缓存）
组件2：LCEL（LangChain 表达式语言）

最重要的组件，管道式组合的标准范式。

# LCEL 管道式组合
chain = prompt | llm | output_parser
result = chain.invoke({"input": "你的问题"})

核心概念：

  • | 管道操作符：从左到右串联组件
  • invoke() / stream() / batch()：三种调用方式
  • RunnablePassthrough / RunnableLambda / RunnableParallel：辅助组件
组件3：Agents（智能体）

Agent 开发使用 create_agent：

from langchain.agents import create_agent

agent = create_agent(
    model=llm,
    tools=[search_tool, weather_tool],
    system_prompt="你是一个有用的助手"
)
result = agent.invoke({"messages": [{"role": "user", "content": "今天天气怎么样？"}]})

关键设计：

  • Middleware 中间件体系，在模型调用前后注入逻辑
  • 底层基于 LangGraph，天然支持流式、持久化、人机协同
组件4：Tools（工具）
  • 自定义工具：@tool 装饰器
  • bind_tools() 绑定工具到模型
  • MCP 协议：连接任何 MCP 服务器的工具
  • tool_choice 参数控制工具调用行为
组件5：Retrieval（检索增强生成）

RAG 推荐用 create_agent + 工具或中间件模式：

from langchain.agents import create_agent
from langchain.tools import tool

# 方式一：Agent + 检索工具
@tool
def retrieve_context(query: str) -> str:
    """检索知识库中的相关信息"""
    docs = vector_store.similarity_search(query, k=3)
    return "\n\n".join(d.page_content for d in docs)

agent = create_agent(
    model=llm,
    tools=[retrieve_context],
    system_prompt="你是问答助手，使用检索工具获取信息后回答。"
)
result = agent.invoke({"messages": [{"role": "user", "content": "你的问题"}]})

5.3 小结

模块 定位
Models 基础，支持结构化输出、多模态等
LCEL 最重要的组合范式
Agents 核心落地场景，create_agent 统一 API
Tools + MCP 工具生态，MCP 作为标准协议
Retrieval RAG 场景，推荐 Agent + 工具或中间件模式

6. LangChain v1.3.7 Hello World

注意：演示代码前需要：

  1. 安装必要的库：pip install langchain langchain-openai
  2. 配置好 .env 文件，准备 API Key

6.1 获取大模型

import dotenv
from langchain.chat_models import init_chat_model
import os

dotenv.load_dotenv()

os.environ['OPENAI_API_KEY'] = os.getenv("OPENAI_API_KEY")
os.environ['OPENAI_BASE_URL'] = os.getenv("OPENAI_BASE_URL")

# init_chat_model 统一初始化
llm = init_chat_model("gpt-4o-mini")

# 或直接使用提供商类
# from langchain_openai import ChatOpenAI
# llm = ChatOpenAI(model="gpt-4o-mini")

response = llm.invoke("什么是大模型？")
print(response.content)

.env 文件：

OPENAI_API_KEY="sk-你的密钥"
OPENAI_BASE_URL="https://api.openai-proxy.org/v1"

6.2 LCEL 管道式组合（核心范式）

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 创建提示模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是世界级的技术文档编写者"),
    ("user", "{input}")
])

# 核心：LCEL 管道式组合
chain = prompt | llm | StrOutputParser()

# 调用
message = chain.invoke({"input": "LangChain 中的 LCEL 是什么?"})
print(message)

6.3 结构化输出

from pydantic import BaseModel, Field

# 定义输出结构
class Answer(BaseModel):
    question: str = Field(description="用户的问题")
    answer: str = Field(description="问题的回答")
    confidence: float = Field(description="置信度 0-1")

# 使用 with_structured_output
structured_llm = llm.with_structured_output(Answer)

result = structured_llm.invoke("LangChain 是什么?")
print(f"问题: {result.question}")
print(f"回答: {result.answer}")
print(f"置信度: {result.confidence}")

6.4 RAG（检索增强生成）

v1.3.7 中推荐使用 create_agent + 检索工具或中间件模式替代旧的 create_retrieval_chain。

pip install faiss-cpu langchain-community langchain-text-splitters

from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.agents import create_agent
from langchain.tools import tool

# 1. 加载文档
loader = WebBaseLoader(web_path="https://www.gov.cn/xinwen/2020-06/01/content_5516649.htm")
docs = loader.load()

# 2. 分割文档
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
documents = text_splitter.split_documents(docs)

# 3. 向量化存储
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector = FAISS.from_documents(documents, embeddings)
retriever = vector.as_retriever(search_kwargs={"k": 3})

# 4. 定义检索工具
@tool
def search_knowledge(query: str) -> str:
    """搜索知识库中的相关信息"""
    docs = retriever.invoke(query)
    return "\n\n".join(d.page_content for d in docs)

# 5. 创建 RAG Agent
agent = create_agent(
    model=llm,
    tools=[search_knowledge],
    system_prompt="你是问答助手。根据检索到的信息回答问题，不要编造答案。"
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "建设用地使用权是什么？"}]
})
print(result["messages"][-1].content)

6.5 Agent（create_agent）

from langchain.agents import create_agent
from langchain.tools import tool

# 1. 定义工具
@tool
def search_knowledge(query: str) -> str:
    """搜索知识库中关于中国民法典的信息"""
    docs = retriever.invoke(query)
    return "\n".join([d.page_content for d in docs])

# 2. 创建 Agent
agent = create_agent(
    model=llm,
    tools=[search_knowledge],
    system_prompt="你是法律知识助手。对于法律问题，先搜索知识库再回答。"
)

# 3. 运行 Agent
result = agent.invoke({
    "messages": [{"role": "user", "content": "建设用地使用权是什么？"}]
})
print(result["messages"][-1].content)

7. 本文档阅读指南

本套文档共 10 章，建议按以下顺序阅读：

章节 内容 重要度 建议
01 全景概览 框架定位、架构设计、Hello World ⭐⭐⭐⭐⭐ 必读
02 Models 模型调用、结构化输出、多模态、流式 ⭐⭐⭐⭐⭐ 必读
03 LCEL 管道式组合、Runnable 接口、流式/批量 ⭐⭐⭐⭐⭐ v1 核心，必读
04 Chains & RAG 检索增强生成、文档处理、向量存储 ⭐⭐⭐⭐ 必读
05 Tools & MCP 工具定义、MCP 协议、工具调用进阶 ⭐⭐⭐⭐ 必读
06 LangGraph 入门 状态图、持久化、人机协同、Memory ⭐⭐⭐⭐ Agent 前置知识
07 Agent 开发实战 create_agent、Middleware、Context Engineering ⭐⭐⭐⭐⭐ 核心落地
08 Deep Agents 高级智能体、子代理、文件系统、规划 ⭐⭐⭐ 进阶选读
09 附录A 迁移速查表 ⭐⭐⭐ 从旧版本迁移时参考
10 附录B langchain-classic 兼容层 ⭐⭐ 按需参考

全文完

Logo
MCP技术社区

欢迎加入 MCP 技术社区！与志同道合者携手前行，一同解锁 MCP 技术的无限可能！

更多推荐

cover

MCP 为什么成了 AI Agent 的通用接口

avatar MCP技术社区

OpenClaw.NET .NET 原生插件开发完全指南：以 Mempalace 插件为范例

是 .NET 原生插件的元数据声明文件，其结构与传统 TypeScript 插件的},},和typeName字段共同定位插件的入口点，前者指定 DLL 文件的相对路径，后者指定实现接口的完整类型名称，包括命名空间。数组声明了插件提供的能力类型，此处为["memory"]，表明这是一个记忆提供者插件，网关会根据此声明将插件纳入记忆服务的候选列表。jitOnly标志是一个关键的设计决策，设置为true

avatar MCP技术社区

LangChain实用技巧，轻松切换AI大模型

在该层级内，完成核心参数配置：模型名称对应的键名为QWEN_model，base_url对应的键名为QWEN_base_url，api_key对应的键名为QWEN_api_key。如，当设置config_prefix="CODE"时，原本用于指定模型接口地址的参数base_url会自动变成CODE_base_url，从而与其他模型的base_url参数彻底隔离开来。完成config字典的构建后，将

avatar MCP技术社区