如何在 6 个月内成为一名 AI 工程师（资源汇总）

AI 工程已迅速成为科技领域最有价值的技能之一

问题在于，大多数初学者并不清楚自己到底该学什么

有些人从机器学习理论开始

有些人陷入无休止的看教程中

还有些人直接跳进提示词和 Agent，却不理解 API、后端基础，或者真实产品到底是怎么构建的

结果通常都一样：混乱一大堆，实际技能却很少

如果你的目标是成为一名 AI 工程师，你不需要掌握人工智能的每一个领域

你需要学习的是如何在现实世界中构建有用的 AI 系统

这意味着要学会如何：

• 使用大语言模型构建端到端的应用
• 使用模型 API（如 OpenAI 和 Anthropic）
• 正确设计提示词和上下文
• 使用结构化输出和工具调用
• 在需要时添加检索功能
• 部署项目，让人们真正能用上

这份指南旨在为你提供一份实用的 6 个月学习路线图

本文超过 10,000 字，阅读可能需要几小时甚至更久

但它的真正价值在于：对于你需要学习的每项技能，都提供了资源和清晰的操作说明

这样一来，六个月内你就能达到 AI 工程的水平，并且在头 1-2 个月内就能开始自己使用

写这篇文章花了超过 40 小时，我和我的朋友 @andy_ai0 一起合作完成

他刚开始在 X 上建立个人品牌，但对 AI 理解很深，对这篇文章帮助很大

我绝对认为他值得你的关注和支持

现在开始阅读文章 ⬇️

AI 工程师到底做什么

很多人听到“AI 工程师”这个词，就想象有人在从头训练巨型模型

实际上，大多数现代 AI 工程师做的事情要实际得多

他们在现有模型之上构建产品和系统

通常包括：

• 连接 LLM API
• 设计提示词和上下文流程
• 构建聊天、搜索或自动化系统
• 集成工具、数据库和外部 API
• 处理结构化输出
• 提高可靠性、成本和延迟
• 将 AI 功能部署到真实应用中

所以实践中，AI 工程师常常处于以下领域的交叉点：

• 软件工程
• 产品工程
• 自动化
• 应用 AI

这就是为什么这个角色增长如此之快

公司不仅需要研究人员

他们需要能把模型转化为有用产品的人

这也是为什么这份路线图更侧重于实践执行，而不是繁重的理论

如果你能构建真正的 LLM 应用、检索系统、自动化和生产级工作流，你已经比大多数初学者更接近就业了

⏩------------------------------------------------------------------------⏪

第 1 个月：扎实掌握编码和基础知识

你这个月的目标：成为一个能用的 Python 开发者

你不需要成为专家，只需要不再需要谷歌基础语法，并能自信地构建简单程序

AI 工程首先是软件工程

后面几个月的一切都假设你能写出干净的 Python 代码、使用终端、调用 API 以及管理代码库。这个月是你的基础

要学什么

1. Python

Python 是 AI 工程的语言。没有之一。你在接下来六个月里遇到的几乎所有库、API 和教程都是用 Python 写的

如何学习：

从一个结构化的课程开始，迫使你写代码，而不仅仅是看视频

初学者最常见的错误就是被动地消费内容，跟着读、点头，却从不打开代码编辑器

通过边学边写每个例子来克服这个毛病

资源：

1. Python for Everybody（Coursera，免费旁听）

链接：https://www.coursera.org/specializations/python

对完全新手来说最好的起点。Dr. Chuck 是互联网上最友好的 Python 老师之一

2. freeCodeCamp Python 课程（YouTube，免费）

链接：https://www.youtube.com/watch?v=rfscVS0vtbw

一个 4 小时的综合视频，涵盖所有基础知识

3. CS50P：Python 编程入门（哈佛，免费）

链接：https://cs50.harvard.edu/python/

更严谨。包含习题集和最终项目。如果你想要结构化学习，这个很不错

4. 官方 Python 文档（教程部分）

链接：https://docs.python.org/3/tutorial/

比较枯燥但权威，用作参考

需要重点关注：

• 变量、数据类型、循环、条件语句、函数
• 列表、字典、集合、元组
• 文件 I/O 和 JSON 操作
• 类与基础 OOP（足够理解你在读什么即可）
• 用 try/except 进行错误处理
• 虚拟环境（venv）和 pip
• 包管理——理解 requirements.txt

练习项目：用 Python 构建一个简单的命令行工具。比如一个个人记账工具，能读写 JSON 文件，或者一个脚本调用公共 API（如天气 API）并打印格式化结果

2. Git 和 GitHub

Git 是专业开发者保存和分享代码的方式。你会经常用到它：进行版本控制、协作、在 GitHub 上展示你的组合项目

如何学习：

Git 一开始令人困惑，因为其思维模型不明显

不要试图记忆命令，而是要理解 Git 解决的是什么问题（跟踪变更、支持协作、让你撤销错误），这样命令自然就合理了

资源：

1. GitHub Skills（免费，互动式）

链接： https://skills.github.com/

GitHub 官方内置的互动课程。从这里开始

2. Learn Git Branching（免费，互动式）

链接： https://learngitbranching.js.org/

绝对是理解分支和合并的最佳可视化工具

3. Pro Git 书（免费在线书）

链接： https://git-scm.com/book/en/v2

全面的参考书。跳到你需要的章节

需要重点关注：

• git init, add, commit, push, pull
• 分支与合并
• 理解 .gitignore
• 在 GitHub 上创建仓库并推送本地项目
• 读写基本的 README 文件

练习： 从现在开始，你构建的每一个项目，甚至小脚本，都应该存放在 GitHub 仓库中。这能培养习惯，并为你提供作品集

3. CLI / 终端基础

作为 AI 工程师，你会完全在命令行中运行脚本、安装包、管理服务器和导航文件

在终端中速度慢或害怕会成为真正的瓶颈

资源：

1. 最流行的 50 个 Linux 和终端命令（完整初学者课程）

链接： https://www.youtube.com/watch?v=ZtqBQ68cfJc

适合 Linux/Mac 的完全初学者

2. 你计算机教育中缺失的一学期（MIT，免费）

链接： https://missing.csail.mit.edu/

涵盖 shell 脚本、终端工具和大多数 CS 课程跳过的命令行熟练度

需要重点关注：

• 导航：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（免费）

链接： https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Overview

对 HTTP 请求和响应如何工作的最清晰解释

2. REST API 教程

链接： https://restfulapi.net/

简短而实用

3. Python requests 库文档

链接： https://requests.readthedocs.io/en/latest/

学习如何在 Python 中调用任何 Web API

4. Python async/await（免费）

链接：https://realpython.com/async-io-python/

理解 async 对于后面处理流式 LLM 响应至关重要

需要重点关注：

• GET、POST 请求——它们是什么，如何在 Python 中发出
• 读写 JSON
• HTTP 状态码（200、400、401、404、500——各表示什么）
• API 密钥是什么以及基本认证模式
• async def 和 await 的作用以及它们存在的原因

练习项目： 写一个 Python 脚本，调用一个免费公共 API（试试 Open-Meteo 获取天气数据——不需要 API 密钥），并将结果格式化为干净的 JSON 输出

5. 基础 SQL 和 Pandas

你不需要成为数据科学家，但你会经常需要检查、查询和操作数据

SQL 基础和 Pandas 熟练度会节省你大量时间

资源：

1. SQLBolt（免费，互动式）

链接： https://sqlbolt.com/

从零开始学习 SQL 的最快方式。20 节短课，含浏览器内练习

2. Pandas 官方入门指南

链接： https://pandas.pydata.org/docs/getting_started/index.html

用 10 分钟 Pandas 教程过一遍

3. Kaggle Pandas 课程（免费）

链接： https://www.kaggle.com/learn/pandas

动手实践，实用，简短

需要重点关注：

• SQL：SELECT, WHERE, GROUP BY, JOIN, ORDER BY
• Pandas：加载 CSV、过滤行、选择列、基本聚合

6. FastAPI

资源：

1. FastAPI 官方教程（免费）

链接：https://fastapi.tiangolo.com/zh/tutorial/

真的是有史以来最好的框架文档之一

从头到尾学一遍。涵盖路径参数、请求体、Pydantic 验证和运行开发服务器

2. Python API 开发（19 小时课程，freeCodeCamp，YouTube，免费）

链接： https://www.youtube.com/watch?v=ZtqBQ68cfJc

涵盖 API 设计基础，包括路由、序列化、模式验证和 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 的官方指南。之后，提示词工程指南会整合所有内容

按顺序依次完成这三个——每个都会强化其他

资源：

1. Anthropic 互动式提示工程教程（免费，GitHub）

链接： https://github.com/anthropics/prompt-eng-interactive-tutorial

一个分步课程，分为 9 章，带练习，旨在让你有多次机会练习编写和调试提示词

作为 Jupyter 笔记本运行，使用 Claude API

2. Anthropic 提示工程文档（免费）

链接： https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview

官方参考。涵盖从基本清晰度到 XML 结构化和 Agent 系统的一切

3. OpenAI 提示工程指南（免费）

链接： https://platform.openai.com/docs/guides/prompt-engineering

OpenAI 的官方指南，涵盖与其模型配合良好并能产生更有用输出的提示格式

4. [PromptingGuide.ai](//PromptingGuide.ai)（免费）

链接： https://www.promptingguide.ai/

涵盖从基本提示到高级策略的基本技术，以及函数调用、工具集成和 Agent 系统

需要重点关注： 系统消息和用户消息的区别，为什么具体性很重要，思维链提示（一步步思考），在提示中使用例子（少样本学习），以及小的措辞变化如何显著改变输出质量

练习： 选择一个真实任务——总结文档、从文本中提取关键信息、对一条反馈进行分类——并写 5 个不同的提示。比较输出。你会立即看到提示设计对可靠性的影响

3. 结构化输出 / JSON Schema

在真实应用中，你几乎从不需要 LLM 的原始文本，你需要的是能够解析、存储并在代码中使用的结构化数据

结构化输出通过强制模型匹配你定义的模式来解决这个问题

资源：

1. OpenAI 结构化输出指南（官方文档，免费）

链接： https://platform.openai.com/docs/guides/structured-outputs

涵盖确保模型始终生成符合你 JSON Schema 的响应的功能，这样你就不需要担心缺失键或幻觉值

2. Instructor 库（免费，开源）

链接： https://python.useinstructor.com/

从任何 LLM 提供商获取结构化输出的最简洁方式，使用 Pydantic 模型

使用相同的代码接口支持 OpenAI、Anthropic、Google 以及超过 15 个其他提供商，在验证失败时自动重试

这是大多数生产 AI 工程师实际使用的工具

3. OpenAI Cookbook：结构化输出入门（免费）

链接： https://developers.openai.com/cookbook/examples/structured_outputs_intro/

涵盖思维链输出、结构化数据提取和 UI 生成的实用例子，适合理解实际用例

需要重点关注： 为数据定义 Pydantic 模型、将模式传递给 API、理解结构化输出和 JSON 模式的区别，以及优雅处理拒绝

练习项目： 构建一个发票或收据解析器。给它原始文本（例如 "Invoice #123, $45.99 for 3 widgets, due March 30"），让它返回一个结构化的 Python 对象，包含 invoice_number、amount、items、due_date 等字段

4. 函数 / 工具调用

工具调用是将 LLM 从文本生成器转变为能够采取行动的实体的关键——搜索网络、查询数据库、调用你的 API、运行代码。这是整个指南中最重要的技能之一

如何理解： 模型实际上并不执行你的函数

它会检查提示词，当它决定应该使用某个工具时，会返回一个结构化的调用，包含函数名和参数

你的代码随后执行该调用并将结果发送回去

资源：

1. OpenAI 函数调用指南（官方文档，免费）

链接： https://platform.openai.com/docs/guides/function-calling

权威参考。涵盖定义工具、5 步调用流程、并行调用和最佳实践

2. Anthropic 工具使用文档（免费）

链接： https://docs.anthropic.com/en/docs/build-with-claude/tool-use

Anthropic 针对 Claude 的等价指南。概念相同，语法略有不同

3. OpenAI Cookbook：如何使用聊天模型调用函数（免费，GitHub）

链接： https://github.com/openai/openai-cookbook/blob/main/examples/How_to_call_functions_with_chat_models.ipynb

一个完整的可运行笔记本，通过真实例子带你走完整个工具调用循环

需要重点关注： 用 JSON Schema 清晰地描述函数、解析工具调用响应、执行函数并反馈结果、处理不需要工具调用的情况，以及 tool_choice: "auto" 的概念

练习项目： 构建一个简单的助手，它有三个工具：get_weather(city)、calculate(expression) 和 search_notes(query)（只需搜索一个硬编码的字典）。将它们全部连接起来，观察模型根据你问的内容决定调用哪个

5. 流式响应

流式意味着在生成模型输出时逐字显示，而不是等待完整响应。它能让你的应用感觉更快、更有活力

资源：

1. OpenAI 流式文档（官方，免费）

链接： https://platform.openai.com/docs/api-reference/streaming

在请求中添加 stream=True 并迭代数据块的参考

2. Anthropic 流式文档（官方，免费）

链接： https://docs.anthropic.com/en/api/messages-streaming

Anthropic 的流式 API 参考，包含 Python 例子

3. 流式 LLM API 如何工作 – Simon Willison（免费）

链接： 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 指南，管理对话（官方，免费）

链接： https://platform.openai.com/docs/guides/conversation-state

对 messages 数组如何工作以及如何管理多轮对话的权威解释

2. Anthropic Messages API 文档（官方，免费）

链接： https://docs.anthropic.com/en/api/messages

Anthropic 的等价文档。概念相同，值得阅读两者以了解差异

需要重点关注： messages 数组结构，为什么你要同时追加用户和助手消息，上下文窗口限制以及超出时会发生什么，以及基本的截断策略（丢弃最旧的消息，总结历史）

练习项目： 在终端中构建一个简单的多轮聊天机器人。每一轮都追加到 messages 列表中。添加 /reset 命令清除历史，并在每次交流后打印当前 token 数量

6. 成本、延迟和 Token 基础

在不理解成本和 token 的情况下发布 AI 应用，会导致意外账单和缓慢的应用。这很无聊但至关重要

资源：

1. OpenAI 定价页面（官方）

链接： https://openai.com/api/pricing

知道每个模型的输入和输出 token 成本。收藏它，并在选择模型时查看

2. Anthropic 定价页面（官方）

链接： https://www.anthropic.com/pricing

Claude 模型相同

3. OpenAI Tokenizer 工具（免费，互动式）

链接： https://platform.openai.com/tokenizer

粘贴任何文本，立即看到它有多少 token。在学习过程中经常使用它

4. Tiktoken（Python 库，免费）

链接： https://github.com/openai/tiktoken

OpenAI 的 tokenizer 库，用于在发送请求之前在代码中计算 token 数量

需要重点关注： 什么是 token（大约 4 个字符 / 3/4 个单词），输入和输出 token 如何定价不同，上下文窗口大小如何影响你能做什么，以及较小较快模型与较大较智能模型之间的延迟权衡

另外：不要对所有事情都用 GPT-4/Opus——更便宜的模型对于简单任务通常已经足够好

7. 错误处理

LLM API 会失败。可能遇到速率限制、响应超时、模型返回格式错误的 JSON。优雅地处理失败是区分演示应用和生产应用的标志

资源：

1. OpenAI 错误码参考（官方，免费）

链接： https://platform.openai.com/docs/guides/error-codes

你会遇到的每种错误类型以及如何处理

2. Anthropic 错误处理文档（官方，免费）

链接： https://docs.anthropic.com/en/api/errors

Claude 相同

3. Tenacity（Python 库，免费）

链接： https://tenacity.readthedocs.io/

一个简洁的库，用于为任何 Python 函数添加带有指数退避的重试逻辑。一个装饰器就能处理重试

需要重点关注： 速率限制错误（429）和指数退避，使用 httpx/requests 处理超时，在使用模型输出之前进行验证，回退策略（用不同的模型重试，返回缓存响应），以及永远不要让 LLM 返回意外输出导致应用崩溃

8. 提示注入意识

提示注入是 LLM 应用中的 #1 安全风险

当不受信任的用户输入与系统指令混合时，用户能够更改、覆盖或向提示中注入新行为，导致系统执行非预期操作或生成被操纵的输出

你不需要成为安全专家，但你在发布任何东西之前需要知道这个风险存在

资源：

1. OWASP LLM 应用十大风险 – LLM01：提示注入（免费）

链接: https://genai.owasp.org/llmrisk/llm01-prompt-injection/

权威分类，涵盖直接注入（越狱）、通过文档或网页等外部内容的间接注入，以及真实世界的攻击场景

2. OWASP 提示注入防御速查表（免费）

链接: https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html

实用的防御模式：输入验证、权限控制和输出验证

3. Evidently AI：什么是提示注入（免费）

链接: https://www.evidentlyai.com/llm-guide/prompt-injection-llm

一份面向开发者的清晰解释，涵盖攻击类型、风险以及缓解攻击的设计模式

重点关注： 直接注入和间接注入之间的区别，为什么系统提示并非真正“安全”，工具访问的最小权限原则，以及永远不要信任未经验证的 LLM 输出来自动做出关键决策

第 2 个月里程碑

到本月底，你应该能够：

• 编写能够为特定任务生成一致、可靠输出的提示
• 使用 Pydantic + Instructor 从任何模型获取结构化的 JSON 数据
• 配置工具调用，让模型能够调用你的 Python 函数
• 通过 FastAPI 端点实时流式传输响应
• 正确管理多轮对话历史
• 在发送请求前估算其 token 成本
• 处理 API 错误、超时和不良输出而不会崩溃
• 解释什么是提示注入并应用基本防御措施

⏩------------------------------------------------------------------------⏪

第 3 个月：深入学习 RAG

本月目标：构建能够根据文档回答问题，而不仅仅依赖训练数据的系统

到月底，你应该能够摄入文档，进行嵌入和存储，在查询时检索正确的文本块，并生成基于事实、准确且可引用的答案

RAG 是目前 AI 工程中最热门的实用技能。几乎所有真实的企业级 AI 用例——客服机器人、内部知识库、文档问答系统——都构建在它之上

深入理解它，而不仅仅是复制教程，这才是区分优秀工程师和普通工程师的关键

1. 嵌入

在构建 RAG 系统之前，你需要理解嵌入到底是什么——因为它是其他一切的基础

文本嵌入是将一段文本投影到高维向量空间中的过程

文本在该空间中的位置由一长串数字表示

关键在于，语义相似的文本在空间中会彼此靠近——这正是实现相似性搜索的基础

资源：

1. Stack Overflow 博客：文本嵌入的直观介绍（免费）

链接: https://stackoverflow.blog/2023/11/09/an-intuitive-introduction-to-text-embeddings/

最适合初学者的解释。由一位多年构建 NLP 产品的开发者撰写，重点在于建立正确的直觉而非数学公式

2. Google ML 速成课程：嵌入（免费）

链接: https://developers.google.com/machine-learning/crash-course/embeddings

涵盖为什么密集向量表示能够解决独热编码无法解决的问题——具体来说，是捕捉项目之间的语义关系

3. HuggingFace：嵌入入门（免费）

链接: https://huggingface.co/blog/getting-started-with-embeddings

实操指南。展示如何使用 sentence-transformers 库生成嵌入，托管它们，并将其用于真实 FAQ 数据集的语义搜索

4. OpenAI 嵌入指南（官方文档，免费）

链接: https://platform.openai.com/docs/guides/embeddings

在代码中使用 OpenAI 的 text-embedding-3-small 和 text-embedding-3-large 模型的参考指南

重点关注： 向量在概念上是什么，为什么相似文本会产生相似向量，余弦相似度如何工作，不同嵌入模型（OpenAI、HuggingFace sentence-transformers）之间的区别，以及嵌入维度在实践中意味着什么

实践： 取 20 个相关主题的句子，使用 OpenAI 或 sentence-transformers 进行嵌入，并编写一个简单的最近邻搜索，返回与查询最相似的 3 个句子。这本质上就是缩微版的 RAG 核心

2. 分块

你的文档太大，无法整体嵌入。分块是在嵌入之前将文档分解成更小片段的过程

你如何对文档进行分块直接影响系统查找相关信息并提供准确答案的能力——即使完美的检索系统，如果在质量差的数据上进行搜索，也会失败

资源：

1. Weaviate：RAG 分块策略（免费）

链接: https://weaviate.io/blog/chunking-strategies-for-rag

最实用的指南。涵盖固定大小、递归和语义分块，并针对每种方法何时使用给出清晰建议

2. Unstructured：RAG 分块最佳实践（免费）

链接: https://unstructured.io/blog/chunking-for-rag-best-practices

关于分块大小、重叠以及嵌入模型的上下文窗口如何施加硬限制的技术深度挖掘

一个不错的实验起点是约 250 个 token（约 1000 个字符）的分块大小，并在相邻块之间设置 10-20% 的重叠，以避免在边界处丢失上下文

3. LangChain 文本分割器文档（官方，免费）

链接: 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 官方文档（免费）

链接: https://docs.trychroma.com/

Chroma 非常适合优先考虑开发速度和简单性的个人开发者和小团队，它在内存中或本地运行，无需管理任何基础设施

2. Pinecone 学习中心（免费）

链接: https://www.pinecone.io/learn/

优秀的免费教程，涵盖向量搜索概念、混合搜索和 RAG 流水线。即使你不使用 Pinecone，这些与供应商无关的内容也很有用

3. Qdrant 文档（免费）

链接: https://qdrant.tech/documentation/

最适合需要高级过滤的生产环境的开源方案。非常快速、灵活，且可以免费自托管

4. pgvector（开源，免费）

链接: https://github.com/pgvector/pgvector

如果你正在构建已经使用 PostgreSQL 的项目，pgvector 可以直接将向量搜索添加到现有数据库中，无需新的基础设施

重点关注： 创建集合，插入带有元数据的嵌入，使用 top_k 进行相似性查询，以及在查询时按元数据进行过滤

你不需要理解索引算法（HNSW、IVF）——只需要理解如何使用它们

练习项目： 将任何公开文档（如 Python 文档或 Wikipedia 文章转储）的 50-100 页索引到 Chroma 中，并附带元数据（来源 URL、章节标题）。编写一个查询函数，能够针对任何问题检索最相关的 5 个块

4. 元数据过滤

单独的原始相似性搜索对于实际应用来说是不够的。元数据过滤允许你将检索限制到相关的子集——按日期、来源、文档类型、用户、类别或你随每个块存储的任何其他属性

资源：

1. Pinecone：元数据过滤指南（免费）

链接: https://docs.pinecone.io/guides/data/filter-with-metadata

清晰的解释，附带代码示例，演示如何在相似性搜索之前或期间按元数据字段过滤向量

2. LlamaIndex：元数据过滤指南（官方文档，免费）

链接: https://docs.llamaindex.ai/en/stable/module_guides/querying/node_postprocessors/node_postprocessors/

解释了如何在 LlamaIndex 流水线中的查询时应用过滤器

重点关注： 在摄入时用相关元数据标记每个块（源文件名、页码、章节、日期、类别），并在查询时使用这些字段过滤结果。这就是玩具演示和真实生产系统之间的区别——在真实系统中，用户可以询问“只显示 2025 年第四季度到 2026 年第一季度报告中的结果”

5. 重新排序

重新排序是一种技术，可以为任何关键字或向量搜索系统的搜索质量添加语义提升

在第一阶段检索返回候选集之后，重新排序器会根据与查询的真正上下文相关性（而不仅仅是向量接近度）重新对这些结果进行评分

两阶段模式是：嵌入并搜索（快速，近似）→ 重新排序 top-k（较慢，更准确）。结果是检索质量显著提高，而延迟成本仅略有增加

资源：

1. Cohere 重新排序文档（官方，免费）

链接: https://docs.cohere.com/docs/reranking-with-cohere

最好的入门点。涵盖完整的重新排序工作流程，包括像邮件和 JSON 文档这样的半结构化数据。只需一行代码即可添加到现有的检索流水线中

2. LangChain：Cohere 重新排序器集成（官方文档，免费）

链接: https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/

解释了如何使用 ContextualCompressionRetriever 将 Cohere 重新排序连接到 LangChain 检索器中

重点关注： 先检索后重新排序的两阶段模式，双编码器（用于第一阶段嵌入搜索）和交叉编码器（用于重新排序）之间的区别，以及重新排序 top-20 与 top-5 结果之间的实际延迟和质量权衡

6. 检索质量问题

大多数 RAG 失败并非模型失败，而是检索失败。理解检索可能出错的方式对于调试真实系统至关重要

要学习的常见问题：

• 语义漂移： 查询嵌入与相关块的嵌入不匹配，即使信息就在那里。修复：尝试查询重写或 HyDE（假设文档嵌入）
• 块边界问题： 相关信息分布在两个块中。修复：增加重叠或使用语义分块
• 缺失元数据上下文： 块在语义上与查询相似，但属于错误的文档、日期或用户。修复：使用元数据过滤
• top-k 太小： 正确的块存在，但不在检索到的前 5 个结果中。修复：在检索时增加 top_k，并在重新排序后减少

资源：

1. LangChain：查询转换（免费）

链接: https://python.langchain.com/docs/how_to/#query-analysis

涵盖查询重写、后退提示和 HyDE

2. Pinecone：提高检索质量（免费）

链接: https://www.pinecone.io/learn/retrieval-augmented-generation/#retrieval-quality

常见失败模式及其修复方法的实用演练

7. 减少幻觉

与普通的 LLM 相比，RAG 显著减少了幻觉，但并没有完全消除幻觉

通过在运行时向模型提供检索到的事实，RAG 将其回答锚定在真实来源上，而不仅仅是依赖训练数据，并且模型的输出甚至可以引用这些来源，从而增加透明度和信任度

但是，检索失败、不良块和相互矛盾的信息仍然可能导致模型编造内容

资源：

1. Zep：减少 LLM 幻觉——开发者指南（免费）

链接: https://www.getzep.com/ai-agents/reducing-llm-hallucinations/

实用的开发者聚焦指南，涵盖提示接地策略、用于事实性任务的思维链以及输出验证模式

2. Voiceflow：减少 LLM 幻觉的 5 种方法（免费）

链接: https://www.voiceflow.com/blog/prevent-llm-hallucinations

很好的概述，介绍了组合策略：RAG + 思维链 + 护栏组合起来优于任何单一方法

重点关注： 提示模型仅根据提供的上下文回答（当答案不存在时回答“我不知道”），在呈现响应之前添加置信度阈值，以及在指责 LLM 之前始终验证检索质量

8. 引用与接地

一个接地的 RAG 系统不仅回答问题——它还会告诉你答案来自哪里。这对于用户信任和调试至关重要

资源：

1. Anthropic：为 Claude 提供来源（文档，免费）

链接: https://docs.anthropic.com/en/docs/build-with-claude/citations

解释了如何提示 Claude 生成带有来源引用的引用式响应

2. LangChain：带来源的 RAG（免费）

链接: https://python.langchain.com/docs/how_to/qa_sources/

解释了如何在 LangChain RAG 流水线中返回答案的同时返回源文档

重点关注： 将块元数据（源文件名、页码、URL）传递到提示上下文中，指示模型在答案中引用来源，并在你的 UI 或 API 响应中展示这些来源

9. 你的 RAG 框架：LangChain 或 LlamaIndex

你不需要从头开始构建 RAG 流水线。有两个框架主导着这个领域，值得了解：

LlamaIndex 优化了搜索和索引优先——它将摄入、分块、嵌入和查询抽象成几行代码，让你可以在一个下午构建出一个可工作的原型

当你的应用程序更像一个编排引擎时，LangChain 表现出色——它擅长多 Agent 工作流、工具调用和条件链，在生成答案之前查询多个 LLM 或外部 API

在第 3 个月，从 LlamaIndex 开始学习 RAG。当你在第 4 个月开始学习 Agent 工作时，再转向 LangChain

资源：

1. LlamaIndex：RAG 简介（官方文档，免费）

链接: https://developers.llamaindex.ai/python/framework/understanding/rag/

涵盖 RAG 的五个关键阶段：加载、索引、存储、查询和评估——以及 LlamaIndex 如何处理每个阶段

2. LlamaIndex 入门教程（官方文档，免费）

链接: https://developers.llamaindex.ai/python/framework/getting_started/starter_example/

官方快速入门。在不到 30 行代码中构建一个可工作的 RAG 系统

3. LangChain：构建 RAG Agent（官方文档，免费）

链接: https://docs.langchain.com/oss/python/langchain/rag

展示如何使用 RAG Agent 构建一个针对非结构化文本的问答应用，从 40 行的最小版本到包含重新排序的完整检索流水线

练习项目： 构建一个“与你的文档聊天”应用。摄入 10-20 个 PDF 或文本文件（你自己的笔记、教科书章节、产品文档——任何内容）。构建一个 FastAPI 端点，接受一个问题，检索包含重新排序的最相关 5 个块，并从 Claude 或 OpenAI 返回带有引用的答案。这是一个真正的作品集项目

第 3 个月里程碑

到本月底，你应该能够：

• 解释什么是嵌入以及为什么相似文本会产生相似向量
• 使用适当的策略智能地分块任何文档
• 在带有元数据过滤的向量数据库中存储和查询嵌入
• 添加重新排序步骤以提高检索质量
• 系统地调试常见的检索失败
• 使用 LlamaIndex 或 LangChain 构建一个完整的端到端 RAG 流水线，能够摄入文档、检索相关块，并返回基于事实、带引用的答案

⏩------------------------------------------------------------------------⏪

第 4 个月：Agent、工具、工作流和评估

本月目标：构建能够自主执行一系列动作、编排多步骤工作流，并严格评估其运行效果的 AI 系统

到月底，你应该能够从头构建一个真实的 Agent，理解何时 Agent 是错误的解决方案，并衡量你构建的任何内容的性能

这是 AI 工程真正变得复杂的地方。第 4 个月的技能将初级 AI 工程师与能够端到端掌控整个 AI 功能的人区分开来

1. Agent 循环

Agent 并不神奇，它是一个出奇简单的模式

将 Agent 视为目标驱动型系统，它们不断循环进行观察、推理和行动

这个循环使它们能够处理超出简单问答的任务，进入真正的自动化、工具使用和实时自适应领域

“思考”发生在提示中，“分支”发生在 Agent 在可用工具之间进行选择时，“执行”发生在我们调用外部函数时。其他一切只是管道

一旦你内化了这一点，即使是最复杂的 Agent 框架也变得易于理解

资源：

1. Anthropic：构建高效的 Agent（官方，免费）

链接: https://www.anthropic.com/research/building-effective-agents

关于生产环境中 Agent 的最佳文章。在编写一行 Agent 代码之前先阅读本文

2. OpenAI：构建 Agent 实用指南（官方 PDF，免费）

链接: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

OpenAI 的补充指南，涵盖生产环境中的 Agent 模式、护栏和安全模式

3. freeCodeCamp：开源 LLM Agent 手册（免费）

链接: https://www.freecodecamp.org/news/the-open-source-llm-agent-handbook/

一份全面的实践指南，涵盖 Agent 循环、LangGraph、CrewAI、规划、记忆和工具使用。适合快速上手实践

4. LangChain Academy：LangGraph 入门（免费课程）

链接: https://academy.langchain.com/courses/intro-to-langgraph

LangGraph 的官方免费课程，LangGraph 是使用最广泛的 Agent 编排框架。涵盖状态、记忆、人机协同等内容

重点关注： 感知 → 规划 → 行动 → 观察循环，Agent 循环如何终止，当工具调用在循环内失败时会发生什么，以及为什么 Agent 只是带 LLM 进行分支决策的 while 循环

实践： 不依赖任何框架，直接使用 OpenAI 或 Anthropic API 从头构建一个 Agent。给它 3 个工具、一个目标和一个循环。这是你真正理解框架在抽象什么的最有价值的事情

2. 工具选择

编写好的工具是成功的一半。你的工具及其参数的描述是 LLM 的用户手册。如果手册含糊不清，LLM 会误用工具。要力求精确、详尽、毫不含糊

描述不当的工具会被错误调用、在错误的时间调用或被完全忽略。描述得当的工具行为可预测，能够在各种输入下被正确选择

资源：

1. OpenAI：函数调用最佳实践（官方文档，免费）

链接: https://platform.openai.com/docs/guides/function-calling/best-practices

编写可靠工具描述的权威指南，包含命名约定和参数文档模式

2. Anthropic：工具使用最佳实践（官方文档，免费）

链接: https://docs.anthropic.com/en/docs/build-with-claude/tool-use/implement-tool-use#best-practices-for-tool-definitions

Anthropic 的对应指南。特别关注关于何时让模型选择与何时强制使用特定工具的指导

重点关注： 编写解释性动词作为工具名称，编写解释何时调用工具（而不仅仅是它做什么）的描述，保持参数最少且类型良好，以及以确保 LLM 为调用者来设计工具

初学者提示： 通过问自己以下问题来测试每个工具描述：“如果我没有文档，只有这个 JSON schema，我能否准确知道何时以及如何调用它？”如果不能，则需要更多工作

3. 状态管理

在 LangGraph 中，状态是一个共享的内存对象，它在图中流动。它存储所有相关信息——消息、变量、中间结果和决策历史——并在整个执行过程中自动管理

理解状态是构建能够处理多轮任务、从故障中恢复以及组件之间干净交接的 Agent 的关键

资源：

1. LangGraph 官方文档：状态管理（免费）

链接: https://langchain-ai.github.io/langgraph/concepts/low_level/#state

重点关注： 在图的节点之间定义和传递状态，使用 StateGraph 和 MessageState 的内置模式

权威参考。涵盖状态模式、reducers 以及状态如何通过节点和边流动

2. DataCamp：LangGraph Agents 教程（免费）

链接： https://www.datacamp.com/tutorial/langgraph-agents

通过动手代码讲解状态、节点和边的基础知识，逐步构建具有跨会话持久内存的有状态 Agent

3. Real Python：Python 中的 LangGraph（免费）

链接： https://realpython.com/langgraph-python/

一个详尽的教程，构建了一个完整的有状态 LangGraph Agent，并对状态图和条件边进行了详细解释

重点学习： 使用 TypedDict 定义状态模式，reducers 如何合并并行更新，内存状态与持久化检查点的区别，以及通过在执行过程中检查和修改状态来实现的人机协同暂停机制

4. Agent 的重试与失败处理

Agent 的失败方式与常规 LLM 调用不同。循环中一个糟糕的工具调用可能会破坏状态、导致无限循环，或悄无声息地产生错误答案。你需要针对所有这些情况制定明确的策略

资源：

1. LangGraph：错误处理与重试（官方文档，免费）

链接： https://langchain-ai.github.io/langgraph/how-tos/autofill-tool-errors/

解释了如何在 LangGraph 的工具节点级别添加自动错误处理和重试逻辑

2. OpenAI 实用 Agent 指南：护栏部分（免费）

链接： https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

将护栏作为分层防御机制，结合基于 LLM 的检查、基于规则的过滤器（如正则表达式）和审核 API，在 Agent 循环的每个阶段审查输入和输出

重点学习： 防止无限循环的最大迭代次数限制，每个工具使用指数退避策略进行重试，在工具执行层捕获和记录异常而不导致 Agent 崩溃，以及何时向用户报告失败与何时静默重试

5. 何时不使用 Agent

这是 AI 工程中最重要但也最容易被忽视的技能之一。Agent 虽然令人兴奋，但它们也缓慢、昂贵、不可预测且难以调试。知道何时选择更简单的方案是良好判断力的体现

Anthropic 建议找到最简单的解决方案，仅在必要时增加复杂性——这可能意味着根本不构建 Agent 系统

Agent 系统用延迟和成本换取更好的任务性能，你需要仔细权衡这种取舍是否合理

决策框架如下：

• 如果任务可以在一个提示中，配合正确的上下文解决，则使用单次 LLM 调用
• 如果步骤是固定且可预测的，则使用工作流
• 仅当步骤数量真正不可预测且需要动态决策时，才使用 Agent

资源：

1. Anthropic：构建高效 Agent，何时使用 Agent（官方，免费）

链接： https://www.anthropic.com/research/building-effective-agents

来自构建模型的团队，对这个问题的权威解答

2. Simon Willison：设计 Agent 循环（免费）

链接： https://simonwillison.net/2025/Sep/30/designing-agentic-loops/

一位资深工程师关于何时 Agent 的复杂性是合理的，以及如何思考 Agent 循环设计的实用见解

需要牢记： 一个由 3 次固定 LLM 调用组成的链，总是比一个可能进行 3 次调用的 Agent 更快、更便宜、更易于调试。将 Agent 保留给真正开放式的任务

6. 多步骤工作流

在“单次提示”和“完整 Agent”之间，存在着一个广阔且高效的生产力中间地带：工作流。当任务可以清晰地分解为固定的子任务时，工作流是理想选择——通过使每个单独的 LLM 调用成为更简单、更专注的任务，以延迟换取更高的准确性

常见模式包括：提示链（一个调用的输出是下一个调用的输入）、路由（对输入进行分类并发送到专门的处理器）、并行化（同时运行多个调用并聚合结果）以及编排器-子 Agent（一个 LLM 负责规划，其他负责执行）

资源：

1. Anthropic：工作流模式（官方，免费）

链接： https://www.anthropic.com/research/building-effective-agents#workflow-patterns

涵盖所有主要模式，并附有图表和代码示例。并行化和编排部分尤其有用

2. LangGraph：多 Agent 网络（官方文档，免费）

链接： https://langchain-ai.github.io/langgraph/concepts/multi_agent/

解释了如何将多个 Agent 作为网络连接起来，包括监督者和交接模式

实践项目： 构建一个 3 步内容处理管线：

步骤 1 – 一个 LLM 从文章中提取关键事实

步骤 2 – 另一个 LLM 调用使用这些事实，并行生成一条推文、一篇 LinkedIn 帖子和一份摘要

步骤 3 – 最后一个 LLM 调用对这三项内容进行质量评分并选出最佳

无需 Agent，纯工作流

7. 评估框架

评估是你了解 AI 系统是否真正有效的方式——不是仅凭你手动测试的几个例子，而是系统地跨数百个输入进行测试

AI Agent 功能强大但部署复杂，因为它们概率性的、多步骤的行为引入了许多潜在的故障点

Agent 的不同部分——LLM、工具、检索器和工作流——各自需要自己的评估方法

资源：

1. DeepEval（开源，免费）

链接： https://deepeval.com/docs/getting-started

一个受 pytest 启发的开源 LLM 评估框架。编写包含输入和预期输出的测试用例，使用 50 多种内置指标（包括幻觉、答案相关性和事实一致性）运行它们，并捕获版本间的回归

2. Promptfoo（开源，免费）

链接： https://github.com/promptfoo/promptfoo

一个用于测试和评估 LLM 应用的 CLI 和库，支持自动化测试套件。支持跨多个模型对多个提示进行并排比较、CI/CD 集成以及针对安全漏洞的红队测试

3. LangSmith（免费层级）

链接： https://smith.langchain.com/

用于 LangChain 和 LangGraph 应用的追踪、调试和评估。免费层级慷慨，其追踪 UI 能极大简化 Agent 循环的调试

4. Ragas（开源，免费）

链接： https://docs.ragas.io/

专门用于 RAG 管线的评估框架。衡量忠实度、答案相关性、上下文精确度和上下文召回率。如果你从第 3 个月开始评估 RAG 系统，这是必不可少的

重点学习： 构建一个包含 20-50 个代表性输入及其预期输出或评分标准的黄金测试集，编写能够确定性评分（字符串匹配、JSON 模式验证）或使用 LLM 作为评判者进行评分的评估函数，并在更改提示或切换模型时自动运行评估

关键心态： 评估不是可选的锦上添花。每次更改提示、切换模型或调整检索参数而不运行评估，都是在赌博。能够交付可靠 AI 产品的工程师会持续运行评估

8. 任务成功指标

除了自动化评估，你还需要能够告诉你 Agent 是否正在完成其实际目标的指标

资源：

1. Hamel Husain：你的 AI 产品需要评估（免费）

链接： https://hamel.dev/blog/posts/evals/

关于为真实生产 AI 系统构建评估管线的最实用文章之一，作者曾大规模实践过

2. OpenAI Evals 框架（开源，免费）

链接： https://github.com/openai/evals

OpenAI 自己的评估框架，拥有大量社区贡献的评估模式库，可供你借鉴

重点学习： 过程指标（Agent 是否调用了正确的工具？）与结果指标（任务是否成功？）之间的区别，在构建任何东西之前明确定义成功标准，以及使用 LLM 作为评判者来评估难以精确匹配的输出（如长文答案或多步推理过程）

实践项目： 拿你第 3 个月的 RAG 管线，围绕它构建一个合适的评估框架。从你的文档中创建 30 个问答对，通过你的管线运行它们，并使用 DeepEval 对每个答案的相关性、忠实度和完整性进行评分。然后更改一个参数（块大小、模型、top-k），重新运行以查看是否有所改进

第 4 个月里程碑

到本月底，你应该能够：

• 解释什么是 Agent 循环，并在没有框架的情况下从头实现一个
• 编写能够被正确且可靠地选中的工具描述
• 使用 LangGraph 或等效工具正确管理 Agent 状态
• 处理 Agent 循环内的故障而不导致崩溃
• 自信地判断一个任务是需要 Agent、工作流还是单次提示
• 构建能够链接、路由和并行化 LLM 调用的多步骤工作流
• 编写自动化评估，在更改提示或模型时捕获回归
• 为你构建的任何 AI 系统定义和衡量任务成功指标

⏩------------------------------------------------------------------------⏪

第 5 个月：部署、产品思维和可靠性

你这个月的目标：让你构建的一切都达到生产就绪状态

到月底，你应该能够部署一个能够处理真实用户、真实流量和真实故障，而不会在凌晨 2 点崩溃的 AI 应用

这是大多数 AI 工程师停滞不前的地方。他们可以构建一个很棒的演示，但无法交付一个能在现实世界中生存的产品

这里的技能是公司真正愿意付费的：可靠性、安全性、成本控制，以及在问题不可避免地发生时保持系统运行的能力

1. FastAPI 生产模式

你已经知道如何从第 1 个月开始构建一个 FastAPI 应用。现在你需要让它能够承受生产流量

开发环境和生产环境之间的差异是残酷的。一个带有 --reload 的单一 uvicorn 进程对于构建来说没问题。但在生产环境中，一旦真实流量到来，它就会成为瓶颈

你实际需要的是：多工作进程 ASGI 配置、适当的错误处理中间件、健康检查端点和 CORS 策略

资源：

1. FastAPI 部署文档（官方，免费）

链接： https://fastapi.tiangolo.com/deployment/

涵盖 Uvicorn 工作进程、Gunicorn 和 Docker 部署的官方指南。在查看其他内容之前，先从这里开始

2. FastAPI 生产部署指南（CYS 文档，免费）

链接： https://craftyourstartup.com/cys-docs/fastapi-production-deployment/

全面的生产模式：Gunicorn 配置、Nginx 反向代理、健康检查、速率限制。包含你可以直接使用的真实配置文件

3. FastAPI 生产最佳实践（FastLaunchAPI，免费）

链接： https://fastlaunchapi.dev/blog/fastapi-best-practices-production-2026

涵盖异步数据库连接池、Redis 缓存、JWT 认证和后台任务。来自一个被 100 多名开发者使用的真实模板的生产验证模式

重点学习： 使用 Gunicorn 配合 Uvicorn 工作进程（而不是裸 Uvicorn），设置健康检查端点，添加 CORS 中间件，实现正确的异步数据库会话，以及使用后台任务处理任何不需要阻塞响应的操作

2. Docker

Docker 是你停止说“在我机器上能跑”并开始交付一致部署的方式

如果你正在构建 AI 应用，Docker 可以解决依赖冲突，确保环境一致，并使扩展变得简单

你不需要成为 Docker 专家。你需要能够将你的 FastAPI + LLM 应用容器化并部署到任何地方

资源：

1. Docker 官方入门指南（免费）

链接： https://docs.docker.com/get-started/

权威的起点。涵盖镜像、容器、Dockerfile 和 Docker Compose

2. freeCodeCamp：如何使用 Python 和 Docker 构建和部署多 Agent AI 系统（免费）

链接： https://www.freecodecamp.org/news/build-and-deploy-multi-agent-ai-with-python-and-docker/

实用的端到端教程，使用 Docker Compose 构建一个真实的多 Agent 管线。涵盖关注点分离、cron 调度和安全考虑

3. DataCamp：使用 Docker 部署 LLM 应用（免费）

链接： https://www.datacamp.com/tutorial/deploy-llm-applications-using-docker

专门针对带有 RAG 管线的 LLM 应用的分步指南。涵盖 Dockerfile 创建、环境管理和部署

4. LLM 应用的 Docker 容器化（ApXML，免费）

链接： https://apxml.com/courses/python-llm-workflows/chapter-10-deployment-operational-practices/containerization-docker-llm-apps

涵盖基础镜像选择、依赖管理、多阶段构建以及用于多服务 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 官方入门指南（免费）

链接： https://docs.celeryq.dev/en/stable/getting-started/introduction.html

标准的 Python 任务队列。涵盖基本设置、任务定义和工作进程管理

2. FastAPI 后台任务文档（官方，免费）

链接： https://fastapi.tiangolo.com/tutorial/background-tasks/

内置的轻量级后台任务，适用于简单用例。对于快速“即发即忘”的任务使用这个，对于更重的任务使用 Celery

重点学习：理解何时使用 FastAPI 的内置 BackgroundTasks 与像 Celery 这样的正式任务队列，设置 Redis 作为消息代理，处理任务失败和重试，以及向用户返回任务状态

4. 认证和 API 密钥安全

如果你的 AI 应用有 API，它需要认证。没有认证，任何人都可以使用你的端点，消耗你的 LLM 额度，你会醒来看到一张 5000 美元的账单

资源：

1. FastAPI 安全文档（官方，免费）

链接： https://fastapi.tiangolo.com/tutorial/security/

涵盖 OAuth2、JWT 令牌、API 密钥和基于依赖注入的认证模式。官方参考，请完成整个教程

2. OWASP API 安全 Top 10（免费）

链接： https://owasp.org/API-Security/

API 安全风险的权威列表。在交付任何东西之前，理解认证失效、注入和批量赋值问题

3. Auth0：API 认证最佳实践（免费）

链接： https://auth0.com/docs/get-started/authentication-and-authorization

在 API 中实现认证和授权的实用指南

重点学习： 用于用户认证的 JWT 令牌，用于服务间通信的 API 密钥管理，按用户/密钥进行速率限制，绝不将密钥存储在代码中（使用环境变量），以及理解认证（你是谁）和授权（你能做什么）之间的区别

5. 日志记录和可观测性

在生产环境中，如果你看不到发生了什么，你就无法修复已损坏的东西

LLM 应用面临一个独特的挑战：模型可以返回 200 状态码，但仍然产生无用或幻觉的回答。传统的监控无法捕捉到这一点。你需要针对 LLM 的可观测性

资源：

1. Langfuse（开源，免费层级）

链接： https://langfuse.com/docs/observability/overview

开源 LLM 可观测性平台。追踪每个请求：发送的提示、收到的响应、令牌使用量、延迟、工具调用。支持提示版本管理、评估和 LLM 作为评判者的评分。与 OpenAI、Anthropic、LangChain、LlamaIndex 集成

2. LangSmith（免费层级）

链接： https://smith.langchain.com/

来自 LangChain 团队。如果你正在使用 LangChain/LangGraph，设置只需一个环境变量。追踪、调试、监控仪表盘和在线评估。免费层级对于开发和小规模生产来说足够慷慨

3. Python Structlog（免费）

链接： https://www.structlog.org/

Python 的结构化日志记录。生成真正可搜索和可解析的 JSON 日志。对于生产应用来说，远优于 print() 或基本日志记录

重点学习： 追踪每个 LLM 调用（输入提示、输出、令牌数、延迟、成本），使用 JSON 输出的结构化日志记录，设置显示请求量、错误率和每日成本的仪表盘，以及在出现故障或成本飙升时发出警报

6. 提示和版本管理

在生产环境中，你的提示就是代码。它们需要版本控制、测试和回滚能力

在生产环境中更改提示而不跟踪你更改了什么，是导致系统损坏且无法查明原因的方式

资源：

1. Langfuse 提示管理（免费）

链接： https://langfuse.com/docs/prompts

集中式提示版本管理，带有内置的测试游乐场。将你的提示与应用程序代码分开进行版本控制。部署提示更改而无需重新部署你的应用

2. Anthropic 提示管理最佳实践（免费）

链接： https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview

大规模组织、迭代和管理提示的最佳实践

重点学习：将提示存储在应用程序代码之外，对每个提示更改进行版本控制，在生产环境中对提示变体进行 A/B 测试，以及在新提示表现更差时制定回滚策略

7. 成本监控和速率限制

LLM API 按令牌收费。没有成本控制，流量激增或提示中的错误可能在几分钟内烧掉数百美元

资源：

1. OpenAI 使用仪表盘（官方）

链接： https://platform.openai.com/usage

按模型、按日跟踪支出，并设置使用限制

2. Anthropic 使用仪表盘（官方）

链接： https://console.anthropic.com/ 用于 Claude API 使用情况

3. Helicone（免费层级）

链接： https://www.helicone.ai/

基于代理的可观测性，捕获每个 LLM 调用并自动跟踪成本。一行代码即可设置：只需更改你的基础 URL

4. LiteLLM（开源，免费）

链接： https://github.com/BerriAI/litellm

100+ LLM 提供商的统一接口。包括预算管理、速率限制和跨提供商的支出跟踪

重点学习： 设置每日/每月的硬性支出限制，在你的 API 中实现按用户的速率限制，对简单任务使用更便宜的模型（不要对所有事情都使用 GPT-4/Opus），使用 Redis 缓存重复的相同请求，以及监控每次请求的成本以尽早发现昂贵的提示

8. 缓存

如果 20% 的用户问类似的问题，你就是在为同一个 LLM 调用付费 20 次

缓存是同时降低成本和延迟的最简单方法

资源：

1. Redis 官方文档（免费）

链接： https://redis.io/docs/

标准的内存数据存储。快速、简单，非常适合 LLM 响应缓存

2. GPTCache（开源，免费）

链接： https://github.com/zilliztech/GPTCache

专门为 LLM 应用设计的语义缓存。使用嵌入相似性来查找语义相似（不仅仅是完全相同）查询的缓存响应

重点学习： 针对相同提示的精确匹配缓存，针对相似查询的语义缓存，缓存失效策略（基于 TTL 是最简单的），以及衡量缓存命中率以了解真实的成本节省

第 5 个月里程碑

到本月底，你应该能够：

• 在 Docker 中部署一个具有适当生产配置的 FastAPI + LLM 应用
• 使用后台任务和队列处理长时间运行的任务
• 使用认证、速率限制和 API 密钥管理保护你的 API
• 使用 Langfuse 或 LangSmith 追踪和调试 LLM 调用
• 使用版本控制和回滚能力管理提示
• 实时监控成本并设置支出限制
• 缓存 LLM 响应以减少延迟和成本

⏩------------------------------------------------------------------------⏪

第 6 个月：专业化并成为可雇佣人才

你获得的知识和技能可以应用于三个方向（当然，这只是我所看到的）

你需要选择其中一个并专注于实践

尽管上面提到的所有内容最好也是通过纯粹实践来学习

方向 1：AI 产品工程师

如果你想要快速获得初创公司的工作，这是最佳选择

这是最常见的路径。你构建真实用户与之交互的 AI 驱动产品

你已经掌握了第 1-5 个月的大部分技能。现在在产品方面更深入

专注于：

• LLM 应用
• RAG
• Agent
• 部署
• 产品用户体验

这个月要学什么：

1. 端到端产品构建

停止构建教程。构建人们可以使用的产品

资源：

1. Vercel AI SDK（免费）

链接： https://sdk.vercel.ai/docs

构建支持流式传输的 AI 驱动用户界面的最快方式。React、Next.js 和 Vue 集成，带有内置的流式 UI 组件

2. Streamlit（免费）

链接： https://docs.streamlit.io/

用纯 Python 构建数据应用和 AI 演示。适用于内部工具和 MVP，但不适用于生产级 UI

3. Gradio（免费）

链接: https://www.gradio.app/docsQuick 用最少代码快速构建 ML/AI 界面。特别适合演示模型和搭建原型。

本月重点：完成 2-3 个完整的可演示项目。比如“与文档聊天”应用、AI 驱动的内部工具，或者能自动化真实工作流程的 Agent。发布它们。上传到 GitHub。部署到别人可以试用的地方。

2. 面向 AI 的产品用户体验

如果用户体验没有考虑到模型的局限性，AI 产品就会失败。

资源：

1. Google: People + AI Guidebook（免费）

链接: https://pair.withgoogle.com/guidebook/

设计人机交互的最佳资源。涵盖设定预期、处理错误和建立信任。

2. Nielsen Norman Group: AI UX Guidelines（免费）

链接: https://www.nngroup.com/topic/artificial-intelligence/

基于研究的 AI 界面设计指南。

本月重点：如何处理流式加载状态，模型出错时显示什么，如何让用户提供反馈，以及为 AI 输出的概率性（有时会出错）而设计。

方向 2：应用 ML / LLM 工程师

适合希望从事更深层技术角色的人。

这个方向适合那些想超越 API 调用、了解底层原理的工程师。

重点关注：

• 微调
• 何时微调 vs 提示工程
• 评估
• 推理优化
• 开源模型
• 训练流水线

本月学习内容：

1. 何时微调 vs 提示工程

应用 ML 中最重要的决策：你是需要改变模型，还是只需要改变与模型对话的方式？

资源：

1. Google ML Crash Course: Fine-tuning, Distillation, and Prompt Engineering（免费）

链接: https://developers.google.com/machine-learning/crash-course/llm/tuning

对三种方法及其各自适用场景的最清晰解释。

2. Codecademy: Prompt Engineering vs Fine-Tuning（免费）

链接: https://www.codecademy.com/article/prompt-engineering-vs-fine-tuning

实用的决策框架，并提供每种方法的明确用例。

3. IBM: RAG vs Fine-Tuning vs Prompt Engineering（免费）

链接: https://www.ibm.com/think/topics/rag-vs-fine-tuning-vs-prompt-engineering

覆盖完整的决策空间，包括何时组合使用这些方法。

需要记住的决策框架：从提示工程开始（最便宜、最快）如果模型需要访问特定数据，添加 RAG只有当提示+RAG 无法达到所需的质量、一致性或延迟时，才进行微调。

2. 微调实践

当你确实需要微调时，以下是操作方法。

资源：

1. OpenAI Fine-tuning Guide（官方，免费）

链接: https://platform.openai.com/docs/guides/fine-tuning

开始微调的最简单方法。上传 JSONL 数据集，运行作业，获得自定义模型。即使你以后转向开源模型，也适合学习工作流程。

2. HuggingFace Transformers Fine-tuning Tutorial（免费）

链接: https://huggingface.co/docs/transformers/training

用于处理开源模型的标准库。涵盖训练、评估和模型保存。

3. Unsloth（开源，免费）

链接: https://github.com/unslothai/unsloth

微调速度提升 2 倍，内存减少 80%。原生支持 LoRA 和 QLoRA。在消费级硬件上微调开源模型的最快途径。

4. LLaMA-Factory（开源，免费）

链接: 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（免费）

链接: https://ollama.ai/

一条命令即可本地运行开源 LLM。支持 Llama、Mistral、Gemma 等数十种模型。尝试开源模型的最快方式。

2. HuggingFace Model Hub（免费）

链接: https://huggingface.co/models

最大的开源模型仓库。浏览、下载和部署适用于任何任务的模型。

3. vLLM（开源，免费）

链接: https://github.com/vllm-project/vllm

高吞吐量 LLM 推理引擎。比朴素的 HuggingFace 服务快 2-4 倍。生产环境中开源模型服务的标准。

本月重点： 使用 Ollama 在本地运行模型进行测试，理解量化（GGUF、GPTQ、AWQ）及其对部署的重要性，针对你的用例对开源模型和 API 模型进行基准测试，以及使用 vLLM 在生产环境中提供模型服务。

4. 推理优化

让模型在生产环境中运行得更快、更便宜。

资源：

1. HuggingFace: Optimizing LLM Inference（免费）

链接: https://huggingface.co/docs/transformers/llm_optims

涵盖 KV-cache 优化、量化和批处理策略。

2. NVIDIA TensorRT-LLM（免费）

链接: https://github.com/NVIDIA/TensorRT-LLM

在 NVIDIA GPU 上实现最大推理性能。大多数大规模生产环境 LLM 服务都在使用。

本月重点： 用于提高吞吐量的批处理策略，用于减少内存和成本的量化，用于加快生成速度的 KV-cache 优化，以及为你的推理工作负载选择合适的硬件。

方向 3：AI 自动化工程师

适合希望立即为企业构建解决方案的人。

这个方向专注于使用 AI 自动化真实业务工作流程。更少地侧重于构建产品，更多地侧重于解决运营问题。

重点关注：

• 工作流程编排
• 业务流程自动化
• 多工具系统
• CRM、文档、邮件、支持、运营用例

本月学习内容：

1. 工作流程编排

真正的业务自动化几乎从来不是一次 LLM 调用就能完成的。它涉及跨多个系统的操作链。

资源：

1. n8n（开源，可自行托管，免费）

链接: https://docs.n8n.io/

带有 AI 节点的可视化工作流程自动化工具。将 LLM 连接到 400+ 个集成（Slack、Gmail、Notion、CRM 等）。用于 AI 自动化的最佳无代码/低代码选项。

2. LangGraph: Multi-Agent Workflows（免费）

链接: https://langchain-ai.github.io/langgraph/concepts/multi_agent/

面向复杂多 Agent 系统的代码优先编排工具。当 n8n 不够用时，你需要完全的程序化控制。

3. Temporal（开源，免费）

链接: https://docs.temporal.io/

用于长时间运行、容错流程的持久化工作流引擎。当你的自动化需要应对崩溃、重试和超时的情况。

本月重点： 设计能够优雅处理故障的工作流，将 AI 连接到真实的业务工具（邮件、CRM、数据库、电子表格），构建人工参与的审批环节，并记录每个自动化操作以供审计追踪。

2. 业务流程自动化

AI 自动化的价值在于解决具体且昂贵的业务问题。

资源：

1. Zapier AI Actions（免费层级）

链接: https://zapier.com/ai

无需代码即可将 AI 连接到 6000+ 个应用。适合在构建自定义解决方案之前进行自动化原型设计。

2. Make (Integromat)（免费层级）

链接: https://www.make.com/

具有高级逻辑和 AI 集成的可视化自动化平台。对于复杂工作流，它比 Zapier 更强大。

本月重点： 识别 ROI 最高的自动化目标（通常是重复、耗时且基于规则的任务），构建增强人类而非取代人类的自动化，并衡量实际节省的时间和金钱。

3. CRM、文档、邮件、支持自动化

最常见且最有价值的 AI 自动化用例。

资源：

1. OpenAI Cookbook: AI-Powered Email Processing（免费）

链接: https://github.com/openai/openai-cookbook

使用 AI 对邮件进行分类、路由和回复的模式。

2. LangChain: Document Processing Pipelines（免费）

链接: https://python.langchain.com/docs/how_to/#document-loaders

从 80+ 个来源提取和处理文档。

本月重点： 构建一个 AI 驱动的邮件分类器和自动回复器，创建一个能够提取结构化数据的文档处理流水线，构建一个基于知识库使用 RAG 的支持聊天机器人，以及将 AI 集成到现有的 CRM 工作流（HubSpot、Salesforce 等）中。

方向 3 的实践项目： 构建一个端到端的潜在客户资格认定系统。它应该：

• 从来源（CSV、API 或表单）抓取或导入潜在客户
• 使用 LLM 研究每个潜在客户（公司信息、匹配度评估）
• 根据你的理想客户画像（ICP）对潜在客户进行评分和排序
• 起草个性化的外联信息
• 将所有内容记录到电子表格或 CRM 中 这是一个真实的、可销售的自动化，企业确实会为此付费。

⏩------------------------------------------------------------------------⏪

结论

这 6 个月后你能期待什么？

老实说，不会有什么金山银山。

这个路线图不会让你在 6 个月内成为高级 AI 工程师。

但它会让你成为一个能够构建、发布和部署解决实际问题的真实 AI 系统的人。

而现在，这正是市场愿意付费的。

对 AI 工程师的需求并没有放缓。职位发布同比增长了 25%。

普华永道发现，需要 AI 技能的职位相比同级别不需要 AI 技能的职位，薪资溢价为 56%。

只有 1% 的公司被认为是“AI 成熟”的，这意味着 99% 的公司仍然需要帮助。美国劳工统计局预测到 2034 年岗位增长率为 26%。

这些不是炒作出来的数字。这是基于分析的真实数字（来自 Claude kek）。

如果你在美国全职工作：

初级 AI 工程师 起薪 $90,000-$130,000

中级（3-5 年） 在 $155,000-$200,000 之间

高级职位 达到 $195,000-$350,000+

根据 Glassdoor（2026 年 3 月），平均薪资为 $184,757

中级薪资区间增长最快，同比增长 9.2%，因为公司迫切需要能够独立交付生产级 AI 的人。

如果你更倾向于自由职业：

AI Agent 开发 每小时 $175-$300

RAG 实施 每小时 $150-$250

LLM 集成 每小时 $125-$200

Reddit 上的一位开发者用两周时间为一家律师事务所构建了一个文档摘要工具，赚了 $8,000。一位自由职业者按每周 25 小时、每小时 $150 计费，年收入为 $195,000。

如果你走咨询路线，正如我在之前文章中提到的，你可以收费：

为企业设置 AI Agent：$300-$5,000

AI 内容管理：每月 $500-$2,000

自动化客户支持：$1,000-$4,000

冷启动外联设置：$500-$2,000

服务范围甚至更广，但一旦你掌握了这个路线图中的技能，你在 2026 年就已经是备受追捧的专家了。

这些都是真实的人做真实工作得出的真实数字。

现在，我真正希望你们从这一切中带走的是：

每个月选择一个项目，然后去构建它。不是阅读它，不是看教程。去构建、破坏、修复、部署，并上传到 GitHub。能获得工作的工程师是那些展示他们构建了什么的人，而不是他们学习了什么的人。

开始分享你学到的东西。在 X、LinkedIn 或其他任何地方写下来。教学是最快的学习方式，同时也能建立你的声誉。我所见过的最好机会都来自那些保持可见度的人，而不是那些投了 500 份简历的人。

请不要等到你觉得自己准备好了。你永远不会觉得准备好。“我在学习”和“我在构建”之间的差距是大多数人永远困住的地方。

一旦你有了可工作的项目，就开始申请、开始自由职业、开始提供服务。即使它们不完美也没关系。市场不奖励完美。它奖励能够交付的人。

如果你真的付出努力，6 个月足以改变一切。

我真的相信读到这篇文章的每个人都能做到。

只要永不停止构建，永不停止学习。

希望这对我的家人们有用 ❤️