本文是一份完整的LangChain框架教程，解决大模型三大局限性（知识过期、无记忆能力、缺乏工具使用能力）。通过七阶段实战路线，从基础模型调用到记忆功能、RAG检索增强、Agents工具使用、Streamlit网页界面，再到LangGraph流程编排，提供完整可运行代码，适合零基础读者，帮助开发者掌握构建大模型应用的核心技能。

在做AI应用开发的时候，大模型都有一个通病，虽然强大，但它不知道你公司的私有文档，记不住之前的对话，更不会主动上网搜索最新信息。大模型就像一个博学但"与世隔绝"的学者——知识丰富，却无法连接现实世界。

LangChain 正是为了解决这个问题而生。它是由 Harrison Chase 开发的开源框架，专门用来构建基于大语言模型(LLM)的应用程序。简单来说，LangChain 就是连接"大脑"(LLM)和"现实世界"(数据库、搜索引擎、私有文档)的桥梁。

这篇文章将手把手带你从零开始掌握 LangChain，每个步骤都提供完整的可运行代码。你不需要有 Python 基础，只要跟着操作，就能构建出自己的 AI 应用。希望对你有所启发。

1、技术背景与挑战

大模型的三大局限性

当我们直接调用 GPT 或其他大模型的 API 时，会遇到三个根本性问题：

知识过期 - 模型只知道训练时的数据，不知道昨天刚发生的新闻，也不知道你公司的内部文档。就像一个 2023 年就"冬眠"的人，醒来后对 2024 年的世界一无所知。

无记忆能力 - 每次 API 调用都是全新的开始。你问它"我叫什么"，它回答了；下次再问，它完全忘记了。这不是模型笨，而是 API 的调用机制决定的——每次请求都是独立的，没有状态保持。

缺乏工具使用能力 - 问它"现在比特币多少钱"，它只能胡乱猜测；让它"帮我算一下 23423 × 82342"，大概率算错。大模型天生不擅长精确计算和实时数据获取。

LangChain 的解决方案：组件化与链式调用

LangChain 的核心哲学是组合优于继承。它把 AI 应用开发拆解成一个个独立的"积木"：

• Models

  • 统一的模型接口，兼容 100+ 种 LLM 提供商

• Prompts

  • 可复用的提示词模板

• Memory

  • 开箱即用的记忆管理组件

• Chains

  • 将多个组件串联成工作流

• Agents

  • 能自主决策、使用工具的智能体

这种设计的精妙之处在于：数据流向清晰，组件职责单一。每个组件只做一件事，并且做好——这正是优秀架构的标志。

2 、 核心架构解析

从企业架构的角度看，LangChain 的设计完美符合 TOGAF 框架的四层模型：

业务架构层 - LangChain 能构建哪些 AI 应用？答案是：AI 对话系统、知识库问答、智能客服、代码助手等。关键是它降低了门槛——以前需要 AI 团队才能做的事，现在几十行代码就能实现。

应用架构层 - 核心组件包括 Models(模型抽象)、Chains(链式调用)、Agents(智能体)、Toolkits(工具集)。这一层的设计哲学是可组合性：你可以像搭乐高一样组合这些组件，而不是从零开始写代码。

数据架构层 - 包含 Memory(记忆管理)、Vector Stores(向量数据库)、Document Loaders(文档加载器)、Text Splitters(文本切割器)。重点是数据的流转和转换：原始文档如何变成 AI 能理解的向量？对话历史如何高效存储和检索？

技术架构层 - 底层涉及 API Integration(多模型兼容)、Prompt Engineering(提示词工程)、Embeddings(向量化)、LLM Provider(模型提供商集成)。这一层解决的是如何让不同技术栈无缝协作。

核心设计：State、Node、Edge

从 LangGraph(LangChain 的进阶版)可以看出架构设计的精髓：

• State

  (状态) - 就像一个"货箱"，在各个处理节点间传递数据。它不是简单的变量，而是结构化的数据容器，清晰定义了"这一步需要什么数据，输出什么数据"。

• Node

  (节点) - 每个节点是一个独立的处理单元，比如"分类器"、“数学专家”、“编辑审核”。节点的职责单一，边界清晰，这样才能组合出复杂的流程而不失控。

• Edge

  (边) - 定义数据流向。普通边是固定路径，条件边可以根据状态动态决定下一步去哪里(就像交通路口的红绿灯)。

这种设计的天才之处在于：把流程控制从代码逻辑中抽离出来，变成可视化的图结构。你画一个流程图，就能直接翻译成代码。

LangChain 基础工作流用户输入QueryPrompt 模板TemplateLLM 调用Model输出 解析Parser结果 返回Response

3 、环境准备与安装

在开始实战之前，我们需要搭建开发环境。以下步骤适用于 macOS、Linux 和 Windows 系统。

步骤 1：安装 Python

确保你的电脑已安装 Python 3.8 或更高版本。打开终端(Terminal 或 CMD)，输入：

python3 --version

如果显示版本号（如 Python 3.12.11），说明已安装。否则请访问 https://www.python.org 下载安装。

步骤 2：安装 LangChain 核心库

在终端中执行以下命令：

pip install langchain langchain-openai

如果下载速度慢，可以使用国内镜像源：

pip install langchain langchain-openai -i https://pypi.tuna.tsinghua.edu.cn/simple

步骤 3：获取 API Key

本教程使用**智谱 AI(ChatGLM)**作为示例，因为它：

• 完美兼容 OpenAI API 格式
• 中文能力强
• 价格实惠（约为 GPT-4 的 1/3）

访问 https://open.bigmodel.cn 注册账号并获取 API Key（通常是一串以 . 分隔的字符）。

重要提示：代码中所有 "你的_API_KEY" 都需要替换成你的真实 API Key。

4 、四阶段实战路线图

第一步：Hello World - 打通引擎

目标：让 AI 开口说话，验证环境配置正确。

核心洞察：LangChain 的模型接口抽象得非常巧妙。它兼容 OpenAI 格式的 API，这意味着你写的代码可以无缝切换到 DeepSeek、Moonshot 等其他模型——只需要改两行配置。

创建文件 lesson1.py，复制以下代码：

# 1. 导入必要的工具包
# ChatOpenAI 是 LangChain 用来连接符合 OpenAI 标准接口的模型（智谱就是其中之一）
from langchain_openai import ChatOpenAI

# 2. 初始化模型 (配置"大脑")
# 这里我们配置了三个关键参数：
# - model: 我们用的是智谱的 GLM-4 模型
# - openai_api_key: 你的通行证
# - openai_api_base: 告诉 LangChain 不要去连 OpenAI 的服务器，而是连智谱的服务器
llm = ChatOpenAI(
    model="glm-4",
    openai_api_key="你的_API_KEY",  # 🔴 记得在这里填入你的 Key
    openai_api_base="https://open.bigmodel.cn/api/paas/v4/"
)

# 3. 直接调用模型
# invoke 就是"调用"的意思，我们发给它一句话
print("正在思考中...")
response = llm.invoke("你好！请用鲁迅的语气夸我一下学编程很快。")

# 4. 打印结果
# response.content 才是模型真正回复的内容
print("--- 回复内容 ---")
print(response.content)

运行方法：

python3 lesson1.py

预期输出：你会看到智谱 AI 用鲁迅的语气夸奖你，类似：

正在思考中...
--- 回复内容 ---
哦，你这位君子，编程之道，竟也能游刃有余...

架构洞察：这看似简单，实则蕴含深意——接口标准化是可移植性的前提。想象一下，如果没有统一的插座标准，每换一个电器就要重新布线，那将是灾难。LangChain 通过统一接口，让你的代码可以在不同模型间自由迁移。

第二步：给 AI 加上记忆 - Memory

目标：让 AI 记住上下文，实现多轮对话。

问题分析：现在的 AI 像一条金鱼，记忆只有 7 秒。如果你告诉它"我叫小明"，然后再问"我叫什么"，它会一脸茫然。因为每次运行都是一次全新的开始。

解决方案：LangChain 的思路很简单——把之前的聊天记录，打包一起发给它。

创建文件 lesson2.py：

from langchain_openai import ChatOpenAI
# 1. 导入三种消息类型
# SystemMessage: 系统指令 (比如：你是一个猫娘...)
# HumanMessage: 用户说的话
# AIMessage: AI 回复的话
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage

# 2. 初始化模型 (配置和之前一样)
llm = ChatOpenAI(
    model="glm-4",
    openai_api_key="你的_API_KEY",  # 🔴 别忘了替换 Key
    openai_api_base="https://open.bigmodel.cn/api/paas/v4/"
)

# 3. 初始化"记忆条"
# 我们用一个列表来保存所有的对话历史
# 先给它定个调子：你是一个资深的 Python 助教
messages = [
    SystemMessage(content="你是一个幽默的 Python 助教，说话喜欢带点 emoji。")
]

print("🤖 助教已上线！(输入 'exit' 退出)")

# 4. 开启循环对话
while True:
    # 获取用户输入
    user_input = input("\n👤 你: ")

    # 如果输入 exit 就结束
    if user_input.lower() == "exit":
        print("再见！")
        break

    # A. 把用户说的话，包装成 HumanMessage，存入记忆列表
    messages.append(HumanMessage(content=user_input))

    # B. 把整个记忆列表 (包含之前的对话) 发给 AI
    print("Thinking...")
    response = llm.invoke(messages)

    # C. 打印 AI 的回复
    ai_reply = response.content
    print(f"🤖 助教: {ai_reply}")

    # D. 关键一步：把 AI 的回复也存入记忆列表
    messages.append(AIMessage(content=ai_reply))

运行方法：

python3 lesson2.py

测试记忆力：

你: 你好，我叫张三
助教: 你好张三！👋 很高兴认识你...
你: 你知道我叫什么名字吗？
助教: 当然知道！你叫张三 😊

架构洞察：记忆的本质是什么？不是什么黑科技，而是把之前的对话记录打包一起发给模型。就像开会时，你不能只告诉老板"我同意"，你得先复述一遍前面讨论了什么，老板才知道你同意的是什么。

如果去掉代码中的 A 和 D 步骤，messages 列表里就永远只有那句系统指令，AI 每次都看不到之前的对话。记忆的本质，就是不断把新的聊天记录"追加"到清单里，再重新发给模型。

第三步：与你的数据对话 - RAG（检索增强生成）

目标：让 AI 基于你提供的文档回答问题（这是目前最火的应用场景）。

问题分析：现在的 AI 虽然博学，但它有两个大问题：

• 知识过期：它不知道昨天刚发生的新闻
• 私有数据盲区：它不知道你们公司的内部文档

解决方案：RAG (检索增强生成) 就是给 AI 搞一场"开卷考试"。我们先把资料给它，当你问问题时，它先去资料里翻书（检索），找到答案后再总结给你（生成）。

比喻：RAG 就像给 AI 配了一个外接移动硬盘。模型本身的参数是"内存"，RAG 是"硬盘"——内存有限但速度快，硬盘容量大但需要检索。

步骤 1：安装额外依赖

pip install langchain-community faiss-cpu

步骤 2：准备知识文档

在你的代码文件夹里新建一个文本文件 knowledge.txt，写入一些只有你知道的秘密知识：

你: 你好，我叫张三
助教: 你好张三！👋 很高兴认识你...
你: 你知道我叫什么名字吗？
助教: 当然知道！你叫张三 😊

步骤 3：创建 RAG 程序

创建文件 lesson3.py：

import os
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import CharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate

# --- 配置 ---
API_KEY = "你的_API_KEY"  # 🔴 记得填 Key
BASE_URL = "https://open.bigmodel.cn/api/paas/v4/"

# 1. 配置"大脑" (负责回答)
llm = ChatOpenAI(
    model="glm-4",
    openai_api_key=API_KEY,
    openai_api_base=BASE_URL
)

# 2. 配置"眼睛" (Embeddings - 负责把文字变成数字，方便搜索)
# 智谱也提供了 embedding 模型，我们这里用 embedding-2
embeddings = OpenAIEmbeddings(
    model="embedding-2",
    openai_api_key=API_KEY,
    openai_api_base=BASE_URL
)

print("📚 正在加载并处理文档...")

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

# --- 第二步：切割文档 ---
# 如果文档太长，模型吃不消，所以要切成小块
text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=0)
docs = text_splitter.split_documents(documents)

# --- 第三步：存入向量数据库 (建立书架) ---
# 这一步会把文字变成向量存起来，这样才能进行语义搜索
vectorstore = FAISS.from_documents(docs, embeddings)
print("✅ 知识库建立完成！")

# --- 第四步：检索与问答 ---
# 这是一个特殊的 Chain，专门用来做 RAG
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain.chains import create_retrieval_chain

# 这是一个提示词模板，告诉 AI：请根据下面的 context (上下文) 来回答问题
prompt = ChatPromptTemplate.from_template("""
请根据下面的内容回答用户的问题：
<context>
{context}
</context>

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

# 创建"文档处理链" (负责把找出来的文档塞给 LLM)
document_chain = create_stuff_documents_chain(llm, prompt)

# 创建"检索链" (负责先去书架找书，再交给上面的链)
retriever = vectorstore.as_retriever()
retrieval_chain = create_retrieval_chain(retriever, document_chain)

# --- 开始提问 ---
query = "学习 LangChain 的秘诀是什么？"
print(f"\n❓ 提问: {query}")

response = retrieval_chain.invoke({"input": query})

print(f"💡 回答: {response['answer']}")

运行方法：

python3 lesson3.py

预期输出：AI 会基于 knowledge.txt 里的内容回答，比如：“学习 LangChain 的秘诀是每天对着电脑大喊三声’奥力给’。”

架构洞察：RAG 的数据流转

1. 文档加载

   • 把 PDF、Word 等文件读成文本

2. 智能分块

   • 每 500 字切一块，关键是相邻块重叠 50 字——为什么？因为如果从段落中间硬切，上下文就断了

3. 向量化

   • 把文本转成 384 维向量（这不是随机数字，而是"语义坐标"）

4. 语义检索

   • 用户提问时，先在向量库里找最相关的文本块，再让 LLM 基于这些文本回答

核心创新：用空间距离表达语义相似度，把 NLP 问题转化为几何问题。意思相近的文本，向量距离会很近——这种"降维打击"的思想极其优雅。

第四步：给 AI 装上"双手" - Agents

目标：让 AI 学会使用工具（如搜索网络、查天气、算数学）。

问题分析：问 AI “现在比特币多少钱”，它只能胡乱猜测；让它算 23423 × 82342，大概率算错。大模型天生不擅长精确计算和实时数据获取。

解决方案：Agent (代理) 的核心概念——当 AI 遇到自己不会的问题时，它知道去使用"工具"。

步骤 1：安装搜索工具

pip install duckduckgo-search
pip install -U ddgs

步骤 2：创建 Agent 程序

创建文件 lesson4.py：

from langchain_openai import ChatOpenAI
# 1. 导入搜索工具
from langchain_community.tools import DuckDuckGoSearchRun
# 2. 导入创建 Agent 的辅助函数
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate

# --- 配置 ---
API_KEY = "你的_API_KEY"  # 🔴 记得填 Key
BASE_URL = "https://open.bigmodel.cn/api/paas/v4/"

# 1. 初始化模型 (大脑)
llm = ChatOpenAI(
    model="glm-4",
    openai_api_key=API_KEY,
    openai_api_base=BASE_URL
)

# 2. 准备工具 (双手)
# 我们创建一个搜索工具实例
search = DuckDuckGoSearchRun()
# 把工具放在一个列表里 (以后你可以往里面加日历工具、计算器工具等)
tools = [search]

# 3. 创建 Prompt (任务书)
# 我们需要告诉 AI：你是一个可以调用工具的助手
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个强大的助手。你可以使用工具来查找最新的信息。如果用户问的问题需要联网，请务必使用搜索工具。"),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}"),  # 🔴 这是一个预留位置，用来存放 AI 的思考过程
])

# 4. 组装 Agent (大脑 + 手 + 任务书)
agent = create_tool_calling_agent(llm, tools, prompt)

# 5. 创建执行器 (监工)
# verbose=True 会打印出 AI 思考和调用工具的详细过程，非常有趣！
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# --- 开始运行 ---
# 问一个它训练数据里肯定没有的问题 (比如最新的新闻)
query = "2024年奥运会是在哪里举办的？结果如何？"

print(f"🔍 用户提问: {query}\n")
print("--- Agent 开始工作 ---")

response = agent_executor.invoke({"input": query})

print("\n--- 最终回答 ---")
print(response["output"])

运行方法：

python3 lesson4.py

预期输出：你会看到 AI 的思考过程（绿色/黄色文字）：

🔍 用户提问: 2024年奥运会是在哪里举办的？结果如何？

--- Agent 开始工作 ---
> Entering new AgentExecutor chain...
需要使用搜索工具...
调用工具: duckduckgo_search
Title: Paris 2024 Olympics...
...最终回答 ---
2024年奥运会在法国巴黎举办...

架构洞察：Agent 的设计哲学是将"决策"和"执行"分离。模型不直接输出答案，而是输出一个"调用工具"的指令，框架负责执行工具并把结果喂回给模型，模型再基于结果生成最终答案。这个循环可以重复多次，直到问题解决。 AI 从"只会说"进化到了"既会想又会做"。

第五步：给代码穿上"外衣" - Streamlit 网页界面

目标：把黑乎乎的终端程序变成漂亮的网页应用。

问题分析：目前的程序都在终端里运行，不够直观，也不方便分享给朋友使用。如果能有一个网页界面，就能像 ChatGPT 一样随时打开使用。

解决方案：Streamlit 是一个 Python 库，专门用来快速构建数据应用的 Web 界面。最神奇的是：你不需要懂 HTML、CSS、JavaScript，完全用 Python 就能写出漂亮的网页。 比喻：Streamlit 就像给你的 Python 程序套上一个精美的外壳，让它从"命令行工具"变成"Web 应用"。

步骤 1：安装 Streamlit

pip install streamlit

步骤 2：创建网页版聊天机器人

我们要把 Lesson 2 的带记忆聊天机器人搬到网页上。创建文件 lesson5_streamlit.py：

import streamlit as st
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
# --- 1. 页面配置 ---
st.set_page_config(page_title="我的 AI 助手", page_icon="🤖")
st.title("🤖 我的专属 AI 聊天室")
# --- 2. 初始化模型 ---
# 为了防止每次页面刷新都重新连接模型，我们加个缓存装饰器 (可选，但推荐)
@st.cache_resource
def get_llm():
return ChatOpenAI(
model="glm-4",
openai_api_key="你的_API_KEY",  # 🔴 记得填 Key
openai_api_base="https://open.bigmodel.cn/api/paas/v4/"
)
llm = get_llm()
# --- 3. 初始化"记忆" (Session State) ---
# 如果"暂存箱"里没有消息记录，我们就创建一个空的，并放入系统指令
if "messages" not in st.session_state:
st.session_state.messages = [
SystemMessage(content="你是一个乐于助人的 AI 助手，回答请简洁明了。")
]
# --- 4. 渲染聊天记录 ---
# 每次刷新页面，都把暂存箱里的历史消息画在屏幕上
for msg in st.session_state.messages:
if isinstance(msg, HumanMessage):
with st.chat_message("user"):  # 渲染用户的气泡
st.write(msg.content)
elif isinstance(msg, AIMessage):
with st.chat_message("assistant"):  # 渲染 AI 的气泡
st.write(msg.content)
# --- 5. 处理用户输入 ---
# st.chat_input 会在页面底部创建一个输入框
user_input = st.chat_input("说点什么吧...")
if user_input:
# A. 显示用户输入
with st.chat_message("user"):
st.write(user_input)
# B. 存入记忆
st.session_state.messages.append(HumanMessage(content=user_input))
# C. 调用模型 (带着之前的记忆)
with st.chat_message("assistant"):
with st.spinner("AI 正在思考..."):  # 显示一个加载转圈圈
response = llm.invoke(st.session_state.messages)
st.write(response.content)
# D. 把 AI 的回复存入记忆
st.session_state.messages.append(AIMessage(content=response.content))

运行方法：

Streamlit 的运行方式和普通 Python 脚本不一样。请在终端输入：

streamlit run lesson5_streamlit.py

预期效果：

终端会自动打开你的默认浏览器（通常地址是 http://localhost:8501），你会看到：

• 一个漂亮的聊天界面（类似 ChatGPT）
• 对话历史会保留在页面上
• 底部有输入框，可以连续对话
• 每次刷新页面，历史记录都还在

架构洞察：Session State 的关键设计

Streamlit 有一个重要机制：每次你点击按钮或输入内容，整个 Python 脚本会从头到尾重新运行一遍。

这意味着什么？如果没有 st.session_state，每次输入都会创建一个新的空 messages 列表，AI 就会失忆。

st.session_state 的作用就是在页面刷新时保持数据不丢失。你可以把它理解为"网页的暂存箱"：

• 第一次访问页面：创建空的 messages 列表
• 用户输入 “你好”：追加到列表，刷新页面，从暂存箱读取完整列表
• AI 回复：追加到列表，刷新页面，从暂存箱读取完整列表
• 用户再次输入：继续追加…

实用技巧：你可以在侧边栏添加控制选项，比如调节 AI 的"创造力"（temperature 参数）：

# 在文件开头添加侧边栏配置
with st.sidebar:
st.header("⚙️ 设置")
temperature = st.slider("创造力", 0.0, 1.0, 0.7, 0.1)
# 更新 llm 配置
llm = ChatOpenAI(
model="glm-4",
openai_api_key="你的_API_KEY",
openai_api_base="https://open.bigmodel.cn/api/paas/v4/",
temperature=temperature
)

5 、 LangGraph 进阶：流程编排的艺术

为什么需要 LangGraph？

LangChain 的 Chain(链)是单向流动的：A → B → C → 结束。但现实场景往往需要：

• 条件分支

  • 如果是数学题走 A 路径，闲聊走 B 路径

• 循环迭代

  • 写文章 → 审核 → 不满意就重写 → 再审核 → 直到满意

• 并行处理

  • 同时调用多个工具，再汇总结果

LangGraph 引入了图结构(Graph)，可以表达任意复杂的流程。

实战：条件路由 - 红绿灯式的智能分流

目标：做一个智能分流系统。用户输入 → AI 判断意图 → 如果是"数学题"走 A 路，如果是"闲聊"走 B 路。

步骤 1：安装 LangGraph

pip install langgraph

步骤 2：创建条件路由程序

创建文件 lesson6_router.py：

import os
from typing import TypedDict, Literal
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import SystemMessage, HumanMessage

# --- 配置 ---
API_KEY = "你的_API_KEY"  # 🔴 别忘了替换 Key
BASE_URL = "https://open.bigmodel.cn/api/paas/v4/"

llm = ChatOpenAI(
    model="glm-4",
    openai_api_key=API_KEY,
    openai_api_base=BASE_URL
)

# --- 1. 定义 State (数据的货箱) ---
# 我们规定这个箱子里只能装这三样东西
class AgentState(TypedDict):
    question: str       # 用户的原始问题
    classification: str # 分类结果 (比如 "math" 或 "general")
    answer: str         # 最终生成的回答

print("✅ 状态定义完成！准备开始构建节点...")

# --- 2. 定义节点 (干活的函数) ---

# 节点 A: 分类员
def classify_input(state: AgentState):
    # 拿到用户的问题
    question = state["question"]

    # 让 AI 做选择题
    response = llm.invoke(
        [SystemMessage(content="你是一个分类器。如果用户的问题是数学计算，请只回复 'math'。如果是其他问题，请只回复 'general'。不要有多余的废话。"),
         HumanMessage(content=question)]
    )

    # 核心步骤：更新 State 中的 classification 字段
    return {"classification": response.content.strip()}

# 节点 B: 数学家
def handle_math(state: AgentState):
    question = state["question"]
    print("🧮 正在调用数学专家...")
    response = llm.invoke(
        [SystemMessage(content="你是一个数学专家。请严谨地计算并给出答案。"),
         HumanMessage(content=question)]
    )
    return {"answer": response.content}

# 节点 C: 聊天员
def handle_general(state: AgentState):
    question = state["question"]
    print("💬 正在调用闲聊助手...")
    response = llm.invoke(
        [SystemMessage(content="你是一个幽默的聊天助手。"),
         HumanMessage(content=question)]
    )
    return {"answer": response.content}

# --- 3. 定义变轨逻辑 (条件边) ---
def route_logic(state: AgentState):
    # 看一眼分类员的结果
    classification = state["classification"]

    # 决定下一步去哪里
    if "math" in classification:
        return "math_expert"
    else:
        return "general_assistant"

# --- 4. 组装图表 (The Graph) ---
workflow = StateGraph(AgentState)

# A. 添加节点 (给工人挂牌)
workflow.add_node("classifier", classify_input)
workflow.add_node("math_expert", handle_math)
workflow.add_node("general_assistant", handle_general)

# B. 设置起点
workflow.set_entry_point("classifier")

# C. 设置条件边 (关键步骤！)
# 意思就是：从 classifier 出来后，执行 route_logic 函数
# 如果函数返回 "math_expert"，就去 math_expert 节点
# 如果函数返回 "general_assistant"，就去 general_assistant 节点
workflow.add_conditional_edges(
    "classifier",
    route_logic,
    {
        "math_expert": "math_expert",
        "general_assistant": "general_assistant"
    }
)

# D. 设置终点
# 数学家和聊天员干完活，就直接结束
workflow.add_edge("math_expert", END)
workflow.add_edge("general_assistant", END)

# E. 编译图表
app = workflow.compile()

print("✅ 路由系统已启动！")

# --- 5. 测试运行 ---

# 测试 1: 数学题
print("\n🧪 测试 1: 输入 '123 * 456 等于几?'")
inputs = {"question": "123 * 456 等于几?"}
for output in app.stream(inputs):
    # 打印每一步的节点名称和输出，方便观察
    for key, value in output.items():
        print(f"  -> 经过节点: {key}")
        print(f"     结果: {value}")

# 测试 2: 闲聊
print("\n🧪 测试 2: 输入 '给我讲个笑话'")
inputs = {"question": "给我讲个笑话"}
for output in app.stream(inputs):
    for key, value in output.items():
        print(f"  -> 经过节点: {key}")
        print(f"     结果: {value}")

运行方法：

python3 lesson6_router.py

预期输出：你会看到不同的问题走不同的路径：

测试 1: 数学题
  -> 经过节点: classifier
  -> 经过节点: math_expert
     结果: 123 * 456 = 56088

测试 2: 闲聊
  -> 经过节点: classifier
  -> 经过节点: general_assistant
     结果: 为什么程序员喜欢用暗色主题？因为光太亮会吸引bug！

架构洞察：这种设计的好处是流程控制逻辑从业务代码中剥离。修改路由规则不需要动核心代码，符合"开闭原则"。你可以轻松添加更多分支，比如"翻译"、“代码生成"等，而不会让代码变成"意大利面条”。

实战：循环流程 - 自我修正的 AI 作家

目标：构建一个"追求完美"的作家 Agent。写初稿 → 检查质量 → 如果不达标，返回重写 → 再检查 → 直到满意。

创建文件 lesson7_loop.py：

import os
from typing import TypedDict
from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import SystemMessage, HumanMessage

# --- 配置 ---
API_KEY = "你的_API_KEY"  # 🔴 记得填 Key
BASE_URL = "https://open.bigmodel.cn/api/paas/v4/"

llm = ChatOpenAI(
    model="glm-4",
    openai_api_key=API_KEY,
    openai_api_base=BASE_URL
)

# --- 1. 定义 State (新的数据结构) ---
class RevisionState(TypedDict):
    topic: str         # 写作的主题 (例如: "关于AI的科普文章")
    draft: str         # 当前的草稿内容
    critique: str      # 编辑的反馈意见
    iterations: int    # 已经修改的次数

print("✅ 循环状态定义完成！")

# --- 2. 定义节点 (干活的函数) ---

# 节点 A: 初稿撰写员/修改员
def draft_writer(state: RevisionState):
    topic = state["topic"]
    draft = state.get("draft")
    critique = state.get("critique")

    # 第一次写作和后续修改使用不同的 Prompt
    if draft is None:
        print("✍️ 首次撰写初稿...")
        prompt_text = f"你是一位优秀的作家。请就以下主题撰写一篇 500 字的简短文章：{topic}"
    else:
        print(f"🔄 收到编辑意见，进行第 {state['iterations'] + 1} 次修改...")
        prompt_text = f"你正在修改一篇关于 '{topic}' 的文章。这是编辑的意见：'{critique}'。请根据意见修改文章，并重新输出完整的文章。"

    response = llm.invoke(
        [SystemMessage(content="你是一位专业作家，请专注于内容和逻辑的改进。"),
         HumanMessage(content=prompt_text)]
    )

    # 核心步骤：更新 State 中的 draft 字段
    return {"draft": response.content}

# 节点 B: 专业编辑
def editor_critique(state: RevisionState):
    draft = state["draft"]
    print("🧐 编辑正在审阅草稿...")

    # 🔴 加入了严格的负面约束
    response = llm.invoke(
        [SystemMessage(content="""
        你是一位苛刻的编辑。请阅读草稿并提出改进意见。
        如果文章已经非常好（字数合理，逻辑清晰），请**只回复 'PASS'**。
        如果需要修改，请给出不超过三点的具体修改意见。
        **【严禁格式要求】**：在你的回复中，**严禁包含**任何 Markdown 格式、代码块、特殊字符或工具调用。你的回复必须是纯文本的建议或 'PASS'。
        """),
         HumanMessage(content=draft)]
    )

    critique = response.content.strip()
    print(f"   -> 编辑反馈: {critique}")

    # 核心步骤：更新 State 中的 critique 字段
    return {"critique": critique}

# 节点 C: 计数员
def increment_iteration(state: RevisionState):
    current_iter = state["iterations"]
    new_iter = current_iter + 1
    return {"iterations": new_iter}

# --- 3. 定义循环的"红绿灯" ---
def should_continue(state: RevisionState):
    critique = state["critique"]

    # 判断条件：如果 critique 包含了 "PASS" 字符串
    if "PASS" in critique:
        return "end"  # 批准通过，结束循环
    else:
        return "continue"  # 需要修改，继续循环

# --- 4. 组装循环图表 (The Graph) ---
workflow = StateGraph(RevisionState)

# A. 添加所有节点 (工人)
workflow.add_node("draft_writer", draft_writer)
workflow.add_node("editor_critique", editor_critique)
workflow.add_node("increment_iteration", increment_iteration)

# B. 设置起点
workflow.set_entry_point("draft_writer")

# C. 设置普通边 (写作 -> 审阅)
workflow.add_edge("draft_writer", "editor_critique")

# D. 设置条件边 (循环的关键!)
# 从审阅出来后，执行 should_continue 函数
# 如果返回 "end"，流程结束
# 如果返回 "continue"，流程转到计数员
workflow.add_conditional_edges(
    "editor_critique",
    should_continue,
    {
        "end": END,
        "continue": "increment_iteration",
    }
)

# E. 设置循环边 (计数员 -> 再次撰写)
# 计数员完成后，跳回到撰写节点，开始下一轮修改！
workflow.add_edge("increment_iteration", "draft_writer")

# F. 编译图表
app = workflow.compile()

print("✅ 完美循环系统已启动！")

# --- 5. 测试运行 ---

# 设定一个主题，并初始化状态 (iterations 从 0 开始)
topic_to_write = "关于智能手机对青少年影响的利弊分析"

print(f"\n🧪 开始撰写主题: {topic_to_write}")
inputs = {
    "topic": topic_to_write,
    "iterations": 0
}

# 运行循环 (使用 invoke，它会一次性跑完所有循环，直到 END)
final_state = app.invoke(inputs)

print("\n--- 任务完成 ---")
print(f"最终修改次数: {final_state['iterations']} 次")
print(f"最终编辑反馈: {final_state['critique']}")
print(f"\n最终文章:\n{final_state['draft']}")

运行方法：

python3 lesson7_loop.py

预期输出：你会看到 AI 反复修改文章，直到编辑满意：

✍️ 首次撰写初稿...
🧐 编辑正在审阅草稿...
   -> 编辑反馈: 1. 需要增加具体数据支持... 2. 段落逻辑需要优化...
🔄 收到编辑意见，进行第 1 次修改...
🧐 编辑正在审阅草稿...
   -> 编辑反馈: 文章已经很好，结构清晰。PASS
--- 任务完成 ---
最终修改次数: 1 次

架构洞察：循环不是盲目重复，而是带着反馈的迭代。每次循环都把上一次的"编辑意见"传给撰写节点，这样 AI 知道哪里需要改进。

Prompt 工程的关键：我们在编辑节点强调"严禁包含 Markdown、代码块"，为什么？因为 LLM 很"礼貌"，如果不管教，它可能回复：“是的，这是一个好文章。” 而不是单独的 “PASS”，导致程序无法识别终止条件，陷入无限循环。

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

为什么要学习大模型？

我国在A大模型领域面临人才短缺,数量与质量均落后于发达国家。2023年，人才缺口已超百万，凸显培养不足。随着AI技术飞速发展，预计到2025年,这一缺口将急剧扩大至400万,严重制约我国AI产业的创新步伐。加强人才培养,优化教育体系,国际合作并进是破解困局、推动AI发展的关键。

大模型入门到实战全套学习大礼包

1、大模型系统化学习路线

作为学习AI大模型技术的新手，方向至关重要。 正确的学习路线可以为你节省时间，少走弯路；方向不对，努力白费。这里我给大家准备了一份最科学最系统的学习成长路线图和学习规划，带你从零基础入门到精通！

---

2、大模型学习书籍&文档

学习AI大模型离不开书籍文档，我精选了一系列大模型技术的书籍和学习文档（电子版），它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础。

3、AI大模型最新行业报告

2025最新行业报告，针对不同行业的现状、趋势、问题、机会等进行系统地调研和评估，以了解哪些行业更适合引入大模型的技术和应用，以及在哪些方面可以发挥大模型的优势。

4、大模型项目实战&配套源码

学以致用，在项目实战中检验和巩固你所学到的知识，同时为你找工作就业和职业发展打下坚实的基础。

5、大模型大厂面试真题

面试不仅是技术的较量，更需要充分的准备。在你已经掌握了大模型技术之后，就需要开始准备面试，我精心整理了一份大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。

适用人群

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。

如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】