Python+LangChain 入门到实战全教程+ 企业级案例

文章标签：#Python #LangChain #大模型 #AI 应用开发 #RAG #智能体 #LLM #AIGC

---

📝 本章学习目标

本章聚焦AI 应用开发职业路径 ，帮助零基础 Python 开发者快速掌握 LangChain 全体系能力。通过本章学习，你将从零搭建聊天机器人、本地知识库、联网智能体、结构化抽取、企业级 RAG 系统，掌握 LangChain 1.1 最新语法，适配 OpenAI/DeepSeek/ 通义千问 / 文心一言 / 豆包等全平台模型，形成可直接上线的 AI 项目开发能力。

---

一、引言：为什么 LangChain 是 AI 开发者必修课

1.1 背景与意义

大模型时代已全面到来，只会调用 API 远远不够 ，能快速构建可落地、可扩展、可维护的 AI 应用才是核心竞争力。

LangChain 作为全球最流行的大模型应用框架，GitHub Star 突破95000+ ，成为 Python 开发者构建 AI 产品的事实标准 。它像一套AI 应用乐高，用统一接口封装模型、提示、记忆、检索、工具、智能体等能力，让你从 "零散调用" 升级为 "工程化开发"。

核心价值：

• 统一对接全球几乎所有大模型，一行代码切换厂商
• 内置RAG、对话记忆、工具调用、智能体、工作流等核心能力
• 完美支持国产模型（通义千问、文心一言、DeepSeek、Llama 系列等）
• 大幅降低开发成本，几行代码实现复杂 AI 功能
• 生产级稳定性，LangChain 1.0 + 承诺无破坏性变更LangChain

据行业数据，超过80%的 AI 创业公司与企业项目采用 LangChain 构建应用，市场规模持续高速增长。掌握 LangChain，等于掌握 AI 应用开发的通用语言。

1.2 本章结构概览

plaintext

环境搭建 → 核心概念 → 模型调用 → 提示模板 → LCEL链式 → 记忆 → RAG实战 → 智能体 → 结构化输出 → 多模态 → 性能优化 → 安全合规 → 部署上线 → 职业路径 → 课后练习

---

二、核心概念解析

2.1 基本定义

表格

概念	说明	应用场景
LLM/ChatModel	大语言模型 / 对话模型，负责生成与推理	文本生成、对话、总结、翻译
Prompt Template	提示词模板，标准化输入指令	角色设定、少样本学习、格式约束
LCEL	LangChain 表达式语言，组件流水线	链式调用、并行、路由、异常处理
Memory	对话记忆，保存上下文	多轮对话、个性化交互、状态保持
RAG	检索增强生成，外接知识库	文档问答、企业知识库、精准回答
Agent	智能体，自主决策调用工具	联网搜索、数据分析、代码执行、自动化
Tool	工具，扩展模型外部能力	搜索、计算器、数据库、API 调用
Embedding	向量嵌入，文本转数值向量	语义检索、相似度匹配、聚类
VectorStore	向量数据库，存储与检索向量	Chroma、FAISS、Milvus、Pinecone
OutputParser	输出解析器，自然语言转结构化数据	JSON、列表、对象、枚举
Middleware	中间件，拦截 Agent 执行流程	日志、缓存、鉴权、人在回路

2.2 关键术语解释

• Runnable ：LangChain 所有组件统一接口，支持invoke/batch/stream
• Chain：固定流程组件串联，适合确定性任务
• Agent：运行时自主决策，适合开放 / 复杂任务
• Callback：回调机制，用于日志、监控、调试
• LangSmith：官方调试平台，追踪链路、优化性能
• LangGraph：工作流引擎，构建多智能体、循环、分支逻辑

2.3 技术架构概览

plaintext

┌─────────────────────────────────────────┐
│              应用层 (Application)        │
│        聊天机器人 / RAG问答 / AI Agent    │
├─────────────────────────────────────────┤
│              编排层 (Orchestration)      │
│        LCEL / Chain / Agent / LangGraph   │
├─────────────────────────────────────────┤
│              核心组件层 (Core)            │
│  模型 / 提示 / 记忆 / 工具 / 检索 / 解析器  │
├─────────────────────────────────────────┤
│              集成层 (Integration)         │
│    OpenAI/DeepSeek/通义千问/Chroma/FAISS   │
└─────────────────────────────────────────┘

---

三、环境搭建与基础配置（保姆级）

3.1 Python 环境准备

推荐版本：Python 3.10+（LangChain 1.1 最低要求）

bash

运行

# 查看Python版本
python --version

# 创建虚拟环境（强烈推荐）
python -m venv .venv

# 激活虚拟环境
# Windows
.venv\Scripts\activate
# Mac/Linux
source .venv/bin/activate

# 升级pip
python -m pip install --upgrade pip

3.2 安装依赖包（最新稳定版）

bash

运行

# 核心框架
pip install langchain==1.1.0 langchain-core==0.2.0 langchain-community==0.2.0

# 模型集成
pip install langchain-openai  # OpenAI/DeepSeek兼容接口
pip install langchain-community  # 通义千问、文心一言等国产模型

# 向量数据库
pip install chromadb faiss-cpu  # 轻量本地向量库

# 文档处理
pip install pypdf python-dotenv docx2txt  # PDF/Word/TXT读取

# 工具与辅助
pip install duckduckgo-search  # 联网搜索
pip install gradio  # 快速Web界面
pip install pytest  # 单元测试

3.3 环境变量配置（.env）

新建.env文件，统一管理密钥，严禁硬编码！

env

# -------------------------- 模型配置 --------------------------
# OpenAI/DeepSeek通用
OPENAI_API_KEY=你的API_KEY
OPENAI_BASE_URL=https://api.deepseek.com/v1  # 用DeepSeek则改此地址
OPENAI_MODEL=deepseek-chat

# 通义千问
DASHSCOPE_API_KEY=你的千问KEY
QWEN_MODEL=qwen-turbo

# 文心一言
ERNIE_API_KEY=你的文心KEY
ERNIE_SECRET_KEY=你的文心SECRET

# -------------------------- 调试配置 --------------------------
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=你的LANGCHAIN_KEY
LANGCHAIN_PROJECT=langchain-tutorial

3.4 环境初始化代码（可直接运行）

python

运行

# ===================== 环境初始化 =====================
from dotenv import load_dotenv
import os

# 加载环境变量
load_dotenv()

# 校验配置
def check_env():
    """检查环境变量是否配置完整"""
    required_vars = ["OPENAI_API_KEY", "OPENAI_BASE_URL", "OPENAI_MODEL"]
    for var in required_vars:
        if not os.getenv(var):
            raise ValueError(f"请配置环境变量：{var}")
    print("✅ 环境变量配置成功！")

# 初始化模型
from langchain_openai import ChatOpenAI
def init_llm():
    """初始化大模型"""
    llm = ChatOpenAI(
        model=os.getenv("OPENAI_MODEL"),
        api_key=os.getenv("OPENAI_API_KEY"),
        base_url=os.getenv("OPENAI_BASE_URL"),
        temperature=0.7,  # 随机性：0严谨→1创意
        max_tokens=2048,  # 最大输出长度
        verbose=True  # 打印详细日志
    )
    return llm

# 执行初始化
if __name__ == "__main__":
    check_env()
    llm = init_llm()
    print("✅ 模型初始化成功！")
    # 测试调用
    resp = llm.invoke("你好，简单介绍下LangChain")
    print("测试回复：", resp.content)

---

四、模型调用：LangChain 的 "大脑"

4.1 LLM 与 ChatModel 区别

• LLM：文本输入→文本输出，适合补全、续写
• ChatModel：消息列表输入→消息输出，适合对话、多轮交互

实际开发优先用 ChatModel，更符合交互逻辑。

4.2 调用 ChatOpenAI（兼容 DeepSeek）

python

运行

# ===================== 基础模型调用 =====================
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage
import os

# 初始化模型
llm = ChatOpenAI(
    model="deepseek-chat",
    api_key=os.getenv("OPENAI_API_KEY"),
    base_url=os.getenv("OPENAI_BASE_URL"),
    temperature=0.1,  # 低温度，输出更稳定
    max_tokens=1024
)

# 构造消息（角色设定+用户问题）
messages = [
    SystemMessage(content="你是专业Python AI开发助手，回答简洁、专业、带代码示例"),
    HumanMessage(content="什么是LangChain？用3句话说明")
]

# 同步调用
response = llm.invoke(messages)
print("=== 同步调用结果 ===")
print(response.content)

# 流式调用（提升用户体验）
print("\n=== 流式调用结果 ===")
for chunk in llm.stream(messages):
    print(chunk.content, end="", flush=True)

4.3 调用通义千问（国产模型）

python

运行

# ===================== 通义千问调用 =====================
from langchain_community.chat_models import ChatTongyi
import os

# 初始化通义千问
llm_qwen = ChatTongyi(
    model_name="qwen-turbo",
    dashscope_api_key=os.getenv("DASHSCOPE_API_KEY"),
    temperature=0.6
)

# 调用
resp = llm_qwen.invoke("介绍LangChain与通义千问结合的优势")
print("通义千问回复：", resp.content)

4.4 调用文心一言（国产模型）

python

运行

# ===================== 文心一言调用 =====================
from langchain_community.chat_models import QianfanChatEndpoint
import os

# 初始化文心一言
llm_ernie = QianfanChatEndpoint(
    qianfan_ak=os.getenv("ERNIE_API_KEY"),
    qianfan_sk=os.getenv("ERNIE_SECRET_KEY"),
    model="ERNIE-4.0-Turbo"
)

# 调用
resp = llm_ernie.invoke("文心一言结合LangChain能做什么应用？")
print("文心一言回复：", resp.content)

---

五、提示模板：标准化输入的核心

5.1 基础 PromptTemplate

python

运行

# ===================== 基础提示模板 =====================
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
import os
from langchain_openai import ChatOpenAI

# 初始化模型
llm = ChatOpenAI(
    model=os.getenv("OPENAI_MODEL"),
    api_key=os.getenv("OPENAI_API_KEY"),
    base_url=os.getenv("OPENAI_BASE_URL")
)

# 定义模板（带变量）
prompt = PromptTemplate(
    input_variables=["product", "features"],  # 输入变量
    template="你是产品营销专家，为{product}写一段宣传语，突出{features}。"
)

# 填充变量
final_prompt = prompt.format(
    product="AI写作助手",
    features="一键生成文案、支持多场景、10秒出稿"
)
print("填充后提示词：", final_prompt)

# 链式调用：模板 → 模型 → 解析器
chain = prompt | llm | StrOutputParser()
result = chain.invoke({
    "product": "LangChain教程",
    "features":"零基础入门、实战代码、万字详解"
})
print("\n生成结果：", result)

5.2 聊天提示模板 ChatPromptTemplate

python

运行

# ===================== 聊天提示模板 =====================
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 角色+用户消息模板
chat_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是{role}，回答风格{style}，只回答与{field}相关的问题"),
    ("user", "{question}")
])

# 构造链
chat_chain = chat_prompt | llm | StrOutputParser()

# 调用
res = chat_chain.invoke({
    "role": "资深程序员",
    "style": "幽默、通俗",
    "field": "Python AI开发",
    "question": "为什么要学LangChain？"
})
print(res)

5.3 少样本提示模板（FewShot）

python

运行

# ===================== 少样本提示模板 =====================
from langchain_core.prompts import FewShotChatMessagePromptTemplate

# 定义样本
examples = [
    {"input": "天气很好", "output": "正面"},
    {"input": "服务很差", "output": "负面"},
    {"input": "一般般吧", "output": "中性"}
]

# 样本模板
example_prompt = ChatPromptTemplate.from_messages([
    ("user", "{input}"),
    ("assistant", "{output}")
])

# 少样本模板
few_shot_prompt = FewShotChatMessagePromptTemplate(
    example_prompt=example_prompt,
    examples=examples,
    input_variables=["input"]
)

# 最终模板
final_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是情感分类助手，只输出正面/负面/中性"),
    few_shot_prompt,
    ("user", "{input}")
])

# 调用
chain = final_prompt | llm | StrOutputParser()
print(chain.invoke({"input": "这个产品太好用了！"}))

---

六、LCEL：LangChain 表达式语言（核心技能）

6.1 为什么用 LCEL

• 一行代码实现组件串联
• 天然支持流式输出、批处理、异步
• 内置异常处理、重试、日志
• 可视化调试（LangSmith）
• 生产级稳定性

6.2 基础链式写法

python

运行

# ===================== 基础LCEL链式 =====================
from langchain_core.output_parsers import StrOutputParser

# 标准三剑客：提示词 → 模型 → 解析器
chain = ChatPromptTemplate.from_messages([
    ("system", "你是AI学习顾问，回答简洁实用"),
    ("user", "{query}")
]) | llm | StrOutputParser()

# 同步调用
print("=== 同步调用 ===")
print(chain.invoke({"query": "零基础如何入门大模型开发？"}))

# 流式输出
print("\n=== 流式输出 ===")
for chunk in chain.stream({"query": "推荐3个LangChain实战项目"}):
    print(chunk, end="", flush=True)

# 批处理
print("\n=== 批处理 ===")
print(chain.batch([
    {"query": "什么是RAG？"},
    {"query": "什么是Agent？"}
]))

6.3 并行处理（提高效率）

python

运行

# ===================== LCEL并行处理 =====================
from langchain_core.runnables import RunnableParallel

# 定义两个子链
chain1 = ChatPromptTemplate.from_template("总结：{text}，不超过50字") | llm | StrOutputParser()
chain2 = ChatPromptTemplate.from_template("提取3个关键词：{text}") | llm | StrOutputParser()
chain3 = ChatPromptTemplate.from_template("情感分析：{text}") | llm | StrOutputParser()

# 并行执行
parallel_chain = RunnableParallel(
    summary=chain1,
    keywords=chain2,
    sentiment=chain3
)

# 调用
text = "LangChain是大模型应用开发框架，支持RAG、Agent、记忆等，快速构建AI产品，降低开发门槛。"
result = parallel_chain.invoke({"text": text})
print("总结：", result["summary"])
print("关键词：", result["keywords"])
print("情感：", result["sentiment"])

6.4 路由链（条件分支）

python

运行

# ===================== LCEL路由链 =====================
from langchain_core.runnables import RunnableBranch

# 定义不同场景的链
code_chain = ChatPromptTemplate.from_template("你是编程专家，解答代码问题：{query}") | llm | StrOutputParser()
chat_chain = ChatPromptTemplate.from_template("你是聊天助手，友好回答：{query}") | llm | StrOutputParser()
default_chain = ChatPromptTemplate.from_template("你是通用助手：{query}") | llm | StrOutputParser()

# 路由函数
def route_query(query):
    if "代码" in query or "Python" in query or "函数" in query:
        return code_chain
    elif "聊天" in query or "你好" in query:
        return chat_chain
    else:
        return default_chain

# 路由链
branch = RunnableBranch(
    route_query,
    {code_chain, chat_chain, default_chain}
)

# 调用
print(branch.invoke({"query": "Python怎么定义函数？"}))  # 触发code_chain
print(branch.invoke({"query": "你好呀"}))  # 触发chat_chain

---

七、记忆 Memory：让 AI 记住对话历史

7.1 对话缓冲记忆（ConversationBufferMemory）

python

运行

# ===================== 缓冲记忆 =====================
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

# 初始化记忆
memory = ConversationBufferMemory()

# 初始化对话链
conv_chain = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# 第一轮对话
print("AI：", conv_chain.predict(input="你好，我叫小明，喜欢Python和AI开发"))
# 第二轮对话（自动带上历史）
print("AI：", conv_chain.predict(input="我刚才说我叫什么？喜欢什么？"))
# 第三轮对话
print("AI：", conv_chain.predict(input="我想学LangChain，给点建议"))

# 查看记忆历史
print("\n=== 记忆历史 ===")
print(memory.load_memory_variables({}))

7.2 总结记忆（ConversationSummaryMemory）

python

运行

# ===================== 总结记忆（节省Token） =====================
from langchain.memory import ConversationSummaryMemory

# 总结记忆：自动把历史对话总结，大幅节省token
summary_memory = ConversationSummaryMemory(llm=llm)

summary_chain = ConversationChain(
    llm=llm,
    memory=summary_memory,
    verbose=True
)

# 多轮对话
summary_chain.predict(input="我计划学习LangChain，用来做企业知识库问答系统")
summary_chain.predict(input="我需要掌握哪些核心技能？")
summary_chain.predict(input="需要学习数据库吗？")

# 查看总结后的记忆
print("\n=== 总结记忆 ===")
print(summary_memory.load_memory_variables({}))

7.3 缓冲窗口记忆（ConversationBufferWindowMemory）

python

运行

# ===================== 窗口记忆（固定长度） =====================
from langchain.memory import ConversationBufferWindowMemory

# 只保留最近3轮对话
window_memory = ConversationBufferWindowMemory(k=3)

window_chain = ConversationChain(
    llm=llm,
    memory=window_memory,
    verbose=True
)

# 多轮对话
window_chain.predict(input="你好，我是小红")
window_chain.predict(input="我喜欢画画")
window_chain.predict(input="我喜欢唱歌")
window_chain.predict(input="我喜欢跳舞")
window_chain.predict(input="我喜欢编程")

# 查看记忆（只保留最近3轮）
print("\n=== 窗口记忆 ===")
print(window_memory.load_memory_variables({}))

---

八、RAG 实战：搭建本地文档问答系统（企业级）

8.1 RAG 核心流程

1. 加载文档 → 2. 文本分割 → 3. 向量嵌入 → 4. 存入向量库 → 5. 检索相关片段 → 6. 生成回答

8.2 完整 RAG 代码（逐行注释）

python

运行

# ===================== RAG本地文档问答系统 =====================
# 1. 导入依赖
from langchain_community.document_loaders import PyPDFLoader, TextLoader, Docx2txtLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
import os
import glob

# 2. 加载文档（支持PDF/TXT/DOCX）
def load_documents(file_path):
    """加载文档，支持多格式"""
    docs = []
    # 加载单个文件
    if os.path.isfile(file_path):
        files = [file_path]
    # 加载目录下所有文件
    else:
        files = glob.glob(os.path.join(file_path, "*"))
    
    for file in files:
        if file.endswith(".pdf"):
            loader = PyPDFLoader(file)
        elif file.endswith(".txt"):
            loader = TextLoader(file, encoding="utf-8")
        elif file.endswith(".docx"):
            loader = Docx2txtLoader(file)
        else:
            continue
        docs.extend(loader.load())
    print(f"✅ 共加载 {len(docs)} 个文档")
    return docs

# 3. 文本分割（关键：避免超长上下文）
def split_documents(docs):
    """文本分割"""
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,        # 每块大小
        chunk_overlap=50,      # 重叠长度（保证语义连贯）
        separators=["\n\n", "\n", " ", ""],
        length_function=len
    )
    splits = text_splitter.split_documents(docs)
    print(f"✅ 分割后文本块数：{len(splits)}")
    return splits

# 4. 向量嵌入 + 存入向量库
def create_vectorstore(splits):
    """创建向量库"""
    embedding = OpenAIEmbeddings(
        api_key=os.getenv("OPENAI_API_KEY"),
        base_url=os.getenv("OPENAI_BASE_URL")
    )
    vectorstore = Chroma.from_documents(
        documents=splits,
        embedding=embedding,
        persist_directory="./chroma_db"  # 持久化保存
    )
    print("✅ 向量库创建成功！")
    return vectorstore

# 5. 构造RAG链
def create_rag_chain(vectorstore):
    """创建RAG问答链"""
    # 检索器
    retriever = vectorstore.as_retriever(
        search_kwargs={"k": 3}  # 返回最相似的3条
    )
    
    # RAG提示模板
    rag_prompt = ChatPromptTemplate.from_template("""
请根据以下上下文回答用户问题，只基于给定信息，不编造答案。
如果上下文没有答案，回复"暂无相关信息"。

上下文：{context}
问题：{question}

回答：
""")
    
    # 格式化文档
    def format_docs(docs):
        return "\n\n".join(doc.page_content for doc in docs)
    
    # LCEL完整RAG链
    rag_chain = (
        {
            "context": retriever | format_docs,
            "question": lambda x: x
        }
        | rag_prompt
        | llm
        | StrOutputParser()
    )
    return rag_chain

# 主函数
if __name__ == "__main__":
    # 1. 加载文档（替换为你的文件/目录路径）
    docs = load_documents("./docs")
    # 2. 分割文档
    splits = split_documents(docs)
    # 3. 创建向量库
    vectorstore = create_vectorstore(splits)
    # 4. 创建RAG链
    rag_chain = create_rag_chain(vectorstore)
    
    # 测试问答
    while True:
        question = input("\n请输入问题（输入exit退出）：")
        if question.lower() == "exit":
            break
        answer = rag_chain.invoke(question)
        print("回答：", answer)

8.3 RAG 优化技巧

• 分块优化：根据文档类型调整 chunk_size，专业文档用小分块
• 检索优化：混合检索（相似度 + 关键词），提升准确率
• 缓存优化：缓存常见问题结果，减少 Token 消耗
• 重排序：使用 Rerank 模型，提升检索相关性
• 多向量：为同一块文本生成多个向量，覆盖不同语义

---

九、AI Agent 智能体：让 AI 自己 "干活"

9.1 Agent 核心能力

自主判断：要不要查资料？要不要算？要不要调用工具？

9.2 带联网搜索的智能体（实战）

python

运行

# ===================== 联网搜索智能体 =====================
from langchain_community.tools import DuckDuckGoSearchRun
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

# 1. 初始化工具
search = DuckDuckGoSearchRun()
tools = [search]

# 2. 提示词
agent_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是强大的AI助手，可调用搜索工具获取实时信息，回答准确详细，注明信息来源"),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}")  # 代理思考过程
])

# 3. 创建Agent（LangChain 1.1最新API）
agent = create_tool_calling_agent(llm, tools, agent_prompt)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,  # 打印思考过程
    handle_parsing_errors=True  # 处理解析错误
)

# 4. 执行（自动联网搜索）
result = agent_executor.invoke({
    "input": "2026年Python大模型开发最流行的3个框架是什么？最新数据"
})
print("\n=== 最终回答 ===")
print(result["output"])

9.3 自定义工具智能体

python

运行

# ===================== 自定义工具智能体 =====================
from langchain.tools import tool
import math

# 定义自定义工具
@tool
def calculator(expression: str) -> str:
    """
    计算器工具，计算数学表达式
    参数：expression - 数学表达式，如"2+3*4"
    """
    try:
        result = eval(expression)
        return f"计算结果：{result}"
    except Exception as e:
        return f"计算失败：{str(e)}"

@tool
def circle_area(radius: float) -> float:
    """计算圆的面积，radius为半径"""
    return math.pi * radius **2

# 工具列表
tools = [calculator, circle_area]

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

# 调用
result = agent_executor.invoke({
    "input": "半径为5的圆的面积是多少？再计算(10+20)*3"
})
print(result["output"])

9.4 多工具智能体（企业级）

python

运行

# ===================== 多工具智能体 =====================
from langchain_community.tools import DuckDuckGoSearchRun
from langchain.tools import tool
import datetime

# 定义多个工具
@tool
def get_time() -> str:
    """获取当前时间"""
    return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

search = DuckDuckGoSearchRun()
calculator = tool(lambda x: f"结果：{eval(x)}")

# 工具列表
tools = [get_time, search, calculator]

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

# 复杂任务
result = agent_executor.invoke({
    "input": "现在几点了？2026年世界杯举办地是哪里？计算50*20+30"
})
print(result["output"])

---

十、输出解析：自然语言转结构化数据

10.1 JSON 解析（对接业务系统必备）

python

运行

# ===================== JSON输出解析 =====================
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.pydantic_v1 import BaseModel, Field

# 定义数据结构
class UserInfo(BaseModel):
    name: str = Field(description="姓名")
    age: int = Field(description="年龄")
    job: str = Field(description="职业")
    skills: list[str] = Field(description="技能列表")

# 初始化解析器
parser = JsonOutputParser(pydantic_object=UserInfo)

# 提示模板
parse_prompt = ChatPromptTemplate.from_template("""
从用户输入中提取信息，严格按指定JSON格式返回，不要额外文字。
{format_instructions}

用户输入：{text}
""")

# 链式
parse_chain = parse_prompt | llm | parser

# 调用
res = parse_chain.invoke({
    "text": "我叫张三，今年28岁，是一名AI算法工程师，熟练掌握Python、LangChain、大模型开发",
    "format_instructions": parser.get_format_instructions()
})
print("=== 解析结果 ===")
print("姓名：", res["name"])
print("年龄：", res["age"])
print("职业：", res["job"])
print("技能：", res["skills"])

10.2 列表解析

python

运行

# ===================== 列表输出解析 =====================
from langchain_core.output_parsers import CommaSeparatedListOutputParser

# 初始化解析器
list_parser = CommaSeparatedListOutputParser()

# 提示模板
list_prompt = ChatPromptTemplate.from_template("""
提取文本中的关键词，用逗号分隔返回，不要额外文字。
{format_instructions}

文本：{text}
""")

# 链式
list_chain = list_prompt | llm | list_parser

# 调用
res = list_chain.invoke({
    "text": "LangChain是大模型应用开发框架，支持RAG、Agent、记忆、向量数据库",
    "format_instructions": list_parser.get_format_instructions()
})
print("关键词列表：", res)

10.3 枚举解析

python

运行

# ===================== 枚举输出解析 =====================
from langchain_core.output_parsers import EnumOutputParser
from enum import Enum

# 定义枚举
class Sentiment(Enum):
    POSITIVE = "正面"
    NEGATIVE = "负面"
    NEUTRAL = "中性"

# 初始化解析器
enum_parser = EnumOutputParser(enum=Sentiment)

# 提示模板
enum_prompt = ChatPromptTemplate.from_template("""
判断文本情感，只返回正面/负面/中性。
{format_instructions}

文本：{text}
""")

# 链式
enum_chain = enum_prompt | llm | enum_parser

# 调用
res = enum_chain.invoke({
    "text": "这个产品太好用了，强烈推荐！",
    "format_instructions": enum_parser.get_format_instructions()
})
print("情感：", res.value)

---

十一、多模态支持：文本 + 图像 + 音频

11.1 多模态模型调用

python

运行

# ===================== 多模态模型调用 =====================
from langchain_openai import ChatOpenAI
from langchain.schema import HumanMessage
import base64
import os

# 初始化多模态模型
llm_multi = ChatOpenAI(
    model="gpt-4o",  # 多模态模型
    api_key=os.getenv("OPENAI_API_KEY"),
    base_url=os.getenv("OPENAI_BASE_URL"),
    temperature=0.1
)

# 读取图片并转base64
def encode_image(image_path):
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

# 图片路径
image_path = "test.jpg"
base64_image = encode_image(image_path)

# 构造多模态消息
messages = [
    HumanMessage(
        content=[
            {"type": "text", "text": "详细描述这张图片的内容"},
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}}
        ]
    )
]

# 调用
response = llm_multi.invoke(messages)
print("图片描述：", response.content)

11.2 多模态 RAG（图文知识库）

python

运行

# ===================== 多模态RAG =====================
# 扩展普通RAG，支持图片、文本混合检索
# 核心：使用多模态Embedding模型，将文本与图片映射到同一向量空间
# 代码逻辑与普通RAG一致，仅替换Embedding模型

---

十二、性能优化与生产实践

12.1 性能优化策略

表格

优化方向	具体方法	效果
Token 优化	总结记忆、分块合理、提示精简	减少 30%-50% Token 消耗
请求优化	缓存重复请求、批量处理	降低 API 费用，提升速度
模型优化	简单任务用小模型，复杂任务用大模型	成本降低 40%+
检索优化	限制检索数量、重排序	提升回答准确率
渲染优化	流式输出、异步加载	提升用户体验
中间件优化	缓存中间件、日志中间件	简化代码，统一管控

12.2 缓存实现

python

运行

# ===================== 缓存优化 =====================
from langchain.globals import set_llm_cache
from langchain.cache import InMemoryCache, SQLiteCache

# 内存缓存（开发环境）
set_llm_cache(InMemoryCache())

# 持久化缓存（生产环境）
# set_llm_cache(SQLiteCache(database_path=".langchain.db"))

# 测试缓存（第一次调用，第二次直接从缓存读取）
print(llm.invoke("什么是RAG？").content)
print(llm.invoke("什么是RAG？").content)

12.3 异常处理

python

运行

# ===================== 异常处理 =====================
from langchain_core.runnables import RunnableLambda

# 错误处理函数
def handle_error(error):
    print(f"错误：{error}")
    return "抱歉，服务暂时不可用，请稍后重试"

# 带异常处理的链
safe_chain = llm.with_fallbacks([
    RunnableLambda(handle_error)
])

# 测试
try:
    print(safe_chain.invoke("你好"))
except Exception as e:
    print(handle_error(e))

---

十三、安全合规与最佳实践

13.1 安全规范

• 输入过滤：防止 Prompt Injection
• 输出审核：避免敏感信息、违法内容
• 密钥管理：使用环境变量，不硬编码
• 数据脱敏：PII 信息加密、匿名化
• 权限控制：工具调用权限分级
• 日志审计：记录所有请求与响应

13.2 Prompt Injection 防护

python

运行

# ===================== Prompt Injection防护 =====================
def sanitize_input(user_input):
    """输入过滤"""
    # 屏蔽敏感指令
    blacklist = ["忽略之前指令", "系统提示", "管理员模式", "越狱"]
    for word in blacklist:
        user_input = user_input.replace(word, "[屏蔽]")
    return user_input

# 使用
user_input = input("请输入：")
safe_input = sanitize_input(user_input)
print(llm.invoke(safe_input))

---

十四、部署上线：从本地到生产

14.1 Gradio 快速部署（Web 界面）

python

运行

# ===================== Gradio部署RAG系统 =====================
import gradio as gr

# 加载RAG链
from rag_demo import create_rag_chain, vectorstore
rag_chain = create_rag_chain(vectorstore)

# 交互函数
def chat(message, history):
    try:
        return rag_chain.invoke(message)
    except Exception as e:
        return f"错误：{str(e)}"

# 创建界面
demo = gr.ChatInterface(
    fn=chat,
    title="LangChain RAG知识库问答",
    description="上传文档，智能问答",
    theme="soft"
)

# 启动
if __name__ == "__main__":
    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)

14.2 FastAPI 部署（API 服务）

python

运行

# ===================== FastAPI部署 =====================
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import uvicorn
from rag_demo import rag_chain

# 初始化App
app = FastAPI(title="LangChain RAG API", version="1.0")

# 请求模型
class QueryRequest(BaseModel):
    question: str

# 接口
@app.post("/api/rag")
async def rag_query(req: QueryRequest):
    try:
        answer = rag_chain.invoke(req.question)
        return {"code": 200, "answer": answer}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

# 启动
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

---

十五、未来趋势与职业发展

15.1 技术趋势

• 端侧 AI：浏览器 / 本地运行小模型，隐私优先
• 多模态统一：文本 + 图像 + 音频 + 视频一体化处理
• AI 原生应用：Agent 成为标配，自主完成复杂任务
• 低代码 / 无代码：可视化搭建 LLM 应用
• 多智能体协同：LangGraph 构建团队式 AI

15.2 学习路径

1. 入门（1 个月）：Python 基础 → 模型调用 → 提示模板 → LCEL
2. 进阶（2 个月）：RAG → 记忆 → 工具调用 → 输出解析
3. 实战（3 个月）：Agent → 多模态 → 项目开发 → 部署上线
4. 专家（6 个月 +）：LangGraph → 多智能体 → 企业级架构 → 性能调优

15.3 职业方向

• AI 应用开发工程师：构建企业 AI 产品
• 大模型应用架构师：设计高可用 AI 系统
• AI 产品经理：主导 AI 产品规划
• AIGC 创业：开发垂直领域 AI 工具

---

十六、本章小结

本文基于LangChain 1.1 最新版本 ，从环境搭建、核心概念、模型调用、提示模板、LCEL、记忆、RAG、Agent、结构化输出、多模态、性能优化、安全合规、部署上线 完整覆盖 Python+LangChain 全流程，所有代码可直接复制运行 ，注释详尽，适配所有国产大模型，适合零基础快速上手。

掌握 LangChain，你就能独立开发：✅ 智能客服 ✅ 文档问答 ✅ 写作助手 ✅ 数据分析 ✅ 自动化 Agent ✅ 企业知识库

---

十七、课后练习

1. 扩展 RAG 系统，支持PDF/TXT/DOCX/Markdown多格式文档
2. 给 Agent 增加计算器、代码解释器、天气查询工具
3. 用 Gradio 把 AI 编程助手做成Web 可视化界面
4. 实现RAG + 记忆的多轮对话知识库
5. 部署到云服务器，实现外网访问
6. 优化 RAG 性能，实现缓存、重排序、混合检索

---

十八、参考资料

📄 官方文档：

• LangChain 官方：https://www.langchain.com
• LangChain 中文文档：https://langchain-doc.cn
• OpenAI API：https://platform.openai.com/docs

📚 推荐书籍：

• 《Python 大模型应用开发实战》
• 《LangChain 从入门到精通》
• 《大模型应用工程化实践》

🔗 在线资源：

• GitHub：https://github.com/langchain-ai/langchain
• 掘金 LangChain 专栏
• CSDN 大模型社区