前言

如果你最近关注 AI 开发，一定听过 LangChain 这个名字。它是目前最流行的 LLM 应用开发框架，GitHub 上已超过 9 万颗星。

简单说：LangChain 就是一套工具箱，让你更方便地把大语言模型（LLM）接进自己的应用里。

本文从零开始，带你搞懂 LangChain 的核心概念，并写出几个真正能跑起来的示例。

一、LangChain 是什么？为什么需要它？

直接调用 OpenAI / Claude 等大模型的 API 能解决很多问题，但一旦你想做更复杂的事，就会遇到麻烦：

• 模型记不住上下文，多轮对话要自己管状态
• 需要让模型"搜索网页"或"查数据库"，不知道怎么接
• 每次换模型都要改一大堆代码
• 想把多个 AI 步骤串联成流水线，代码写得乱七八糟

LangChain 就是来解决这些问题的。 它提供了统一的抽象层，把模型调用、上下文管理、工具调用、流水线编排全部标准化。

二、核心概念一览

LangChain 有六个核心模块，理解了这六个，你就掌握了 80% 的内容：

┌─────────────────────────────────────────────┐
│              LangChain 核心模块               │
├───────────┬──────────────────────────────────┤
│ Models    │ 统一接入各种 LLM（GPT、Claude…）    │
│ Prompts   │ 提示词模板管理                     │
│ Chains    │ 把多个步骤串联成流水线               │
│ Memory    │ 让模型记住对话历史                  │
│ Agents    │ 让模型自主决策、调用工具             │
│ Tools     │ 搜索、计算、数据库等外部能力          │
└───────────┴──────────────────────────────────┘

下面逐一展开讲解，每个都配代码示例。

三、安装环境

pip install langchain langchain-openai langchain-community

然后配置 API Key（以 OpenAI 为例）：

import os
os.environ["OPENAI_API_KEY"] = "sk-你的key"

提示：国内用户如需访问 OpenAI，可以用支持 OpenAI 协议的国内代理服务，或者改用通义千问等有国内接入点的模型。

四、Models：统一接入各种 LLM

这是 LangChain 最基础的部分，它把不同厂商的模型封装成统一接口。

from langchain_openai import ChatOpenAI

# 初始化模型
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0.7# 0=保守，1=创意，建议 0.7 左右
)

# 最简单的调用
response = llm.invoke("用一句话解释什么是量子纠缠")
print(response.content)

切换到其他模型只需换一行：

# 换成 Claude
from langchain_anthropic import ChatAnthropic
llm = ChatAnthropic(model="claude-sonnet-4-5")

# 换成通义千问
from langchain_community.llms import Tongyi
llm = Tongyi(model="qwen-turbo")

这就是 LangChain 的价值之一——换模型不用改业务逻辑。

五、Prompts：提示词模板管理

硬编码提示词很难维护，LangChain 提供了模板系统：

from langchain_core.prompts import ChatPromptTemplate

# 定义模板，用 {} 占位
template = ChatPromptTemplate.from_messages([
    ("system", "你是一名{role}，请用{style}的风格回答问题。"),
    ("human", "{question}")
])

# 填充变量
prompt = template.invoke({
"role": "资深程序员",
"style": "简洁幽默",
"question": "Python 和 Go 哪个更好？"
})

response = llm.invoke(prompt)
print(response.content)

Few-shot 提示词（给模型看例子）：

from langchain_core.prompts import FewShotChatMessagePromptTemplate

examples = [
    {"input": "苹果", "output": "🍎"},
    {"input": "香蕉", "output": "🍌"},
    {"input": "西瓜", "output": "🍉"},
]

few_shot_prompt = FewShotChatMessagePromptTemplate(
    examples=examples,
    example_prompt=ChatPromptTemplate.from_messages([
        ("human", "{input}"),
        ("ai", "{output}")
    ])
)

final_prompt = ChatPromptTemplate.from_messages([
    few_shot_prompt,
    ("human", "{fruit}")
])

chain = final_prompt | llm
print(chain.invoke({"fruit": "葡萄"}).content)  # 输出：🍇

六、Chains：把步骤串联成流水线

这是 LangChain 名字里 "Chain" 的由来。用 | 管道符把组件串起来（LCEL 语法）：

from langchain_core.output_parsers import StrOutputParser

# 三步流水线：模板 -> 模型 -> 解析输出
chain = template | llm | StrOutputParser()

result = chain.invoke({
"role": "营养师",
"style": "专业",
"question": "早餐吃什么最健康？"
})
print(result)  # 直接返回字符串，不是消息对象

串联两个 Chain（多步推理）：

# 第一步：生成一个创业想法
idea_prompt = ChatPromptTemplate.from_template(
"给我一个关于{topic}领域的创业想法，一句话描述"
)

# 第二步：分析这个想法的可行性
analysis_prompt = ChatPromptTemplate.from_template(
"分析这个创业想法的可行性，列出3个优点和3个风险：\n{idea}"
)

parser = StrOutputParser()

# 串联：idea_chain 的输出自动传给 analysis_chain
idea_chain = idea_prompt | llm | parser
full_chain = (
    idea_chain
    | (lambda idea: {"idea": idea})
    | analysis_prompt
    | llm
    | parser
)

print(full_chain.invoke({"topic": "宠物经济"}))

七、Memory：让模型记住对话

默认情况下，每次调用 LLM 都是无状态的，它不记得你上一句说了什么。Memory 模块解决这个问题：

from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# 存储每个会话的历史
store = {}

defget_session_history(session_id: str):
if session_id notin store:
        store[session_id] = InMemoryChatMessageHistory()
return store[session_id]

# 构建带记忆的对话链
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个友善的助手"),
    ("placeholder", "{chat_history}"),  # 历史记录插入位置
    ("human", "{input}")
])

chain = prompt | llm | StrOutputParser()

# 包装成有记忆能力的链
with_memory = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history"
)

config = {"configurable": {"session_id": "user_001"}}

# 第一轮
r1 = with_memory.invoke({"input": "我叫小明，我喜欢打篮球"}, config=config)
print(r1)

# 第二轮（模型能记住上文）
r2 = with_memory.invoke({"input": "我叫什么名字？我喜欢什么运动？"}, config=config)
print(r2)  # 会正确回答：小明，篮球

八、Tools & Agents：让模型自己"干活"

这是 LangChain 最强大也是最有趣的部分。Agent = 让 LLM 自主规划并调用工具完成任务。

8.1 定义工具

from langchain_core.tools import tool

@tool
defcalculate(expression: str) -> str:
"""计算数学表达式，例如 '2 + 3 * 4'"""
try:
return str(eval(expression))
except Exception as e:
returnf"计算出错: {e}"

@tool
defget_weather(city: str) -> str:
"""获取指定城市的天气（模拟数据）"""
    weather_data = {
"北京": "晴天，气温 22°C",
"上海": "多云，气温 18°C",
"广州": "小雨，气温 26°C"
    }
return weather_data.get(city, f"暂无 {city} 的天气数据")

8.2 创建 Agent

from langchain.agents import create_tool_calling_agent, AgentExecutor

tools = [calculate, get_weather]

agent_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个智能助手，可以调用工具来帮助用户"),
    ("placeholder", "{agent_scratchpad}"),
    ("human", "{input}")
])

# 创建 agent
agent = create_tool_calling_agent(llm, tools, agent_prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 让 agent 自主决策用哪个工具
result = executor.invoke({
"input": "北京今天天气怎么样？另外帮我算一下 (123 + 456) * 2 等于多少"
})
print(result["output"])

运行时你会看到 Agent 的思考过程：

> 进入 AgentExecutor chain...
调用工具: get_weather(city="北京")
工具返回: 晴天，气温 22°C
调用工具: calculate(expression="(123 + 456) * 2")
工具返回: 1158
最终答案: 北京今天是晴天，气温 22°C。(123+456)×2 = 1158。

九、RAG：让模型基于你的文档回答问题

RAG（检索增强生成）是 LangChain 最常见的实战场景——上传文档，然后用自然语言提问。

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.chains import RetrievalQA

# 第一步：加载文档
loader = TextLoader("company_docs.txt", encoding="utf-8")
docs = loader.load()

# 第二步：切分成小块（模型有 token 限制）
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,    # 每块 500 字符
    chunk_overlap=50# 相邻块有 50 字符重叠，避免截断关键信息
)
chunks = splitter.split_documents(docs)

# 第三步：向量化并存入向量数据库
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# 第四步：构建问答链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3}),
    return_source_documents=True
)

# 提问
result = qa_chain.invoke({"query": "公司的退款政策是什么？"})
print(result["result"])

RAG 的完整流程：文档 → 切块 → 向量化 → 存库 → 检索相关块 → 拼入 Prompt → LLM 生成答案

十、一个完整的实战示例

把前面学的全部串起来，做一个带记忆、能查文档的智能客服：

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.vectorstores import FAISS
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

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

# 假设已有向量库
vectorstore = FAISS.load_local("my_vectorstore", OpenAIEmbeddings())
retriever = vectorstore.as_retriever()

# 构建 RAG prompt
rag_prompt = ChatPromptTemplate.from_template("""
你是公司的智能客服，请根据以下参考资料回答用户问题。
如果资料中没有相关信息，就说"我暂时没有这方面的信息，请联系人工客服"。

参考资料：
{context}

用户问题：{question}
""")

defformat_docs(docs):
return"\n\n".join(doc.page_content for doc in docs)

# 最终的 RAG 链
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

answer = rag_chain.invoke("你们的产品支持退款吗？")
print(answer)

十一、常见问题 & 踩坑指南

Q：LangChain 版本变化很快，代码跑不起来怎么办？

确认使用 langchain >= 0.3，旧版 API 已大幅调整。优先用 langchain_core 和 langchain_openai 包，避免用已废弃的 langchain.llms。

Q：Token 费用太贵怎么控制？

# 设置 max_tokens 限制输出长度
llm = ChatOpenAI(model="gpt-4o-mini", max_tokens=500)

# 开发阶段用 gpt-4o-mini，上线再换 gpt-4o

Q：Agent 调用工具出错了还一直重试，怎么设置最大次数？

executor = AgentExecutor(
    agent=agent,
    tools=tools,
    max_iterations=5,        # 最多执行 5 步
    handle_parsing_errors=True# 解析失败时优雅处理
)

Q：想看到 Chain 内部每一步的输入输出？

# 开启 verbose 模式
chain = (prompt | llm | parser).with_config({"verbose": True})

# 或者用回调
from langchain.callbacks import StdOutCallbackHandler
llm = ChatOpenAI(callbacks=[StdOutCallbackHandler()])

十二、学习路线推荐

阶段一（1周）：基础
  ✅ 跑通第一个 ChatOpenAI 示例
  ✅ 掌握 Prompt Template
  ✅ 写第一个 Chain

阶段二（2周）：进阶
  ✅ 做一个带 Memory 的多轮对话机器人
  ✅ 实现一个 RAG 文档问答系统
  ✅ 自定义 Tool 并接入 Agent

阶段三（1月）：实战
  ✅ 接入真实数据库 / API
  ✅ 部署到 FastAPI 提供 Web 服务
  ✅ 学习 LangGraph（更复杂的多 Agent 编排）

总结

LangChain 的学习曲线初期有点陡，但一旦掌握核心概念，你会发现构建复杂 AI 应用变得异常流畅。从最小可用示例开始，跑通一个，再加一个特性，是最好的学习方式。

本文代码基于 LangChain 0.3.x，如有疑问欢迎留言交流。