如何在 6 个月内成为一名 AI 工程师：完整路线图与资源清单
AI 工程（AI engineering）已经迅速成为技术领域最有价值的技能组合之一
问题在于，大多数初学者并不清楚自己到底该学什么
有些人从机器学习理论开始
有些人则陷入无休止地看教程的循环里
还有些人直接跳到提示词（prompt）和智能体（agent），却不了解 API、后端基础，也不了解真实产品到底是怎么被做出来的
结果通常都一样：大量困惑，极少实用技能
如果你的目标是成为一名 AI 工程师，你并不需要掌握人工智能的每一个领域
你需要学会的是如何在真实世界中构建有用的 AI 系统
这意味着要学会如何：
- 用 LLM 构建端到端应用
- 使用 OpenAI、Anthropic 等模型 API
- 正确地设计提示词和上下文
- 使用结构化输出和工具调用
- 在需要时加入检索（retrieval）
- 部署项目，让别人真的能用上
这份指南的目的，是给你一条可执行的 6 个月路线图
这篇文章有 10,000 多词，所以读完它可能需要几个小时甚至更久
但它真正的价值在于：你需要的每一项技能，都配有资源和清晰的说明，告诉你具体该做什么
这样一来，你就能在六个月内达到 AI 工程的水平，并且在头 1–2 个月里就能开始为自己所用
写这篇文章花了 40 多个小时，我是和我的朋友 @andy_ai0 一起完成的
他刚开始在 X 上建立自己的个人品牌，但他对 AI 理解得很深，这篇文章他帮了很多忙
我绝对认为，随着他的成长，他值得你的关注和支持
现在我们开始读这篇文章吧 ⬇️
AI 工程师到底做什么
很多人听到“AI 工程师”这个词，会想象一个人从零开始训练巨型模型
而在现实中，大多数现代 AI 工程师做的事情要实用得多
他们是在现有模型之上构建产品和系统
这通常包括：
- 连接 LLM API
- 设计提示词与上下文流程
- 构建聊天、搜索或自动化系统
- 集成工具、数据库和外部 API
- 处理结构化输出
- 提升可靠性、成本与延迟表现
- 把 AI 功能部署到真实应用中
所以在实践中，AI 工程师常常处在以下几者的交汇处：
- 软件工程
- 产品工程
- 自动化
- 应用型 AI
这就是这个角色增长如此之快的原因
公司不仅需要研究人员，他们需要能把模型变成有用产品的人
这也是为什么这份路线图较少强调沉重的理论，而更关注实际落地
如果你能构建真实的 LLM 应用、检索系统、自动化和生产级工作流，你就已经比大多数初学者更接近“可以被雇用”的状态了
⏩------------------------------------------------------------------------⏪
第 1 个月：把编程和基础打扎实
你这个月的目标：成为一名能真正干活的 Python 开发者
你不需要成为专家，你只需要不再靠 Google 查基础语法，并且能自信地构建简单程序
AI 工程首先是软件工程
后面所有月份的内容，都假定你能写出干净的 Python 代码、使用终端、调用 API，并管理一个代码库。这个月是你的地基
该学什么
1. Python
Python 就是 AI 工程的语言。句号。接下来六个月里你遇到的几乎每一个库、API 和教程，都是 Python 的
怎么学：
从一门会逼你写代码的结构化课程开始，而不是只看视频
初学者最常犯的错误是被动消费内容：跟着读、点头，却从没打开过代码编辑器
对抗这一点的方法，就是一边学一边把每一个示例都敲一遍
资源：
1. Python for Everybody（Coursera，可免费旁听）
Link: https://www.coursera.org/specializations/python
对零基础的人来说最好的起点。Chuck 博士是互联网上最友好的 Python 老师之一
2. freeCodeCamp Python 课程（YouTube，免费）
Link: https://www.youtube.com/watch?v=rfscVS0vtbw
一个 4 小时的完整视频，覆盖所有基础知识
3. CS50P：Python 编程导论（哈佛，免费）
Link: https://cs50.harvard.edu/python/
更严格一些，包含习题集和一个期末项目。如果你想要有结构的学习路径，这门很适合
4. 官方 Python 文档（教程部分）
Link: https://docs.python.org/3/tutorial/
枯燥但权威，当作参考手册使用
重点关注：
- 变量、数据类型、循环、条件判断、函数
- 列表、字典、集合、元组
- 文件读写（File I/O）与 JSON 处理
- 类与基础的面向对象（够你看懂别人的代码就行）
- 用 try/except 做错误处理
- 虚拟环境（venv）与 pip
- 包管理——理解 requirements.txt
练习项目：用 Python 构建一个简单的命令行（CLI）工具。比如一个读写 JSON 文件的个人记账工具，或者一个调用公共 API（例如天气 API）并打印格式化结果的脚本
2. Git 与 GitHub
Git 是专业开发者保存和共享代码的方式。你会一直用到它：给项目做版本管理、协作，以及在 GitHub 上展示你的作品集
怎么学：
Git 一开始让人困惑，是因为它的心智模型并不直观
不要试图死记命令，而是去理解 Git 在解决什么问题
（追踪变更、支持协作、让你可以撤销错误）这样命令就会变得合理
资源：
1. GitHub Skills（免费，交互式）
Link: https://skills.github.com/
在 GitHub 内部构建的官方交互式课程。从这里开始
2 . Learn Git Branching（免费，交互式）
Link: https://learngitbranching.js.org/
毫无疑问是理解分支与合并最好的可视化工具
3. Pro Git Book（免费在线书）
Link: https://git-scm.com/book/en/v2
全面的参考书。直接跳到你需要的章节
重点关注：
- git init、add、commit、push、pull
- 分支与合并
- 理解 .gitignore
- 在 GitHub 上创建仓库并把本地项目推上去
- 读写基础的 README 文件
练习： 从今往后，你构建的每一个项目，哪怕是小的脚本，都应该放在 GitHub 仓库里。这能养成习惯，也为你积累作品集
3. CLI / 终端基础
作为 AI 工程师，你会完全在命令行里跑脚本、装包、管理服务器、浏览文件
在终端里操作缓慢或害怕终端，是实打实的瓶颈
资源：
1. 最流行的 50 个 Linux 与终端命令（面向初学者的完整课程）
Link: https://www.youtube.com/watch?v=ZtqBQ68cfJc
对 Linux/Mac 上的绝对新手很友好
2. The Missing Semester of Your CS Education（MIT，免费）
Link: https://missing.csail.mit.edu/
涵盖 shell 脚本、终端工具，以及大多数计算机课程跳过的那部分命令行熟练度
重点关注：
- 导航：cd、ls、pwd、mkdir、rm
- 读文件：cat、less、grep
- 从终端运行 Python 脚本
- 环境变量
- 对 PATH 的基本理解
4. JSON、API、HTTP 与异步基础
第 2 个月的第一天你就要调用 LLM API 了
这意味着在碰 OpenAI 或 Anthropic 的 SDK 之前，你需要先搞懂 web API 是怎么工作的
资源：
1. HTTP 基础 – MDN Web Docs（免费）
Link: https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview
关于 HTTP 请求与响应如何工作最清晰的解释
2. REST API Tutorial
Link: https://restfulapi.net/
简短而实用
3. Python requests 库文档
Link: https://requests.readthedocs.io/en/latest/
学会在 Python 里调用任何 web API
4. Python async/await（免费）
Link: https://realpython.com/async-io-python/
理解异步，对之后处理流式（streaming）LLM 响应至关重要
重点关注：
- GET、POST 请求——它们是什么，以及如何在 Python 里发起
- 读写 JSON
- HTTP 状态码（200、400、401、404、500——每一个是什么意思）
- API key 是什么，以及基础的认证模式
- async def 和 await 的作用，以及它们为什么存在
练习项目： 写一个 Python 脚本，调用一个免费的公共 API（可以试试 Open-Meteo 的天气数据——不需要 API key），并把结果格式化成整洁的 JSON 输出
5. SQL 与 Pandas 基础
你不需要成为数据科学家，但你会经常需要查看、查询和处理数据
SQL 基础和熟练使用 pandas 会一直帮你省时间
资源：
1 . SQLBolt（免费，交互式）
Link: https://sqlbolt.com/
从零学 SQL 最快的方式。20 节短课，配有浏览器内练习
2. Pandas 官方入门指南
Link: https://pandas.pydata.org/docs/getting_started/index.html
跟着 10 Minutes to Pandas 教程做一遍
3. Kaggle Pandas 课程（免费）
Link: https://www.kaggle.com/learn/pandas
上手实战、实用、简短
重点关注：
- SQL：SELECT、WHERE、GROUP BY、JOIN、ORDER BY
- Pandas：加载 CSV、筛选行、选择列、基础聚合
6. FastAPI
资源：
1. FastAPI 官方教程（免费）
Link: https://fastapi.tiangolo.com/tutorial/
真的是有史以来写得最好的框架文档之一
从头到尾做一遍。涵盖路径参数、请求体、Pydantic 校验，以及运行开发服务器
2. Python API 开发（19 小时课程，freeCodeCamp，YouTube，免费）
Link: https://www.youtube.com/watch?v=ZtqBQ68cfJc
涵盖 API 设计基础，包括路由、序列化、schema 校验和 SQL 数据库集成。从零构建一个完整的社交媒体风格 API
重点关注： 创建 GET 和 POST 接口、路径参数与查询参数、用 Pydantic 定义请求体、运行 uvicorn，以及使用 FastAPI 内置的 /docs 界面在不写客户端的情况下测试你的 API
第 1 个月里程碑
到这个月结束时，你应该能够：
- 写出能读写文件、调用 API、处理错误的 Python 程序
- 用 Git 给代码做版本管理，并把项目推到 GitHub
- 毫不犹豫地在终端里操作
- 理解什么是 HTTP 请求，并在 Python 里发出一个
- 用基础 SQL 查询 SQLite 数据库
- 在本地构建并运行一个简单的 FastAPI 应用
⏩------------------------------------------------------------------------⏪
第 2 个月：掌握 LLM 应用开发
你这个月的目标：使用 OpenAI 和 Anthropic 的 API 构建真正的 AI 驱动应用
到这个月底，你应该能自如地写出稳定可靠的提示词、从模型里取出结构化数据、让模型调用你的函数，并处理所有可能出错的情况
这就是 AI 工程的核心。路线图里其他的一切，都建立在你这里学到的东西之上
该学什么
1. 提示词基础
写提示词并不只是“礼貌地提问”。它的手艺在于写出能产生一致、可靠输出的指令——而模型本质上是概率性的
作为 AI 工程师，你会在这里花掉多得惊人的时间
怎么学：
从 Anthropic 的交互式教程开始，因为它最动手
然后读 OpenAI 的官方指南。之后，Prompt Engineering Guide 把一切整合起来
按顺序把这三份材料过一遍——它们彼此强化
资源：
1. Anthropic 交互式提示词工程教程（免费，GitHub）
Link: https://github.com/anthropics/prompt-eng-interactive-tutorial
一门分成 9 章、带练习的分步课程，设计上就是让你有很多机会自己练习写提示词和排查问题
用 Claude API 以 Jupyter notebook 的形式运行它
2. Anthropic 提示词工程文档（免费）
Link: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview
官方参考资料。从基础的清晰表达到 XML 结构化，再到智能体系统，都覆盖了
3. OpenAI 提示词工程指南（免费）
Link: https://platform.openai.com/docs/guides/prompt-engineering
来自 OpenAI 的官方指南，涵盖与其模型配合良好、能带来更有用输出的提示词格式
4. PromptingGuide.ai （免费）
Link: https://www.promptingguide.ai/
涵盖从基础提示到高级策略的关键技巧，还包括函数调用、工具集成和智能体系统
重点关注： system 消息与 user 消息的区别、为什么具体性很重要、思维链提示（chain-of-thought，即“一步一步思考”）、在提示词中使用示例（few-shot），以及措辞上的细微改动如何大幅改变输出质量
练习： 拿一个真实任务——总结一份文档、从文本中抽取关键信息、给一条反馈分类——为它写 5 个不同的提示词。比较输出结果。你会立刻看到提示词设计对稳定性的影响有多大
3. 结构化输出 / JSON Schema
在真实应用里，你几乎从不想要 LLM 输出裸文本，你想要的是可以解析、可以存储、可以在代码里使用的结构化数据
结构化输出通过强制模型匹配你定义的 schema 来解决这个问题
资源：
1. OpenAI 结构化输出指南（官方文档，免费）
Link: https://platform.openai.com/docs/guides/structured-outputs
介绍的那个特性可以确保模型总是生成符合你 JSON Schema 的响应，这样你就不用担心字段缺失或凭空捏造的值
2. Instructor 库（免费，开源）
Link: https://python.useinstructor.com/
用 Pydantic 模型从任何 LLM 提供商获取结构化输出最干净的方式
用同一套代码接口就能支持 OpenAI、Anthropic、Google 以及 15 家以上其他提供商，校验失败时会自动重试
这也是大多数生产环境的 AI 工程师实际在用的东西
3. OpenAI Cookbook：结构化输出入门（免费）
Link: https://developers.openai.com/cookbook/examples/structured_outputs_intro/
覆盖思维链输出、结构化数据抽取和 UI 生成等实用示例，适合用来理解真实世界的用例
重点关注： 为你的数据定义 Pydantic 模型、把 schema 传给 API、理解结构化输出与 JSON mode 的区别，以及优雅地处理拒答（refusal）
练习项目： 构建一个发票或收据解析器。给它原始文本（例如 "Invoice #123, $45.99 for 3 widgets, due March 30"），让它返回一个结构化的 Python 对象，包含 invoice_number、amount、items、due_date 等字段
4. 函数 / 工具调用
工具调用（tool calling）正是把 LLM 从文本生成器变成能采取行动的东西——搜索网页、查询数据库、调用你的 API、运行代码。这是整份指南中最重要的技能之一
怎么理解它： 模型实际上并不执行你的函数
它会检查提示词，当它判断应该使用某个工具时，就返回一个结构化调用，里面包含函数名和参数
然后你的代码执行这个调用，再把结果发回去
资源：
1. OpenAI 函数调用指南（官方文档，免费）
Link: https://platform.openai.com/docs/guides/function-calling
权威参考。涵盖工具定义、5 步调用流程、并行调用以及最佳实践
2. Anthropic 工具使用文档（免费）
Link: https://docs.anthropic.com/en/docs/build-with-claude/tool-use
Anthropic 为 Claude 提供的对应指南。概念相同，语法略有差异
3. OpenAI Cookbook：如何用聊天模型调用函数（免费，GitHub）
一个完整可运行的 notebook，用真实例子走完整个工具调用循环
重点关注： 用 JSON Schema 清晰地描述函数、解析工具调用响应、执行函数并把结果回传、处理不需要调用工具的情况，以及 tool_choice: "auto" 这个概念
练习项目： 构建一个带三个工具的简单助手：get_weather(city)、calculate(expression) 和 search_notes(query)（后者只要搜索一个硬编码的 dict 就行）。把它们都接好，然后看模型如何根据你的提问决定该调用哪一个
5. 流式响应
流式（streaming）是指模型生成输出的同时就把它显示出来——逐词显示——而不是等整个响应完成。它能让你的应用感觉快得多、更有生命力
资源：
1. OpenAI 流式文档（官方，免费）
Link: https://platform.openai.com/docs/api-reference/streaming
关于在请求里加上 stream=True 并对分块（chunk）进行迭代的参考
2. Anthropic 流式文档（官方，免费）
Link: https://docs.anthropic.com/en/api/messages-streaming
Anthropic 的流式 API 参考，附带 Python 示例
3. 流式 LLM API 是如何工作的 – Simon Willison（免费）
Link: https://til.simonwillison.net/llms/streaming-llm-apis
清晰的技术拆解，讲清了 OpenAI、Anthropic 和 Google 的 Server-Sent Events 在底层如何工作，对理解 HTTP 层面到底发生了什么很有用
重点关注： 设置 stream=True、遍历 delta 分块、把各部分拼装成完整响应，以及用 StreamingResponse 把流式接入一个 FastAPI 接口
提示： 对于面向用户的应用，流式几乎总是正确的选择。没人愿意盯着加载转圈看 10 秒，等一个完整响应一次性蹦出来
5. 对话状态
LLM 是无状态的——调用之间没有记忆。对话历史需要你自己管理：每次请求都把完整的消息列表发过去。理解这一点是基础
资源：
1. OpenAI Chat Completions 指南：管理对话（官方，免费）
Link: https://platform.openai.com/docs/guides/conversation-state
关于 messages 数组如何工作、如何管理多轮对话的标准解释
2. Anthropic Messages API 文档（官方，免费）
Link: https://docs.anthropic.com/en/api/messages
Anthropic 的对应文档。概念相同，两份都值得读一读，看看差异在哪
重点关注： messages 数组的结构、为什么 user 和 assistant 消息都要追加、上下文窗口限制以及超出时会发生什么，还有基础的截断策略（丢掉最旧的消息、对历史做摘要）
练习项目： 在终端里构建一个简单的多轮聊天机器人。每一轮都往 messages 列表里追加内容。加一个 /reset 命令来清空历史，并在每次交互后打印当前的 token 数
6. 成本、延迟与 Token 基础
在不理解成本和 token 的情况下上线 AI 应用，结果就是意外的账单和卡顿的应用。这部分很无聊，但极其关键
资源：
1. OpenAI 定价页（官方）
Link: https://openai.com/api/pricing
搞清楚每个模型的输入和输出 token 各是多少钱。把它收藏起来，每次选模型时都看一眼
2. Anthropic 定价页（官方）
Link: https://www.anthropic.com/pricing
Claude 系列模型同理
3. OpenAI Tokenizer 工具（免费，交互式）
Link: https://platform.openai.com/tokenizer
粘贴任意文本，就能看到它到底是多少个 token。学习期间你会经常用它
4. Tiktoken（Python 库，免费）
Link: https://github.com/openai/tiktoken
OpenAI 的 tokenizer 库，可以在发请求前就在代码里统计 token 数
重点关注： 什么是 token（大约 4 个字符 / 一个词的 3/4）、输入 token 与输出 token 的计价为何不同、上下文窗口大小如何限制你能做的事情，以及“更小更快”与“更大更聪明”的模型之间的延迟取舍
另外：不要什么事都用 GPT-4/Opus——对简单任务来说，更便宜的模型往往已经够用了
7. 失败处理
LLM API 会失败。会撞到限流（rate limit）、响应会超时、模型会返回格式错误的 JSON。能否优雅地处理失败，是区分 demo 和生产应用的分水岭
资源：
1. OpenAI 错误码参考（官方，免费）
Link: https://platform.openai.com/docs/guides/error-codes
你会遇到的每一种错误类型，以及该怎么应对
2. Anthropic 错误处理文档（官方，免费）
Link: https://docs.anthropic.com/en/api/errors
Claude 同理
3. Tenacity（Python 库，免费）
Link: https://tenacity.readthedocs.io/
一个干净的库，能给任何 Python 函数加上带指数退避（exponential backoff）的重试逻辑。一个装饰器，重试就搞定了
重点关注： 限流错误（429）与指数退避、用 httpx/requests 处理超时、在使用模型输出前先做校验、兜底策略（换一个模型重试、返回缓存响应），以及绝不要因为 LLM 返回了预料之外的输出就让你的应用崩掉
8. 提示词注入意识
提示词注入（prompt injection）是 LLM 应用中的头号安全风险
当不可信的用户输入与系统指令被组合在一起时就会发生这种情况，用户因此可以修改、覆盖或向提示词中注入新的行为——导致系统执行非预期的操作或生成被操控的输出
你不需要成为安全专家，但在上线任何东西之前，你需要知道这件事存在
资源：
1. OWASP Top 10 for LLM Apps – LLM01：提示词注入（免费）
Link: https://genai.owasp.org/llmrisk/llm01-prompt-injection/
权威的分类，涵盖直接注入（越狱）、通过文档或网站等外部内容进行的间接注入，以及真实世界的攻击场景
2. OWASP 提示词注入防御速查表（免费）
Link: https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html
实用防御模式：输入校验、权限控制和输出校验
3. Evidently AI：什么是提示词注入（免费）
Link: https://www.evidentlyai.com/llm-guide/prompt-injection-llm
一篇面向开发者的清晰讲解，介绍攻击类型、风险以及用于缓解它们的设计模式
重点关注： 直接注入与间接注入的区别、为什么 system prompt 并不真正“安全”、工具访问的最小权限原则，以及绝不要信任未经校验的 LLM 输出，让它自动做出有后果的决策
第 2 个月里程碑
到这个月结束时，你应该能够：
- 写出能为特定任务产生一致、可靠输出的提示词
- 用 Pydantic + Instructor 从任何模型取出结构化 JSON 数据
- 接通工具调用，让模型可以调用你的 Python 函数
- 通过 FastAPI 接口实时流式返回响应
- 正确管理多轮对话历史
- 在发送请求前估算它的 token 成本
- 处理 API 错误、超时和糟糕的输出而不崩溃
- 解释什么是提示词注入，并应用基础防御措施
⏩------------------------------------------------------------------------⏪
第 3 个月：正确地学习 RAG
你这个月的目标：构建能让 LLM 基于你的文档（而不只是它们的训练数据）回答问题的系统
到这个月底，你应该能够导入文档、把它们向量化并存储、在查询时检索出正确的文本块（chunk），并生成有依据、准确、可引用的回答
RAG 是当下 AI 工程中最抢手的实用技能。几乎所有真实的企业 AI 用例——客服机器人、内部知识库、文档问答——都建立在它之上
深入理解它（而不是照抄一份教程），是优秀工程师和卓越工程师之间的分水岭
1. 嵌入（Embeddings）
在你能构建 RAG 系统之前，你需要理解嵌入到底是什么——因为它是其他一切赖以建立的基础
文本嵌入（text embedding）是把一段文本投射到一个高维向量空间中
这段文本在该空间中的位置，用一长串数字来表示
关键在于：语义相近的文本在这个空间里会彼此靠得很近——这正是相似度搜索得以可能的原因
资源：
1 . Stack Overflow 博客：文本嵌入的直觉式入门（免费）
Link: https://stackoverflow.blog/2023/11/09/an-intuitive-introduction-to-text-embeddings/
最好的入门解释。作者是一位做了多年 NLP 产品的开发者，重点在于建立正确的直觉，而不是讲数学
2. Google 机器学习速成课程：嵌入（免费）
Link: https://developers.google.com/machine-learning/crash-course/embeddings
讲解为什么稠密向量表示能解决 one-hot 编码解决不了的问题——具体来说，就是捕捉条目之间的语义关系
3. HuggingFace：嵌入入门（免费）
Link: https://huggingface.co/blog/getting-started-with-embeddings
实操指南。演示如何用 sentence-transformers 库生成嵌入、如何托管它们，以及如何在一个真实的 FAQ 数据集上做语义搜索
4. OpenAI 嵌入指南（官方文档，免费）
Link: https://platform.openai.com/docs/guides/embeddings
关于在代码中使用 OpenAI 的 text-embedding-3-small 和 text-embedding-3-large 模型的参考
重点关注： 概念上向量是什么、为什么相似的文本会产生相似的向量、余弦相似度（cosine similarity）如何工作、不同嵌入模型之间的差异（OpenAI、HuggingFace sentence-transformers），以及嵌入维度在实践中意味着什么
练习： 取 20 个主题相关的句子，用 OpenAI 或 sentence-transformers 做嵌入，然后写一个简单的最近邻搜索，返回与查询最相似的 3 个句子。这实际上就是 RAG 的核心，只是缩小版
2. 切块（Chunking）
你的文档太大，没法整体做嵌入。切块就是在嵌入之前把文档拆成更小片段的过程
你如何切块，会直接影响系统找到相关信息、给出准确答案的能力：即使检索系统本身完美，只要它搜索的是准备得很差的数据，也照样会失败
资源：
1. Weaviate：面向 RAG 的切块策略（免费）
Link: https://weaviate.io/blog/chunking-strategies-for-rag
最实用的指南。涵盖固定大小切块、递归切块和语义切块，并清楚说明各自适用的场景
2. Unstructured：RAG 切块最佳实践（免费）
Link: https://unstructured.io/blog/chunking-for-rag-best-practices
关于文本块大小、重叠（overlap），以及嵌入模型的上下文窗口如何构成硬性限制的技术深入探讨
一个不错的实验起点是：块大小约 250 个 token（大约 1,000 个字符），并在相邻块之间保留 10–20% 的重叠，以免在边界处丢失上下文
3. LangChain 文本切分器文档（官方，免费）
Link: https://python.langchain.com/docs/concepts/text_splitters/
关于在代码中使用 RecursiveCharacterTextSplitter、MarkdownTextSplitter 和语义切分器的实用参考
重点关注： 把带重叠的固定大小切块作为你的基线、对结构化文档使用递归切块、用语义切块获得更好的边界识别，以及核心取舍：块太大就丢失检索精度，块太小就丢失上下文
新手提示： 从 LangChain 的 RecursiveCharacterTextSplitter 开始，设置 chunk_size=500、chunk_overlap=50。对大多数文档来说这是最合理的默认值，能给你一个可用的基线再去改进
3. 向量数据库
有了嵌入之后，你需要一个地方来高效地存储和检索它们。这就是向量数据库的用途
正确的选择取决于你的情况：快速本地原型用 Chroma；想要托管、开箱即用的规模化用 Pinecone；想要开源灵活性并具备强混合检索用 Weaviate；需要复杂过滤和低成本自托管用 Qdrant；如果你已经在用 PostgreSQL、不想再引入一个系统，就用 pgvector
资源：
1. Chroma 官方文档（免费）
Link: https://docs.trychroma.com/
Chroma 非常适合把开发速度和简洁性放在首位的个人开发者和小团队，它可以在内存中或本地运行，不需要管理任何基础设施
2. Pinecone 学习中心（免费）
Link: https://www.pinecone.io/learn/
优秀的免费教程，涵盖向量搜索概念、混合检索和 RAG 流水线。即使你不用 Pinecone，这些材料对任何提供商都适用
3. Qdrant 文档（免费）
Link: https://qdrant.tech/documentation/
生产环境中支持高级过滤的最佳开源选项。非常快、灵活，而且可以免费自托管
4. pgvector（开源，免费）
Link: https://github.com/pgvector/pgvector
如果你构建的东西已经在用 PostgreSQL，pgvector 能直接把向量搜索加到现有数据库里，不需要新的基础设施
重点关注： 创建集合（collection）、插入带元数据的嵌入、用 top_k 做相似度查询，以及在查询时按元数据过滤
你不需要理解索引算法（HNSW、IVF）——只要知道怎么用它们就行
练习项目： 把任何公开文档的 50–100 个页面（例如 Python 文档，或一份维基百科条目转储）连同元数据（来源 URL、章节标题）索引进 Chroma。写一个查询函数，对任何问题都返回最相关的 5 个块
4. 元数据过滤
只做原始的相似度搜索，对真实应用来说是不够的。元数据过滤让你能把检索限制在相关的子集里——按日期、来源、文档类型、用户、分类，或任何你随每个块一起存储的属性
资源：
1. Pinecone：元数据过滤指南（免费）
Link: https://docs.pinecone.io/guides/data/filter-with-metadata
解释清晰，附带代码示例，说明如何在相似度搜索之前或之中按元数据字段过滤向量
2. LlamaIndex：元数据过滤器指南（官方文档，免费）
Link: https://docs.llamaindex.ai/en/stable/module_guides/querying/node_postprocessors/node_postprocessors/
讲解了如何在 LlamaIndex 流水线中于查询时应用过滤器
重点关注： 在入库时给每个块打上相关元数据（源文件名、页码、章节、日期、分类），并在查询时用这些字段过滤结果。这正是玩具 demo 与生产系统之间的差别——在生产系统里，用户可以说“只给我看 2025 年 Q4 到 2026 年 Q1 报告里的结果”
5. 重排序（Reranking）
重排序是一种技术，能为任何关键词或向量搜索系统的搜索质量加上一层语义增益
在第一阶段检索返回候选集之后，重排序器会基于查询的真实上下文相关性对这些结果重新打分——而不只是看向量距离
两阶段模式是：嵌入并搜索（快、近似）→ 对 top-k 重排序（慢一些、更准确）。结果是检索质量大幅提升，而延迟成本只增加不多
资源：
1. Cohere 重排序文档（官方，免费）
Link: https://docs.cohere.com/docs/reranking-with-cohere
最好的起点。涵盖完整的重排序工作流，包括邮件和 JSON 文档这类半结构化数据。加进现有检索流水线只需一行代码
2. LangChain：Cohere 重排序器集成（官方文档，免费）
Link: https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/
讲解了如何用 ContextualCompressionRetriever 把 Cohere 重排序接入 LangChain 检索器
重点关注： 两阶段的“先检索再重排序”模式、双编码器（bi-encoder，用于第一阶段嵌入搜索）与交叉编码器（cross-encoder，用于重排序）的区别，以及对 top-20 还是 top-5 结果重排序在延迟与质量上的实际取舍
6. 检索质量问题
大多数 RAG 失败并不是模型失败，而是检索失败。理解检索可能出错的种种方式，对调试真实系统至关重要
需要了解常见问题：
- 语义漂移（Semantic drift）： 查询的嵌入与相关块的嵌入匹配不上，尽管信息确实在那里。修复方法：尝试查询改写（query rewriting）或 HyDE（假设性文档嵌入）
- 块边界问题： 相关信息被拆到了两个块里。修复方法：增大重叠，或使用语义切块
- 缺少元数据上下文： 块在语义上与查询相似，但属于错误的文档、日期或用户。修复方法：使用元数据过滤
- top-k 太小： 正确的块确实存在，但没进入检索出的前 5 名。修复方法：检索时增大 top_k，重排序后再缩减
资源：
1. LangChain：查询变换（免费）
Link: https://python.langchain.com/docs/how_to/#query-analysis
涵盖查询改写、退步提示（step-back prompting）以及 HyDE
2. Pinecone：提升检索质量（免费）
Link: https://www.pinecone.io/learn/retrieval-augmented-generation/#retrieval-quality
对常见失败模式及修复方法的实用讲解
7. 减少幻觉
与原生 LLM 相比，RAG 能大幅减少幻觉，但并不能完全消除它们
通过在运行时把检索到的事实提供给模型，RAG 把它的回答锚定在真实来源上，而不是只依赖训练数据；模型输出甚至可以引用这些来源，从而提升透明度和信任度
但检索失败、糟糕的块以及相互冲突的信息，仍然会让模型编造内容
资源：
1. Zep：减少 LLM 幻觉——开发者指南（免费）
Link: https://www.getzep.com/ai-agents/reducing-llm-hallucinations/
面向开发者的实用指南，涵盖提示词锚定（grounding）策略、面向事实性任务的思维链，以及输出校验模式
2. Voiceflow：减少 LLM 幻觉的 5 种方法（免费）
Link: https://www.voiceflow.com/blog/prevent-llm-hallucinations
很好地概述了组合策略：RAG + 思维链 + 护栏（guardrails）一起用，效果优于任何单一方法
重点关注：在提示词里要求模型只根据提供的上下文回答（当答案不在其中时就说“我不知道”）、在返回响应前加一个置信度阈值，以及在责怪 LLM 之前始终先校验检索质量
8. 引用与锚定
一个有依据（grounded）的 RAG 系统不只是回答问题——它还会告诉你答案来自哪里。这对用户信任和调试都至关重要
资源：
1. Anthropic：为 Claude 提供来源（文档，免费）
Link: https://docs.anthropic.com/en/docs/build-with-claude/citations
讲解了如何通过提示词让 Claude 生成附带来源引用的回答
2. LangChain：带来源的 RAG（免费）
Link: https://python.langchain.com/docs/how_to/qa_sources/
讲解了如何在 LangChain RAG 流水线中随答案一起返回来源文档
重点关注： 把块的元数据（源文件名、页码、URL）传进提示词上下文、指示模型在回答中引用来源，并在你的 UI 或 API 响应中把这些来源展示出来
9. 你的 RAG 框架：LangChain 还是 LlamaIndex
你不需要从零构建 RAG 流水线。有两个框架主导了这个领域，值得了解：
LlamaIndex 把搜索和索引放在第一位：它把数据导入、切块、嵌入和查询抽象成几行代码，让你一个下午就能搭出可用的原型
LangChain 在你应用更像一个编排引擎时更出彩——它擅长多智能体工作流、工具调用，以及那种在生成答案之前先查询多个 LLM 或外部 API 的条件链
第 3 个月，RAG 从 LlamaIndex 开始。到第 4 个月做智能体时再转向 LangChain
资源：
1. LlamaIndex：RAG 入门（官方文档，免费）
Link: https://developers.llamaindex.ai/python/framework/understanding/rag/
涵盖 RAG 的五个关键阶段：加载、索引、存储、查询和评估——以及 LlamaIndex 如何处理每一个阶段
2. LlamaIndex 入门教程（官方文档，免费）
Link: https://developers.llamaindex.ai/python/framework/getting_started/starter_example/
官方快速上手。用不到 30 行代码搭出一个能用的 RAG 系统
3. LangChain：构建 RAG 智能体（官方文档，免费）
Link: https://docs.langchain.com/oss/python/langchain/rag
展示如何用 RAG 智能体在非结构化文本上构建问答应用，从 40 行的最小版本一直到带重排序的完整检索流水线
练习项目： 构建一个“和你的文档聊天”的应用。导入 10–20 个 PDF 或文本文件（你自己的笔记、教材的一章、产品文档——什么都行）。构建一个 FastAPI 接口，接收问题、检索出最相关的 5 个块并做重排序，然后返回来自 Claude 或 OpenAI 的带引用答案。这是一个真正的作品集项目
第 3 个月里程碑
到这个月结束时，你应该能够：
- 解释什么是嵌入，以及为什么相似的文本会产生相似的向量
- 用合适的策略智能地切分任何文档
- 在向量数据库中存储并查询嵌入，并做元数据过滤
- 增加重排序步骤以提升检索质量
- 系统地调试常见的检索失败
- 用 LlamaIndex 或 LangChain 构建完整的端到端 RAG 流水线：导入文档、检索相关块，并返回有依据、带引用的答案
⏩------------------------------------------------------------------------⏪
第 4 个月：智能体、工具、工作流与评估
你这个月的目标：构建能够自主执行一连串动作的 AI 系统，把多步骤工作流串起来，并且能批判性地评估它们是否真的在起作用
到这个月底，你应该能够从零构建一个真实的智能体、理解什么情况下用智能体是错误选择，并衡量你所构建的任何东西的表现
这正是 AI 工程真正开始复杂的地方。第 4 个月的技能，是初级 AI 工程师与能够端到端负责一整个 AI 功能的人之间的分水岭
1. 智能体循环
智能体不是魔法，它是一套简单得令人意外的模式
把智能体看作由目标驱动的系统，它们不断循环经历观察、推理和行动
这个循环让它们能够处理超出简单问答范围的任务，进入真正的自动化、工具使用，并能在过程中随机应变
“思考”发生在提示词里，“分支”发生在智能体于可用工具之间做选择时，“执行”发生在调用外部函数时。其余的一切都只是管道
一旦你内化了这一点，即使是最复杂的智能体框架也会变得可读
资源：
1. Anthropic：构建有效的智能体（官方，免费）
Link: https://www.anthropic.com/research/building-effective-agents
关于生产环境智能体的最佳单篇文字。在写第一行智能体代码之前先读它
2. OpenAI：构建智能体的实用指南（官方 PDF，免费）
Link: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf
OpenAI 的补充指南，涵盖生产环境中的智能体模式、护栏和安全模式
3. freeCodeCamp：开源 LLM 智能体手册（免费）
Link: https://www.freecodecamp.org/news/the-open-source-llm-agent-handbook/
一份全面的实用指南，涵盖智能体循环、LangGraph、CrewAI、规划、记忆和工具使用。适合快速上手
4. LangChain Academy：LangGraph 入门（免费课程）
Link: https://academy.langchain.com/courses/intro-to-langgraph
LangGraph 的官方免费课程，它是最广泛使用的智能体编排框架。涵盖状态、记忆、人在环（human-in-the-loop）等
重点关注： 感知 → 规划 → 行动 → 观察的循环、智能体循环如何终止、工具调用在循环内部失败时会发生什么，以及为什么智能体不过是“让 LLM 来做分支判断的 while 循环”
练习： 不用任何框架、只用 OpenAI 或 Anthropic 的 API，从零构建一个智能体。给它 3 个工具、一个目标和一层循环。这是真正理解框架到底抽象掉了什么的最有价值的做法
2. 工具选择
把工具写好，等于完成了工作的一半。你为工具及其参数写的描述，就是给 LLM 的用户手册。手册写得含糊，LLM 就会误用工具。要极其、毫不留情地明确
描述得糟糕的工具会被错误调用、在错误的时机被调用，或者干脆被忽略。描述得好的工具行为可预测，并能在各种输入下被正确选中
资源：
1. OpenAI：函数调用最佳实践（官方文档，免费）
Link: https://platform.openai.com/docs/guides/function-calling/best-practices
关于如何写出稳定可靠的工具描述的权威指南，包含命名约定和参数文档的写法模式
2. Anthropic：工具使用最佳实践（官方文档，免费）
Anthropic 的对应内容。特别留意关于“何时让模型自行选择、何时强制指定某个工具”的建议
重点关注： 工具名要写成能自我解释的动词、描述里要说明何时调用该工具（而不只是它做什么）、参数要尽量少且类型明确，以及以“LLM 是调用方”为前提来设计工具
新手提示： 检验每一条工具描述时问自己：“如果我没有任何文档，只有这份 JSON schema，我会不会清楚地知道什么时候、怎样调用它？”如果不会，那就是还需要打磨
3. 状态管理
在 LangGraph 中，状态（state）是一个贯穿图结构的共享记忆对象。它存储所有相关信息——消息、变量、中间结果和决策历史——并在整个执行过程中被自动管理
理解状态，是构建能处理多轮任务、能从失败中恢复、能在组件之间干净交接的智能体的关键
资源：
1. LangGraph 官方文档：状态管理（免费）
Link: https://langchain-ai.github.io/langgraph/concepts/low_level/#state
权威参考。涵盖 state schema、reducer，以及状态如何在节点（node）和边（edge）之间流动
2. DataCamp：LangGraph 智能体教程（免费）
Link: https://www.datacamp.com/tutorial/langgraph-agents
用手把手的代码讲解状态、节点和边的基础，一步步构建出能跨会话保留持久记忆的有状态智能体
3. Real Python：Python 中的 LangGraph（免费）
Link: https://realpython.com/langgraph-python/
一份详尽的教程，构建完整的有状态 LangGraph 智能体，详细解释了状态图和条件边
重点关注： 用 TypedDict 定义 state schema、reducer 如何合并并行更新、内存状态与持久化检查点（checkpointing）的差别，以及人在环的暂停机制如何通过在执行中途读取并修改状态来实现
4. 智能体中的重试与失败处理
智能体失败的方式与普通 LLM 调用不同。循环中途一次糟糕的工具调用可能污染状态、造成无限循环，或者静默地产生错误答案。你需要为所有这些情况准备明确的策略
资源：
1. LangGraph：错误处理与重试（官方文档，免费）
Link: https://langchain-ai.github.io/langgraph/how-tos/autofill-tool-errors/
讲解了如何在 LangGraph 的工具节点层面加入自动错误处理和重试逻辑
2. OpenAI 智能体实用指南：护栏章节（免费）
Link: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf
把护栏（guardrails）讲成分层防御：结合基于 LLM 的检查、正则等基于规则的过滤器，以及审核（moderation）API，在智能体循环的每个阶段同时审查输入和输出
重点关注： 用最大迭代次数限制防止无限循环、对每个工具做带指数退避的重试、在工具执行层捕获并记录异常而不让智能体崩掉，以及何时把失败抛给用户、何时静默重试
5. 什么时候不要用智能体
这是 AI 工程中最重要的技能之一，也是最常被忽视的技能之一。智能体很令人兴奋，但它们也慢、贵、不可预测、难以调试。知道什么时候该改用更简单的方案，是判断力良好的表现
Anthropic 建议：寻找尽可能简单的方案，只在确实需要时才增加复杂度——这可能意味着干脆不构建智能体系统
智能体系统用延迟和成本换取更好的任务表现，你需要仔细考虑这种取舍什么时候才划算
判断框架是：
- 如果任务在给足正确上下文后用一个提示词就能解决，就用单次 LLM 调用
- 如果步骤是固定且可预测的，就用工作流
- 只有当步骤数量真的不可预测、需要动态决策时，才用智能体
资源：
1. Anthropic：构建有效的智能体，何时使用智能体（官方，免费）
Link: https://www.anthropic.com/research/building-effective-agents
关于这个问题最权威的回答，直接来自构建这些模型的团队
2. Simon Willison：设计智能体循环（免费）
Link: https://simonwillison.net/2025/Sep/30/designing-agentic-loops/
一位资深工程师的务实看法：智能体的复杂度何时才算合理，以及该如何思考智能体循环的设计
要记住的结论： 由 3 次固定 LLM 调用组成的链条，永远比一个“可能会做出 3 次调用”的智能体更快、更便宜、更容易调试。把智能体留给真正开放式的任务
6. 多步骤工作流
在“单次提示”与“完整智能体”之间，存在一大片高产的中间地带：工作流。当任务可以被干净地拆解成固定的子任务时，工作流是最理想的选择——它用延迟换取更高的准确率，因为每一次 LLM 调用都变成了更简单、更聚焦的任务
常见模式包括：提示词链（一次调用的输出是下一次的输入）、路由（对输入分类后交给专门的处理者）、并行化（同时运行多次调用并汇总结果），以及编排者–子智能体（一个 LLM 做规划，其他执行）
资源：
1. Anthropic：工作流模式（官方，免费）
Link: https://www.anthropic.com/research/building-effective-agents#workflow-patterns
用图和代码示例涵盖所有主要模式。并行化和编排这两节尤其有用
2. LangGraph：多智能体网络（官方文档，免费）
Link: https://langchain-ai.github.io/langgraph/concepts/multi_agent/
讲解了如何把多个智能体连成一张网络，包含监督者（supervisor）与交接（handoff）模式
练习项目： 构建一个 3 步的内容流水线：
第 1 步 – 一个 LLM 从一篇文章中提取关键事实
第 2 步 – 另一次 LLM 调用用这些事实并行生成一条推文、一条 LinkedIn 帖子和一份摘要
第 3 步 – 最后一次 LLM 调用为这三份产出打分并挑出最好的
不需要智能体，纯工作流
7. 评估框架（Evaluation Harness）
评估（evals）是你知道 AI 系统是否真的在起作用的方式——不只是在你手动试过的那几个例子上，而是系统性地在数百个输入上
AI 智能体很强，但部署起来很复杂，因为它们概率性的、多步骤的行为会带来许多失败点
智能体的不同部分——LLM、工具、检索器和工作流——各自需要自己的评估方法
资源：
1. DeepEval（开源，免费）
Link: https://deepeval.com/docs/getting-started
一个受 pytest 启发的开源 LLM 评估框架。用输入和期望输出写测试用例，用 50 多个内置指标（包括幻觉、答案相关性、事实一致性）来运行，并捕获不同版本之间的回归
Link: https://github.com/promptfoo/promptfoo
一个用于测试和评估 LLM 应用的 CLI 和库，带自动化测试套件。支持在多个模型上并排比较多个提示词、CI/CD 集成，以及针对安全漏洞的红队测试
3. LangSmith（免费额度）
Link: https://smith.langchain.com/
为 LangChain 和 LangGraph 应用提供追踪、调试和评估。免费额度很慷慨，它的追踪界面能让调试智能体循环变得容易得多
4. Ragas（开源，免费）
Link: https://docs.ragas.io/
专为 RAG 流水线设计的评估框架。衡量忠实性（faithfulness）、答案相关性、上下文精度和上下文召回。如果你要评估第 3 个月的 RAG 系统，这是必备的
重点关注： 构建一个由 20–50 个代表性输入组成的黄金测试集，附带期望输出或评分标准；编写评估函数，用确定性方式（字符串匹配、JSON schema 校验）或 LLM-as-judge 给输出打分；以及在你改动提示词或更换模型时自动运行评估
关键心态： 评估不是可选的锦上添花。每一次你在没跑评估的情况下改动提示词、更换模型或调整检索，都是一次赌博。能交付可靠 AI 产品的工程师，会持续不断地跑评估
8. 任务成功指标
除了自动化评估，你还需要一些指标来判断智能体是否真的达成了它的目标
资源：
1. Hamel Husain：你的 AI 产品需要评估（免费）
Link: https://hamel.dev/blog/posts/evals/
关于为真实生产 AI 系统构建评估流水线，最实用的文章之一，作者在大规模场景下真正做过这件事
2. OpenAI Evals 框架（开源，免费）
Link: https://github.com/openai/evals
OpenAI 自己的评估框架，附带一个庞大的社区贡献评估模式库，你可以直接改造使用
重点关注： 过程指标（智能体是否调用了正确的工具？）与结果指标（任务是否成功？）的区别、在动手构建之前先定义清晰的成功标准，以及用 LLM-as-judge 来评估那些无法精确匹配的输出（例如长文本回答或多步推理轨迹）
练习项目： 拿你第 3 个月的 RAG 流水线，为它构建一套像样的评估框架。从你的文档里做 30 组问答对，让它们跑过你的流水线，用 DeepEval 为每个答案的相关性、忠实性和完整性打分。然后只改一个变量（块大小、模型、top-k）再跑一遍，看看是否变好了
第 4 个月里程碑
到这个月结束时，你应该能够：
- 解释什么是智能体循环，并且不用框架从零实现一个
- 写出能被正确、稳定选中的工具描述
- 用 LangGraph 或同类工具正确管理智能体状态
- 处理智能体循环内部的失败而不崩溃
- 有把握地判断一个任务需要智能体、工作流，还是单次提示
- 构建能链接、路由和并行化 LLM 调用的多步骤工作流
- 写出在你改动提示词或模型时能捕获回归的自动化评估
- 为你构建的任何 AI 系统定义并衡量任务成功指标
⏩------------------------------------------------------------------------⏪
第 5 个月：部署、产品思维与可靠性
你这个月的目标：把你构建的一切变成可上生产的形态
到这个月底，你应该能部署一个能应对真实用户、真实流量和真实故障的 AI 应用，而不至于在凌晨两点崩掉
大多数 AI 工程师就是在这里卡住的。他们能做出很棒的 demo，却交付不了一个经得起真实世界碰撞的产品
这里的技能才是公司真正付钱买的东西：可靠性、安全性、成本控制，以及在事情不可避免地坏掉时把系统维持住的能力
1. FastAPI 生产模式
你在第 1 个月已经会构建 FastAPI 应用了。现在你需要让它扛得住生产流量
开发环境与生产环境之间的差距是残酷的。开发时用单个带 --reload 的 uvicorn 进程就足够了；到了生产环境，一旦真实流量到来，它立刻就成了瓶颈
你真正需要的是：多 worker 的 ASGI 配置、正确的错误处理中间件、健康检查接口，以及 CORS 策略
资源：
1. FastAPI 部署文档（官方，免费）
Link: https://fastapi.tiangolo.com/deployment/
官方指南，涵盖 Uvicorn worker、Gunicorn 以及 Docker 部署。在做任何其他事情之前先看这个
2. FastAPI 生产部署指南（CYS Docs，免费）
Link: https://craftyourstartup.com/cys-docs/fastapi-production-deployment/
全面的生产模式：Gunicorn 配置、Nginx 反向代理、健康检查、限流。包含你可以直接改造的真实配置文件
3. FastAPI 生产环境最佳实践（FastLaunchAPI，免费）
Link: https://fastlaunchapi.dev/blog/fastapi-best-practices-production-2026
涵盖异步数据库连接池、Redis 缓存、JWT 认证和后台任务。这些是经过生产验证的模式，来自一个被 100 多位开发者使用的真实模板
重点关注： 用 Gunicorn 搭配 Uvicorn worker 运行（而不是裸跑 Uvicorn）、设置健康检查接口、加上 CORS 中间件、实现正确的异步数据库会话，以及对任何不需要阻塞响应的操作使用后台任务
2. Docker
Docker 是你不再说“在我机器上是好的”、开始交付一致性部署的方式
如果你在构建 AI 应用，Docker 能解决依赖冲突、保证环境一致，并让扩展变得简单直接
你不需要成为 Docker 专家。你只需要能把自己的 FastAPI + LLM 应用容器化，并部署到任何地方
资源：
1. Docker 官方入门指南（免费）
Link: https://docs.docker.com/get-started/
标准的起点。涵盖镜像、容器、Dockerfile 和 Docker Compose
2. freeCodeCamp：如何用 Python 和 Docker 构建并部署多智能体 AI 系统（免费）
Link: https://www.freecodecamp.org/news/build-and-deploy-multi-agent-ai-with-python-and-docker/
端到端的实操教程，用 Docker Compose 构建一个真实的多智能体流水线。涵盖关注点分离、cron 定时调度和安全方面的考量
3. DataCamp：用 Docker 部署 LLM 应用（免费）
Link: https://www.datacamp.com/tutorial/deploy-llm-applications-using-docker
专门面向带 RAG 流水线的 LLM 应用的分步指南。涵盖 Dockerfile 编写、环境管理和部署
4. 面向 LLM 应用的 Docker 容器化（ApXML，免费）
涵盖基础镜像选择、依赖管理、多阶段构建，以及用于多服务 LLM 部署的 Docker Compose
重点关注： 为 Python/FastAPI 应用编写 Dockerfile、用多阶段构建让镜像保持精简、用 Docker Compose 编排多服务（应用 + 数据库 + Redis）、用环境变量管理密钥，以及用 .dockerignore 避免泄露敏感文件
练习项目： 把第 3 个月的 RAG 应用容器化。写一个 docker-compose.yml，同时运行你的 FastAPI 应用、一个向量数据库（Chroma 或 Qdrant）和用于缓存的 Redis。做到 docker compose up 一条命令就启动所有东西
3. 后台任务与队列
LLM 调用很慢。如果用户让你的应用处理一份文档，而你让他等 30 秒才有响应，他就走了
后台任务让你可以立即接受请求、异步处理，并在完成时通知用户
资源：
1. Celery 官方入门指南（免费）
Link: https://docs.celeryq.dev/en/stable/getting-started/introduction.html
Python 标准任务队列。涵盖基础配置、任务定义和 worker 管理
2. FastAPI 后台任务文档（官方，免费）
Link: https://fastapi.tiangolo.com/tutorial/background-tasks/
内置的轻量后台任务，适用于简单场景。快速“发了就不管”的任务用它，更重的任务用 Celery
重点关注：理解何时该用 FastAPI 内置的 BackgroundTasks、何时该用 Celery 这类正式任务队列、把 Redis 配成消息中间件、处理任务失败与重试，以及把任务状态返回给用户
4. 认证与 API Key 安全
如果你的 AI 应用有 API，它就需要身份认证。没有认证，任何人都能用你的接口、烧掉你的 LLM 额度，然后你一觉醒来看到一张 5,000 美元的账单
资源：
1. FastAPI 安全文档（官方，免费）
Link: https://fastapi.tiangolo.com/tutorial/security/
涵盖 OAuth2、JWT token、API key，以及基于依赖注入的认证模式。这是官方参考，把整个教程做一遍
2. OWASP API 安全 Top 10（免费）
Link: https://owasp.org/API-Security/
API 安全风险的权威清单。在上线任何东西之前，先理解认证失效、注入和批量赋值（mass assignment）
3. Auth0：API 认证最佳实践（免费）
Link: https://auth0.com/docs/get-started/authentication-and-authorization
在 API 中实现身份认证与授权的实用指南
重点关注： 用 JWT token 做用户认证、用 API key 管理服务间通信、按用户/按 key 限流、绝不把密钥写进代码（用环境变量），以及理解认证（你是谁）与授权（你能做什么）的区别
5. 日志与可观测性
在生产环境里，如果你看不见正在发生什么，你就修不好坏掉的东西
LLM 应用有一个独特的难题：模型可能返回 200 状态码，却给出无用或幻觉的答案。传统监控抓不到这种情况。你需要 LLM 专用的可观测性
资源：
1. Langfuse（开源，有免费额度）
Link: https://langfuse.com/docs/observability/overview
开源 LLM 可观测性平台。追踪每一次请求：发出的提示词、收到的响应、token 用量、延迟、工具调用。支持提示词版本管理、评估和 LLM-as-judge 打分。可与 OpenAI、Anthropic、LangChain、LlamaIndex 集成
2. LangSmith（免费额度）
Link: https://smith.langchain.com/
来自 LangChain 团队。如果你在用 LangChain/LangGraph，配置只需要一个环境变量。提供追踪、调试、监控面板和在线评估。免费额度对开发和小规模生产来说很慷慨
3. Python Structlog（免费）
Link: https://www.structlog.org/
Python 的结构化日志库。产出真正可搜索、可解析的 JSON 日志。对生产应用来说，比 print() 或基础 logging 好得多
重点关注： 追踪每一次 LLM 调用（输入提示词、输出、token、延迟、成本）、用 JSON 输出做结构化日志、搭建能显示请求量、错误率和每日成本的面板，以及在出问题或成本飙升时告警
6. 提示词与版本管理
在生产环境里，你的提示词就是代码。它们需要版本控制、测试和回滚能力
在生产中改动提示词却不记录改了什么，正是那种让你把东西搞坏又查不出原因的做法
资源：
1. Langfuse 提示词管理（免费）
Link: https://langfuse.com/docs/prompts
集中化的提示词版本管理，内置用于测试的 playground。让你的提示词版本控制与应用程序代码分离。无需重新部署应用即可发布提示词改动
2. Anthropic 提示词管理最佳实践（免费）
Link: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview
在大规模场景下组织、迭代和管理提示词的最佳实践
重点关注：把提示词存放在应用代码之外、为每一次提示词改动做版本记录、在生产中对提示词变体做 A/B 测试，以及在新提示词表现更差时有回滚策略
7. 成本监控与限流
LLM API 按 token 收费。没有成本控制，一次流量高峰或提示词里的一个 bug，就能在几分钟内烧掉几百美元
资源：
1. OpenAI 用量面板（官方）
Link: https://platform.openai.com/usage
按模型、按天追踪花费，并设置用量上限
2. Anthropic 用量面板（官方）
Link: https://console.anthropic.com/Same 用于查看 Claude API 用量
3. Helicone（免费额度）
Link: https://www.helicone.ai/
基于代理的可观测性，捕获每一次 LLM 调用并自动追踪成本。配置只需一行代码：改一下你的 base URL 就行
4. LiteLLM（开源，免费）
Link: https://github.com/BerriAI/litellm
面向 100 多家 LLM 提供商的统一接口。包含跨提供商的预算管理、限流和花费追踪
重点关注： 设置每日/每月的硬性花费上限、在 API 中实现按用户限流、对简单任务使用更便宜的模型（不要什么都用 GPT-4/Opus）、用 Redis 缓存重复的相同请求，以及监控单次请求成本以便尽早发现昂贵的提示词
8. 缓存
如果你的用户里有 20% 在问相似的问题，你就是在为同一次 LLM 调用付 20 次钱
缓存是同时降低成本和延迟最简单的方式
资源：
1. Redis 官方文档（免费）
Link: https://redis.io/docs/
标准的内存数据存储。快、简单，用于 LLM 响应缓存非常合适
2. GPTCache（开源，免费）
Link: https://github.com/zilliztech/GPTCache
专为 LLM 应用设计的语义缓存。用嵌入相似度为语义相似（而不只是完全相同）的查询找到已缓存的响应
重点关注： 对相同提示词做精确匹配缓存、对相似查询做语义缓存、缓存失效策略（基于 TTL 最简单），以及测量缓存命中率以了解真实的成本节省
第 5 个月里程碑
到这个月结束时，你应该能够：
- 用 Docker 部署一个配置到位的 FastAPI + LLM 生产应用
- 用后台任务和队列处理长时间运行的任务
- 用认证、限流和 API key 管理保护你的 API
- 用 Langfuse 或 LangSmith 追踪并调试 LLM 调用
- 用版本控制和回滚能力管理提示词
- 实时监控成本并设置花费上限
- 缓存 LLM 响应以降低延迟和成本
⏩------------------------------------------------------------------------⏪
第 6 个月：专精并变得“可被雇用”
你获得的这些知识和技能可以应用到三个方向上（当然，这只是我所看到的那些）
你需要选择其中一个，专注练习
尽管上面提到的一切，同样是最好纯粹通过实践来学
方向 1：AI 产品工程师
如果你想快速拿到创业公司的职位，这是最好的选择
这是最常见的路径。你构建真实用户会与之交互的 AI 驱动产品
第 1–5 个月的技能你大部分已经具备。现在要在产品这一侧更深入
重点关注：
- LLM 应用
- RAG
- 智能体
- 部署
- 产品体验（product UX）
这个月要学什么：
1. 端到端产品构建
别再构建教程了。去构建人们能用的产品
资源：
1. Vercel AI SDK（免费）
Link: https://sdk.vercel.ai/docs
构建带流式支持的 AI 界面最快的方式。提供 React、Next.js 和 Vue 集成，内置流式 UI 组件
2. Streamlit（免费）
Link: https://docs.streamlit.io/
用纯 Python 构建数据应用和 AI demo。非常适合内部工具和 MVP，不适合生产级 UI
3. Gradio（免费）
Link: https://www.gradio.app/docsQuick 用最少的代码构建 ML/AI 界面。特别适合演示模型和构建原型
重点关注：这个月构建 2–3 个可以演示的完整项目。一个“和你的文档聊天”应用、一个 AI 驱动的内部工具，或者一个能自动化真实工作流的智能体。把它们交付出去。放到 GitHub 上。部署到别人能试用它们的地方
2. 面向 AI 的产品体验
当 UX 没有考虑模型的局限性时，AI 产品就会失败
资源：
1. Google：People + AI 指南（免费）
Link: https://pair.withgoogle.com/guidebook/
关于设计人机交互最好的资源。涵盖设定预期、处理错误和建立信任
2. Nielsen Norman Group：AI UX 指南（免费）
Link: https://www.nngroup.com/topic/artificial-intelligence/
有研究支撑的 AI 界面设计指南
重点关注：如何用流式处理加载状态、模型出错时该显示什么、如何让用户给出反馈，以及如何针对“AI 输出是概率性的、有时一定会错”这一事实来设计
方向 2：应用机器学习 / LLM 工程师
如果你想要技术更深入的角色，这是最好的选择
这个方向面向那些不满足于调用 API、想理解底层到底发生了什么的工程师
重点关注：
- 微调（fine-tuning）
- 何时该微调、何时该用提示词
- 评估
- 推理优化
- 开源模型
- 训练流水线
这个月要学什么：
1. 何时微调、何时做提示词工程
应用机器学习中最重要的决策：你需要改变模型，还是只需要改变你与它对话的方式？
资源：
1. Google 机器学习速成课程：微调、蒸馏与提示词工程（免费）
Link: https://developers.google.com/machine-learning/crash-course/llm/tuning
关于这三种方法以及各自适用时机最清晰的解释
2. Codecademy：提示词工程 vs 微调（免费）
Link: https://www.codecademy.com/article/prompt-engineering-vs-fine-tuning
实用的决策框架，清楚说明每种方法各自的用例
3. IBM：RAG vs 微调 vs 提示词工程（免费）
Link: https://www.ibm.com/think/topics/rag-vs-fine-tuning-vs-prompt-engineering
涵盖完整的决策空间，包括何时把不同方法组合起来使用
要记住的决策框架：从提示词工程开始（最便宜、最快）。如果模型需要访问特定数据，就加上 RAG。只有当提示词 + RAG 无法达到所需的质量、一致性或延迟要求时，才做微调
2. 微调实践
当你确实需要微调时，下面是做法
资源：
1. OpenAI 微调指南（官方，免费）
Link: https://platform.openai.com/docs/guides/fine-tuning
开始微调最简单的方式。上传一份 JSONL 数据集、运行一个任务，就得到一个定制模型。即使你之后会转向开源模型，用它来了解整个流程也很值得
2. HuggingFace Transformers 微调教程（免费）
Link: https://huggingface.co/docs/transformers/training
使用开源模型的标准库。涵盖训练、评估和模型保存
3. Unsloth（开源，免费）
Link: https://github.com/unslothai/unsloth
微调速度快 2 倍，内存占用少 80%。开箱即用支持 LoRA 和 QLoRA。在消费级硬件上微调开源模型最快的一条路
4. LLaMA-Factory（开源，免费）
Link: https://github.com/hiyouga/LLaMA-Factory
用于微调 100 多个 LLM 的统一框架。附带一个可无代码微调的 Web UI。支持 LoRA、QLoRA、全量微调、RLHF 和 DPO
重点关注： 准备训练数据集（JSONL 格式）、理解 LoRA 和 QLoRA（参数高效微调）、在 OpenAI 上或用 HuggingFace 跑一次微调任务、把微调后的模型与基座模型做对比评估，以及知道什么时候微调并不值得那些成本
3. 开源模型
并不是所有东西都需要走 OpenAI 或 Anthropic。开源模型给你完全的控制权、没有 API 成本，还能在本地运行
资源：
1. Ollama（免费）
Link: https://ollama.ai/
一条命令在本地运行开源 LLM。支持 Llama、Mistral、Gemma 以及几十种其他模型。试用开源模型最快的方式
2. HuggingFace 模型中心（免费）
Link: https://huggingface.co/models
最大的开源模型仓库。浏览、下载并部署适用于任何任务的模型
3. vLLM（开源，免费）
Link: https://github.com/vllm-project/vllm
高吞吐的 LLM 推理引擎。比朴素的 HuggingFace 服务方式快 2–4 倍。是开源模型生产级服务的标准
重点关注： 用 Ollama 在本地跑模型做测试、理解量化（GGUF、GPTQ、AWQ）以及它为何对部署很重要、在你的用例上对开源模型和 API 模型做基准对比，以及用 vLLM 在生产中服务模型
4. 推理优化
让模型在生产环境中跑得更快、更便宜
资源：
1. HuggingFace：优化 LLM 推理（免费）
Link: https://huggingface.co/docs/transformers/llm_optims
涵盖 KV-cache 优化、量化和批处理策略
2. NVIDIA TensorRT-LLM（免费）
Link: https://github.com/NVIDIA/TensorRT-LLM
在 NVIDIA GPU 上获得极致的推理性能。大多数大规模生产环境的 LLM 服务都在用它
重点关注： 为提升吞吐的批处理策略、为降低内存与成本的量化、为加快生成速度的 KV-cache 优化，以及为你的推理负载选择合适的硬件
方向 3：AI 自动化工程师
如果你想立刻为企业做事情，这是最好的选择
这个方向是用 AI 自动化真实的业务流程。更偏向解决运营问题，而不是构建产品
重点关注：
- 工作流编排
- 业务流程自动化
- 多工具系统
- CRM、文档、邮件、客服、运维等场景
这个月要学什么：
1. 工作流编排
真实的企业自动化几乎从来不是一次 LLM 调用，而是跨越多个系统的一连串动作
资源：
1. n8n（开源，可免费自托管）
Link: https://docs.n8n.io/
带 AI 节点的可视化工作流自动化。把 LLM 接到 400 多个集成上（Slack、Gmail、Notion、各类 CRM 等）。AI 自动化领域最好的无代码/低代码选择
2. LangGraph：多智能体工作流（免费）
Link: https://langchain-ai.github.io/langgraph/concepts/multi_agent/
面向复杂多智能体系统的代码优先编排。当 n8n 不够用、你需要完全的编程控制时用它
3. Temporal（开源，免费）
Link: https://docs.temporal.io/
面向长时间运行、容错流程的持久化工作流引擎。当你的自动化需要在崩溃、重试和超时中存活时用它
重点关注： 设计能优雅处理失败的工作流、把 AI 接到真实的业务工具上（邮件、CRM、数据库、电子表格）、构建人在环的审批步骤，以及为每一次自动化动作记录日志以便审计
2. 业务流程自动化
AI 自动化里的钱，在于解决具体且昂贵的业务问题
资源：
1. Zapier AI Actions（免费额度）
Link: https://zapier.com/ai
无需代码就把 AI 接到 6,000 多个应用上。适合在构建定制方案之前先做自动化原型
2. Make（Integromat）（免费额度）
Link: https://www.make.com/
支持高级逻辑和 AI 集成的可视化自动化平台。对复杂工作流来说比 Zapier 更强大
重点关注： 识别 ROI 最高的自动化目标（通常是重复、耗时、基于规则的任务）、构建增强人类而不是取代人类的自动化，以及衡量实际节省的时间和金钱
3. CRM、文档、邮件、客服自动化
最常见也最有价值的 AI 自动化用例
资源：
1. OpenAI Cookbook：AI 驱动的邮件处理（免费）
Link: https://github.com/openai/openai-cookbook
用 AI 对邮件做分类、路由和回复的模式
2. LangChain：文档处理流水线（免费）
Link: https://python.langchain.com/docs/how_to/#document-loaders
从 80 多个来源导入并处理文档
重点关注： 构建一个 AI 驱动的邮件分类器与自动回复、创建能从文档中抽取结构化数据的处理流水线、构建一个在你的知识库上使用 RAG 的客服机器人，以及把 AI 集成进现有的 CRM 工作流（HubSpot、Salesforce 等）
方向 3 的练习项目： 构建一个端到端的线索资格评估（lead qualification）系统。它应该：
从某个来源（CSV、API 或表单）抓取或导入线索
用 LLM 对每一条线索做调研（公司信息、匹配度评估）
基于你的 ICP 为线索打分并排序
起草个性化的触达消息
把所有内容记录到电子表格或 CRM 中 这是一个真实、可出售的自动化方案，企业确实会为它付钱
⏩------------------------------------------------------------------------⏪
结论
这 6 个月之后你能期待什么？？？
我要跟你说实话，不掺一点水分的实话
这份路线图不会让你在 6 个月内成为资深（senior）AI 工程师
但它会让你成为一个能够构建、交付并部署真正解决真实问题的 AI 系统的人
而在当下，这正是市场愿意付钱买的东西
对 AI 工程师的需求并没有放缓。职位发布数量同比增长了 25%
PwC 发现，要求 AI 技能的岗位相比同样但不要求 AI 技能的岗位，薪资溢价达 56%
只有 1% 的公司被认为是“AI 成熟”的，这意味着 99% 的公司仍然需要帮助。美国劳工统计局预测到 2034 年该领域就业将增长 26%
这些不是炒作出来的数字。这是基于分析得出的真实数字（从 Claude 那儿拿的，嘿嘿）
如果你在美国全职工作：
初级 AI 工程师起薪为 90,000–130,000 美元
**中级（3–5 年）**大约在 155,000–200,000 美元
资深岗位可达 195,000–350,000 美元以上
根据 Glassdoor（2026 年 3 月）的数据，平均值为 184,757 美元
中级薪资区间增长最快，同比增速 9.2%，因为公司极度需要那些不用时刻盯着就能交付生产级 AI 的人
如果你更想做自由职业：
AI 智能体开发报价 175–300 美元/小时
RAG 实现报价 150–250 美元/小时
LLM 集成报价 125–200 美元/小时
Reddit 上有一位开发者为一家律所两周内做出了文档摘要工具，赚了 8,000 美元。一位按 150 美元/小时、每周接 25 小时活的自由职业者，一年能拿到 195,000 美元
如果你走咨询路线（也就是我在之前那篇文章里讲过的），你可以收取：
300–5,000 美元来为一家企业搭建 AI 智能体
500–2,000 美元/月做 AI 内容管理
1,000–4,000 美元做客服自动化
500–2,000 美元做冷启动触达搭建
服务的光谱还要更宽，但一旦你掌握了这份路线图里的技能，你在 2026 年就已经是一位被需要的专家了
这些都是真实的人做真实的工作所得到的真实数字
现在，我真正希望你能从这里带走的是：
每个月挑一个项目，把它做出来。不是读一读它。不是看个教程。把它做出来、弄坏它、修好它、部署它、放到 GitHub 上。被录用的是那些展示自己做过什么的人，而不是展示自己学过什么的人
开始分享你学到的东西。在 X、LinkedIn，任何地方写出来。教是学得最快的方式，同时还建立了你的声誉。我见过的最好的机会，都来自那些“被看见”的人，而不是那些投了 500 份职位申请的人
还有，请不要等到你觉得自己准备好了。你永远不会觉得自己准备好了。在“我在学习”和“我在构建”之间的那道缝隙里，大多数人一辈子卡在那儿
一旦你有了能跑的项目，就开始投递、开始做自由职业、开始提供服务。哪怕它们并不完美。市场不奖励完美。它奖励那些能交付的人
如果你真的投入去做，6 个月足以改变一切
而且我真心相信，读到这里你们每一个人都做得到
只要永远不要停止构建，永远不要停止学习
希望这些内容对你有用，我的家人 ❤️