LangChain入门完整指南2025
从零构建AI应用（含代码实战）

🦜 LangChain是什么？

LangChain是一个用于构建AI应用的开源框架，GitHub Star数已超过95,000，是AI应用开发领域最流行的工具之一。它解决的核心问题是：如何将LLM（大语言模型）与外部数据、工具和工作流连接起来，构建真正有用的AI应用。

单独的LLM（如GPT-4、Claude）只能回答问题，但无法：访问你的私有文档、调用外部API、执行多步骤任务、记住对话历史、自主决策下一步行动。LangChain提供了实现这些能力的标准化框架。

⚙️ 安装与环境配置

# 安装核心包（LangChain 0.3+）
pip install langchain langchain-openai langchain-community

# 如果使用Anthropic Claude
pip install langchain-anthropic

# RAG所需的向量数据库（选一个）
pip install chromadb         # 本地，最适合入门
pip install pinecone-client  # 云端生产环境

# PDF处理
pip install pypdf langchain-text-splitters

# LangGraph（Agent工作流）
pip install langgraph
bash

# .env 文件（不要提交到Git！）
OPENAI_API_KEY=sk-proj-xxxxxx
ANTHROPIC_API_KEY=sk-ant-xxxxxx
LANGCHAIN_API_KEY=ls__xxxxxx      # LangSmith追踪（可选）
LANGCHAIN_TRACING_V2=true
.env

# Python中加载环境变量
from dotenv import load_dotenv
import os
load_dotenv()

# 验证安装
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o-mini")
response = llm.invoke("Hello, LangChain!")
print(response.content)
Python

🧩 核心概念详解

1. LLM / ChatModel — 模型接口

LangChain统一了不同LLM的调用接口，切换模型只需改一行代码：

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

# OpenAI
llm_gpt = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

# Anthropic Claude
llm_claude = ChatAnthropic(model="claude-3-5-sonnet-20241022")

# 调用方式完全一致（统一接口）
result = llm_gpt.invoke("用一句话解释量子纠缠")
print(result.content)

# 流式输出
for chunk in llm_claude.stream("写一首关于Python的俳句"):
    print(chunk.content, end="", flush=True)
Python

2. PromptTemplate — 动态提示词

from langchain_core.prompts import ChatPromptTemplate

# 定义带变量的提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一位专业的{role}，用{language}回答，风格{style}。"),
    ("human", "{question}")
])

# 使用 | 管道符连接（LCEL语法）
chain = prompt | llm_gpt

result = chain.invoke({
    "role": "Python工程师",
    "language": "中文",
    "style": "简洁直接",
    "question": "如何优化列表推导式的性能？"
})
print(result.content)
Python

3. LCEL — LangChain表达式语言

LCEL（LangChain Expression Language）是0.3版本的核心，用|管道符连接组件，像搭积木一样构建复杂链：

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

llm = ChatOpenAI(model="gpt-4o-mini")
parser = StrOutputParser()  # 从AIMessage提取纯文本

# 链1：生成博客大纲
outline_prompt = ChatPromptTemplate.from_template(
    "为以下主题生成5点博客大纲：{topic}"
)
outline_chain = outline_prompt | llm | parser

# 链2：基于大纲写引言
intro_prompt = ChatPromptTemplate.from_template(
    "基于以下大纲写一个引人入胜的引言（150字）：\n{outline}"
)
intro_chain = intro_prompt | llm | parser

# 顺序链：大纲 → 引言（自动传递）
full_chain = outline_chain | (lambda x: {"outline": x}) | intro_chain

result = full_chain.invoke({"topic": "AI如何改变软件开发"})
print(result)
Python

4. Memory — 对话记忆

from langchain_core.chat_history import InMemoryChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# 带历史记忆的聊天机器人
store = {}  # session_id → 对话历史

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = InMemoryChatMessageHistory()
    return store[session_id]

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个友好的AI助手，记住我们的对话内容。"),
    MessagesPlaceholder(variable_name="history"),  # 历史消息插入位置
    ("human", "{input}")
])

chain = prompt | ChatOpenAI(model="gpt-4o-mini") | StrOutputParser()

chat_with_memory = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history"
)

# 同一session_id = 记住对话
config = {"configurable": {"session_id": "user_001"}}
print(chat_with_memory.invoke({"input": "我叫小明，是一名Python开发者"}, config=config))
print(chat_with_memory.invoke({"input": "我叫什么名字？"}, config=config))  # 能记住！
Python

📚 RAG：检索增强生成

RAG（Retrieval-Augmented Generation）是LangChain最常见的应用场景：将私有文档变成可以问答的知识库，解决LLM训练数据截止和私有知识问题。

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# ① 加载PDF文档
loader = PyPDFLoader("your_document.pdf")
docs = loader.load()

# ② 分块（每块1000字符，重叠200）
splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000, chunk_overlap=200
)
chunks = splitter.split_documents(docs)

# ③ 向量化并存入ChromaDB（本地）
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})  # 检索最相关4块

# ④ RAG提示词模板
rag_prompt = ChatPromptTemplate.from_template("""
基于以下上下文回答问题。如果上下文没有相关信息，说明你不知道。

上下文：
{context}

问题：{question}

请用中文回答，并引用相关段落。
""")

# ⑤ 构建RAG链
def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | ChatOpenAI(model="gpt-4o")
    | StrOutputParser()
)

# ⑥ 提问！
answer = rag_chain.invoke("这份文档的主要结论是什么？")
print(answer)
Python - PDF RAG问答

🤖 Agents：自主AI代理

Agent是能自主决定使用哪些工具、按什么顺序执行的AI。给Agent一个目标，它会自己规划步骤。

from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

# 定义工具（用@tool装饰器）
@tool
def calculate(expression: str) -> str:
    """计算数学表达式。输入：数学表达式字符串，如 '2 + 3 * 4'"""
    try:
        return str(eval(expression))
    except:
        return "计算错误"

@tool
def get_weather(city: str) -> str:
    """获取城市天气信息。输入：城市名称（英文）"""
    # 真实场景：调用天气API
    weather_db = {
        "Beijing": "晴天，25°C",
        "Shanghai": "多云，22°C",
    }
    return weather_db.get(city, "暂无该城市天气数据")

@tool
def web_search(query: str) -> str:
    """搜索网络获取最新信息。"""
    # 真实场景：接入Tavily/SerpAPI
    return f"搜索结果：关于'{query}'的最新信息..."

# 创建ReAct Agent（使用LangGraph）
llm = ChatOpenAI(model="gpt-4o")
tools = [calculate, get_weather, web_search]
agent = create_react_agent(llm, tools)

# 运行Agent
result = agent.invoke({
    "messages": [("user", "北京今天天气怎么样？适合跑步吗？同时帮我算一下5km配速6分钟跑完需要多少分钟")]
})
print(result["messages"][-1].content)
# Agent会自动：①查天气 ②计算 ③综合回答
Python - ReAct Agent

🕸️ LangGraph：构建复杂工作流

LangGraph是LangChain团队推出的状态机框架，用于构建有状态、可循环、多步骤的AI工作流。它是2025年构建生产级Agent的推荐方式。

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

# 定义状态
class ResearchState(TypedDict):
    topic: str
    search_results: str
    outline: str
    draft: str
    final_article: str

# 定义各节点（工作步骤）
llm = ChatOpenAI(model="gpt-4o")

def search_node(state: ResearchState):
    """搜索相关资料"""
    # 真实场景：接入搜索API
    results = f"关于'{state['topic']}'的搜索结果：[模拟数据]"
    return {"search_results": results}

def outline_node(state: ResearchState):
    """生成文章大纲"""
    response = llm.invoke(f"基于以下资料为'{state['topic']}'生成文章大纲：\n{state['search_results']}")
    return {"outline": response.content}

def write_node(state: ResearchState):
    """根据大纲写文章"""
    response = llm.invoke(f"根据以下大纲写一篇完整文章：\n{state['outline']}")
    return {"draft": response.content}

def review_node(state: ResearchState):
    """审阅并优化"""
    response = llm.invoke(f"审阅并改进以下文章，提升流畅性和准确性：\n{state['draft']}")
    return {"final_article": response.content}

# 构建图
workflow = StateGraph(ResearchState)
workflow.add_node("search", search_node)
workflow.add_node("outline", outline_node)
workflow.add_node("write", write_node)
workflow.add_node("review", review_node)

# 定义执行顺序
workflow.set_entry_point("search")
workflow.add_edge("search", "outline")
workflow.add_edge("outline", "write")
workflow.add_edge("write", "review")
workflow.add_edge("review", END)

app = workflow.compile()

# 运行工作流
result = app.invoke({"topic": "2025年AI技术趋势"})
print(result["final_article"])
Python - LangGraph写作流水线

🛠️ 5个实战项目

# 组合Memory + RAG的核心代码片段
qa_chain = RunnableWithMessageHistory(
    rag_chain,
    get_session_history,
    input_messages_key="question",
    history_messages_key="chat_history",
    output_messages_key="answer"
)
Python

from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_community.tools import WikipediaQueryRun
from langchain_community.utilities import WikipediaAPIWrapper

search_tool = TavilySearchResults(max_results=5)
wiki_tool = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())

research_agent = create_react_agent(
    ChatOpenAI(model="gpt-4o"),
    [search_tool, wiki_tool],
    state_modifier="你是研究助手。综合多个来源，生成带引用的研究报告。"
)
Python

from langchain_community.utilities import SQLDatabase
from langchain.chains import create_sql_query_chain
from langchain_community.tools.sql_database.tool import QuerySQLDataBaseTool

db = SQLDatabase.from_uri("sqlite:///sales.db")
llm = ChatOpenAI(model="gpt-4o", temperature=0)

generate_query = create_sql_query_chain(llm, db)
execute_query = QuerySQLDataBaseTool(db=db)

sql_chain = generate_query | execute_query
result = sql_chain.invoke({"question": "2025年4月销量前10的产品是什么？"})
print(result)
Python

⚖️ LangChain vs LlamaIndex：怎么选？

🗺️ 学习路径与进阶资源

4周学习计划

1. 第1周：基础 — 安装配置 → LLM调用 → PromptTemplate → LCEL基础链 → 做一个简单问答机器人
2. 第2周：RAG — 文档加载 → 文本分块 → 向量嵌入 → ChromaDB → 完整RAG问答系统
3. 第3周：Agent — 工具定义 → ReAct Agent → LangGraph基础 → 带工具的对话Agent
4. 第4周：生产化 — LangSmith调试 → 错误处理 → 流式输出 → Streamlit/FastAPI部署 → LangGraph复杂工作流

推荐学习资源

• 官方文档：python.langchain.com（最权威，配合本文食用）
• LangChain Academy：官方免费课程，LangGraph专项
• LangSmith：免费调试工具，可视化追踪每个Chain/Agent的执行过程
• DeepLearning.AI：吴恩达 × LangChain 合作课程（免费）
• GitHub示例：github.com/langchain-ai/langchain/tree/master/cookbook

常见错误与解决方案

• RateLimitError：API调用频率超限 → 添加重试逻辑（langchain.globals.set_verbose(True)调试）
• Context window exceeded：文档太长 → 减小chunk_size，增加检索精度，或换更大上下文模型
• Tool not called correctly：Agent不知道用哪个工具 → 改善工具docstring，增加few-shot示例
• Deprecated warnings：升级到0.3后旧代码警告 → 参考迁移指南（python.langchain.com/docs/versions/migrating_chains）