Python LangChain 从入门到精通：LCEL、RAG、Agent 与生产实践（2026版）

Au Pt

295人浏览 · 2026-08-16 15:01:27

Au Pt · 2026-08-16 15:01:27 发布

本文面向第一次接触 LangChain 的 Python 开发者，也适合用过早期版本、准备迁移到 LangChain v1 的读者。我们将从一次最简单的模型调用出发，逐步掌握 Prompt、LCEL、结构化输出、RAG、Agent、记忆、流式响应、测试与生产部署。文中代码以 Python 3.10+ 与 LangChain v1 风格 API 为基准。

一、LangChain 到底解决什么问题？

直接调用大模型 API 并不困难，真正困难的是把模型变成可靠的应用：

如何切换 OpenAI、Anthropic、Gemini、Ollama 等不同模型？
如何维护 Prompt，而不是到处拼接字符串？
如何让输出稳定满足 JSON 或业务对象格式？
如何让模型查询私有文档，而不是凭空回答？
如何让模型调用搜索、数据库、业务接口等工具？
如何保存多轮对话状态，并支持流式输出？
如何调试、评测、追踪成本和延迟？

LangChain 的价值，就是为这些问题提供一组统一、可组合的抽象。

可以把它理解为 AI 应用的“积木箱”：

组件	作用
Model	统一调用不同模型提供商
Message / Prompt	描述系统指令与对话输入
Runnable / LCEL	用管道组合多个处理步骤
Structured Output	让模型返回符合 Schema 的数据
Document / Retriever	文档处理与知识检索
Tool / Agent	让模型决定何时调用外部能力
Memory	保存线程级或跨线程状态
LangSmith	追踪、调试、评测与部署
LangGraph	为有状态、长流程 Agent 提供运行时

需要特别注意：LangChain 并不是模型，也不会提高模型本身的智力。 它负责的是编排、集成、状态管理与工程化。

二、认识 LangChain v1 的包结构

网上大量旧教程仍在使用 LLMChain、ConversationChain、initialize_agent。这些知识并非完全失效，但在 LangChain v1 中，核心命名空间已经精简。

常见包的职责如下：

langchain：Agent、Tool、Message、模型初始化等主线 API。
langchain-core：Runnable、Prompt、Document、输出解析器等核心抽象。
langchain-openai：OpenAI 模型与 Embedding 集成。
langchain-community：社区维护的加载器、工具和第三方集成。
langchain-text-splitters：文本切分器。
langgraph：Agent 的图运行时、状态与持久化。
langsmith：可观测性、数据集与评测。
langchain-classic：兼容旧式 Chain、Retriever 等历史 API。

本文优先使用 v1 主线写法。新项目不要再把 LLMChain 当作默认起点。

三、环境安装

3.1 创建虚拟环境

mkdir langchain-tutorial
cd langchain-tutorial

python -m venv .venv

# macOS / Linux
source .venv/bin/activate

# Windows PowerShell
# .venv\\Scripts\\Activate.ps1

3.2 安装依赖

python -m pip install -U pip
pip install -U langchain langchain-openai langgraph
pip install -U langchain-community langchain-text-splitters pypdf

如果只想完成最小模型调用，可以先安装：

pip install -U "langchain[openai]"

查看版本：

python -c "import langchain; print(langchain.__version__)"

3.3 配置密钥

不要把 API Key 直接写进代码或提交到 Git。

macOS / Linux：

export OPENAI_API_KEY="你的密钥"

Windows PowerShell：

$env:OPENAI_API_KEY="你的密钥"

开发环境也可以使用 .env，但必须把它加入 .gitignore。

四、第一次调用模型

LangChain 提供两种常见初始化方式：统一入口 init_chat_model，以及提供商专属类。初学阶段推荐先理解统一入口。

import os
from langchain.chat_models import init_chat_model

model = init_chat_model(
    os.getenv("MODEL_NAME", "openai:gpt-5.4-mini"),
    temperature=0,
    timeout=30,
    max_retries=2,
)

response = model.invoke("用三句话解释什么是 RAG。")

print(response.text)
print(response.usage_metadata)

如果账号没有示例中的模型权限，只需把 MODEL_NAME 换成当前账号可用、且支持 Chat 的模型。业务代码无需随之重写。

也可以直接使用集成类：

from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    model="gpt-5.4-mini",
    temperature=0,
)

4.1 为什么返回值不是字符串？

Chat Model 返回的是 AIMessage。除了正文，它通常还携带：

content：原始内容块；
text：便于读取的文本；
tool_calls：模型请求调用的工具；
usage_metadata：输入、输出 Token 用量；
response_metadata：提供商返回的其他信息。

保留消息对象比只返回字符串更适合多模态、工具调用和成本统计。

五、Message 与 Prompt：从字符串升级为可维护模板

5.1 使用消息列表

messages = [
    {
        "role": "system",
        "content": "你是一位严谨的 Python 导师，回答必须包含一个例子。",
    },
    {
        "role": "user",
        "content": "解释装饰器。",
    },
]

response = model.invoke(messages)
print(response.text)

常见角色包括：

system：定义身份、边界和总体行为；
user：用户输入；
assistant：历史模型回复；
tool：工具执行结果。

5.2 使用 ChatPromptTemplate

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一位{domain}专家，回答要准确、简洁。"),
    ("human", "请解释：{question}"),
])

prompt_value = prompt.invoke({
    "domain": "Python",
    "question": "生成器为什么节省内存？",
})

response = model.invoke(prompt_value)
print(response.text)

模板的意义不只是少写几个 f-string。它能让输入变量、消息角色和后续链式组合更清晰，也方便测试和版本管理。

5.3 一个实用的 Prompt 原则

优秀的系统提示通常应明确：

角色与目标；
可使用的信息；
不允许做什么；
输出结构；
信息不足时如何处理。

例如：

你是企业知识库助手。
只根据提供的 context 回答问题。
若 context 中没有答案，明确回复“根据现有资料无法确定”，不得猜测。
回答先给结论，再列出依据，并标注来源编号。

六、LCEL：LangChain 最值得掌握的组合方式

LCEL 是 LangChain Expression Language。它通过 | 把多个 Runnable 连接成数据管道。

from langchain_core.output_parsers import StrOutputParser

chain = prompt | model | StrOutputParser()

result = chain.invoke({
    "domain": "Python",
    "question": "上下文管理器解决了什么问题？",
})

print(result)

数据流可以表示为：

dict 输入
  -> ChatPromptTemplate
  -> PromptValue
  -> ChatModel
  -> AIMessage
  -> StrOutputParser
  -> str

6.1 invoke、batch、stream、ainvoke

同一条链通常天然支持多种执行方式。

# 单次调用
one = chain.invoke({"domain": "Python", "question": "解释 GIL"})

# 批量调用
many = chain.batch([
    {"domain": "Python", "question": "解释迭代器"},
    {"domain": "Python", "question": "解释生成器"},
])

# 流式调用
for chunk in chain.stream({
    "domain": "Python",
    "question": "解释 asyncio 的事件循环",
}):
    print(chunk, end="", flush=True)

异步调用：

import asyncio

async def main():
    result = await chain.ainvoke({
        "domain": "Python",
        "question": "解释协程",
    })
    print(result)

asyncio.run(main())

6.2 RunnableLambda 与并行分支

普通 Python 函数可以包装为 Runnable：

from langchain_core.runnables import RunnableLambda, RunnableParallel

def normalize(text: str) -> str:
    return text.strip().lower()

pipeline = RunnableLambda(normalize) | model | StrOutputParser()
print(pipeline.invoke("  Explain Python List Comprehensions  "))

parallel = RunnableParallel(
    summary=ChatPromptTemplate.from_template("总结：{text}") | model | StrOutputParser(),
    keywords=ChatPromptTemplate.from_template("提取关键词：{text}") | model | StrOutputParser(),
)

print(parallel.invoke({"text": "LangChain 用统一接口编排模型和工具。"}))

工程上应优先组合小而清晰的 Runnable，而不是把加载、检索、生成、解析全部塞进一个巨型函数。

七、结构化输出：让模型结果真正可被程序消费

仅靠“请输出 JSON”并不可靠。推荐用 Pydantic 描述业务 Schema，再调用 with_structured_output。

from pydantic import BaseModel, Field

class Ticket(BaseModel):
    category: str = Field(description="问题类别")
    priority: int = Field(ge=1, le=5, description="优先级，5 最高")
    summary: str = Field(description="一句话摘要")
    need_human: bool = Field(description="是否需要人工处理")

structured_model = model.with_structured_output(Ticket)

ticket = structured_model.invoke(
    "线上支付连续失败三次，客户非常着急，并且已被重复扣款。"
)

print(ticket)
print(ticket.priority)

如果需要同时保留模型原始消息和解析结果：

structured_model = model.with_structured_output(
    Ticket,
    include_raw=True,
)

result = structured_model.invoke("用户忘记密码，无法登录。")
print(result["parsed"])
print(result["raw"].usage_metadata)
print(result["parsing_error"])

结构化输出适合：

信息抽取；
分类与路由；
表单生成；
API 参数生成；
数据清洗；
工作流中的中间状态。

生产环境仍要对字段做业务校验。Schema 正确不代表事实正确。

八、Tool 与 Agent：让模型能够采取行动

普通 Chain 的执行路径由开发者预先决定；Agent 则让模型根据任务动态决定是否调用工具以及调用顺序。

8.1 定义工具

from langchain.tools import tool

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

@tool
def get_inventory(product: str) -> str:
    """查询指定商品库存。仅返回演示数据。"""
    demo_data = {"keyboard": 12, "mouse": 0}
    return f"{product} 库存：{demo_data.get(product.lower(), '未知')}"

工具的名称、参数类型和 docstring 都会影响模型选择。描述应准确说明“何时使用、输入是什么、输出是什么”。

8.2 创建 Agent

from langchain.agents import create_agent

agent = create_agent(
    model=model,
    tools=[multiply, get_inventory],
    system_prompt=(
        "你是电商助理。需要计算或查库存时必须调用工具，"
        "不能编造工具结果。"
    ),
)

result = agent.invoke({
    "messages": [
        {"role": "user", "content": "买 7 个单价 19.9 元的键盘套，一共多少钱？"}
    ]
})

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

create_agent 底层使用 LangGraph 构建循环。典型过程是：

用户消息 -> 模型判断 -> 请求调用工具 -> 执行工具
                  ^                       |
                  |-----------------------|
                 再次判断，直到给出最终回复

8.3 Agent 不等于“越自主越好”

如果流程固定，例如“先查数据库，再生成摘要”，直接使用确定性的 Chain 往往更快、更便宜、更容易测试。只有当执行路径确实需要动态决策时，才引入 Agent。

高风险工具还应增加：

参数白名单与权限检查；
超时、重试和幂等设计；
人工确认节点；
结果长度限制；
审计日志；
对写操作与读操作进行隔离。

九、记忆：不要再手动拼接无限历史消息

LangChain v1 的 Agent 把短期记忆作为状态的一部分，并通过 checkpointer 持久化。

9.1 内存型短期记忆

from langgraph.checkpoint.memory import InMemorySaver

checkpointer = InMemorySaver()

memory_agent = create_agent(
    model=model,
    tools=[],
    checkpointer=checkpointer,
    system_prompt="你是一位友好的助理。",
)

config = {"configurable": {"thread_id": "user-001-session-01"}}

memory_agent.invoke(
    {"messages": [{"role": "user", "content": "我叫小林，喜欢 Python。"}]},
    config,
)

result = memory_agent.invoke(
    {"messages": [{"role": "user", "content": "我叫什么，喜欢什么？"}]},
    config,
)

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

相同 thread_id 表示同一段会话；不同 thread_id 应彼此隔离。

9.2 生产环境怎么做？

InMemorySaver 只适合教程和本地测试。进程退出后数据会消失，也不适合多实例服务。生产环境应使用数据库型 checkpointer，例如 PostgreSQL。

还要区分：

短期记忆：当前线程内的对话与状态；
长期记忆：跨线程保存的用户偏好、事实或业务数据。

不要把全部历史消息永久塞进上下文。对话变长后，应考虑裁剪、摘要、按需检索与隐私保留策略。

十、RAG：让模型基于私有知识回答

RAG（Retrieval-Augmented Generation，检索增强生成）的核心不是“训练模型”，而是在提问时检索相关资料，并把资料作为上下文交给模型。

标准流水线：

原始文件
  -> Document Loader
  -> Text Splitter
  -> Embedding
  -> Vector Store
  -> Retriever
  -> Prompt + Model
  -> 有依据的回答

10.1 加载并切分 PDF

假设项目目录中有 handbook.pdf：

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

loader = PyPDFLoader("handbook.pdf")
documents = loader.load()

splitter = RecursiveCharacterTextSplitter(
    chunk_size=800,
    chunk_overlap=120,
    add_start_index=True,
)

chunks = splitter.split_documents(documents)

print(f"原始页数：{len(documents)}")
print(f"切分块数：{len(chunks)}")
print(chunks[0].metadata)

切块并非越小越好：

太大：召回内容不够聚焦，浪费上下文；
太小：语义被切碎，答案缺少完整信息；
overlap 太大：索引成本和重复内容增加。

推荐根据文档结构和真实问题集进行评测，不要迷信固定参数。

10.2 建立向量索引

from langchain_core.vectorstores import InMemoryVectorStore
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

vector_store = InMemoryVectorStore.from_documents(
    documents=chunks,
    embedding=embeddings,
)

retriever = vector_store.as_retriever(
    search_kwargs={"k": 4}
)

matched_docs = retriever.invoke("年假最多可以结转几天？")

for i, doc in enumerate(matched_docs, start=1):
    print(i, doc.metadata, doc.page_content[:100])

内存向量库适合学习。生产环境可以根据规模、过滤能力、延迟、成本和运维条件选择专用向量库。

10.3 构建 2-Step RAG Chain

2-Step RAG 总是先检索，再生成，路径确定、延迟容易预测，是大多数知识问答的好起点。

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableLambda, RunnablePassthrough

def format_docs(docs):
    parts = []
    for index, doc in enumerate(docs, start=1):
        source = doc.metadata.get("source", "unknown")
        page = doc.metadata.get("page", "unknown")
        parts.append(
            f"[资料{index}] source={source}, page={page}\\n{doc.page_content}"
        )
    return "\\n\\n".join(parts)

rag_prompt = ChatPromptTemplate.from_messages([
    (
        "system",
        "你是企业知识库助手。只根据 context 回答。"
        "如果资料不足，明确说无法确定；回答末尾列出引用的资料编号。",
    ),
    ("human", "问题：{question}\\n\\ncontext：\\n{context}"),
])

rag_chain = (
    {
        "context": retriever | RunnableLambda(format_docs),
        "question": RunnablePassthrough(),
    }
    | rag_prompt
    | model
    | StrOutputParser()
)

answer = rag_chain.invoke("年假最多可以结转几天？")
print(answer)

10.4 把 Retriever 变成 Agent 工具

当问题不一定需要查知识库，或 Agent 需要在多个数据源之间动态选择时，可以采用 Agentic RAG。

@tool
def search_handbook(query: str) -> str:
    """搜索员工手册。涉及休假、考勤、报销或公司制度时使用。"""
    docs = retriever.invoke(query)
    return format_docs(docs)

rag_agent = create_agent(
    model=model,
    tools=[search_handbook],
    system_prompt=(
        "你是企业助手。回答公司制度前必须搜索员工手册；"
        "资料不足时不要猜测。"
    ),
)

10.5 RAG 精度优化顺序

RAG 回答差，不要第一时间更换大模型。建议按下面顺序定位：

原始文档是否完整、可解析；
用户问题是否需要查询改写；
切块是否破坏语义结构；
Embedding 是否匹配语言和领域；
k 值与过滤条件是否合理；
是否需要关键词 + 向量的混合检索；
是否需要 reranker 重排；
Prompt 是否明确“只能基于资料”；
是否正确展示来源；
最后再比较不同生成模型。

检索质量决定了 RAG 的上限。模型无法回答根本没有被召回的内容。

十一、流式输出：改善用户等待体验

模型完整生成后再返回，会让用户感觉系统“卡住了”。最简单的模型流式输出如下：

for chunk in model.stream("写一段 200 字的 Python 学习建议"):
    if chunk.text:
        print(chunk.text, end="", flush=True)

Agent 流式输出不仅可以展示 Token，还可以展示执行步骤。

for state in agent.stream(
    {
        "messages": [
            {"role": "user", "content": "查询 keyboard 库存，并计算买 3 个需要多少件商品。"}
        ]
    },
    stream_mode="values",
):
    latest = state["messages"][-1]
    if latest.text:
        print(latest.text)
    elif latest.tool_calls:
        print("正在调用工具：", latest.tool_calls)

前端应用通常还需要处理取消、断线重连、超时、半成品消息与重复事件。

十二、可观测性：用 LangSmith 看见链路内部

复杂 AI 应用的错误经常不是传统异常，而是“输出看起来不对”。你需要看到：

实际发送给模型的 Prompt；
每个 Tool 的输入与输出；
Retriever 返回了哪些文档；
Agent 执行了多少步；
每一步的耗时、Token 和错误；
同一个输入在不同版本下的输出差异。

开启 LangSmith tracing：

export LANGSMITH_TRACING="true"
export LANGSMITH_API_KEY="你的 LangSmith Key"
export LANGSMITH_PROJECT="langchain-tutorial"

建议为调用附加元数据：

config = {
    "tags": ["rag", "production"],
    "metadata": {
        "tenant_id": "demo-tenant",
        "app_version": "1.0.0",
    },
}

result = rag_chain.invoke("如何申请年假？", config=config)

注意不要把密码、API Key、身份证号等敏感数据写入 trace。

十三、测试与评测：AI 应用不能只靠“感觉不错”

传统软件测试强调确定性断言；LLM 应用还需要关注语义质量与执行轨迹。

13.1 先测试确定性部分

def test_format_docs():
    from langchain_core.documents import Document

    docs = [
        Document(
            page_content="年假可结转 5 天。",
            metadata={"source": "handbook.pdf", "page": 3},
        )
    ]

    text = format_docs(docs)
    assert "年假可结转 5 天" in text
    assert "handbook.pdf" in text
    assert "page=3" in text

对这些内容做普通单元测试：

文档解析与清洗；
切块边界；
权限过滤；
Tool 参数校验；
输出 Schema；
缓存键与重试逻辑。

13.2 建立评测数据集

一个 RAG 数据集至少可以包含：

字段	示例
question	年假最多结转几天？
expected_answer	5 天
expected_sources	handbook.pdf 第 4 页
forbidden_claims	不得声称可无限结转

评测指标可以包括：

检索 Recall@k；
答案正确性；
引用准确性；
对无答案问题的拒答率；
Agent 工具选择是否正确；
延迟和 Token 成本；
安全策略命中率。

上线前做离线评测，上线后对真实 trace 采样做在线评测，并把失败样本加入回归数据集。

十四、生产级实践清单

14.1 配置与安全

API Key 通过密钥管理服务或环境变量注入；
不记录敏感 Prompt、原始文件或完整工具返回；
对 Tool 做最小权限、参数校验和调用审计；
防范 Prompt Injection：检索到的网页和文档是数据，不是系统指令；
写操作、付款、删除、发消息等动作必须设计人工确认；
多租户检索必须先做权限过滤，再做语义召回。

14.2 稳定性

设置 timeout 和有限次数的 max_retries；
对可重试错误使用指数退避；
写工具必须幂等，避免重试造成重复下单或重复通知；
限制 Agent 最大步数、工具输出长度和总运行时间；
为模型、Embedding、向量库准备降级策略；
处理模型限流和上下文窗口超限。

14.3 成本与性能

简单分类使用小模型，复杂推理再路由到大模型；
对稳定结果做语义或精确缓存；
用 batch 和 async 提升吞吐；
RAG 只传真正相关的片段；
监控输入 Token、输出 Token、工具耗时和端到端 P95 延迟；
不要为了“更智能”无上限增加 Agent 循环。

14.4 可维护性

固定依赖版本并定期升级；
Prompt、Schema、工具与业务逻辑分文件管理；
给 Chain 和 Agent 增加版本号；
保存关键数据集，升级模型或依赖前跑回归评测；
优先使用公开稳定 API，避免依赖内部实现。

十五、常见报错与迁移避坑

15.1 `ModuleNotFoundError: langchain_openai`

安装独立集成包：

pip install -U langchain-openai

正确导入：

from langchain_openai import ChatOpenAI, OpenAIEmbeddings

15.2 旧教程中的 `LLMChain` 无法导入

LangChain v1 已将很多旧式 Chain 移到 langchain-classic。旧项目可临时安装：

pip install -U langchain-classic

但新项目更推荐：

chain = prompt | model | StrOutputParser()

15.3 `initialize_agent`、旧 AgentExecutor 教程失效

新项目优先使用：

from langchain.agents import create_agent

15.4 模型输出的 JSON 偶尔解析失败

不要只在 Prompt 中要求 JSON，优先使用：

model.with_structured_output(YourPydanticModel)

并检查当前模型提供商是否支持原生 Structured Output 或 Tool Calling。

15.5 RAG 总是答非所问

先打印 retriever.invoke(question) 的结果。如果相关文档根本没被召回，问题在检索侧；如果召回正确但回答错误，再检查 Prompt 和模型。

15.6 对话记忆串号

检查 thread_id 是否按用户和会话正确隔离。多租户系统绝不能让不同用户共享同一个固定 thread id。

15.7 版本升级后示例突然失效

记录环境：

pip freeze > requirements-lock.txt

同时查看官方迁移指南。LangChain 生态迭代较快，教程代码必须带版本背景。

十六、从入门到精通的学习路线

第一阶段：能调用

掌握虚拟环境与密钥管理；
能使用 invoke、stream；
理解 Message 和 Chat Model 返回值。

第二阶段：能组合

掌握 ChatPromptTemplate；
熟悉 LCEL 的 |；
会用结构化输出；
会使用 batch 与 async。

第三阶段：能接知识

理解 Document、Splitter、Embedding、Vector Store、Retriever；
能搭建 2-Step RAG；
会用真实数据集评测检索质量。

第四阶段：能做 Agent

设计清晰、安全的 Tool；
使用 create_agent；
管理短期记忆和线程状态；
理解什么时候不该使用 Agent。

第五阶段：能上线

掌握 tracing、离线评测和在线监控；
处理权限、重试、幂等、限流与降级；
持续优化正确率、延迟与成本。

真正的“精通”不是记住所有类名，而是能在确定性流程、RAG 与 Agent 之间做出正确选择，并能用数据证明系统有效。

十七、总结

本文完成了从最小模型调用到生产实践的完整闭环：

用统一模型接口屏蔽提供商差异；
用 Message 和 Prompt 管理输入；
用 LCEL 组合可复用流水线；
用 Structured Output 获得稳定业务对象；
用 Tool 和 Agent 动态执行任务；
用 checkpointer 保存线程状态；
用 Loader、Splitter、Embedding、Vector Store 与 Retriever 搭建 RAG；
用 streaming、tracing、测试与评测走向生产。

如果只记住一句话：先用最简单、最确定的 Chain 解决问题；只有流程确实需要动态决策时，再引入 Agent。

参考资料

LangChain 安装文档：https://docs.langchain.com/oss/python/langchain/install
LangChain 模型文档：https://docs.langchain.com/oss/python/langchain/models
LangChain Agent 文档：https://docs.langchain.com/oss/python/langchain/agents
LangChain Retrieval 文档：https://docs.langchain.com/oss/python/langchain/retrieval
LangChain 短期记忆文档：https://docs.langchain.com/oss/python/langchain/short-term-memory
LangChain v1 迁移指南：https://docs.langchain.com/oss/python/migrate/langchain-v1
LangSmith Evaluation：https://docs.langchain.com/langsmith/evaluation

说明：模型名称与第三方集成可能随时间变化。若示例模型在你的账号中不可用，请替换为当前账号可用的 Chat Model；LangChain 的整体组合方式不变。

MCP技术社区

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

更多推荐

初识智能体

在过去两年中，几乎所有人都体验过大语言模型（如 ChatGPT、Claude、DeepSeek）的强大能力：写周报、润色邮件、解答编程疑难。被动响应：你问一句，它答一句。如果你的 Prompt 没有写清楚约束条件，它无法主动追问或修正目标。知行脱节：大模型能用流畅的文字告诉你“如何部署一个高可用 K8s 集群”，但它无法替你登录服务器敲下命令、查看报错日志并自动回滚。信息孤岛：大模型的知识止步于预

MCP技术社区

Windows 下部署 New API 中转站全过程实录（含 6 个真实踩坑）

MCP技术社区

Google能索引，AI却抓不到

很多技术团队有个错觉：只要Google能正常收录，内容就没问题。但现实是，你的页面在Google搜索结果里好好的，在ChatGPT、Perplexity、Claude的答案里却像从未存在过一样。

MCP技术社区

所有评论(0)

查看更多评论

Au Pt

@JSX1437

已为社区贡献1条内容

Python LangChain 从入门到精通：LCEL、RAG、Agent 与生产实践（2026版）

Au Pt

一、LangChain 到底解决什么问题？

二、认识 LangChain v1 的包结构

三、环境安装

3.1 创建虚拟环境

3.2 安装依赖

3.3 配置密钥

四、第一次调用模型

4.1 为什么返回值不是字符串？

五、Message 与 Prompt：从字符串升级为可维护模板

5.1 使用消息列表

5.2 使用 ChatPromptTemplate

5.3 一个实用的 Prompt 原则

六、LCEL：LangChain 最值得掌握的组合方式

6.1 invoke、batch、stream、ainvoke

6.2 RunnableLambda 与并行分支

七、结构化输出：让模型结果真正可被程序消费

八、Tool 与 Agent：让模型能够采取行动

8.1 定义工具

8.2 创建 Agent

8.3 Agent 不等于“越自主越好”

九、记忆：不要再手动拼接无限历史消息

9.1 内存型短期记忆

9.2 生产环境怎么做？

十、RAG：让模型基于私有知识回答

10.1 加载并切分 PDF

10.2 建立向量索引

10.3 构建 2-Step RAG Chain

10.4 把 Retriever 变成 Agent 工具

10.5 RAG 精度优化顺序

十一、流式输出：改善用户等待体验

十二、可观测性：用 LangSmith 看见链路内部

十三、测试与评测：AI 应用不能只靠“感觉不错”

13.1 先测试确定性部分

13.2 建立评测数据集

十四、生产级实践清单

14.1 配置与安全

14.2 稳定性

14.3 成本与性能

14.4 可维护性

十五、常见报错与迁移避坑

15.1 ModuleNotFoundError: langchain_openai

15.2 旧教程中的 LLMChain 无法导入

15.3 initialize_agent、旧 AgentExecutor 教程失效

15.4 模型输出的 JSON 偶尔解析失败

15.5 RAG 总是答非所问

15.6 对话记忆串号

15.7 版本升级后示例突然失效

十六、从入门到精通的学习路线

第一阶段：能调用

第二阶段：能组合

第三阶段：能接知识

第四阶段：能做 Agent

第五阶段：能上线

十七、总结

参考资料

所有评论(0)

温馨提示：您尚未绑定手机号

Au Pt

15.1 `ModuleNotFoundError: langchain_openai`

15.2 旧教程中的 `LLMChain` 无法导入

15.3 `initialize_agent`、旧 AgentExecutor 教程失效