LangGraph大揭秘：构建复杂AI应用不再难，告别LangChain的四大痛点！

本文深入探讨了LangGraph在构建复杂AI应用中的优势，详细阐述了LangChain在处理循环逻辑、条件分支、状态管理和暂停恢复等方面的局限性。LangGraph通过将AI工作流抽象为有向图，有效解决了这些痛点，并通过State、Node、Edge和Graph等核心概念，实现了更灵活、高效的状态管理和控制流。文章还提供了三个实战案例，展示了LangGraph在构建ReAct Agent、自我纠错代码生成Agent和带记忆及人工审核的客服Agent中的应用。最后，本文对比了LangGraph与LangChain的适用场景，并提出了最佳实践与常见陷阱，为开发者提供了全面的指导。

当你的 AI 应用不再是简单的"输入→输出"，而是需要循环推理、条件分支、多步决策时，LangGraph 就是你需要的武器。

一、为什么需要 LangGraph？从痛点说起

1.1 LangChain 的瓶颈

如果你用过 LangChain，一定对它的"链式调用"不陌生：

用户提问 → 检索文档 → 组装 Prompt → 调用 LLM → 返回结果

这种线性流程对于简单的问答系统、RAG 应用来说绰绰有余。但当你尝试构建更复杂的 AI 应用时，很快就会遇到这些痛点：

痛点一：无法处理循环逻辑

假设你在做一个代码生成 Agent，LLM 生成的代码可能有 bug，你需要让它"自我纠错"——执行代码、检查结果、如果出错就重新生成。这种"重试循环"在纯 LangChain 中非常难以优雅地实现。

痛点二：条件分支很别扭

你的客服 Bot 需要根据用户意图走不同路径——咨询价格走一条路、投诉走另一条路、技术问题走第三条路。用 LangChain 的 RunnableBranch 可以做，但嵌套多了代码就变成了"意大利面条"。

痛点三：状态管理是噩梦

多步推理过程中，每一步的中间结果需要传递、累积、修改。在链式调用中，你不得不手动维护一个越来越庞大的上下文字典，又丑又容易出 bug。

痛点四：没有原生的"暂停-恢复"能力

想在 AI 做出关键决策前加个人工审核？想让一个长时间运行的任务在中途断开后能恢复？LangChain 原生并不支持这些。

1.2 LangGraph 的答案

LangGraph 的核心思路其实很朴素：把 AI 工作流抽象成一张"有向图"。

● 节点（Node）：每个节点是一个执行单元（调用 LLM、执行工具、处理数据等）

● 边（Edge）：定义节点间的流转路径，可以是固定的，也可以是条件的

● 状态（State）：一个在所有节点间流动的共享数据结构

这不是什么新发明——状态机、工作流引擎早就有了。但 LangGraph 的巧妙之处在于，它专门为 LLM 应用场景设计，把图论的概念和 AI Agent 的需求完美结合在了一起。

┌──────────────────────────────────────────────┐│ LangGraph 工作流 ││ ││ [START] → [路由] ──条件边──→ [工具调用] ││ │ │ ││ │ ↓ ││ │ [执行工具] ││ │ │ ││ │ ↓ ││ └─────────→ [LLM 总结] → [END] ││ ↑ │ ││ └──────┘ ││ (不满意？重来) │└──────────────────────────────────────────────┘

二、核心概念：5 分钟搞懂 LangGraph 的"世界观"

2.1 State（状态）—— 流动的"血液"

State 是整个图的"血液"，它在每个节点间传递、更新。你需要预先定义好它的结构：

from typing import TypedDict, Annotatedfrom langgraph.graph.message import add_messagesclass AgentState(TypedDict): """Agent 的状态定义""" messages: Annotated[list, add_messages] # 对话消息列表（自动追加） current_step: str # 当前执行到哪一步 retry_count: int # 重试次数

这里有个精妙的设计：Annotated[list, add_messages]。add_messages 是一个归约器（Reducer），它告诉 LangGraph：当节点返回新的 messages 时，不要覆盖原来的，而是追加上去。这完美解决了对话历史的管理问题。

2.2 Node（节点）—— 干活的"工人"

节点就是一个普通的 Python 函数，接收 State，返回更新后的部分 State：

def chatbot(state: AgentState): """聊天节点：调用 LLM 生成回复""" response = llm.invoke(state["messages"]) return {"messages": [response]}def search_tool(state: AgentState): """搜索节点：执行搜索工具""" query = state["messages"][-1].content results = tavily_search.invoke(query) return {"messages": [ToolMessage(content=results, ...)]}

就这么简单——输入是完整的 State，输出是你想更新的那部分字段。

2.3 Edge（边）—— 连接的"道路"

边分两种：

普通边：从 A 节点无条件跳到 B 节点。

graph.add_edge("search_tool", "chatbot") # 搜索完了，一定回到聊天

条件边：根据当前状态动态决定下一步去哪。

def should_continue(state: AgentState): """判断是否需要调用工具""" last_message = state["messages"][-1] if last_message.tool_calls: return "tools" # 有工具调用 → 去执行工具 return "end" # 没有 → 结束graph.add_conditional_edges("chatbot", should_continue, { "tools": "search_tool", "end": END})

2.4 Graph（图）—— 完整的"工厂"

把上面的零件组装在一起，就是一个完整的图：

from langgraph.graph import StateGraph, START, END# 1. 创建图，指定状态类型graph = StateGraph(AgentState)# 2. 添加节点graph.add_node("chatbot", chatbot)graph.add_node("search_tool", search_tool)# 3. 添加边graph.add_edge(START, "chatbot") # 入口 → 聊天graph.add_conditional_edges("chatbot", should_continue, { "tools": "search_tool", "end": END})graph.add_edge("search_tool", "chatbot") # 工具 → 回到聊天# 4. 编译app = graph.compile()

一目了然的结构，每个节点干什么、怎么连接、什么条件走什么路径，全部显式定义。

三、实战一：构建一个会使用工具的 ReAct Agent

这是最经典的 LangGraph 场景——让 LLM 自主决定是否调用工具，调用哪个工具，然后根据工具结果继续推理。

3.1 安装依赖

pip install langgraph langchain-openai tavily-python

3.2 完整代码

"""实战：用 LangGraph 构建一个 ReAct Agent功能：能搜索网络、做数学计算的智能助手"""import osfrom typing import TypedDict, Annotatedfrom langchain_openai import ChatOpenAIfrom langchain_core.messages import HumanMessage, SystemMessagefrom langchain_community.tools.tavily_search import TavilySearchResultsfrom langgraph.graph import StateGraph, START, ENDfrom langgraph.graph.message import add_messagesfrom langgraph.prebuilt import ToolNode# ========== 1. 定义状态 ==========class AgentState(TypedDict): messages: Annotated[list, add_messages]# ========== 2. 定义工具 ==========# 网络搜索工具search_tool = TavilySearchResults(max_results=3)# 你可以轻松添加自定义工具from langchain_core.tools import tool@tooldef calculator(expression: str) -> str: """计算数学表达式。输入应该是一个合法的 Python 数学表达式。""" try: result = eval(expression) return f"计算结果: {expression} = {result}" except Exception as e: return f"计算错误: {e}"tools = [search_tool, calculator]# ========== 3. 初始化 LLM ==========llm = ChatOpenAI( model="gpt-4o", temperature=0,).bind_tools(tools) # 关键：绑定工具，让 LLM 知道有哪些工具可用# ========== 4. 定义节点 ==========def agent(state: AgentState): """Agent 节点：调用 LLM 进行推理""" system_prompt = SystemMessage(content=( "你是一个智能助手，可以使用搜索工具查找最新信息，" "也可以使用计算器进行数学运算。" "请根据用户的问题，判断是否需要使用工具。" )) messages = [system_prompt] + state["messages"] response = llm.invoke(messages) return {"messages": [response]}def should_continue(state: AgentState): """路由函数：判断 Agent 是否需要调用工具""" last_message = state["messages"][-1] # 如果 LLM 返回了工具调用请求，就去执行工具 if hasattr(last_message, "tool_calls") and last_message.tool_calls: return "tools" # 否则结束 return "end"# ========== 5. 构建图 ==========graph = StateGraph(AgentState)# 添加节点graph.add_node("agent", agent)graph.add_node("tools", ToolNode(tools)) # ToolNode 是预置的工具执行节点# 添加边graph.add_edge(START, "agent")graph.add_conditional_edges("agent", should_continue, { "tools": "tools", "end": END,})graph.add_edge("tools", "agent") # 工具执行完，回到 Agent 继续推理# 编译app = graph.compile()# ========== 6. 运行 ==========if __name__ == "__main__": # 测试 1：需要搜索的问题 print("=" * 60) print("测试 1：搜索问题") print("=" * 60) result = app.invoke({ "messages": [HumanMessage(content="2026年最新的 Python 版本是什么？有哪些新特性？")] }) print(result["messages"][-1].content) print("\n") # 测试 2：需要计算的问题 print("=" * 60) print("测试 2：计算问题") print("=" * 60) result = app.invoke({ "messages": [HumanMessage(content="帮我算一下，如果我每月投资 5000 元，年化收益 8%，10 年后有多少钱？用复利公式。")] }) print(result["messages"][-1].content)

3.3 执行流程详解

当用户问"2026年最新的 Python 版本是什么？"时，整个流程是这样的：

[START] ↓[agent] → LLM 分析问题，发现需要搜索最新信息 ↓ → 返回 tool_calls: [TavilySearch("Python latest version 2026")][should_continue] → 检测到 tool_calls → 路由到 "tools" ↓[tools] → 执行 Tavily 搜索，得到结果 ↓[agent] → LLM 收到搜索结果，组织语言回答用户 ↓[should_continue] → 没有 tool_calls → 路由到 "end" ↓[END] → 返回最终结果

这就是 ReAct（Reasoning + Acting）模式：LLM 先"思考"要做什么，然后"行动"（调用工具），再根据行动结果继续"思考"。LangGraph 的循环图结构天然支持这种模式。

四、实战二：带有自我纠错能力的代码生成 Agent

这个场景更能体现 LangGraph 的优势——当 LLM 生成的代码有 bug 时，自动执行、检查、修复，循环直到正确。

4.1 完整代码

"""实战：自我纠错的代码生成 Agent场景：用户描述需求 → 生成代码 → 执行测试 → 如果失败则修复 → 重复直到成功"""from typing import TypedDict, Annotated, Literalfrom langchain_openai import ChatOpenAIfrom langchain_core.messages import HumanMessage, SystemMessage, AIMessagefrom langgraph.graph import StateGraph, START, ENDfrom langgraph.graph.message import add_messagesimport subprocessimport tempfileimport os# ========== 1. 定义状态 ==========class CodeGenState(TypedDict): messages: Annotated[list, add_messages] generated_code: str # 当前生成的代码 test_result: str # 测试执行结果 test_passed: bool # 测试是否通过 retry_count: int # 已重试次数 max_retries: int # 最大重试次数# ========== 2. 初始化 LLM ==========llm = ChatOpenAI(model="gpt-4o", temperature=0)# ========== 3. 定义节点 ==========def generate_code(state: CodeGenState): """代码生成节点""" system_prompt = SystemMessage(content=( "你是一个 Python 代码专家。根据用户的需求生成代码。\n" "只输出纯 Python 代码，不要 Markdown 格式。\n" "代码末尾必须包含简单的测试用例（用 assert 语句）。" )) # 如果是重试，附加上次的错误信息 if state.get("test_result") and not state.get("test_passed"): error_msg = HumanMessage(content=( f"上次生成的代码执行失败了，错误信息如下：\n" f"```\n{state['test_result']}\n```\n" f"之前生成的代码：\n" f"```python\n{state['generated_code']}\n```\n" f"请修复代码中的问题。" )) messages = [system_prompt] + state["messages"] + [error_msg] else: messages = [system_prompt] + state["messages"] response = llm.invoke(messages) code = response.content.strip() # 清理可能的 Markdown 代码块标记 if code.startswith("```python"): code = code[9:] if code.startswith("```"): code = code[3:] if code.endswith("```"): code = code[:-3] code = code.strip() return { "generated_code": code, "retry_count": state.get("retry_count", 0) + 1, "messages": [AIMessage(content=f"生成的代码（第 {state.get('retry_count', 0) + 1} 次尝试）：\n```python\n{code}\n```")] }def execute_code(state: CodeGenState): """代码执行节点：在安全环境中运行代码""" code = state["generated_code"] with tempfile.NamedTemporaryFile( mode="w", suffix=".py", delete=False ) as f: f.write(code) tmp_path = f.name try: result = subprocess.run( ["python", tmp_path], capture_output=True, text=True, timeout=10, ) if result.returncode == 0: return { "test_result": result.stdout or "所有测试通过！", "test_passed": True, } else: return { "test_result": result.stderr, "test_passed": False, } except subprocess.TimeoutExpired: return { "test_result": "执行超时（10秒）", "test_passed": False, } finally: os.unlink(tmp_path)def should_retry(state: CodeGenState) -> Literal["retry", "success", "give_up"]: """路由：决定下一步走向""" if state["test_passed"]: return "success" if state["retry_count"] >= state.get("max_retries", 3): return "give_up" return "retry"def success_node(state: CodeGenState): """成功节点""" return { "messages": [AIMessage(content=( f"✅ 代码生成成功！经过 {state['retry_count']} 次尝试。\n\n" f"最终代码：\n```python\n{state['generated_code']}\n```\n\n" f"测试输出：{state['test_result']}" ))] }def give_up_node(state: CodeGenState): """放弃节点""" return { "messages": [AIMessage(content=( f"❌ 经过 {state['retry_count']} 次尝试仍未成功。\n" f"最后的错误：{state['test_result']}\n" f"最后的代码：\n```python\n{state['generated_code']}\n```" ))] }# ========== 4. 构建图 ==========graph = StateGraph(CodeGenState)# 添加节点graph.add_node("generate", generate_code)graph.add_node("execute", execute_code)graph.add_node("success", success_node)graph.add_node("give_up", give_up_node)# 添加边graph.add_edge(START, "generate")graph.add_edge("generate", "execute")graph.add_conditional_edges("execute", should_retry, { "retry": "generate", # 失败 → 重新生成 "success": "success", # 成功 → 庆祝 "give_up": "give_up", # 超过重试上限 → 放弃})graph.add_edge("success", END)graph.add_edge("give_up", END)# 编译app = graph.compile()# ========== 5. 运行 ==========if __name__ == "__main__": result = app.invoke({ "messages": [HumanMessage(content=( "写一个函数 merge_sorted_lists(list1, list2)，" "将两个已排序的列表合并成一个排序列表。" "不要使用内置的 sorted() 函数。" ))], "generated_code": "", "test_result": "", "test_passed": False, "retry_count": 0, "max_retries": 3, }) # 输出最终消息 print(result["messages"][-1].content)

4.2 这个例子解决了什么痛点？

五、实战三：带记忆和人工审核的客服 Agent

这是一个更贴近生产环境的例子，展示了 LangGraph 的两个高级特性：持久化记忆 和 Human-in-the-Loop（人机协作）。

5.1 持久化与 Checkpointer

LangGraph 内置了 Checkpointer 机制，可以将图的执行状态保存到内存、SQLite 或 PostgreSQL 中。这意味着：

● 对话可以跨会话保持上下文

● 长时间运行的任务可以在中断后恢复

● 同一个 Agent 可以同时处理多个用户的请求

"""实战：带记忆和人工审核的智能客服"""from typing import TypedDict, Annotated, Literalfrom langchain_openai import ChatOpenAIfrom langchain_core.messages import HumanMessage, SystemMessage, AIMessagefrom langgraph.graph import StateGraph, START, ENDfrom langgraph.graph.message import add_messagesfrom langgraph.checkpoint.memory import MemorySaver# ========== 1. 定义状态 ==========class CustomerServiceState(TypedDict): messages: Annotated[list, add_messages] intent: str # 用户意图：inquiry / complaint / refund sentiment: str # 用户情绪：positive / neutral / negative needs_human: bool # 是否需要人工介入 resolved: bool # 问题是否已解决# ========== 2. LLM 初始化 ==========llm = ChatOpenAI(model="gpt-4o", temperature=0)# ========== 3. 节点定义 ==========def classify_intent(state: CustomerServiceState): """意图分类节点：分析用户消息的意图和情绪""" classify_prompt = SystemMessage(content=( "分析用户消息，返回 JSON 格式：\n" '{"intent": "inquiry|complaint|refund", "sentiment": "positive|neutral|negative"}\n' "只返回 JSON，不要其他内容。" )) response = llm.invoke([classify_prompt] + state["messages"][-1:]) import json try: result = json.loads(response.content) needs_human = ( result.get("intent") == "refund" or result.get("sentiment") == "negative" ) return { "intent": result.get("intent", "inquiry"), "sentiment": result.get("sentiment", "neutral"), "needs_human": needs_human, } except json.JSONDecodeError: return { "intent": "inquiry", "sentiment": "neutral", "needs_human": False, }def route_by_intent(state: CustomerServiceState) -> Literal[ "handle_inquiry", "handle_complaint", "human_review"]: """路由：根据意图和情绪分流""" if state["needs_human"]: return "human_review" if state["intent"] == "complaint": return "handle_complaint" return "handle_inquiry"def handle_inquiry(state: CustomerServiceState): """处理咨询""" response = llm.invoke([ SystemMessage(content=( "你是一位友善的客服。用户在咨询产品信息。" "请热情、详细地回答。如果信息不足，引导用户提供更多细节。" )), *state["messages"], ]) return {"messages": [response], "resolved": True}def handle_complaint(state: CustomerServiceState): """处理投诉""" response = llm.invoke([ SystemMessage(content=( "你是一位专业的客服主管。用户在投诉。\n" "请首先表示理解和歉意，然后提出具体的解决方案。\n" "语气要诚恳，避免模板化的回复。" )), *state["messages"], ]) return {"messages": [response], "resolved": True}def human_review(state: CustomerServiceState): """人工审核节点：标记需要人工处理""" return { "messages": [AIMessage(content=( "🔔 您的问题已升级至人工客服。\n" f"系统分析：意图={state['intent']}，情绪={state['sentiment']}\n" "人工客服将在 5 分钟内接入，请稍候。" ))], "resolved": False, }# ========== 4. 构建图 ==========graph = StateGraph(CustomerServiceState)graph.add_node("classify", classify_intent)graph.add_node("handle_inquiry", handle_inquiry)graph.add_node("handle_complaint", handle_complaint)graph.add_node("human_review", human_review)graph.add_edge(START, "classify")graph.add_conditional_edges("classify", route_by_intent, { "handle_inquiry": "handle_inquiry", "handle_complaint": "handle_complaint", "human_review": "human_review",})graph.add_edge("handle_inquiry", END)graph.add_edge("handle_complaint", END)graph.add_edge("human_review", END)# 关键：添加 Checkpointer 实现记忆持久化memory = MemorySaver()app = graph.compile(checkpointer=memory)# ========== 5. 运行（带记忆） ==========if __name__ == "__main__": # 配置 thread_id，相同 thread_id 的对话共享记忆 config = {"configurable": {"thread_id": "user-001"}} # 第一轮对话 print("=" * 50) print("第一轮：咨询") print("=" * 50) result = app.invoke( { "messages": [HumanMessage(content="你们的 Pro 套餐多少钱？包含哪些功能？")], "intent": "", "sentiment": "", "needs_human": False, "resolved": False, }, config=config, ) print(result["messages"][-1].content) # 第二轮对话（同一个 thread，有记忆） print("\n" + "=" * 50) print("第二轮：投诉（情绪升级）") print("=" * 50) result = app.invoke( { "messages": [HumanMessage(content=( "我买了你们的 Pro 套餐，但是功能根本不能用！" "客服电话也打不通，这是什么服务态度！我要退款！" ))], "intent": "", "sentiment": "", "needs_human": False, "resolved": False, }, config=config, ) print(result["messages"][-1].content) print(f"\n→ 需要人工介入: {result['needs_human']}") print(f"→ 用户意图: {result['intent']}") print(f"→ 用户情绪: {result['sentiment']}")

5.2 关键设计要点

记忆持久化：通过 MemorySaver + thread_id，同一个用户的多轮对话自动关联。第二轮对话时，Agent 已经知道用户之前咨询过 Pro 套餐。

人机协作：当检测到退款请求或负面情绪时，自动升级到人工处理。在生产环境中，你可以用 LangGraph 的 interrupt() 原语实现真正的暂停等待。

意图路由：一个 classify 节点 + 条件边，就实现了多路径分流，比一堆 if-else 清晰得多。

六、LangGraph vs LangChain：到底该选哪个？

这不是一个"二选一"的问题。LangGraph 是 LangChain 生态的一部分，它们是互补关系：

选择建议：

● 用 LangChain：当你的应用是线性的，输入→处理→输出，不需要循环和复杂分支

● 用 LangGraph：当你需要 Agent 自主决策、循环推理、多路径分支、状态持久化

● 两者结合：在 LangGraph 的节点内部使用 LangChain 的组件（如 Retriever、Tool）

七、进阶概念速览

7.1 子图（Subgraph）

当图变得复杂时，可以将一部分逻辑封装为子图，然后作为一个节点嵌入到父图中：

# 定义子图research_subgraph = StateGraph(ResearchState)research_subgraph.add_node("search", search_node)research_subgraph.add_node("summarize", summarize_node)# ... 配置边 ...research_compiled = research_subgraph.compile()# 作为节点嵌入父图main_graph = StateGraph(MainState)main_graph.add_node("research", research_compiled)# 子图作为节点main_graph.add_node("write", write_node)

7.2 流式输出（Streaming）

LangGraph 支持多种级别的流式输出：

# 流式输出每个节点的更新for event in app.stream({"messages":[HumanMessage(content="你好")]}, stream_mode="updates",):print(event)# 流式输出 LLM 的 token（最细粒度）asyncfor event in app.astream_events({"messages":[HumanMessage(content="你好")]}, version="v2",):if event["event"]=="on_chat_model_stream":print(event["data"]["chunk"].content, end="", flush=True)

7.3 LangGraph Platform（生产部署）

LangGraph 提供了一套生产级部署方案：

● LangGraph Server：将图部署为 API 服务

● LangGraph Studio：可视化调试工具，可以看到图的执行过程

● LangSmith 集成：监控、追踪、评估你的 Agent 表现

八、最佳实践与常见陷阱

✅ DO（推荐做法）

1. State 设计要精简：只放真正需要在节点间传递的数据，临时变量在节点内部处理

2. 善用 Reducer：add_messages 用于对话历史，自定义 Reducer 用于列表累积等场景

3. 条件边要有兜底：确保 should_continue 类函数覆盖所有可能的返回值

4. 先画图再写代码：在白板上画出流程图，然后翻译成 LangGraph 代码

5. 利用 get_graph().draw_mermaid_png()：一行代码生成流程图，方便团队沟通

❌ DON’T（避免的做法）

1. 不要在节点里做太多事：一个节点只做一件事，复杂逻辑拆成多个节点

2. 不要忘记退出条件：循环图必须有明确的终止条件，否则会无限循环

3. 不要滥用全局状态：不是所有变量都要放进 State，过度使用会让图变得难以理解

4. 不要忽视错误处理：工具调用可能失败，LLM 可能返回格式异常，要有兜底方案

九、总结

LangGraph 的本质是一种编排思维的升级：

● 从"链式"到"图式"

● 从"线性流程"到"循环决策"

● 从"无状态"到"有状态"

● 从"纯自动"到"人机协作"

它不是要取代 LangChain，而是在你的 AI 应用复杂到一定程度时，提供一个更合适的架构选择。如果你正在构建的 Agent 需要"思考-行动-观察-再思考"的循环，或者需要多个 Agent 协同工作，那么 LangGraph 几乎是目前最佳的选择。

最后

对于正在迷茫择业、想转行提升，或是刚入门的程序员、编程小白来说，有一个问题几乎人人都在问：未来10年，什么领域的职业发展潜力最大？

答案只有一个：人工智能（尤其是大模型方向）

当下，人工智能行业正处于爆发式增长期，其中大模型相关岗位更是供不应求，薪资待遇直接拉满——字节跳动作为AI领域的头部玩家，给硕士毕业的优质AI人才（含大模型相关方向）开出的月基础工资高达5万—6万元；即便是非“人才计划”的普通应聘者，月基础工资也能稳定在4万元左右。

再看阿里、腾讯两大互联网大厂，非“人才计划”的AI相关岗位应聘者，月基础工资也约有3万元，远超其他行业同资历岗位的薪资水平，对于程序员、小白来说，无疑是绝佳的转型和提升赛道。

如果你还不知道从何开始，我自己整理一套全网最全最细的大模型零基础教程，我也是一路自学走过来的，很清楚小白前期学习的痛楚，你要是没有方向还没有好的资源，根本学不到东西！

下面是我整理的大模型学习资源，希望能帮到你。

👇👇扫码免费领取全部内容👇👇

最后

1、大模型学习路线

2、从0到进阶大模型学习视频教程

从入门到进阶这里都有，跟着老师学习事半功倍。

3、 入门必看大模型学习书籍&文档.pdf（书面上的技术书籍确实太多了，这些是我精选出来的，还有很多不在图里）

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

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

5、面试试题/经验

【大厂 AI 岗位面经分享（107 道）】

【AI 大模型面试真题（102 道）】

【LLMs 面试真题（97 道）】

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

适用人群

四阶段学习规划（共90天，可落地执行）

第一阶段（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 项目

• 内容安全

• 互联网信息服务算法备案

• …

  👇👇扫码免费领取全部内容👇👇

3、这些资料真的有用吗？

这份资料由我和鲁为民博士(北京清华大学学士和美国加州理工学院博士)共同整理，现任上海殷泊信息科技CEO，其创立的MoPaaS云平台获Forrester全球’强劲表现者’认证，服务航天科工、国家电网等1000+企业，以第一作者在IEEE Transactions发表论文50+篇，获NASA JPL火星探测系统强化学习专利等35项中美专利。本套AI大模型课程由清华大学-加州理工双料博士、吴文俊人工智能奖得主鲁为民教授领衔研发。

资料内容涵盖了从入门到进阶的各类视频教程和实战项目，无论你是小白还是有些技术基础的技术人员，这份资料都绝对能帮助你提升薪资待遇，转行大模型岗位。

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