LangChain 入门：构建你的第一个 AI 应用

LangChain 是什么

LangChain 是一个用于构建 LLM 应用的开源框架。它的核心思想是把和大语言模型交互的各个环节——提示词构建、模型调用、输出解析、记忆管理、工具调用——抽象成可组合的模块，让你像搭积木一样构建 AI 应用。

如果你想做的不只是调一个 API 拿到回复，而是构建一个有记忆、能使用工具、能处理复杂流程的 AI 应用，LangChain 是一个很好的起点。

核心概念

在开始写代码之前，我们先理解 LangChain 的几个核心概念：

1. Models（模型）

LangChain 支持多种 LLM 提供商，统一了调用接口：

提供商	模型	包
OpenAI	GPT-4o, GPT-4o-mini	`langchain-openai`
Anthropic	Claude Sonnet, Opus	`langchain-anthropic`
Google	Gemini	`langchain-google-genai`
Ollama	Llama, Mistral 等	`langchain-ollama`

2. Prompts（提示词）

LangChain 提供了模板系统来构建提示词：

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个{role}，用{language}回答问题。"),
    ("human", "{question}")
])

# 使用模板
formatted = prompt.format_messages(
    role="Python 专家",
    language="中文",
    question="什么是装饰器？"
)

3. Chains（链）

Chain 是 LangChain 的核心抽象。它把多个步骤串联起来，形成一个处理管道：

输入 → 提示词模板 → 模型调用 → 输出解析 → 结果

4. Memory（记忆）

Memory 让 AI 应用能记住之前的对话内容：

用户: 我叫张三
AI: 你好张三！
用户: 我叫什么？
AI: 你叫张三。（有了 Memory 才能回答这个问题）

5. Agents（智能体）

Agent 可以根据用户输入自主决定使用哪些工具来完成任务。

安装与配置

安装

# 安装核心包
pip install langchain langchain-core

# 安装模型提供商包（按需选择）
pip install langchain-openai
pip install langchain-anthropic

# 安装常用工具
pip install langchain-community

配置 API Key

# 设置环境变量
export OPENAI_API_KEY="your-openai-key"
export ANTHROPIC_API_KEY="your-anthropic-key"

或者在代码中配置：

import os
os.environ["OPENAI_API_KEY"] = "your-key"

Hello World：第一个 LangChain 应用

最简单的调用

from langchain_openai import ChatOpenAI

# 创建模型实例
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

# 直接调用
response = llm.invoke("用一句话解释什么是 Python")
print(response.content)
# 输出: Python 是一种简洁易读的高级编程语言，广泛用于 Web 开发、数据分析和人工智能等领域。

使用提示词模板

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个编程导师，用简洁易懂的方式解释技术概念。"),
    ("human", "请解释{concept}，并给出一个{language}的代码示例。")
])

# 组合成 Chain
chain = prompt | llm

# 调用 Chain
response = chain.invoke({
    "concept": "闭包",
    "language": "JavaScript"
})

print(response.content)

这里的 | 操作符是 LangChain Expression Language (LCEL) 的语法，用来把多个组件串联成一个 Chain。

构建一个 Q&A Chain

基础问答

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

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

prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个技术问答助手。
    请根据以下规则回答：
    1. 回答要简洁准确
    2. 如果不确定，说明你不确定
    3. 适当给出代码示例
    4. 用中文回答"""),
    ("human", "{question}")
])

# 添加输出解析器
chain = prompt | llm | StrOutputParser()

# 调用
answer = chain.invoke({"question": "Python 的 GIL 是什么？"})
print(answer)

带上下文的问答

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", """根据以下上下文回答用户的问题。
    如果上下文中没有相关信息，请说明你无法从给定信息中找到答案。

    上下文：
    {context}"""),
    ("human", "{question}")
])

chain = prompt | llm | StrOutputParser()

context = """
FastAPI 是一个现代的 Python Web 框架，基于 Starlette 和 Pydantic。
它支持自动生成 OpenAPI 文档，性能接近 Node.js 和 Go。
FastAPI 使用 Python 类型提示来进行数据验证和序列化。
"""

answer = chain.invoke({
    "context": context,
    "question": "FastAPI 的性能怎么样？"
})
print(answer)

Memory 管理

对话记忆

让 AI 记住之前的对话内容：

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

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个友好的助手。"),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

chain = prompt | llm

# 存储会话历史
store = {}

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

# 包装成带记忆的 Chain
with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history"
)

# 第一轮对话
config = {"configurable": {"session_id": "user-1"}}

response1 = with_history.invoke(
    {"input": "我叫张三，我是一个 Python 开发者"},
    config=config
)
print(response1.content)

# 第二轮对话（AI 会记住之前的内容）
response2 = with_history.invoke(
    {"input": "我叫什么？我做什么工作？"},
    config=config
)
print(response2.content)
# AI 会回答：你叫张三，你是一个 Python 开发者。

Memory 类型

类型	说明	适用场景
InMemoryChatMessageHistory	内存存储	开发测试
RedisChatMessageHistory	Redis 存储	生产环境
SQLChatMessageHistory	SQL 数据库存储	需要持久化
FileChatMessageHistory	文件存储	简单场景

输出解析

结构化输出

让 AI 返回结构化的数据：

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import ChatPromptTemplate
from pydantic import BaseModel, Field

# 定义输出结构
class CodeReview(BaseModel):
    score: int = Field(description="代码质量评分 1-10")
    issues: list[str] = Field(description="发现的问题列表")
    suggestions: list[str] = Field(description="改进建议列表")

parser = JsonOutputParser(pydantic_object=CodeReview)

prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个代码审查专家。
    请审查用户提供的代码，并按以下格式返回 JSON：
    {format_instructions}"""),
    ("human", "请审查这段代码：\n```\n{code}\n```")
])

chain = prompt.partial(
    format_instructions=parser.get_format_instructions()
) | llm | parser

result = chain.invoke({
    "code": """
def get_user(id):
    user = db.query("SELECT * FROM users WHERE id = " + str(id))
    return user
"""
})

print(result)
# {'score': 3, 'issues': ['SQL 注入风险', '没有错误处理', ...], ...}

列表输出

from langchain_core.output_parsers import CommaSeparatedListOutputParser

parser = CommaSeparatedListOutputParser()

prompt = ChatPromptTemplate.from_template(
    "列出 5 个{topic}相关的 Python 库。\n{format_instructions}"
)

chain = prompt.partial(
    format_instructions=parser.get_format_instructions()
) | llm | parser

result = chain.invoke({"topic": "数据可视化"})
print(result)
# ['matplotlib', 'seaborn', 'plotly', 'bokeh', 'altair']

流式输出

对于需要实时展示结果的场景，使用流式输出：

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

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

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个技术博客作者。"),
    ("human", "写一篇关于{topic}的简短介绍。")
])

chain = prompt | llm

# 流式输出
for chunk in chain.stream({"topic": "WebAssembly"}):
    print(chunk.content, end="", flush=True)

实用技巧

1. 错误处理

from langchain_core.runnables import RunnableConfig

try:
    result = chain.invoke(
        {"question": "..."},
        config=RunnableConfig(
            max_retries=3,
            timeout=30
        )
    )
except Exception as e:
    print(f"调用失败: {e}")

2. 批量处理

# 批量调用，提高效率
questions = [
    {"question": "什么是 REST API？"},
    {"question": "什么是 GraphQL？"},
    {"question": "什么是 gRPC？"},
]

results = chain.batch(questions, config={"max_concurrency": 3})
for r in results:
    print(r)

3. 调试和追踪

# 开启 LangSmith 追踪（需要注册 LangSmith）
import os
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "your-langsmith-key"

# 现在所有 Chain 调用都会被记录到 LangSmith
result = chain.invoke({"question": "..."})

4. 切换模型

LangChain 的一大优势是可以轻松切换模型：

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

# OpenAI
llm_openai = ChatOpenAI(model="gpt-4o-mini")

# Anthropic
llm_anthropic = ChatAnthropic(model="claude-sonnet-4-20250514")

# 同一个 Chain，不同模型
chain_openai = prompt | llm_openai | parser
chain_anthropic = prompt | llm_anthropic | parser

下一步

这篇文章介绍了 LangChain 的基础概念和用法。掌握了这些之后，你可以继续探索：

RAG（检索增强生成）— 让 AI 基于你的文档回答问题
Agents — 让 AI 自主使用工具完成任务
LangGraph — 构建复杂的多步骤工作流
LangServe — 将 Chain 部署为 API 服务

LangChain 的生态很丰富，但不需要一次学完。从简单的 Chain 开始，根据实际需求逐步引入更多功能。

框架是工具，不是目的。先想清楚你要解决什么问题，再决定用哪些功能。最简单的方案往往是最好的方案。

加载中...