但真实世界的复杂任务，往往需要多个专家协作才能完成——就像一个项目团队，有人负责调研，有人负责撰写，还有人负责审核。

单一 Agent 的局限性在哪里？

假设你要求 AI “写一份关于2025年AI药物研发趋势的报告”。一个全能 Agent 需要：

• 上网搜索最新数据
• 整理和分析信息
• 撰写专业报告
• 自我审核质量

这就像要求一个人既是侦探、又是作家、还是编辑——虽然可能做到，但效率和质量都会打折扣。

多智能体协作的优势是什么？

• 专业分工

  研究员专注搜索，报告员专注写作，协调员专注质量控制

• 并行处理

  不同 Agent 可以同时工作（本教程聚焦顺序协作，并行协作是下一个进阶主题）

• 质量保证

  通过协调员的循环检查，确保输出达标

• 易于调试

  每个 Agent 职责清晰，问题定位更简单

本教程将带你从零构建一个研究-报告团队系统，包含三个专业 Agent：

1. 研究员(Researcher)

   • 使用本地搜索工具获取实时数据

2. 报告撰写员(Reporter)

   • 将数据整理成专业报告

3. 协调员(Coordinator)

   • 判断数据质量，决定是继续研究还是进入撰写

最精彩的部分是：协调员可以让研究员重复搜索，直到数据质量达标——这就是动态协作与循环机制的威力。希望对你有所启发。

PART 01 - 多智能体架构设计

1.为什么需要 TeamState？

在单一 Agent 中，我们只需要关心"用户输入"和"AI 输出"。但在多智能体系统中，数据需要在 Agent 之间流转：

用户查询 → 研究员(搜索数据) → 协调员(评估) → 报告员(撰写) → 最终报告

问题来了：研究员找到的数据怎么传给协调员？协调员的决策怎么告诉系统"下一步去哪里"？

这就需要一个团队共享的数据包 —— TeamState。

2.TeamState 设计：三核心字段

TeamState 必须包含：

class TeamState(TypedDict):    query: str          # 用户的原始查询/任务 - 所有 Agent 的起点    research_data: str  # 研究员收集到的数据 - 传递给协调员和报告员    report: str         # 撰写员最终的报告 - 系统的输出    coordinator_decision: str  # 协调员的决策 - 控制流程分支

关键设计理念：

• query

  是不变的锚点，所有 Agent 都知道最初的目标是什么

• research_data

  是数据流转的核心，从研究员流向协调员和报告员

• coordinator_decision

  是流程控制的关键，决定循环还是结束

• report

  是最终产物，只有报告员会写入

3.LangGraph 架构：State + Nodes + Edges

从 LangGraph 的角度看，整个系统是一个有向图：

[START]   ↓[Researcher 节点] ← ┐   ↓               │[Coordinator 节点] │   ↓               │  判断             │   ├─ 数据不足 ────┘ (循环)   ├─ 数据充足 → [Reporter 节点] → [END]

三种边的类型：

1. 普通边

   (add_edge) - 固定流向，如 Researcher → Coordinator

2. 条件边

   (add_conditional_edges) - 根据 State 动态决定下一步

3. 终点边

   • 指向 END，结束流程

PART 02 - 顺序协作：研究员 + 报告员

我们先构建一个简化版本：研究员搜索数据 → 报告员撰写报告，没有循环机制。这样可以先理解基础的数据流转。

步骤 1：环境准备与工具定义

创建新文件 lesson8_multiteam.py，首先导入依赖并定义本地化搜索工具：

import osfrom typing import TypedDict, Annotated, List, Unionfrom langgraph.graph import StateGraph, ENDfrom langchain_openai import ChatOpenAIfrom langchain_core.messages import BaseMessage, SystemMessage, HumanMessagefrom langchain.agents import AgentExecutor, create_openai_functions_agentfrom langchain.tools import toolfrom langchain_core.prompts import ChatPromptTemplate# --- 配置 LLM ---API_KEY = "你的_API_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)# 🌐 定义本地化搜索工具@tooldef local_search_proxy(query: str) -> str:    """使用国内本地搜索引擎代理，查找实时数据或事实。"""    print(f"\n🌐 正在调用本地搜索代理，查询: {query[:30]}...")    # 模拟搜索结果    if "人工智能" in query or "AI" in query:        return "【本地搜索结果】: AI在药物研发、气候建模和多模态交互方面取得了重要进展。2025年行业报告显示，'具身智能'是下一代热点。"    return "【本地搜索结果】: 未找到针对该主题的实时数据。"tools = [local_search_proxy]

技术要点：

• @tool

  装饰器将普通函数转换为 LangChain 可识别的工具

• 本教程使用模拟数据，实际应用中可替换为真实搜索 API（如 Serper、Bing Search）

步骤 2：定义 TeamState 和 Agent

# --- 1. 定义团队状态 ---class TeamState(TypedDict):    query: str    research_data: str    report: str# --- 2. 定义研究员 Agent ---researcher_prompt = ChatPromptTemplate.from_messages([    ("system", "你是一位顶尖的研究员，你唯一的任务是使用 'local_search_proxy' 工具来获取关于用户查询的最新事实和数据。"),    ("human", "{query}"),    ("placeholder", "{agent_scratchpad}"),  # 🔴 必需字段])researcher_agent = create_openai_functions_agent(llm, tools, researcher_prompt)researcher_executor = AgentExecutor(agent=researcher_agent, tools=tools, verbose=True)# --- 3. 定义报告撰写员 Agent ---reporter_prompt = ChatPromptTemplate.from_messages([    ("system", "你是一位专业的报告撰写员。你将接收研究员提供的数据，并将其整理成一份清晰、简洁的报告。"),    ("human", "请根据以下数据撰写报告：\n\n数据：{research_data}"),    ("placeholder", "{agent_scratchpad}"),  # 🔴 必需字段])reporter_agent = create_openai_functions_agent(llm, [], reporter_prompt)reporter_executor = AgentExecutor(agent=reporter_agent, tools=[], verbose=True)

关键错误预防：

每个 Agent 的 Prompt 都必须包含 {agent_scratchpad} 占位符，这是 LangChain 框架的强制要求。它用于记录 Agent 的思考过程和工具调用历史。

❌ 常见错误：

("human", "{query}")  # 缺少 agent_scratchpad

✅ 正确写法：

("human", "{query}"),("placeholder", "{agent_scratchpad}")

步骤 3：定义节点函数

节点函数是 LangGraph 和 Agent 之间的适配器，负责：

1. 从 TeamState 中提取 Agent 需要的数据
2. 调用 Agent Executor
3. 将 Agent 的输出更新回 TeamState

# --- 4. 定义节点函数 ---def run_researcher(state: TeamState):    """研究员节点：执行搜索任务"""    query = state["query"]    print("🔍 [节点 A] 研究员启动，开始搜索...")    # 运行研究员 Agent    result = researcher_executor.invoke({"query": query})    research_data = result["output"]    print(f"✅ 研究员完成。数据摘要: {research_data[:100]}...")    return {"research_data": research_data}def run_reporter(state: TeamState):    """报告撰写员节点：整理数据为报告"""    research_data = state["research_data"]    print("📝 [节点 B] 报告撰写员启动...")    # 运行报告员 Agent    result = reporter_executor.invoke({"research_data": research_data})    report = result["output"]    print(f"✅ 报告完成。摘要: {report[:100]}...")    return {"report": report}

设计模式：

这是典型的适配器模式(Adapter Pattern)。LangGraph 需要的是接受 TeamState 参数并返回 dict 的函数，而 Agent Executor 期望的是特定格式的输入。节点函数就是这两者之间的桥梁。

步骤 4：构建 LangGraph 工作流

# --- 5. 组装图表 ---workflow = StateGraph(TeamState)# A. 添加节点workflow.add_node("researcher", run_researcher)workflow.add_node("reporter", run_reporter)# B. 设置起点workflow.set_entry_point("researcher")# C. 连接节点（顺序执行）workflow.add_edge("researcher", "reporter")# D. 设置终点workflow.add_edge("reporter", END)# E. 编译图表app = workflow.compile()print("✅ 研究与报告团队系统已启动！")# --- 6. 测试运行 ---query_task = "请使用联网搜索，总结2025年人工智能在药物研发领域的最新突破。"print(f"\n🧪 任务启动: {query_task}")final_state = app.invoke({"query": query_task})print("\n--- 协作任务完成 ---")print(f"最终报告：\n{final_state['report']}")

运行流程：

用户输入 query    ↓set_entry_point("researcher")  # 从研究员开始    ↓run_researcher() 执行    ├─ 调用 researcher_executor    ├─ Agent 使用 local_search_proxy 工具    └─ 更新 state["research_data"]    ↓add_edge("researcher", "reporter")  # 自动跳转到报告员    ↓run_reporter() 执行    ├─ 读取 state["research_data"]    ├─ 调用 reporter_executor    └─ 更新 state["report"]    ↓add_edge("reporter", END)  # 结束

运行结果

✅ 研究员成功调用了 local_search_proxy 工具

✅ 数据通过 TeamState 从研究员流向报告员

✅ 报告员生成了结构化的专业报告

PART 03 - 动态协作：引入协调员与循环机制

顺序协作的局限性

在上面的系统中，研究员只搜索一次就把数据交给报告员。但如果：

• 搜索结果质量不高？
• 数据量太少？
• 包含大量无关信息？

我们需要一个质量检查机制，能够让研究员重新搜索，直到数据达标——这就是循环协作的核心价值。

架构升级：加入协调员

# --- 更新 TeamState ---class TeamState(TypedDict):    query: str    research_data: str    report: str    coordinator_decision: str  # 🔴 新增：协调员的决策

定义协调员 Agent

# --- 协调员 Agent ---coordinator_prompt = ChatPromptTemplate.from_messages([    ("system", """    你是一位专业的团队协调员。你的任务是评估研究员提供的数据是否足以撰写完整报告。    【严格格式要求】:    - 如果数据充足，请**只回复** 'finish'。    - 如果数据不足，请**只回复** 'research_more'。    - 严禁包含任何其他文字或Markdown格式。    """),    ("human", "请评估以下数据是否充足：\n\n{research_data}"),    ("placeholder", "{agent_scratchpad}"),  # 🔴 必需])coordinator_agent = create_openai_functions_agent(llm, [], coordinator_prompt)coordinator_executor = AgentExecutor(agent=coordinator_agent, tools=[], verbose=True)# --- 协调员节点 ---def run_coordinator(state: TeamState):    """协调员节点：评估数据质量"""    research_data = state["research_data"]    print("🚦 [节点 C] 协调员启动，评估数据质量...")    result = coordinator_executor.invoke({"research_data": research_data})    decision = result["output"].strip().lower()    print(f"✅ 协调员决策: {decision}")    return {"coordinator_decision": decision}

关键设计：

协调员的输出必须是 "finish" 或 "research_more" 之一，因为这两个字符串会直接用于 LangGraph 的路由决策。

构建动态流程：条件边

# --- 路由函数 ---def route_coordinator(state: TeamState):    """根据协调员决策路由流程"""    return state["coordinator_decision"]# --- 组装动态图表 ---workflow = StateGraph(TeamState)# 添加所有节点workflow.add_node("researcher", run_researcher)workflow.add_node("coordinator", run_coordinator)workflow.add_node("reporter", run_reporter)# 设置起点workflow.set_entry_point("researcher")# 研究员 → 协调员（固定）workflow.add_edge("researcher", "coordinator")# 协调员 → 动态路由（关键！）workflow.add_conditional_edges(    "coordinator",        # 从协调员节点出发    route_coordinator,    # 调用路由函数    {        "finish": "reporter",          # 数据充足 → 报告员        "research_more": "researcher"  # 数据不足 → 回到研究员（循环）    })# 报告员 → 结束workflow.add_edge("reporter", END)app = workflow.compile()

条件边的工作原理：

┌─────────────┐                    │ Coordinator │                    └──────┬──────┘                           │                    route_coordinator()                           │              ┌────────────┴────────────┐              │                         │      decision == "finish"     decision == "research_more"              │                         │              ↓                         ↓        ┌──────────┐            ┌────────────┐        │ Reporter │            │ Researcher │ ← 形成循环        └──────────┘            └─────┬──────┘                                      │                                      ↓                               回到 Coordinator

完整代码

import osfrom typing import TypedDictfrom langgraph.graph import StateGraph, ENDfrom langchain_openai import ChatOpenAIfrom langchain.agents import AgentExecutor, create_openai_functions_agentfrom langchain.tools import toolfrom langchain_core.prompts import ChatPromptTemplate# ========== 配置 ==========API_KEY = "你的_API_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)# ========== 工具定义 ==========@tooldef local_search_proxy(query: str) -> str:    """使用国内搜索引擎获取实时数据"""    print(f"\n🌐 搜索: {query[:30]}...")    if "人工智能" in query or "AI" in query:        return "【搜索结果】: AI在药物研发、气候建模领域取得重要进展。2025年'具身智能'成为热点。"    return "【搜索结果】: 未找到相关数据。"tools = [local_search_proxy]# ========== 状态定义 ==========class TeamState(TypedDict):    query: str    research_data: str    report: str    coordinator_decision: str# ========== Agent 定义 ==========# 1. 研究员researcher_prompt = ChatPromptTemplate.from_messages([    ("system", "你是顶尖研究员，使用 'local_search_proxy' 工具获取最新数据。"),    ("human", "{query}"),    ("placeholder", "{agent_scratchpad}"),])researcher_agent = create_openai_functions_agent(llm, tools, researcher_prompt)researcher_executor = AgentExecutor(agent=researcher_agent, tools=tools, verbose=True)# 2. 协调员coordinator_prompt = ChatPromptTemplate.from_messages([    ("system", """评估数据是否充足。    - 充足回复: finish    - 不足回复: research_more    - 严禁其他内容"""),    ("human", "评估数据：\n{research_data}"),    ("placeholder", "{agent_scratchpad}"),])coordinator_agent = create_openai_functions_agent(llm, [], coordinator_prompt)coordinator_executor = AgentExecutor(agent=coordinator_agent, tools=[], verbose=True)# 3. 报告员reporter_prompt = ChatPromptTemplate.from_messages([    ("system", "你是专业报告撰写员，整理数据为清晰报告。"),    ("human", "根据数据撰写报告：\n{research_data}"),    ("placeholder", "{agent_scratchpad}"),])reporter_agent = create_openai_functions_agent(llm, [], reporter_prompt)reporter_executor = AgentExecutor(agent=reporter_agent, tools=[], verbose=True)# ========== 节点定义 ==========def run_researcher(state: TeamState):    print("🔍 研究员启动...")    result = researcher_executor.invoke({"query": state["query"]})    return {"research_data": result["output"]}def run_coordinator(state: TeamState):    print("🚦 协调员评估...")    result = coordinator_executor.invoke({"research_data": state["research_data"]})    decision = result["output"].strip().lower()    print(f"✅ 决策: {decision}")    return {"coordinator_decision": decision}def run_reporter(state: TeamState):    print("📝 报告员撰写...")    result = reporter_executor.invoke({"research_data": state["research_data"]})    return {"report": result["output"]}# ========== 路由函数 ==========def route_coordinator(state: TeamState):    return state["coordinator_decision"]# ========== 构建图表 ==========workflow = StateGraph(TeamState)workflow.add_node("researcher", run_researcher)workflow.add_node("coordinator", run_coordinator)workflow.add_node("reporter", run_reporter)workflow.set_entry_point("researcher")workflow.add_edge("researcher", "coordinator")workflow.add_conditional_edges(    "coordinator",    route_coordinator,    {"finish": "reporter", "research_more": "researcher"})workflow.add_edge("reporter", END)app = workflow.compile()# ========== 运行测试 ==========if __name__ == "__main__":    print("✅ 动态多智能体系统启动！\n")    query = "总结2025年AI在药物研发领域的最新突破"    final_state = app.invoke({"query": query})    print("\n" + "="*60)    print("📊 最终报告：")    print("="*60)    print(final_state['report'])

运行结果与分析

1. 研究员调用工具，获取数据

   

2. 协调员评估数据充足，返回 "finish"

   

3. LangGraph 根据路由规则跳转到报告员，生成最终报告

   

如果数据不足会发生什么？

假设搜索结果是 "未找到相关数据"，协调员会返回 "research_more"，流程会：

Researcher → Coordinator (decision: research_more)                ↓                ↓ (循环)                ↓             Researcher (再次搜索)                ↓             Coordinator (再次评估)                ↓             ...直到 decision == "finish"

PART 04 - 调试与优化技巧

常见错误 1：agent_scratchpad 缺失

错误信息：

ValueError: Prompt must have input variable

原因：create_openai_functions_agent 强制要求 Prompt 包含 {agent_scratchpad} 占位符。 解决方案：

# ❌ 错误prompt = ChatPromptTemplate.from_messages([    ("system", "..."),    ("human", "{query}"),])# ✅ 正确prompt = ChatPromptTemplate.from_messages([    ("system", "..."),    ("human", "{query}"),    ("placeholder", "{agent_scratchpad}"),  # 必需])

常见错误 2：协调员决策格式不规范

问题：协调员返回了 "finish。" 或 "我建议finish"，导致路由失败。 解决方案：

1. 在 System Prompt 中明确强调格式要求
2. 在节点函数中清洗输出

def run_coordinator(state: TeamState):    result = coordinator_executor.invoke({"research_data": state["research_data"]})    decision = result["output"].strip().lower()    # 🔴 清洗输出，提取关键词    if "finish" in decision:        decision = "finish"    elif "research_more" in decision or "more" in decision:        decision = "research_more"    else:        decision = "finish"  # 默认策略    return {"coordinator_decision": decision}

调试技巧：启用详细日志

# 在 AgentExecutor 中启用 verboseresearcher_executor = AgentExecutor(    agent=researcher_agent,    tools=tools,    verbose=True,  # 🔴 显示详细思考过程    max_iterations=3,  # 限制最大迭代次数，防止死循环)

输出示例：

> Entering new AgentExecutor chain...Thought: 我需要使用 local_search_proxy 工具来搜索数据。Action: local_search_proxyAction Input: 2025年AI药物研发突破Observation: 【搜索结果】: ...Thought: 我现在知道了答案。Final Answer: ...> Finished chain.

性能优化：限制循环次数

如果协调员一直返回 "research_more"，可能导致无限循环。

解决方案：在 TeamState 中增加循环计数器

class TeamState(TypedDict):    query: str    research_data: str    report: str    coordinator_decision: str    loop_count: int  # 🔴 新增：循环计数def run_researcher(state: TeamState):    loop_count = state.get("loop_count", 0) + 1    print(f"🔍 研究员启动 (第 {loop_count} 次)...")    if loop_count > 3:  # 最多循环3次        print("⚠️ 达到最大循环次数，强制结束研究。")        return {            "research_data": state.get("research_data", "数据收集超时"),            "loop_count": loop_count        }    result = researcher_executor.invoke({"query": state["query"]})    return {        "research_data": result["output"],        "loop_count": loop_count    }

PART 05 - 进阶主题与实战建议

进阶 1：并行多智能体

本教程的 Agent 是顺序执行的。在实际应用中，多个 Agent 可以并行工作：

# 并行执行多个研究员workflow.add_node("researcher_ai", run_researcher_ai)workflow.add_node("researcher_bio", run_researcher_bio)# 从起点同时启动两个研究员workflow.set_entry_point("researcher_ai")workflow.set_entry_point("researcher_bio")  # LangGraph 支持多起点# 两个研究员都完成后才进入协调员workflow.add_edge("researcher_ai", "aggregator")workflow.add_edge("researcher_bio", "aggregator")

进阶 2：人类在环(Human-in-the-Loop)

在协调员节点增加人类审核：

def run_coordinator_with_human(state: TeamState):    print("🚦 协调员评估...")    result = coordinator_executor.invoke({"research_data": state["research_data"]})    decision = result["output"].strip().lower()    # 🔴 增加人类确认    print(f"\nAI 建议: {decision}")    user_confirm = input("是否同意？(y/n): ")    if user_confirm.lower() != 'y':        decision = input("请输入决策 (finish/research_more): ")    return {"coordinator_decision": decision}

进阶 3：持久化状态

将 TeamState 保存到数据库，支持长时间运行的任务：

from langgraph.checkpoint.sqlite import SqliteSaver# 使用检查点机制memory = SqliteSaver.from_conn_string("checkpoints.db")app = workflow.compile(checkpointer=memory)# 运行时指定 thread_idconfig = {"configurable": {"thread_id": "task_001"}}final_state = app.invoke({"query": query}, config=config)# 稍后可以恢复执行final_state = app.invoke(None, config=config)  # 从上次中断处继续

实战建议

1. 工具选择

• 搜索工具：国内推荐 Serper API（需翻墙）或自建爬虫
• 向量数据库：Chroma(本地)、Pinecone(云端)、阿里云向量检索
• LLM 选择：智谱 GLM-4(中文强)、Kimi(长文本)、通义千问(免费额度高)

2. Prompt 工程

• 协调员的 Prompt 是系统稳定性的关键，务必多次测试
• 使用 Few-shot Learning 提升输出稳定性：

("system", """你是协调员。参考以下示例：示例1:数据: "AI在药物研发取得突破..."决策: finish示例2:数据: "未找到相关数据"决策: research_more现在评估以下数据...""")

3. 错误处理

• 每个节点函数都应该有 try-except
• Agent 调用超时后的降级策略

def run_researcher(state: TeamState):    try:        result = researcher_executor.invoke(            {"query": state["query"]},            {"max_execution_time": 30}  # 30秒超时        )        return {"research_data": result["output"]}    except Exception as e:        print(f"⚠️ 研究员执行失败: {e}")        return {"research_data": "搜索超时，使用缓存数据"}

结论

恭喜你完成了 LangChain 多智能体协作的进阶学习！你现在已经掌握：

✅ TeamState 设计 - 理解数据如何在 Agent 间流转

✅ LangGraph 架构 - 使用 Nodes、Edges、Conditional Edges 构建复杂流程

✅ Agent 分工协作 - 将任务拆解为专业节点，提升质量和可维护性

✅ 动态循环机制 - 通过协调员实现质量检查和重试逻辑

✅ 调试与优化 - 处理常见错误，提升系统稳定性

技术总结表

技术点	核心概念	实战价值
TeamState	类型化的数据容器	保证数据流转的类型安全
Agent Executor	Agent 的运行时环境	封装 LLM + 工具调用逻辑
addedge	固定流向的边	构建顺序执行流程
addconditionaledges	动态路由的边	实现循环和分支逻辑
agentscratchpad	Agent 的工作记忆	LangChain 框架强制要求
工具(@tool)	扩展 Agent 能力	连接外部系统(搜索、数据库)

下一步学习路径

1. 并行多智能体

   • 多个 Agent 同时工作，提升效率

2. 流式输出(Streaming)

   • 实时显示 Agent 的思考过程

3. 向量数据库集成

   • 构建 RAG 系统，让 Agent 访问私有知识库

4. 生产级部署

   • 使用 FastAPI + Docker 部署到云端

5. 成本优化

   • 混合使用不同价位的模型，降低 API 费用

如何学习大模型 AI ？

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

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

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

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

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

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

第一阶段（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%免费】