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

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

问题是，大多数初学者不知道他们究竟应该学习什么。有些人从机器学习理论开始，有些人无休止地观看教程，还有些人在不理解 API、后端基础知识或实际产品是如何构建的情况下，直接跳入了提示和代理。结果通常是相同的：大量的困惑和很少的实用技能。

如果你的目标是成为一名 AI 工程师，你不需要掌握人工智能的每一个领域。你需要学习如何在现实世界中构建有用的 AI 系统。这意味着要学习如何：

• 使用 LLM 构建端到端应用程序
• 使用 OpenAI 和 Anthropic 等模型 API
• 正确设计提示和上下文
• 使用结构化输出和工具调用
• 在需要时添加检索
• 部署项目，以便人们实际使用它们

本指南提供了一个实用的 6 个月路线图。对于你需要学习的每一项技能，都有资源和清晰的解释，让你可以在六个月内达到 AI 工程水平，并在前 1-2 个月内开始应用。

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 构建一个简单的 CLI 工具。例如，一个读取/写入 JSON 文件的个人费用追踪器，或者一个调用公共 API（例如天气 API）并打印格式化结果的脚本。

2. Git 和 GitHub

Git 是专业开发者保存和共享代码的方式。你将不断需要它来版本化你的项目、协作，并在 GitHub 上展示你的作品集。

如何学习：

Git 最初令人困惑，因为其心智模型不直观。不要试图记忆命令；相反，理解 Git 解决了什么问题（追踪更改、实现协作、允许撤销错误），然后这些命令就会变得有意义。

资源：

1. GitHub Skills (免费, 互动式) 链接: https://skills.github.com/ GitHub 内部构建的官方互动课程。从这里开始。
2. 学习 Git 分支 (免费, 互动式) 链接: 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. 你的计算机科学教育缺失的一学期 (麻省理工, 免费) 链接: https://missing.csail.mit.edu/ 涵盖了大多数 CS 课程跳过的 shell 脚本、终端工具和命令行熟练度。

关注点：

• 导航: cd, ls, pwd, mkdir, rm
• 读取文件: cat, less, grep
• 从终端运行 Python 脚本
• 环境变量
• 对 PATH 的基本理解

4. JSON, APIs, HTTP, 和 Async 基础

你将在第 2 个月的第一天开始调用 LLM API。这意味着你需要在接触 OpenAI 或 Anthropic 的 SDK 之前，理解 Web API 的工作原理。

资源：

1. HTTP 基础 – MDN Web Docs (免费) 链接: https://developer.mozilla.org/en-US/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/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 的官方指南。之后，提示工程指南（Prompt Engineering Guide）整合了所有内容。按顺序完成这三者——每一个都会加强其他。

资源：

1. Anthropic 互动式提示工程教程 (免费, GitHub) 链接: https://github.com/anthropics/prompt-eng-interactive-tutorial 一个分为 9 章的逐步课程，附带练习，旨在为你提供多次练习编写和调试提示的机会。使用 Claude API 将其作为 Jupyter notebooks 运行。
2. Anthropic 提示工程文档 (免费) 链接: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview 官方参考资料。涵盖从基本清晰度到 XML 结构和代理系统的一切。
3. OpenAI 提示工程指南 (免费) 链接: https://platform.openai.com/docs/guides/prompt-engineering OpenAI 的官方指南，涵盖了与其模型配合良好并能产生更有用输出的提示格式。
4. PromptingGuide.ai (免费) 链接: https://www.promptingguide.ai/ 涵盖从基本提示到高级策略的所有基本技术，以及函数调用、工具集成和代理系统。

关注点：系统消息和用户消息之间的区别，为什么特异性很重要，思维链 (chain-of-thought) 提示（逐步思考），在提示中使用示例（少样本 (few-shot)），以及措辞上的微小变化如何显著改变输出质量。

实践：选择一个实际任务——总结文档、从文本中提取关键信息、分类一段反馈——并为其编写 5 个不同的提示。比较输出。你将立即看到提示设计对可靠性的影响有多大。

3. 结构化输出 / JSON Schemas

在实际应用程序中，你几乎从不需要 LLM 的原始文本，你想要的是可以解析、存储和在代码中使用的结构化数据。结构化输出通过强制模型匹配你定义的 schema 来解决这个问题。

资源：

1. OpenAI 结构化输出指南 (官方文档, 免费) 链接: https://platform.openai.com/docs/guides/structured-outputs 涵盖了确保模型始终生成符合你的 JSON Schema 的响应的功能，因此你无需担心缺失的键或幻觉值。
2. Instructor 库 (免费, 开源) 链接: https://python.useinstructor.com/ 使用 Pydantic 模型从任何 LLM 提供商获取结构化输出的最简洁方式。与 OpenAI、Anthropic、Google 和其他 15+ 提供商使用相同的代码接口，并在验证失败时自动重试。这是大多数生产 AI 工程师实际使用的。
3. OpenAI Cookbook: 结构化输出介绍 (免费) 链接: https://developers.openai.com/cookbook/examples/structured_outputs_intro/ 实用示例涵盖了思维链输出、结构化数据提取和 UI 生成，有助于理解真实世界的用例。

关注点：为你的数据定义 Pydantic 模型，将 schema 传递给 API，理解结构化输出和 JSON 模式之间的区别，以及优雅地处理拒绝。

实践项目：构建一个发票或收据解析器。给它原始文本（例如“发票 #123, 45.99 美元用于 3 个小部件，3 月 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 到请求并迭代 chunk 的参考资料。
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 chunks，从片段组装完整响应，以及使用 StreamingResponse 将流式传输连接到 FastAPI 端点。

提示：对于面向用户的应用程序，流式传输几乎总是正确的选择。没有人愿意盯着加载旋转器 10 秒钟，等待完整的响应一次性出现。

5. 对话状态

LLM 是无状态的——它们在调用之间没有记忆。对话历史是你通过每次请求发送完整的消息列表来管理的。理解这一点是基础。

资源：

1. OpenAI 聊天补全指南，管理对话 (官方, 免费) 链接: https://platform.openai.com/docs/guides/conversation-state 规范地解释了 messages 数组如何工作以及如何管理多轮对话。
2. Anthropic 消息 API 文档 (官方, 免费) 链接: https://docs.anthropic.com/en/api/messages Anthropic 的等效文档。概念相同，值得阅读两者以了解它们之间的差异。

关注点：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 分词器工具 (免费, 互动式) 链接: https://platform.openai.com/tokenizer 粘贴任何文本，准确查看它有多少Token。学习过程中不断使用此工具。
4. Tiktoken (Python 库, 免费) 链接: https://github.com/openai/tiktoken OpenAI 的分词器库，用于在发送请求之前在代码中计算Token。

关注点：Token是什么（大致 4 个字符 / 3/4 个单词），输入Token和输出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. 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

你本月的目标：构建能够让 LLM 从你的文档中回答问题，而不仅仅是根据它们的训练数据回答问题的系统。

到本月末，你应该能够摄取文档，嵌入并存储它们，在查询时检索正确的片段，并生成有依据、准确且可引用的答案。

RAG 是当前 AI 工程领域最受欢迎的实用技能。几乎每一个真实的企业 AI 用例——客户支持机器人、内部知识库、文档问答——都是建立在它之上的。

深入理解它，而不仅仅是复制教程，是区分优秀工程师和卓越工程师的关键。

1. 嵌入 (Embeddings)

在构建 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/llm/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. 分块 (Chunking)

你的文档太大了，无法作为一个整体进行嵌入。分块是在嵌入之前将其分解为更小片段的过程。

你如何对文档进行分块直接影响你的系统查找相关信息和给出准确答案的能力，即使完美的检索系统在处理准备不当的数据时也会失败。

资源：

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（约 1,000 个字符），并结合连续分块之间 10-20% 的重叠，以避免在边界处丢失上下文。

3. LangChain 文本分割器文档 (官方, 免费) 链接: https://python.langchain.com/docs/concepts/text_splitters/ 在代码中使用 RecursiveCharacterTextSplitter、MarkdownTextSplitter 和语义分割器的实用参考。

关注点：以重叠的固定大小分块作为基线，用于结构化文档的递归分块，用于更好边界检测的语义分块，以及核心权衡：过大的分块会降低检索精度；过小的分块会丢失上下文。

初学者提示：从 LangChain 的 RecursiveCharacterTextSplitter 开始，设置 chunk_size=500 和 chunk_overlap=50。这对于大多数文档来说是最合理的默认值，并为你提供一个可以改进的工作基线。

3. 向量数据库 (Vector Databases)

一旦有了嵌入，就需要一个地方来高效存储和搜索它们。这就是向量数据库的作用。

正确的选择取决于你的情况：使用 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 文档或维基百科文章转储）中的 50-100 页连同元数据（源 URL、章节标题）索引到 Chroma 中。编写一个查询函数，用于为任何问题检索 5 个最相关的片段。

4. 元数据过滤 (Metadata Filtering)

仅靠原始相似性搜索不足以满足实际应用。元数据过滤允许你将检索限制到相关的子集——按日期、来源、文档类型、用户、类别或你与每个分块一起存储的任何其他属性。

资源：

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. 重排序 (Reranking)

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

在第一阶段检索返回候选集后，重排序器会根据对查询的真实上下文相关性——而不仅仅是向量邻近度——重新评估这些结果。

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

资源：

1. Cohere 重排序文档 (官方, 免费) 链接: https://docs.cohere.com/docs/reranking-with-cohere 最好的起点。涵盖了完整的重排序工作流，包括半结构化数据，如电子邮件和 JSON 文档。只需一行代码即可添加到现有检索管道中。
2. LangChain: Cohere Reranker 集成 (官方文档, 免费) 链接: https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/ 解释了如何使用 ContextualCompressionRetriever 将 Cohere 重排序连接到 LangChain 检索器中。

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

6. 检索质量问题

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

要学习的常见问题：

• 语义漂移 (Semantic drift)：查询嵌入与相关块嵌入不匹配，即使信息在那里。解决方法：尝试查询重写 (query rewriting) 或 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. 幻觉减少 (Hallucination Reduction)

RAG 相比于普通 LLM 显著减少了幻觉，但并未完全消除它们。

通过在运行时向模型提供检索到的事实，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. 引用和 grounding (Citations and Grounding)

一个已接地的 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 在你的应用程序更像一个编排引擎时表现出色——它擅长多代理工作流、工具调用和条件链，这些链在生成答案之前查询多个 LLM 或外部 API。

对于第 3 个月，从 LlamaIndex 开始构建 RAG。当你到第 4 个月代理工作时，再转向 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 代理 (官方文档, 免费) 链接: https://docs.langchain.com/oss/python/langchain/rag 展示了如何使用 RAG 代理在非结构化文本上构建一个问答应用程序，从 40 行的最小版本到带有重排序的完整检索管道。

实践项目：构建一个“与你的文档聊天”应用程序。摄取 10-20 个 PDF 或文本文件（你自己的笔记、教科书章节、产品文档——任何东西）。构建一个 FastAPI 端点，接收一个问题，检索 5 个最相关的分块并进行重排序，然后返回 Claude 或 OpenAI 提供的有引用的答案。这是一个真正的作品集。

第 3 个月里程碑

到本月末，你应该能够：

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

第 4 个月：代理、工具、工作流和评估 (Evals)

你本月的目标：构建能够自主执行一系列动作、连接多步骤工作流的 AI 系统，并批判性地评估它们是否有效。

到本月末，你应该能够从头开始构建一个真实的代理，理解何时代理是错误的选择，并衡量你构建的任何系统的性能。

这是 AI 工程真正复杂的地方。第 4 个月的技能是区分初级 AI 工程师和能够独立负责整个 AI 功能的人的关键。

1. 代理循环 (Agent Loops)

代理并非魔法，它是一个出奇简单的模式。

将代理视为目标驱动的系统，它们不断循环进行观察、推理和行动。这个循环使它们能够处理超越简单问答的任务，进入真正的自动化、工具使用和即时适应。

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

一旦你内化了这一点，即使最复杂的代理框架也会变得易读。

资源：

1. Anthropic: 构建高效代理 (官方, 免费) 链接: https://www.anthropic.com/research/building-effective-agents 关于生产中代理的最佳文章。在编写任何代理代码之前阅读此文。
2. OpenAI: 构建代理的实用指南 (官方 PDF, 免费) 链接: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf OpenAI 的补充指南，涵盖生产中的代理模式、护栏和安全模式。
3. freeCodeCamp: 开源 LLM 代理手册 (免费) 链接: https://www.freecodecamp.org/news/the-open-source-llm-agent-handbook/ 一个全面的实用指南，涵盖代理循环、LangGraph、CrewAI、规划、内存和工具使用。适合快速上手。
4. LangChain Academy: LangGraph 介绍 (免费课程) 链接: https://academy.langchain.com/courses/intro-to-langgraph 最广泛使用的代理编排框架 LangGraph 的官方免费课程。涵盖状态、内存、人机交互等。

关注点：感知 → 计划 → 行动 → 观察循环，代理循环如何终止，当工具调用在循环中失败时会发生什么，以及为什么代理只是一个 while 循环，其中 LLM 做出分支决策。

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

2. 工具选择 (Tool Selection)

编写好的工具占工作的一半。你的工具及其参数的描述是 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. 状态管理 (State Management)

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

理解状态是构建能够处理多轮任务、从故障中恢复并在组件之间干净切换的代理的关键。

资源：

1. LangGraph 官方文档: 状态管理 (免费) 链接: https://langchain-ai.github.io/langgraph/concepts/low_level/#state 权威参考资料。涵盖状态模式、reducer 以及状态如何流经节点和边。
2. DataCamp: LangGraph 代理教程 (免费) 链接: https://www.datacamp.com/tutorial/langgraph-agents 涵盖状态、节点和边的基础知识以及动手代码，构建具有跨会话持久内存的有状态代理。
3. Real Python: Python 中的 LangGraph (免费) 链接: https://realpython.com/langgraph-python/ 一个全面的教程，构建一个完整的有状态 LangGraph 代理，详细解释了状态图和条件边。

关注点：使用 TypedDict 定义状态模式，reducer 如何工作以合并并行更新，内存中状态与持久化检查点之间的区别，以及人机交互暂停如何通过检查和修改执行中的状态来工作。

4. 代理中的重试和错误处理 (Retries and Failure Handling in Agents)

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

资源：

1. LangGraph: 错误处理与重试 (官方文档, 免费) 链接: https://langchain-ai.github.io/langgraph/how-tos/autofill-tool-errors/ 解释了如何在 LangGraph 的工具节点级别添加自动错误处理和重试逻辑。
2. OpenAI 实用代理指南: 护栏部分 (免费) 链接: https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf 涵盖了护栏作为分层防御，结合基于 LLM 的检查、基于规则的过滤器（如正则表达式）和审查 API，以在代理循环的每个阶段审查输入和输出。

关注点：最大迭代限制以防止无限循环，带指数退避的每个工具重试，在不使代理崩溃的情况下在工具执行层捕获和记录异常，以及何时将故障显示给用户而不是默默重试。

5. 何时不使用代理 (When NOT to Use Agents)

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

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

代理系统以延迟和成本换取更好的任务性能，你应该仔细考虑这种权衡何时有意义。

决策框架是：

• 如果任务可以通过一个带有正确上下文的提示解决，则使用单个 LLM 调用。
• 如果步骤是固定的和可预测的，则使用工作流。
• 仅当步骤数量真正不可预测且需要动态决策时才使用代理。

资源：

1. Anthropic: 构建高效代理，何时使用代理 (官方, 免费) 链接: https://www.anthropic.com/research/building-effective-agents 这个问题的最权威答案，直接来自构建模型的团队。
2. Simon Willison: 设计代理循环 (免费) 链接: https://simonwillison.net/2025/Sep/30/designing-agentic-loops/ 一位资深工程师对何时代理复杂性是合理的以及如何思考代理循环设计的实用看法。

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

6. 多步骤工作流 (Multi-Step Workflows)

在“单个提示”和“完整代理”之间，存在一个巨大的富有成效的中间地带：工作流。当任务可以清晰地分解为固定子任务时，工作流是理想选择——通过使每个单独的 LLM 调用更容易、更集中，从而以延迟换取更高的准确性。

常见模式包括提示链（一个调用的输出是下一个调用的输入）、路由（分类输入并发送到专用处理器）、并行化（同时运行多个调用并聚合）以及协调器-子代理（一个 LLM 规划，其他执行）。

资源：

1. Anthropic: 工作流模式 (官方, 免费) 链接: https://www.anthropic.com/research/building-effective-agents#workflow-patterns 涵盖了所有主要模式，附有图表和代码示例。并行化和编排部分特别有用。
2. LangGraph: 多代理网络 (官方文档, 免费) 链接: https://langchain-ai.github.io/langgraph/concepts/multi_agent/ 用于复杂多代理系统的代码优先编排，带有监督者和移交模式。

实践项目：构建一个 3 步内容管道： 第 1 步 – 一个 LLM 从文章中提取关键事实。 第 2 步 – 另一个 LLM 调用使用这些事实并行生成推文、领英帖子和摘要。 第 3 步 – 最终的 LLM 调用评估所有三个的质量并选择最佳的一个。 不需要代理，纯粹的工作流。

7. 评估工具 (Evaluation Harnesses)

评估是你了解你的 AI 系统是否实际工作的方式——不仅仅是你手动测试的示例，而是在数百个输入中系统地进行。

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

代理的不同部分——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 使调试代理循环变得异常容易。
4. Ragas (开源, 免费) 链接: https://docs.ragas.io/ 专门用于 RAG 管道的评估框架。衡量忠实度、答案相关性、上下文精度和上下文召回率。如果你正在评估第 3 个月的 RAG 系统，这是必不可少的。

关注点：构建一个包含 20-50 个具有代表性的输入以及预期输出或评估标准的小金库测试集，编写能确定性地评估输出的评估函数（字符串匹配、JSON schema 验证）或使用 LLM 作为评估者，并在更改提示或模型时自动运行评估。

关键心态：评估不是可有可无的修饰。你在没有运行评估的情况下所做的每一个提示更改、模型切换或检索调整都是一场赌博。发布可靠 AI 产品的工程师会持续运行评估。

8. 任务成功指标 (Task Success Metrics)

除了自动化评估之外，你还需要指标来判断你的代理是否真正实现了其目标。

资源：

1. Hamel Husain: 你的 AI 产品需要评估 (免费) 链接: https://hamel.dev/blog/posts/evals/ 由一位在大规模实践中完成过此任务的人撰写，是关于为真实生产 AI 系统构建评估管道的最实用文章之一。
2. OpenAI Evals 框架 (开源, 免费) 链接: https://github.com/openai/evals OpenAI 自己的评估框架，包含一个由社区贡献的大量评估模式库，你可以进行改编。

关注点：过程指标（代理是否调用了正确的工具？）和结果指标（任务是否成功？）之间的区别，在构建任何东西之前定义明确的成功标准，以及使用 LLM 作为评估者来评估难以精确匹配的输出（例如长篇答案或多步骤推理轨迹）。

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

第 4 个月里程碑

到本月末，你应该能够：

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

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

你本月的目标：将你所构建的一切都达到生产就绪水平。

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

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

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

1. FastAPI 生产模式

你已经在第 1 个月学会了如何构建 FastAPI 应用程序。现在你需要让它在生产流量下存活。

开发环境和生产环境之间的差异是残酷的。单个带有 --reload 的 uvicorn 进程在构建时很好用。但在生产环境中，当真实流量到来时，它会立即成为瓶颈。

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

资源：

1. FastAPI 部署文档 (官方, 免费) 链接: https://fastapi.tiangolo.com/deployment/ 涵盖 Uvicorn worker、Gunicorn 和 Docker 部署的官方指南。在其他任何内容之前从这里开始。
2. FastAPI 生产部署指南 (CYS Docs, 免费) 链接: 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 多个开发者使用的真实模板的生产经验证的模式。

关注点：使用 Uvicorn worker 运行 Gunicorn（而不是裸 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 构建和部署多代理 AI 系统 (免费) 链接: https://www.freecodecamp.org/news/build-and-deploy-multi-agent-ai-with-python-and-docker/ 实用的端到端教程，使用 Docker Compose 构建真实的多代理管道。涵盖职责分离、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. 后台任务和队列 (Background Jobs and Queues)

LLM 调用很慢。如果用户让你的应用程序处理一个文档，而你让他们等待 30 秒才能得到响应，他们就会离开。

后台任务允许你立即接受请求，异步处理它，并在完成后通知用户。

资源：

1. Celery 官方入门指南 (免费) 链接: https://docs.celeryq.dev/en/stable/getting-started/introduction.html 标准的 Python 任务队列。涵盖基本设置、任务定义和 worker 管理。
2. FastAPI 后台任务文档 (官方, 免费) 链接: https://fastapi.tiangolo.com/tutorial/background-tasks/ 内置的轻量级后台任务，适用于简单用例。将其用于快速的“即发即忘”任务，对于更繁重的任务则使用 Celery。

关注点：理解何时使用 FastAPI 的内置 BackgroundTasks 与适当的任务队列（如 Celery），设置 Redis 作为消息代理，处理任务失败和重试，以及向用户返回任务状态。

4. 认证和 API 密钥安全 (Auth and API Key Security)

如果你的 AI 应用程序有 API，它就需要认证。没有它，任何人都可以使用你的端点，消耗你的 LLM 积分，然后你会在醒来时收到一张 5,000 美元的账单。

资源：

1. FastAPI 安全文档 (官方, 免费) 链接: https://fastapi.tiangolo.com/tutorial/security/ 涵盖 OAuth2、JWT Token、API 密钥和基于依赖项的认证模式。官方参考资料，请完成整个教程。
2. OWASP API 安全十大风险 (免费) 链接: https://owasp.org/API-Security/ API 安全风险的权威列表。在发布任何东西之前，了解被破坏的认证、注入和批量赋值。
3. Auth0: API 认证最佳实践 (免费) 链接: https://auth0.com/docs/get-started/authentication-and-authorization 实现 API 中认证和授权的实用指南。

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

5. 日志和可观测性 (Logging and Observability)

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

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

资源：

1. Langfuse (开源, 免费套餐) 链接: https://langfuse.com/docs/observability/overview 开源 LLM 可观测性平台。追踪每个请求：发送的提示、收到的响应、Token使用、延迟、工具调用。支持提示版本控制、评估和 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 调用（输入提示、输出、Token、延迟、成本），结构化日志与 JSON 输出，设置显示请求量、错误率和每日成本的仪表板，以及在出现问题或成本飙升时发出警报。

6. 提示和版本管理 (Prompt and Version Management)

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

在生产环境中更改提示而不追踪你更改了什么，是你搞砸事情却无法找出原因的方式。

资源：

1. Langfuse 提示管理 (免费) 链接: https://langfuse.com/docs/prompts 中心化提示版本控制，内置用于测试的 playground。将你的提示与应用程序代码分开进行版本控制。部署提示更改而无需重新部署你的应用程序。
2. Anthropic 提示管理最佳实践 (免费) 链接: https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview 规模化组织、迭代和管理提示的最佳实践。

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

7. 成本监控和速率限制 (Cost Monitoring and Rate Limits)

LLM API 按Token收费。如果没有成本控制，流量激增或提示中的 bug 可能会在几分钟内烧掉数百美元。

资源：

1. OpenAI 使用情况仪表板 (官方) 链接: https://platform.openai.com/usage 按模型、按天追踪支出，并设置使用限制。
2. Anthropic 使用情况仪表板 (官方) 链接: https://console.anthropic.com/Same 用于 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. 缓存 (Caching)

如果 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
• 代理
• 部署
• 产品用户体验 (UX)

本月学习内容

1. 端到端产品构建

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

资源：

1. Vercel AI SDK (免费) 链接: https://sdk.vercel.ai/docs 构建带有流式传输支持的 AI 驱动 UI 的最快方式。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 驱动的内部工具，或者一个自动化实际工作流的代理。发布它们。把它们放在 GitHub 上。部署到人们可以尝试的地方。

2. AI 产品用户体验 (Product UX for AI)

当用户体验未能考虑到模型的局限性时，AI 产品就会失败。

资源：

1. Google: 人与 AI 指南 (免费) 链接: https://pair.withgoogle.com/guidebook/ 关于设计人机 AI 交互的最佳资源。涵盖了设定期望、处理错误和建立信任。
2. Nielsen Norman Group: AI 用户体验指南 (免费) 链接: https://www.nngroup.com/topic/artificial-intelligence/ 针对 AI 界面，基于研究的指南。

关注点：如何处理流式传输的加载状态，当模型出错时显示什么，如何让用户提供反馈，以及设计时要考虑到 AI 输出是概率性的——它有时会出错。

方向 2：应用机器学习 / LLM 工程师

如果你想从事更深层次的技术角色，这是最好的选择。

这个方向适用于那些想超越 API 调用，理解底层发生了什么的工程师。

关注点：

• 微调 (fine-tuning)
• 何时微调与提示工程 (prompt)
• 评估 (evaluation)
• 推理优化 (inference optimization)
• 开源模型 (open-source models)
• 训练管道 (training pipelines)

本月学习内容

1. 何时进行微调与提示工程 (When to Fine-tune vs Prompt Engineer)

应用机器学习中最重要的决定：你需要改变模型，还是只需改变你与它的交互方式？

资源：

1. Google ML 速成课程: 微调、蒸馏和提示工程 (免费) 链接: https://developers.google.com/machine-learning/crash-course/llm/tuning 对三种方法以及何时使用每种方法的清晰解释。
2. Codecademy: 提示工程 vs 微调 (免费) 链接: https://www.codecademy.com/article/prompt-engineering-vs-fine-tuning 带有清晰用例的实用决策框架。
3. IBM: RAG vs 微调 vs 提示工程 (免费) 链接: https://www.ibm.com/think/topics/rag-vs-fine-tuning-vs-prompt-engineering 涵盖了完整的决策空间，包括何时结合使用这些方法。

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

2. 微调的实践 (Fine-tuning in Practice)

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

资源：

1. OpenAI 微调指南 (官方, 免费) 链接: https://platform.openai.com/docs/guides/fine-tuning 开始微调的最简单方法。上传 JSONL 数据集，运行作业，获得自定义模型。即使你以后转向开源模型，这也适合学习工作流程。
2. HuggingFace Transformers 微调教程 (免费) 链接: 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. 开源模型 (Open-Source Models)

并非所有事情都需要通过 OpenAI 或 Anthropic。开源模型给你完全的控制权，没有 API 成本，并且能够在本地运行。

资源：

1. Ollama (免费) 链接: https://ollama.ai/ 一条命令即可在本地运行开源 LLM。支持 Llama、Mistral、Gemma 和许多其他模型。实验开源模型的最快方式。
2. HuggingFace 模型中心 (免费) 链接: https://huggingface.co/models 最大的开源模型仓库。浏览、下载和部署适用于任何任务的模型。
3. vLLM (开源, 免费) 链接: https://github.com/vllm-project/vllm 高吞吐量 LLM 推理引擎。比朴素的 HuggingFace 服务快 2-4 倍。开源模型生产服务的标准。

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

4. 推理优化 (Inference Optimization)

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

资源：

1. HuggingFace: 优化 LLM 推理 (免费) 链接: https://huggingface.co/docs/transformers/llm_optims 涵盖 KV 缓存优化、量化和批处理策略。
2. NVIDIA TensorRT-LLM (免费) 链接: https://github.com/NVIDIA/TensorRT-LLM 在 NVIDIA GPU 上实现最大推理性能。大多数大规模生产 LLM 服务都使用它。

关注点：用于吞吐量的批处理策略，用于减少内存和成本的量化，用于更快生成的 KV 缓存优化，以及为你的推理工作负载选择合适的硬件。

方向 3：AI 自动化工程师

如果你想立即为企业构建东西，这是最好的选择。

这个方向是关于使用 AI 自动化真实的业务工作流。它更侧重于解决运营问题，而不是构建产品。

关注点：

• 工作流编排 (workflow orchestration)
• 业务流程自动化 (business process automation)
• 多工具系统 (multi-tool systems)
• CRM、文档、电子邮件、支持、运营用例 (CRM, docs, email, support, ops use cases)

本月学习内容

1. 工作流编排 (Workflow Orchestration)

真正的业务自动化几乎从来不是一次 LLM 调用。它是跨多个系统的行动链。

资源：

1. n8n (开源, 免费自托管) 链接: https://docs.n8n.io/ 带有 AI 节点的视觉工作流自动化。将 LLM 连接到 400 多个集成（Slack, Gmail, Notion, CRM 等）。AI 自动化的最佳无代码/低代码选项。
2. LangGraph: 多代理工作流 (免费) 链接: https://langchain-ai.github.io/langgraph/concepts/multi_agent/ 用于复杂多代理系统的代码优先编排。当 n8n 不足且你需要完全编程控制时。
3. Temporal (开源, 免费) 链接: https://docs.temporal.io/ 耐久工作流引擎，用于长时间运行、容错的进程。当你的自动化需要经受住崩溃、重试和超时时。

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

2. 业务流程自动化 (Business Process Automation)

AI 自动化中的金钱在于解决具体、昂贵的业务问题。

资源：

1. Zapier AI Actions (免费套餐) 链接: https://zapier.com/ai 无需代码即可将 AI 连接到 6,000 多个应用程序。非常适合在构建自定义解决方案之前进行自动化原型开发。
2. Make (Integromat) (免费套餐) 链接: https://www.make.com/ 具有高级逻辑和 AI 集成的可视化自动化平台。对于复杂工作流，比 Zapier 更强大。

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

3. CRM、文档、电子邮件、支持自动化 (CRM, Docs, Email, Support Automation)

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

资源：

1. OpenAI Cookbook: AI 驱动的邮件处理 (免费) 链接: https://github.com/openai/openai-cookbook 使用 AI 对电子邮件进行分类、路由和回复的模式。
2. LangChain: 文档处理管道 (免费) 链接: https://python.langchain.com/docs/how_to/#document-loaders 摄取和处理来自 80 多个来源的文档。

关注点：构建一个 AI 驱动的电子邮件分类器和自动回复器，创建一个提取结构化文档的文档处理管道，构建一个使用 RAG 访问你的知识库的支持聊天机器人，并将 AI 集成到现有的 CRM 工作流中（HubSpot、Salesforce 等）。

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

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

结论

这份路线图不会让你在 6 个月内成为一名高级 AI 工程师，但它会让你成为一个能够构建、交付和部署解决实际问题的真实 AI 系统的人。这正是市场正在支付的价值。

对 AI 工程师的需求并没有放缓。公司急需能够独立交付生产级 AI 而无需持续监督的人才。

以下是需要牢记的几点：

• 构建项目： 从每个月选择一个项目并实际构建它。不要只阅读或观看教程。构建它，破坏它，修复它，部署它，把它放到 GitHub 上。被雇佣的工程师是那些展示了他们构建了什么，而不仅仅是他们学习了什么的人。
• 分享你的学习： 开始在 X 或 LinkedIn 等平台上分享你的学习成果。教学是学习最快的方式，并能建立你的声誉。
• 不要等到准备好： 你永远不会感觉完全准备好。“学习”和“构建”之间的鸿沟是大多数人停滞不前的地方。一旦你有了可用的项目，即使它们不完美，也要开始申请工作、做自由职业或提供服务。市场会奖励那些能够交付成果的人。

如果你付诸努力，六个月足以改变一切。永不止步地构建，永不止步地学习。

• 原文链接： x.com/deronin_/status/20...
• 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～