LangChain入门教程

LangChain 入门实战教程（2026 v1.x 版）

官网：https://www.langchain.com/ · 文档：https://python.langchain.com/docs · GitHub：https://github.com/langchain-ai/langchain

---

目录

• [一、LangChain 是什么](#一、LangChain 是什么)
• 二、环境准备与安装
• 三、核心概念详解
• 四、实战：智能客服机器人
• 五、进阶话题一览
• 六、总结与学习路线

---

一、LangChain 是什么

LangChain 是一个基于大语言模型的应用开发框架，提供了一套模块化工具，帮助开发者将 LLM 与外部数据源、API、工具结合起来，构建强大的 AI 应用。

LangChain 的核心入口是 Agent（代理） ，通过 create_agent 一行即可创建。Agent 底层构建在 LangGraph 之上，支持持久化执行、人工审核、流式输出等高级特性。
观测平台
模型生态
LangChain 2026 架构
create_agent()
Agent 实例
LangGraph 引擎
模型接口
工具系统
记忆系统
RAG 检索
OpenAI GPT
Anthropic Claude
Google Gemini
DeepSeek
Ollama 本地
LangSmith 追踪/调试

1.1 为什么需要 LangChain？

场景	直接调 API 的问题	LangChain 方案
多轮对话 + 工具调用	需要手动维护循环逻辑	create_agent 自动管理
读取 PDF / 网页	需要自己实现文档切分、向量化	Document Loaders + Text Splitters
调用外部 API	需要硬编码函数调用逻辑	@tool 装饰器自动注册
复杂业务流程	多个大模型调用，代码耦合度高	LangGraph 有向图编排
模型切换	各厂商 API 格式不同	init_chat_model 统一接口

1.2 一句话体验

from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """获取某个城市的天气"""
    return f"{city} 今天晴天，气温 22°C。"

agent = create_agent(
    model="openai:gpt-4o",           # 模型标识 厂商:模型名
    tools=[get_weather],
    system_prompt="你是一个天气助手",
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "北京天气怎么样？"}]
})
print(result["messages"][-1].content_blocks)

---

二、环境准备与安装

2.1 Python 环境

推荐 Python 3.10+，建议使用虚拟环境：

python -m venv .venv
source .venv/bin/activate   # Linux/Mac
.venv\Scripts\activate      # Windows

2.2 安装 LangChain

LangChain 2026 采用按需安装策略，核心包 + 模型提供方包：

# 核心 + OpenAI
pip install langchain "langchain[openai]"

# 或者用 Anthropic
pip install langchain "langchain[anthropic]"

# 或者用 Google Gemini
pip install langchain "langchain[google-genai]"

# 或者本地模型
pip install langchain langchain-ollama

核心包说明：

包	说明
langchain	核心框架（Agent、Tool、LCEL、所有基础抽象）
langchain[openai]	同时安装 langchain-openai
langchain-community	社区集成（文档加载器、向量库等），按需安装
langchainhub	社区提示词模板库

2.3 配置 API Key

# .env 文件
OPENAI_API_KEY=sk-xxxxx
# 或用 Anthropic
ANTHROPIC_API_KEY=sk-ant-xxxxx
# 国产模型
DEEPSEEK_API_KEY=sk-xxxxx

各国产模型接入方式：

模型	安装包	模型标识
DeepSeek	langchain[openai]	使用 ChatOpenAI(base_url="https://api.deepseek.com")
通义千问	langchain[openai]	使用 ChatOpenAI(base_url="https://dashscope.aliyuncs.com/compatible-mode/v1")
GLM（智谱）	langchain[openai]	使用 ChatOpenAI(base_url="https://open.bigmodel.cn/api/paas/v4")

---

三、核心概念详解

3.1 Chat Models（聊天模型）

LangChain 提供两种方式初始化模型：

方式一：init_chat_model（推荐，统一接口）

from langchain.chat_models import init_chat_model

# OpenAI GPT-4o
model = init_chat_model("gpt-4o")

# Anthropic Claude
model = init_chat_model("claude-sonnet-4-6")

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

方式二：直接使用提供方包

from langchain_openai import ChatOpenAI
model = ChatOpenAI(model="gpt-4o", temperature=0.7)

模型标识格式： provider:model_name，例如 openai:gpt-4o、azure_openai:gpt-4o、ollama:llama3。

核心方法：

# 普通调用
response = model.invoke("LangChain 是什么？")
print(response.text)           # 取文本

# 流式调用
for chunk in model.stream("讲个故事"):
    print(chunk.text, end="", flush=True)

# 批量调用
results = model.batch(["问题1", "问题2"])

模型能力自省（v1.1+）：

model.profile
# → {"max_input_tokens": 128000, "tool_calling": True, "image_inputs": True, ...}

3.2 Prompts（提示词）

LangChain 2026 支持多种消息格式：

# 字典格式（推荐，简洁）
messages = [
    {"role": "system", "content": "你是一个 Python 专家"},
    {"role": "user", "content": "什么是装饰器？"},
]
response = model.invoke(messages)

# Message 对象格式
from langchain.messages import HumanMessage, SystemMessage
messages = [
    SystemMessage("你是一个 Python 专家"),
    HumanMessage("什么是装饰器？"),
]
response = model.invoke(messages)

Message 类型：

类型	字典 role	说明
SystemMessage	system	系统角色设定
HumanMessage	user	用户输入
AIMessage	assistant	模型回复（含 tool_calls）
ToolMessage	tool	工具调用结果

3.3 Tools（工具）

LangChain 2026 使用 @tool 装饰器定义工具：

from langchain.tools import tool

@tool
def add(a: int, b: int) -> int:
    """计算两个数字的和"""
    return a + b

@tool(response_format="content_and_artifact")
def search(query: str) -> str:
    """搜索网络信息"""
    # 返回内容及原始文档
    return "搜索结果文本", [raw_docs]

# 绑定工具到模型
model_with_tools = model.bind_tools([add])

# 调用后获取工具请求
response = model_with_tools.invoke("23+45等于多少？")
for tc in response.tool_calls:
    print(f"工具: {tc['name']}, 参数: {tc['args']}")

3.4 Agents（代理）--- 核心

create_agent 是 LangChain 2026 的核心入口，底层基于 LangGraph，自动处理思考→工具调用→继续推理的循环。

from langchain.agents import create_agent

# 定义工具
@tool
def add(a: int, b: int) -> int:
    """计算两个数字的和"""
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """计算两个数字的乘积"""
    return a * b

tools = [add, multiply]

# 创建 Agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=tools,
    system_prompt="你是一个数学助手，使用工具计算结果",
)

# 执行
result = agent.invoke({
    "messages": [{"role": "user", "content": "(23+45)×2等于多少？"}]
})
print(result["messages"][-1].content_blocks)

Agent 执行流程：
Tools LLM Agent 用户 Tools LLM Agent 用户 (23+45)×2=? 思考 + 决策 调用 add(23,45) 返回 68 调用 multiply(68,2) 返回 136 生成最终答案 (23+45)×2 = 136

模型切换（只需改字符串！）：

# 换 Claude
agent = create_agent(
    model="claude-sonnet-4-6",  # ← 只改这一行
    tools=tools,
    system_prompt="...",
)

# 换 Gemini
agent = create_agent(
    model="google_genai:gemini-2.5-flash-lite",  # ← 只改这一行
    tools=tools,
    system_prompt="...",
)

3.5 RAG：知识库问答

RAG（检索增强生成）让 LLM 基于你自己的文档回答问题。
查询阶段（每次问答）
索引阶段（一次性）
文档
文本切分
Embedding
向量数据库
用户提问
Embedding
向量检索 Top-K
Agent 获取上下文
生成回答

from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_community.docstore.in_memory import InMemoryDocstore
from langchain.agents import create_agent
from langchain.tools import tool
import faiss

# ---- 1. 加载与切分 ----
loader = TextLoader("readme.txt")
docs = loader.load()
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_documents(docs)

# ---- 2. 构建向量库 ----
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
index = faiss.IndexFlatL2(len(embeddings.embed_query("hello")))
vector_store = FAISS(
    embedding_function=embeddings,
    index=index,
    docstore=InMemoryDocstore(),
    index_to_docstore_id={},
)
_ = vector_store.add_documents(documents=chunks)

# ---- 3. 构建检索工具 ----
@tool(response_format="content_and_artifact")
def retrieve_context(query: str):
    """检索文档内容来回答问题"""
    docs = vector_store.similarity_search(query, k=3)
    serialized = "\n\n".join(d.page_content for d in docs)
    return serialized, docs  # content + artifact

# ---- 4. 创建 Agent ----
agent = create_agent(
    model="openai:gpt-4o",
    tools=[retrieve_context],
    system_prompt="你是文档问答助手。使用检索工具获取相关上下文来回答问题。"
    "如果检索内容不足以回答，请如实告知。",
)

# ---- 5. 问答 ----
result = agent.invoke({
    "messages": [{"role": "user", "content": "这个项目是什么？"}]
})
print(result["messages"][-1].content_blocks)

常用向量数据库：

数据库	安装	适用场景
FAISS	pip install faiss-cpu langchain-community	本地/小规模
Chroma	pip install langchain-chroma	本地/开发调试
InMemoryVectorStore	内置在 langchain-core	快速原型
Pinecone	pip install langchain-pinecone	生产/云端

3.6 Memory（记忆）

LangChain 2026 的 Agent 内置 LangGraph 持久化支持：

from langchain.agents import create_agent

agent = create_agent(
    model="openai:gpt-4o",
    tools=[],
    system_prompt="你是一个友好的助手",
)

# 多轮对话（自动记忆）
result1 = agent.invoke({
    "messages": [{"role": "user", "content": "我叫小明"}]
})

result2 = agent.invoke({
    "messages": [
        {"role": "user", "content": "我叫小明"},
        {"role": "assistant", "content": result1["messages"][-1].text},
        {"role": "user", "content": "我叫什么名字？"}
    ]
})
print(result2["messages"][-1].text)  # → "你叫小明"

对于持久化存储，使用 LangGraph 的 checkpointer：

from langgraph.checkpoint.memory import MemorySaver

checkpointer = MemorySaver()
agent = create_agent(
    model="openai:gpt-4o",
    tools=[],
    system_prompt="你是一个友好的助手",
    checkpointer=checkpointer,  # ← 持久化
)

config = {"configurable": {"thread_id": "user_001"}}
result = agent.invoke(
    {"messages": [{"role": "user", "content": "我叫小明"}]},
    config,
)

---

四、实战：智能客服机器人

综合运用以上知识，构建一个可以查文档、带记忆的智能客服：

from langchain_openai import OpenAIEmbeddings
from langchain_community.document_loaders import DirectoryLoader, TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_community.docstore.in_memory import InMemoryDocstore
from langchain.agents import create_agent
from langchain.tools import tool
from langgraph.checkpoint.memory import MemorySaver
import faiss
import os

# ---- 1. 构建知识库 ----
loader = DirectoryLoader("./docs", glob="**/*.md", loader_cls=TextLoader)
docs = loader.load()
chunks = RecursiveCharacterTextSplitter(
    chunk_size=500, chunk_overlap=50
).split_documents(docs)

embeddings = OpenAIEmbeddings()
dim = len(embeddings.embed_query("hello"))
index = faiss.IndexFlatL2(dim)
vector_store = FAISS(
    embedding_function=embeddings,
    index=index,
    docstore=InMemoryDocstore(),
    index_to_docstore_id={},
)
_ = vector_store.add_documents(documents=chunks)

# ---- 2. 检索工具 ----
@tool(response_format="content_and_artifact")
def retrieve_context(query: str):
    """检索文档内容来回答问题"""
    docs = vector_store.similarity_search(query, k=3)
    serialized = "\n\n".join(d.page_content for d in docs)
    return serialized, docs

# ---- 3. 创建 Agent（自带记忆） ----
agent = create_agent(
    model="openai:gpt-4o",
    tools=[retrieve_context],
    system_prompt=(
        "你是一个友好的客服助手。根据检索到的资料回答问题。"
        "如果资料不足以回答，请如实告知。"
    ),
    checkpointer=MemorySaver(),
)

# ---- 4. 运行交互 ----
config = {"configurable": {"thread_id": "user_001"}}
while True:
    q = input("请输入问题 (exit 退出)：")
    if q == "exit":
        break
    result = agent.invoke(
        {"messages": [{"role": "user", "content": q}]},
        config,
    )
    print(result["messages"][-1].text)
    print("=" * 50)

知识库
Agent内部
用户输入
create_agent 客服 Agent
LLM 推理
工具节点

文档检索
记忆 (MemorySaver)
docs/ 目录
文本切分
FAISS 向量库
回答用户

---

五、进阶话题一览

5.1 结构化输出

让模型按指定 Schema 返回数据：

from pydantic import BaseModel, Field

class Movie(BaseModel):
    title: str = Field(description="电影标题")
    year: int = Field(description="上映年份")
    rating: float = Field(description="评分")

model_with_structure = model.with_structured_output(Movie)
result = model_with_structure.invoke("介绍电影《盗梦空间》")
print(result)  # Movie(title="Inception", year=2010, rating=8.8)

5.2 异步与流式

# 异步调用
response = await model.ainvoke("什么是LangChain？")

# 异步流式
async for chunk in model.astream("讲个故事"):
    print(chunk.text, end="", flush=True)

# 获取推理过程（reasoning）
for chunk in model.stream("1+1=?"):
    for block in chunk.content_blocks:
        if block["type"] == "reasoning":
            print("推理:", block["reasoning"])
        elif block["type"] == "text":
            print("回答:", block["text"])

5.3 LangGraph --- 低阶编排

对于复杂流程，直接使用 LangGraph：

from langgraph.graph import StateGraph, MessagesState
from langgraph.prebuilt import ToolNode

builder = StateGraph(MessagesState)
builder.add_node("llm", call_model)
builder.add_node("tools", ToolNode(tools))
builder.add_conditional_edges("llm", should_continue, {...})
graph = builder.compile()

5.4 Deep Agents（开箱即用）

LangChain 提供 Deep Agents，内置上下文压缩、虚拟文件系统、子代理孵化等高级功能：

pip install langchain
python -m langchain.deep_agents

5.5 话题速览

话题	说明	入口
Agent	智能代理，自动思考-工具-推理循环	create_agent()
RAG	检索增强生成	@tool + 向量库
LangGraph	有向图编排	StateGraph
Deep Agents	开箱即用高级 Agent	langchain.deep_agents
LangSmith	全链路追踪	LANGSMITH_TRACING=true

5.6 LangSmith 可观测性

LangSmith 是 LangChain 官方观测平台，支持：

• 全链路 Agent 调用追踪
• Token 消耗与延迟分析
• 回归测试
• Prompt 版本管理

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=lsv2_xxxx

---

六、总结与学习路线

核心理念

LangChain 2026 的核心是 Agent：

旧模式（旧版本）：  Chain → LCEL → Memory → AgentExecutor
新模式（v1.x）：   create_agent()  ← 统一入口，内置 LangGraph

推荐学习路线

① create_agent

• @tool
  ② RAG 检索

• 向量库
  ③ LangGraph

• Memory
  ④ 生产部署

• LangSmith

1. 基础 ：掌握 create_agent + @tool，10 行代码构建 Agent
2. RAG：添加检索工具，构建知识库问答系统
3. 进阶：使用 LangGraph 构建复杂工作流
4. 生产：集成 LangSmith 做追踪和评估

参考链接

资源	地址
官网	https://www.langchain.com/
Python 文档	https://python.langchain.com/docs
GitHub	https://github.com/langchain-ai/langchain
LangSmith	https://smith.langchain.com/
LangGraph 文档	https://langchain-ai.github.io/langgraph/
提示词模板库	https://smith.langchain.com/hub

LangChain 迭代很快，建议锁定主版本号 langchain>=1.0.0,<2.0.0。学习时以官方文档为准。