你看过十几个 AI 教程视频、收藏过几十个 Prompt 合集、订阅过几个 Newsletter——然后下周你什么都没记住。知识太碎、路径太乱、不知道从哪开始。这节课不是让你再看一堆内容，是帮你把"4 周后要成为入门 AI Engineer"这件事拆成可执行的每周任务。
如果你是软件工程师/后端/全栈/DevOps/数据工程师，想系统学 AI Engineer 但每次打开教程看十分钟就走神——这节课会帮你定一个你真能跟完的节奏表。
你会有一份写好的 4 周学习计划表，OpenAI + Claude + Google AI Studio 三个账号开好，知道每周要看哪几节课、每周要产出什么。不再是"慢慢看"，是"有目标地冲"。
你已经写过 Python，但 AI 相关的开发环境跟你熟悉的"装 pip、跑脚本"不完全一样——OpenAI API Key 怎么申请？额度要充多少？.env 怎么放才不会被 push 到 GitHub？这节课帮你把这些"第一次才会踩"的坑一次性踩完。
.env + dotenv + .gitignore 三件套，一次配好永不再犯会用 pip、能在终端跑 Python 脚本、但从没调过 OpenAI API 的人。不需要你会装 Docker 或配 CUDA。
你的电脑上有一个能跑的 Python venv，.env 里有可用的 OpenAI Key，跑 python hello.py 能看到 GPT-4o-mini 返回的真实回答。后面 72 节课的所有代码都能在这套环境里直接跑。
"调 OpenAI API 很简单"——这句话 99% 的教程都说过。但真跑起来你会发现：response 长什么样？token 用了多少？temperature 为什么跟聊天里看到的不一样？这个 Lab 让你亲眼看到这些东西，而不是继续把 LLM 当黑盒。
choices[0].message.content 之外还有哪些字段，finish_reason 是什么意思usage.prompt_tokens 和 completion_tokens 怎么算成本，1 次调用烧多少钱temperature=0 vs 0.7 vs 1.0 下输出完全不同，亲眼对比想把 LLM 从"黑魔法"变成"可预测的 API"的软件工程师。10 分钟内你就会对 LLM 的输入输出有 90% 的直觉。
你能独立写一段调用 OpenAI / Claude / Gemini 的 Python 代码，看懂 response 的每一个字段，知道你这次请求花了多少钱、用了多少 token。LLM 不再是魔法，就是一个有明确 schema 的 HTTP API。
你身边的人已经在用 AI 写代码、写文档、做数据分析了，但你打开 ChatGPT 不知道让它做什么——"高级搜索引擎"的定位很难拉开差距。这节课给你 12 个真实生产力场景，每个都有具体的 prompt 模板和工具组合，下课你就能开始用。
每天用 AI 但总觉得"用得不够深"的技术从业者。你知道 ChatGPT，但你可能从没用过 NotebookLM 上传 PDF 做问答、从没用 Perplexity 做带引用的调研。
你会至少挑出 3 个自己工作里能立刻用上的高频场景，每个都知道该用哪个工具 + 怎么写 prompt。不再是"随便问问 ChatGPT"，是"有固定 playbook 的专业用户"。
上一节你学了"12 个生产力场景"，但知道场景不等于会写 prompt。你可能还是习惯对 AI 说"帮我写个邮件"——这节 Lab 强迫你立刻写一个"专业化"的第一次对话：同样的需求，加上角色 + 任务 + 约束 + 例子，输出质量拉开一档。
每次跟 AI 对话都要来回改 5 遍才拿到想要的输出的人。或者总是觉得"AI 好像不太懂我意思"的人。
你能在 30 秒内把一个模糊的需求改写成包含角色 + 任务 + 约束 + 例子的专业 prompt，第一次就拿到能用的输出，不用来回改。这是你整个 Prompt Engineering 生涯的第一块肌肉记忆。
"生成式 AI"这四个字被滥用到失去意义——每个产品都自称 GenAI，但它们背后可能是完全不同的技术路线。你如果分不清 LLM vs Diffusion vs VLM 的本质差异，就很难判断一个 AI 产品到底能做什么不能做什么。
想在同事讨论 AI 产品时"听得懂"的技术人。你不需要能训模型，但你需要能在 5 分钟内判断"这个产品背后用了什么模型、靠不靠谱"。
下次产品经理问"这个需求用 AI 能做吗"，你能在 30 秒内给出判断：该用哪类模型、为什么、预期的成本和局限是什么。能看懂 Gartner / a16z 的 AI 报告，不再被 Marketing 话术带偏。
Prompt Engineering 不是"会写中文就行"——同一个需求用错的 prompt 写法可能让模型的准确率差 30%+。这节课给你一个工程化的框架（R-T-C-E 四要素），让每次写 prompt 都像写函数一样有结构、可复用、可调试。
已经会简单用 ChatGPT 但想从"会用"跳到"会写生产级 prompt"的技术从业者。下一步你要把 prompt 写进代码里，这节课是基础。
你能写出结构化的、可复用的 prompt，不用再来回改 5 遍。对任何新任务，你都能在 1 分钟内套用 R-T-C-E 写出第一版 prompt，后面就是微调。
你经常发现自己写的 prompt "差一点"——AI 明白大方向但总是漏关键细节。比如你让它帮你写邮件，它用词太书面；让它总结文档，它总结得太长。问题不是它不会做，是你没写清楚"任务是什么"。
经常需要改 prompt 才能拿到可用输出的人。或者总是纠结"AI 为什么不直接给我要的结果"的人。
你能把任何模糊需求转写成 AI 能 1 次就做对的明确任务。从此写 prompt 不再是"来回改"的艺术，是"第 1 次就写对"的工程。
你的 prompt 写得不错，但 AI 输出总是"长度不对、格式不对、语气不对"——就是不好嵌进你的业务系统。问题不是 AI 没理解任务，是你没给它"交付标准"。这节课让你学会用约束把输出收敛到可复用的形状。
想把 LLM 接进自己产品的软件工程师。如果你的后端需要稳定的 JSON 输出，这节 Lab 是必看——约束写不好，下游 JSON parse 一错一个准。
你能让 LLM 输出稳定的 JSON / markdown / 固定字数文本，直接嵌进你的后端或前端，不需要写一堆字符串处理代码兜底。
LLM 为什么会"乱编"？为什么你问 2024 年的新闻它不知道？为什么公司内部文档它看不到？你如果不理解这三个天生缺陷，就不知道什么场景必须上 RAG。这节课把 RAG 的"为什么"讲透，后面 20+ 节 RAG 技术细节才有意义。
企业里负责"把 AI 接进现有业务"的工程师。你老板肯定会问"能不能让 AI 回答公司内部的问题"——这节课告诉你答案是"能，但得用 RAG，不是 Fine-tune"。
你能向非技术同事解释"为什么需要 RAG"，能判断一个业务需求该用 RAG 还是 Prompt Engineering 还是 Fine-tune，不会再把"想让 AI 知道新数据"误以为是 Fine-tune 问题。
"AI Agent" 是 2025-2026 最火的概念，但 80% 的人连 Agent 和 Workflow 的区别都说不清。这节课用一个具体例子（订机票 Agent）把 Agent = LLM + 工具 + 记忆 + 循环的本质讲透，你学完就能判断自己的业务需求该不该上 Agent。
在公司听到"我们要做个 AI Agent"的产品会议时，想第一时间判断"这个需求配得上 Agent 还是用普通 Workflow 就够了"的工程师。
你能画出一个 Agent 的推理循环图，能区分 Agent 和 Workflow 的适用场景，能判断一个业务需求值不值得花 3 倍的成本上 Agent（大部分不值得）。
你把 LLM 接进产品上线后会面对一堆新问题：Prompt 改了一次效果变差怎么回滚？输出质量怎么量化？月底成本账单突然爆了怎么追？这些问题传统 MLOps 没教过，因为 LLMOps 是新物种。这节课给你一个完整的能力地图。
已经有 LLM 应用要上线或刚上线的工程师。生产环境的第一周你就会遇到这节课讲的所有问题——提前学完能少吃几次亏。
你能给自己的 LLM 应用加上第一层 trace（每次请求都能回溯），能跑第一次 offline 评估（用 Ragas 量化 RAG 质量），能做 prompt 版本管理——三件事一做，你的 LLM 应用就从"玩具"变成"生产级"。
上一节讲了 LLMOps 的六大能力，但"听懂 ≠ 会用"。这个 Lab 让你亲手跑一次完整的 LLMOps 流程：用一个小 RAG 应用触发 trace、写一个 eval 测试集、看真实的成本追踪面板——10 分钟内感受 LLMOps 的真实价值。
已经有 LLM 应用或打算上线 LLM 应用的工程师。没跑过 trace 的人会觉得"线上没事"，跑过一次 trace 的人会发现每次调用都有改进空间。
你能用一行代码替换给自己的项目加上完整 trace，能写一个最小评估集跑 faithfulness 检查，能把 LLMOps 从概念变成可验证的工程实践。
企业数据里 80% 是非结构化的（邮件、合同、PDF、聊天记录），而这恰好是 LLM 最擅长的领域。但很多工程师还在用正则和规则引擎去硬扒这些文本——维护成本高、准确率 60%。搞清楚结构化 vs 非结构化的本质差别，你就知道 AI Engineer 的价值区在哪。
在公司看到一堆 PDF 合同 / 扫描件 / 邮件堆在那里没人处理的工程师。这些数据就是 AI Engineer 最大的价值点，前提是你知道怎么下手。
你能识别公司里哪些数据是 LLM 能处理的"金矿"，能用一个通用 Prompt 模板从任何非结构化文本里抽出结构化数据。下次老板说"我们有一堆合同没人看"，你能立刻给出一个 2 天能 POC 的方案。
理论上 LLM 能从任何文本抽结构化数据——但真跑起来你会发现：长文档怎么拆？抽出来的 JSON 格式总是不稳？同一个字段不同文档里叫法不同怎么办？这个 Lab 让你亲手踩完这些真实工程坑。
要把 LLM 接进 ETL / 数据管道的数据工程师。或者要处理大批量非结构化文档的后端。
你能写一个从 PDF / 合同 / 邮件里抽结构化数据的 Python pipeline，output 是稳定的 JSON 可以直接进数据库。这是 AI Engineer 在企业里最常被要求做的事之一。
你学 LLM 不需要会训模型，但你需要看懂别人的架构图 + 术语。"Loss function 在下降"、"过拟合"、"梯度爆炸"这些词如果你完全没概念，在读论文 / 看 Anthropic 博客的时候就会卡住。这节课用直观方式把 ML 核心概念讲透，不需要数学。
没学过 ML 但想看懂 LLM 原理的软件工程师。你不会需要写反向传播，但你需要能和机器学习工程师对话不怯场。
你能看懂 ML 相关的博客、论文摘要和架构图，能和 ML 工程师讨论模型训练相关的基本问题，不再是"我只会调 API"的纯 AI Engineer。
上一节讲了 ML 的核心概念，但"听懂"和"看过"差一截。这个 Lab 让你在浏览器里可视化一个神经网络的训练过程：亲眼看 loss 怎么下降、过拟合是什么样、参数越大为什么效果越好。10 分钟让你对 ML 有真实的直觉。
刚学完 L16 ML 基础想立刻巩固的工程师。视觉型学习者尤其喜欢这个 Lab——看一次动画顶读 10 页博客。
"梯度下降" / "过拟合" / "正则化" 这些词从此不再是你读论文时的拦路虎，都是你亲眼看过的具体现象。
上一节讲了 ML 的基本概念，这节课讲三大学习范式——监督、无监督、强化学习。很多人分不清这三者的差别，看论文看到 "RLHF" 就懵。搞清楚每种范式的数据长什么样、目标是什么，你就知道 GPT-4 为什么需要三个训练阶段（Pre-training + SFT + RLHF）。
看到 "RLHF / DPO / PPO" 这些术语就头晕的技术从业者。不需要会推导数学，但需要知道这些是什么、有什么用。
看 Anthropic / OpenAI / Meta 的论文时不再看到 "RLHF" 就跳过。你能解释"为什么 ChatGPT 比 GPT-3 更听话"的本质原因，能判断一个任务该用监督还是强化学习。
"深度学习" 听起来很高大上，但它的最小单元其实就一行公式：output = activation(weighted_sum + bias)。理解这一行后，整个神经网络就不再是黑盒。这节课用直观方式讲清神经元、激活函数、反向传播——不推公式，只讲"这些东西在做什么"。
想读懂 Transformer 架构图但被"神经网络"吓到的工程师。看完这节你会发现 Transformer 其实就是"用 attention 堆起来的深度网络"，没那么神秘。
你能看懂任何神经网络架构图的基本结构，能解释 "深度学习为什么在 2012 年突然起飞"，能把 Transformer 看成 "一种特殊结构的深度网络" 而不是魔法。
LLM 出现前，NLP 是一个复杂的"任务拼盘"——分词、POS、NER、翻译、问答，每种任务一个专门的小模型，维护成本极高。LLM 出现后，这些任务几乎都能用一个模型 + prompt 搞定。理解这个转折，你就知道为什么传统 NLP 工具链正在被淘汰。
过去学过传统 NLP（jieba / NLTK / SpaCy）的工程师，想搞清楚"为什么这些工具最近这么冷"。或者完全没学过 NLP 想直接跳到 LLM 时代的人。
你能判断一个 NLP 任务该用 LLM 还是传统工具，能理解 "为什么 LLM 能做所有 NLP 任务但不是每个任务都该用 LLM"，这是成本优化的基础认知。
所有现代 LLM（GPT / Claude / Llama / Gemini）都基于 Transformer。看论文、看模型架构图、读 Anthropic / OpenAI 技术博客，你都会撞到 "Self-Attention"、"Multi-Head"、"Q·K·V"这些术语。这节课把 "Attention is All You Need" 论文的核心贡献讲透——没有公式，只有直觉。
看过 Transformer 架构图但一直没完全搞懂的工程师。或者想读懂 LLM 相关论文摘要的技术从业者。
你能向同事用 5 句话解释 "Transformer 为什么取代 RNN"，能看懂任何 LLM 论文里的 Attention 相关段落，能理解为什么 Transformer 是支撑 GPT-3 / GPT-4 / Claude 4 的核心架构。
上一节你学了 Attention 的理论，但"听过"和"看过" 差一截。这个 Lab 让你亲眼看 Attention 权重分布 + Token 拆分 —— 当你输入一句话，Transformer 内部到底怎么"读"它？10 分钟让你把所有 Transformer 术语从抽象变成可视化。
想把 Transformer 从"数学公式"变成"可观察现象"的工程师。视觉学习者特别受益，10 分钟的动手胜过读 10 篇博客。
"Self-Attention"、"Multi-Head"、"Context Window" 这些词你看到都有视觉化的直觉，不再是 paper 里的符号。下次读 Anthropic 的 Interpretability 博客（他们经常可视化 attention）你不会再跳过技术段落。
"Language Model" 这个词被用得太随意——n-gram 是 LM、LSTM 是 LM、GPT 也是 LM。它们本质上在做同一件事：预测下一个 token。但从 n-gram 到 GPT 中间跨越了 50 年。搞清楚这个演化路径，你才能理解 Scaling Law 为什么这么震撼。
想理解"为什么大家都在堆参数量"的技术从业者。Scaling Law 不是营销概念，是真实的可验证规律，理解它你就能预测未来 5 年的模型演化。
你能解释"为什么 Llama 3 405B 比 70B 强"（不只是"参数多"，是 Scaling Law 的可预测性），能读懂 Kaplan 等人的 Scaling Law 论文的结论，能判断下一代模型大概率在哪个方向突破。
Transformer 的完整结构图上有一堆模块：Embedding、Positional Encoding、Multi-Head Attention、Add & Norm、Feed-Forward、Residual Connection——每一个都有明确的角色。这节课把整张图拆开讲清楚，你就能看懂 90% 的 LLM 论文架构章节。
看 LLM 论文看到 "architecture" 章节就跳过的工程师。这节课帮你把跳过的段落补回来。
你能看懂 GPT-4 / Claude / Llama 的架构图每一个模块在做什么，能解释为什么现代 LLM 都是 Decoder-only，能和 ML 工程师讨论 "为什么残差连接让深层网络可训"。
LLM 不直接处理文字——它处理数字。Tokenizer 把文字变数字，Embedding 把数字变向量，Positional Encoding 告诉模型"谁在前谁在后"。这三步决定了 LLM 怎么"读"你的 prompt，也决定了你的 API 账单。理解它你就知道为什么一个中文字比一个英文单词贵 2 倍。
想搞懂 "为什么我的 API 账单里 token 数和字数对不上" 的工程师。这节课让你对 token 计费有精确直觉。
你能精确预估一段文字会消耗多少 token，能决定什么时候该 RAG 什么时候能直接塞长 context，能理解 "为什么 1M context 很贵"——这是成本优化的底层知识。
基础 prompt 你已经会写了——R-T-C-E 框架、给例子、加约束。但遇到复杂推理任务（数学题、多步决策、代码调试）基础写法不够用。这节课给你 4 个进阶技巧：CoT、Self-Consistency、ToT、ReAct，每个都有明确的适用场景。
基础 prompt 已经熟练、想把 LLM 用在需要"推理"的任务上的工程师。
你能把需要多步推理的复杂任务从"LLM 做不来"变成"LLM 能做但要加 CoT"。面对任何新任务你都知道该用 4 种技巧里的哪一个，不用瞎试。
CoT 听起来很玄——"让 LLM 一步一步想"。但它到底能把准确率从多少提到多少？你亲眼看一次才有真实感受。这个 Lab 给你一道数学题，分别用 "直接问" 和 "加 CoT" 两种 prompt 跑，准确率差异让你服气。
想把 CoT 从"听过"变成"会用"的工程师。做完这个 Lab 你永远不会忘记 "step-by-step" 是最便宜最好用的 prompt 技巧。
下次遇到任何需要推理的任务，你会自动加上 "请一步一步分析" 这一句话。这是你整个 AI Engineer 生涯里用得最多的一个技巧。
"为什么不 Fine-tune 一个自己的 GPT？" 是每个新入门的人都会问的问题。但 99% 的情况 Fine-tune 是错的选择——贵、慢、容易废。这节课给你一个明确的决策树：Prompt Engineering → RAG → Fine-tune，什么时候该跳到下一级。
老板跟你说"我们 Fine-tune 一个模型吧"的工程师。这节课帮你判断这个想法是不是对的，以及如何有礼貌地说服老板改用 RAG。
面对任何"要不要 Fine-tune"的需求，你能在 5 分钟内给出判断 + 替代方案。这会在公司里直接节省几万到几十万的算力费。
Full Fine-tuning 一个 7B 模型需要 24GB+ GPU，大部分人没有。LoRA 用一个巧妙的技巧绕开这个限制：冻结原模型、只训一个小 adapter 矩阵。QLoRA 更狠，先把原模型 4-bit 量化再训 adapter。这个 Lab 让你亲手跑一次 QLoRA 微调流程。
手头有一点 GPU 资源（或者想用 Colab / Modal 免费 GPU）想第一次试 Fine-tune 的工程师。或者想在简历上写"做过 LLM 微调"的人。
你能在 Colab / Modal 上跑通一个 7B 模型的 QLoRA 微调，能判断一个业务场景值不值得微调，能在面试时自信地说"我做过 LoRA 微调"。
RAG 这个词你听了 10 遍了，但真去搭一个你不知道从哪开始——Loader？Splitter？Embedder？每个都是什么？哪个必须要、哪个可以跳过？这节课把 RAG 拆成 6 个核心组件，每个组件讲清楚"做什么 + 选型 + 常见坑"。
听过 RAG 但没搭过的工程师。这节课是你从 0 到 1 的基础，后面 15 节 RAG 相关课都建立在这 6 个组件上。
你能画出一个完整的 RAG 系统架构图并解释每个组件的作用，能独立做选型决策。后面 L37 Project 2 "RAG from Scratch" 的基础就是这节课。
上一节你学了 RAG 的 6 个组件，这个 Lab 让你动手搭前 4 个——Loader / Splitter / Embedder / Vector Store。这一步叫 "Ingestion Pipeline"，是所有 RAG 系统的离线起点。跑完你会发现原来 RAG 的 Ingestion 没那么神秘。
想第一次亲手搭 RAG ingestion 的工程师。做完这个你对 RAG 的前半段就有完整的信心。
你能独立写一个从 PDF 到 ChromaDB 的 ingestion 脚本，这是所有 RAG 系统的前半段。配上下一节的 Query Pipeline，你就能搭完整的 RAG 原型。
Naive RAG = 纯向量相似度 top-K 检索——够跑 demo 但离生产级差一截。这节课讲 4 个进阶检索策略：Hybrid Search、MMR、Re-ranking、Query Rewriting。每个都解决 Naive RAG 的一个真实痛点。
已经搭过 Naive RAG 发现"检索不准"的工程师。这节课是你从 "能用" 到 "好用" 的关键一步。
你能为任何 Naive RAG 系统加上 Hybrid Search + Rerank，把检索质量拉到生产级。这是很多公司愿意付钱请 AI Engineer 做的事。
上一节讲了 4 个进阶检索策略，这个 Lab 让你在浏览器里亲手对比它们的效果。同一个问题用 Similarity / MMR / Hybrid / Rerank 四种策略跑，top-5 结果有什么不同——一次看清楚。
做 RAG 检索质量优化的工程师。这个 Lab 胜过读 10 篇论文。
你能凭直觉判断一个 RAG 系统"检索不准"的原因是在哪一步——向量召回低？BM25 缺了？没 rerank？每个问题都有对应的修复方向。
"Agent" 这个词在 2025-2026 被用滥了，每个产品都自称 Agent。但真正能落地的 Agent 形态就那么几种：Function Calling / MCP Server / OpenAI Assistant API / LangGraph。这节课把它们从稳定性 / 开发成本 / 代表产品三个维度对比清楚，你就知道该选哪个。
听到 "我们要做个 AI Agent" 想认真做方案的工程师。或者想搞懂 MCP 为什么是 2025 最重要的协议的人。
面对任何 Agent 需求你能在 10 分钟内给出选型方案。你会知道 MCP 不只是"另一个协议"，是类似 LSP 之于 IDE 的生态基础设施。
上一节讲了 5 种 Agent 形态，这个 Lab 让你亲手实现一个最小的 ReAct Agent——LLM + 3 个工具 + Thought/Action/Observation 循环。跑一次你就会发现 "Agent 到底是怎么工作的"——不是魔法，是一个清晰的循环。
想从 "Agent 用户" 变成 "Agent 开发者" 的工程师。做完这个 Lab 你以后看任何 Agent 框架（LangGraph / CrewAI）都不会怯场。
你能从零写一个带 3 个工具的 Agent，不依赖 LangChain / CrewAI。这是理解所有 Agent 框架的底座。
"把 LLM 上进来" 是很多公司的口号，但 LLM 不是万能的。选错场景上 LLM 是 AI Engineer 最贵的错误——不只是钱，还有产品信誉和监管风险。这节课给你 LLM 的"甜蜜区" vs "禁区" 清单，让你在老板问 "这个需求能用 AI 吗" 时能理性回答。
被要求 "把 LLM 接进业务" 的工程师。这节课能帮你识别哪些需求真的适合 LLM，哪些其实 regex 就够。
面对任何 "我们来上 AI 吧" 的需求你能在 5 分钟内判断可行性，给出 "该上 LLM" 或 "别上 LLM" 的理由。这直接影响公司是不是要烧几十万的算力费。
做 AI 项目最容易翻车的不是技术，是"没定义成功是什么"。模型跑出来看着还行 → 上线 → 用户吐槽 → 才发现评估维度不全。这节课给你一个三层评估体系，从模型层到产品层到业务层，避免"感觉还行就上线"。
要对自己的 AI 项目对老板 / 用户 / 投资人负责的人。没指标就没法迭代，没法迭代就只能永远"感觉还行"。
你能为任何 AI 项目定义 "成功是什么"，能说服老板花时间建评估体系（而不是直接上线）。这是你从"实验者"变成"工程师"的分水岭。
L07 给你讲了 R-T-C-E 框架，这节课把框架升级成 6 条工程化准则——每一条都能解决一类真实生产 prompt 的问题。这不是"新手技巧集合"，是从几百个生产级 prompt 里总结出来的铁律。
已经会写基础 prompt、想写生产级 prompt 的技术从业者。这节课的准则你会反复用 10 年。
你写的每一个生产 prompt 都会自动套用这 6 条准则，不会再犯 "LLM 输出 parse 不了" / "被 injection 攻击" / "AI 编造事实不说不知道" 这些典型错误。
"给 LLM 3 个例子它就能学会新的输出格式"——这是 Few-shot Learning 的魔力。但例子怎么选？放多少个？放哪个位置？这个 Lab 让你对比 Zero-shot、1-shot、3-shot 的输出差异，10 分钟让你对 Few-shot 有直觉。
做数据抽取 / 分类 / 格式化输出的工程师。Few-shot 是你每天都会用的技巧。
你能在任何格式化输出任务上立刻想到"加 3 个例子"，不再纠结"为什么 LLM 输出格式不稳"。这是从 prompt 初级到中级的标志技巧。
LLM 输出 JSON 是后端最头疼的事——你让它输出 JSON，它给你 ```json{...}``` 带了 markdown fence；它给你 "OK, here is the JSON: {...}" 带了解释文字；或者 JSON 本身格式就错。这个 Lab 让你用 OpenAI Structured Outputs 强制输出合法 JSON，不用再写正则兜底。
要把 LLM 接进后端 API 的工程师。下游需要稳定的 JSON，你这里不 parse 错误就谢天谢地——这节 Lab 就是解决这个的。
你能让 LLM 返回 100% 可 parse 的 JSON，后端代码不用写 10 行兜底逻辑。这直接让你的 LLM 应用可靠性跳一档。
直接在代码里改 prompt → 跑 → 看结果，一次迭代要 30 秒。用 Playground 可以压到 5 秒。这节课教你用 OpenAI / Claude / Google AI Studio 三大 Playground 做快速迭代，外加 temperature / top_p / max_tokens 这三个关键参数怎么调。
每天都要写 prompt 的技术从业者。迭代速度从 30 秒到 5 秒，一天能多迭代 20 次。
你能用 Playground 在 10 分钟内迭代出一个生产可用的 prompt，然后复制进代码立刻能跑。这个速度在做 prompt 调优时非常关键。
temperature / top_p / max_tokens 听起来很简单，但你可能没真正感受过它们的影响。这个 Lab 让你把同一个 prompt 在不同参数下跑几次，亲眼看到输出的稳定性 / 创意度 / 长度如何被参数精确控制。
已经知道这些参数但没真正对比过的工程师。10 分钟让你对参数有精确的数字直觉。
面对任何 prompt 任务你能第一眼就给出 "这个用 temperature=0 / 这个用 0.7" 的判断。从此调参不再靠玄学，是有明确依据的工程决策。
课程前 42 节课你学了 prompt / LLM / agent 基础。现在是时候交第一个作品了——在 OpenAI GPT Builder 里打造并发布你的第一个 GPT。不写代码、全程可视化配置、终点是一个 GPT Store 分享链接 + 3 个真实用户反馈。这是你以后面试时能拿出来的第一个"我做过"。
想在 4 周内有一个"真实上线"的 AI 作品，而不是只跑过 Jupyter Notebook 的人。面试时 "我发布过 GPT 到 GPT Store" 比 "我做过 Python tutorial" 有说服力得多。
✅ 一个 GPT Store 分享链接
✅ 3 份用户真实反馈（截图 / 文字）
✅ 一份迭代总结（你根据反馈改了哪些 Instructions）
这是你整个课程的第一个可展示作品。
Prompt Engineering 不是每次从零写——大部分日常任务有固定模板，你需要的是一个自己的 Prompt 库。这节课给你 5 大场景的 40+ 模板：写作、代码、数据、营销、学习，全部经过真实业务验证，可以直接复制使用。
每天都会用 AI 做重复任务的技术从业者。你现在可能每次都重写 prompt，这节课之后你会有一个自己的 prompt 库，开箱即用。
你会有一份 40+ 个模板的起步 prompt 库，每次遇到重复任务直接查库不用重写。每天能省 30-60 分钟的 prompt 撰写时间。
上一节给你 40+ 个模板，这个 Lab 让你用其中一个（Business Writing 商务写作）跑一次完整流程——改写一封真实的工作邮件，对比原版和工程化版的输出差异。10 分钟让你把模板用法变成肌肉记忆。
每天要写英文 / 中文商务邮件的人。练习一次你就会把 AI 当成默认的邮件辅助工具。
你能在 2 分钟内把任何工作邮件需求转成专业输出，不用再纠结"这样写会不会太生硬 / 太软"。这是每天都能省时间的技能。
AI 工具每周都在变——上周的 SOTA 这周就过时。你需要一份按场景分类的工具清单，而不是"哪个最强"的榜单。这节课给你 2026 年的主流 GenAI 工具箱，按对话 / 搜索 / 文档 / 代码 / 设计 / Agent 分类，外加个人生产力组合推荐。
每次在 X / 小红书看到新 AI 工具就想试试的人。这节课帮你从"工具收藏家"变成"工具使用者"——只用 3-5 个深度用好。
你会有一份适合自己工作的 5 件套工具组合，不再被"这个更强"的新闻动摇。深度用 5 个工具 >> 浅度用 20 个。
LLM 再强也有天生缺陷——上下文塞不下、数学推理烂、不知道最新信息、输出不确定。这节课把 4 大硬伤列清楚，每个配一个工程化对策。理解这些，你就知道为什么 RAG / Tool Use / JSON Mode 这些技术会出现。
已经用过 LLM 撞过墙的工程师。你知道 LLM 有问题但不知道怎么系统性解决——这节课给你一个对照表。
面对 LLM 的任何"翻车"你能立刻诊断原因（上下文 / 数学 / 知识 / 确定性），然后给出对应的工程化修复方案。这是资深 AI Engineer 的日常工作。
前面讲的都是"最小 RAG"——一个 Loader + Vector Store + Retriever 就能跑。但企业级 RAG 架构远比这复杂。这节课给你完整的双管道架构图：Ingestion Pipeline（离线跑批）+ Query Pipeline（在线实时）+ 各层的技术栈推荐。
想从"能跑 Demo RAG"跨到"能上线企业 RAG"的工程师。企业级架构和 demo 架构差的不只是量级。
你能画一张企业级 RAG 架构图并解释每一层的职责。面试被问 "你会怎么设计一个 RAG 系统" 你能给出完整答案。
RAG 的效果上限很大程度由 Embedding 模型决定——embedding 不行，后面怎么优化都白搭。但 OpenAI 3-small / 3-large / Cohere v3 / BGE-M3 哪个好？中文场景怎么选？这节课给你一个选型决策框架。
要搭 RAG 系统但纠结 "Embedding 用哪个" 的工程师。这节课给你一个可直接用的选型流程。
你能根据业务场景（语言 / 预算 / 规模 / 合规）快速决定用哪个 Embedding 模型。不再是"随便选一个 OpenAI"，是有理有据的工程决策。
你有 100 万向量，要在 50 毫秒内找到 top-10 最相似的——这是向量数据库解决的核心问题。但 Pinecone / Weaviate / Qdrant / ChromaDB / pgvector 哪个适合你？这节课给你一个选型决策表，外加 HNSW 索引的直观原理。
第一次做 RAG 选向量库的工程师。这节课让你避免"一上来就上 Pinecone"的过度选型。
你能根据项目规模和团队情况选对向量库。原型用 ChromaDB 几分钟跑起来，中型生产切 Qdrant 自部署，这些决策都有依据。
搭一个"hello world" RAG 很容易，10 行 LangChain 就够了。但上线后你会遇到一堆真实问题：召回不准、Chunk 切错、幻觉、答非所问、多跳失败。这节课把 Naive RAG 的 8 大翻车现场列清楚，让你提前知道坑在哪。
已经搭过或要搭 RAG 的工程师。这节课帮你"提前踩坑"，避免上线后才发现问题。
面对任何 RAG 翻车现场你能第一眼诊断属于 8 大坑里的哪一个，然后给出对应的修复方向。这是区分"搭过 RAG demo"和"做过 RAG 项目"的分水岭。
Naive RAG 应付不了复杂问题。Advanced RAG + Agentic RAG 给你 4 个进阶技巧：Query Rewriting、Query Decomposition、HyDE、Self-RAG。加上 Agentic RAG 让 LLM 自主决定"什么时候检索、检索什么、检索几次"——从"一次性检索生成"跨到"可控的多轮推理"。
已经搭过 Naive RAG 发现"问题一复杂就翻车"的工程师。这节课是从"能用"到"好用"的关键一步。
你能诊断一个 RAG 系统需要哪种 Advanced 技巧，能判断什么场景值得上 Agentic RAG（贵 3-5 倍但质量提升 30-50%）。
上一节讲了 Agentic RAG 的理论，这个 Lab 让你亲眼对比 Naive 和 Agentic：同一个复杂问题（"去年 Q3 财报提到的三个风险，现在有几个已经发生"），Naive 检索一次就答，Agentic 会自主多次检索 + 交叉验证。差距不是一点点。
做企业知识库 / 高价值 RAG 应用的工程师。对这类场景 Agentic RAG 是值得投入的。
你能判断一个 RAG 场景值不值得上 Agentic RAG，能向老板解释 "贵 3 倍但质量翻倍" 的取舍。这是企业 RAG 项目里最关键的决策之一。
Anthropic 2024 年 9 月提出的 Contextual Retrieval 是近两年 RAG 领域最简单也最有效的改进——在 chunk 做 embedding 前，先用 LLM 给每个 chunk 生成一段上下文描述拼到前面。不改架构、只加一步 LLM 调用，显著降低检索失败率。
已经有 RAG 系统想做一次"低改动高回报"优化的工程师。这是 2024 年性价比最高的 RAG 改进之一。
你能给自己的 RAG 系统加上 Contextual Retrieval 这一层，几乎零架构改动但召回质量显著提升。这是可以立刻在当前项目里落地的改进。
这是课程的第二个 Project，也是最硬核的一个。不用 LangChain / LlamaIndex，纯 Python 从 0 到 1 搭 RAG——让你搞清楚每一行代码在做什么。做完这个 Project 你就是真懂 RAG 的人，以后用不用框架都由你决定。
对"RAG 黑盒"不满意的工程师。做完这个 Project 你能看懂任何 RAG 框架的源代码。
✅ GitHub 完整仓库（代码 + README）
✅ 3 组真实问答测试截图
✅ README 包含架构图 + 已知限制
这是第二个能写进简历的作品：不用任何 RAG 框架独立实现的 RAG 系统。
Project 2 需要你自己写代码，但如果你想先"预览"一下 RAG from Scratch 长什么样——这个 Lab 给你一个浏览器内直接能跑的最小 RAG 实现。不用配环境，5 分钟看完整流程。
想在做 Project 2 之前先"看一眼完整版"的人。或者想把这段代码作为模板改造自己 RAG 系统的工程师。
你会有一段 100 行以内的 RAG 模板代码可以随时拿来改造。配上 Project 2 的深度练习，你对 RAG 的理解会跳一个级别。
自己从零搭 RAG 是学习用的——真要做生产系统通常会用框架。但 LangChain / LlamaIndex / Haystack / Cohere Chat 哪个适合你？这节课给你选型表：每个框架的强项 / 弱项 / 代表场景。
纠结 "RAG 该用哪个框架" 的工程师。这节课给你决策依据，不再盲选。
你能根据项目特点快速选框架。快速原型上 LlamaIndex，复杂 workflow 上 LangGraph，不想运维上 Cohere Chat——每个决策都有理由。
同样一个 RAG 需求，用 LangChain 写 100 行，用 LlamaIndex 写 30 行，用 Haystack 写 50 行——代码量和灵活度的差别肉眼可见。这个 Lab 让你亲手对比三种框架的同一个实现，10 分钟让你有选型直觉。
想在 RAG 框架上"下一个决定"的工程师。对比一次胜过读 10 篇对比文章。
你能凭直觉判断"这个项目用哪个框架"，不再纠结"听说 LangChain 复杂"、"听说 LlamaIndex 只能做文档"。自己跑过对比后你有真实的判断依据。
AI 领域每周都有新东西——新模型、新框架、新技巧。信息爆炸时代最重要的能力不是"看得多"，是"看得对"。这节课给你一份 AI Engineer 必逛的信息源清单，按每日 / 每周 / 每月 / 每季度分层，帮你建立可持续的跟进节奏。
有信息焦虑的 AI 从业者。这节课帮你从"不停刷 Twitter"变成"有计划地跟进"，学到的更多焦虑更少。
你会有一套可持续的 AI 学习节奏表，知道每天看什么每周看什么每月深入什么，不再被"这个新工具我还没看"的焦虑困扰。
你写好了应用，上线前跑了几次都 OK——上线后用户一多立刻 429 错误。OpenAI 的 Rate Limit 不是"请求数"这么简单，它有 RPM / TPM / RPD / Batch 四个维度，任何一个超了都触发 429。这节课帮你搞清楚完整机制 + 正确的退避策略。
要把 LLM 应用上生产环境的工程师。没处理过 Rate Limit 的人，用户一多就吃瘪。
你能写一个生产级的 API 调用 wrapper，自动处理 429、自动重试、自动降级。上线后用户量涨 10 倍也能扛住。
LLM 应用的成本可以非常快地失控——一个客服机器人一个月烧几万块很常见。这个 Lab 让你亲手实现 4 大降本策略：小模型分流 / Prompt Caching / Batch API / 语义缓存。对比优化前后的成本数字，让你知道"调 prompt 也是调成本"。
看到每月 OpenAI 账单吓一跳的工程师。或者老板说"这个成本降不下来我们就下线"的团队。
你能把一个月 $10000 的 LLM 账单砍到 $3000，同时保持质量不下降。这是 AI Engineer 在公司里最被看重的能力之一。
企业为什么不直接用 OpenAI 而要用 Azure OpenAI？三个原因：数据驻留 / 企业合规 / 配额保障。这节课把 Azure OpenAI 的 Standard vs PTU 讲清楚，外加选 Region 和企业部署的常见坑——如果你在企业里做 AI 项目，这是绕不过去的。
在大公司 / 金融 / 医疗 / 政府这类严监管环境做 AI 项目的工程师。这节课的每一个坑你都迟早会踩。
你能为公司设计一个符合合规要求的 Azure OpenAI 部署方案。面对"数据不能出 XX 国"的硬约束你知道怎么满足。
企业 RAG 最常见的文档格式是 PDF，而 PDF 解析是最容易翻车的一环。选错工具，后面所有优化都白搭。这节课给你 PyPDF / PDFPlumber / Unstructured / LlamaParse / Azure DI / GPT-4V 六种工具的选型对比，外加扫描件 / 多栏 / 表格的特殊处理。
要做企业文档 RAG 的工程师。公司给你一堆 PDF 让你做问答，前 1 小时你会卡在"怎么把 PDF 变成干净文本"——这节课让你跳过这个坑。
你能为任何 PDF 场景选对工具。纯文字 PDF 秒跑、复杂表格用 LlamaParse、扫描件 OCR + Vision 双路兜底——每种都有明确路径。
发票抽取是企业 AI 落地最高频的场景之一——每家公司都有一堆 PDF / 图片发票要录入系统。这节课给你完整的 LLM + Vision 抽取流程，包括多国税制（澳洲 GST / 新加坡 GST / 日本消费税 / 美国 Sales Tax / 马来西亚 SST / 中国增值税 / 欧盟 VAT）的处理方式。
在企业里被要求"自动化发票录入"的 AI Engineer。或者做跨境业务需要处理多国发票的团队。
你能独立做一个支持多国的发票抽取系统。不管是澳洲 GST 还是日本消費税还是美国 Sales Tax，你都知道 Prompt 怎么写、Schema 怎么定、怎么避坑。
LLM 应用上线后成本很容易失控。这节课讲清 Token 计费的三档（Input / Cached / Output）+ 怎么估月度成本 + 4 大降本策略的底层逻辑。搞懂这些，你就能在 PRD 阶段就估出一个靠谱的成本数字，而不是上线后被账单吓一跳。
要为 LLM 项目做预算估算的 AI Engineer / 技术负责人。也适合在老板问 "这个会花多少钱" 时想给出专业回答的人。
你能为任何 LLM 项目给出靠谱的月度成本估算，能提前规划降本路径。这是 AI Engineer 进阶到"能对成本负责"的标志。
推理优化听起来很高级，其实是一些可执行的具体技巧：batching / caching / model routing。这个 Lab 让你对比应用前后的吞吐和成本变化，让"降本 3-5 倍"从口号变成可验证的数字。
要把 LLM 应用做到高并发 / 低成本的工程师。
你能为一个 LLM 应用设计完整的推理优化方案，从"能跑"跨到"能高并发低成本地跑"。
这是课程的最后一个 Project，也是最接近真实工作的一个：你要做一个可以上线的 PDF RAG 应用，支持上传、处理 Rate Limit、监控 Token 成本、有前端 UI。交付物是一个可以演示给朋友看的 GitHub 仓库 + 3 分钟演示视频。
想做一个"能发给朋友试用"的真实 AI 作品的工程师。这比任何教程练习都能展示你的能力。
✅ GitHub 完整仓库 + README
✅ 3 分钟演示视频
✅ .env.example + requirements.txt
✅ 可部署到 Streamlit Cloud（免费）或 Azure Container Apps
这是你整个课程的收官作品——能用、能演示、能写进简历。
Project 3 是需要你自己搭的完整 PDF RAG 应用。这个 Lab 是它的浏览器预览版——让你在 5 分钟内体验完整流程：上传 → ingest → 提问 → 看引用。跑一次你就知道 Project 3 要达到什么目标。
要做 Project 3 之前想先"看效果"的人。或者做完 Project 3 想对比一下完整版的工程师。
你对 PDF RAG 应用的完整用户体验有清晰预期，做 Project 3 时知道目标在哪，不会跑到一半才发现少做了关键功能。
真实生产 RAG 系统的工具链覆盖 6 层：Ingest → Chunk → Embed → Vector Store → Retrieval → Observability。每一层都有多个选择。这节课给你一份按层分类的工具清单 + 2 个组合推荐（MVP 组合 和 企业级组合），选型时直接查表。
要做 RAG 系统选型的技术负责人 / AI Engineer。或者给老板做 PRD 要说明"技术栈为什么选这些"的人。
面对任何 RAG 项目的技术栈选型，你能在 10 分钟内给出完整方案。不再纠结 "这个是最好的吗"，每个选择都有理由。
LangChain 是 RAG / Agent 最流行的框架，也是被吐槽最多的——抽象层厚、版本变动大、学习曲线陡。这节课帮你避开这些坑，只学真正有用的部分：LCEL 语法 + 核心抽象 + LangGraph Agent。学完你就能看懂 LangChain 90% 的代码。
prompt | model | parser 这种 pipe 风格，现代 LangChain 的核心想学 LangChain 但被它的复杂度吓到的工程师。这节课帮你只学"必须会"的部分，跳过 "看着都会用不到" 的抽象。
你能读懂 LangChain 90% 的生产代码，能写出一个带 Retriever 的 LCEL Chain。对于复杂 Agent，你知道用 LangGraph 不要用老的 LangChain Agent。
Project 3 让你搭了一个能跑的 RAG。要把它变成能跑一年的生产系统，还需要 4 个能力：Evaluation / Observability / Caching / Guardrails。这节课给你一个完整工具箱 + 落地顺序建议。
已经有 RAG 项目上线或准备上线的工程师。这 4 个能力不是"可选加分项"，是上线后必须有的。
你能为一个 Demo 级 RAG 加上生产级的 4 大能力，让它从"能跑"变成"能跑一年"。这是企业 RAG 项目从 POC 到 Production 的关键一步。
"我觉得效果还行"不是评估。Ragas 是 RAG 评估的事实标准——用几行代码跑完 Faithfulness / Answer Relevance / Context Precision 等指标，给你一个量化的分数。这个 Lab 让你亲手用 Ragas 评估一个 RAG 系统。
要对 RAG 效果负责的工程师 / 产品经理。没有指标就没法迭代，有指标了才能"有依据地改"。
你能为自己的 RAG 系统写一个最小评估集（30 条）+ 跑 Ragas，每次改 prompt / 换模型都能量化地知道效果变化。这是资深 AI Engineer 的日常工作。
前面讲的都是"从零搭 RAG"，这节课给你另一条路线：用云厂商的全托管组件。AWS Bedrock Knowledge Base 让你只需要把文档放 S3，剩下全自动——解析 + chunk + embed + 存储都是托管的。对于"要快上线"的企业场景这是最省心的路径。
已经在 AWS 生态里的企业工程师。或者要"一周上线 RAG" 不想自己维护向量库的团队。
你能为 AWS 生态的公司设计一个全托管 RAG 方案，把上线时间从"几周"压到"几天"。也能判断什么场景值得自建、什么场景该用托管。
课程的最后一个 Lab——模型部署。不管你用哪家云、哪个框架，最终都要把一个模型（或 LLM 应用）变成生产级 endpoint。这个 Lab 给你一个最小的部署流程 + Rate Limit / Logging / Monitoring 三件套的集成示例。
想把 LLM 应用真正"上生产"的工程师。Demo 跑通是一回事，上线让几千个用户用又是另一回事——这节 Lab 帮你把中间的差距补上。
你能把一个 LLM 应用从 Jupyter Notebook 变成生产级 HTTP endpoint，支持速率限制、可追溯、可监控。这是课程结束时你手上应该具备的完整能力闭环。