前端转 AI 第 45 天:阶段复盘 - 从"会调 API"到"做出 AI 产品"
说在前面
今天是复盘日,不学新东西。
Day 31-44 这 14 天,我们把"假 LLM"换成了真 LLM,走完了从"调用大模型"到"做出完整 AI 产品"的完整链路。
明天开始进入 RAG 阶段。今天停下来,回头看这 14 天走了多远。
一、14 天全景图
先看知识地图:
┌────────────────────────────────────────────────────────┐
│ 第三阶段:LLM 应用(Day 31-45) │
├────────────────────────────────────────────────────────┤
│ │
│ ── 基础能力(Day 31-35)── │
│ Day 31 LLM 入门 第一次真实调用 │
│ Day 32 客户端工程化 重试/超时/降级/限流 │
│ Day 33 流式输出 SSE + 打字机效果 │
│ Day 34 Function Calling 工具调用(Agent 起点) │
│ Day 35 结构化输出 JSON Schema + Pydantic │
│ │
│ ── 提升质量(Day 36-37)── │
│ Day 36 Prompt 工程 四要素 + 六原则 + 反模式 │
│ Day 37 Few-shot & CoT 推理技巧 │
│ │
│ ── 工程化(Day 38-40)── │
│ Day 38 Token 成本 四大省钱策略 │
│ Day 39 多模型适配 抽象/路由/降级 │
│ Day 40 本地模型 Ollama + 混合模式 │
│ │
│ ── 项目整合(Day 41-45)── │
│ Day 41 阶段复盘 十项最佳实践 │
│ Day 42 跨模型对比 用数据选模型 │
│ Day 43 综合项目 完整 Agent 后端 │
│ Day 44 前端集成 React + 流式界面 │
│ Day 45 阶段复盘 本篇 │
│ │
└────────────────────────────────────────────────────────┘
一句话总结每一天
| Day | 一句话记住它 |
|---|---|
| 31 | LLM 调用本质是 HTTP 请求,但更慢、更贵、更不确定 |
| 32 | 5 种失败模式,不同策略:网络重试、限流退避、4xx 直接失败 |
| 33 | SSE 让"等 5 秒"变成"0.5 秒开始输出",感知快 10 倍 |
| 34 | Function Calling = 模型说要调什么,我来执行 |
| 35 | strict: True 让 JSON 输出从"祈祷"到"保证" |
| 36 | Prompt 不是"问问题",是"给 AI 写说明书" |
| 37 | "一步步思考"六个字,数学题准确率翻 4 倍 |
| 38 | 选对模型省 90%,Prompt Cache 省 80% |
| 39 | 不写死任何模型,业务代码只依赖抽象接口 |
| 40 | 云端强、本地快,混合模式才是最优解 |
| 41 | 十项最佳实践 + 8 段可复用代码 |
| 42 | 用数据选模型,不靠"听说" |
| 43 | Agent = 记忆 + 工具 + 循环 + 工程化 |
| 44 | 前端是 AI 产品的"体验放大器" |
| 45 | 从"会调 API"到"做出产品" |
二、这 14 天的核心转变
1. 认知转变
Day 31 前的你:
"大模型很神奇,但我不知道怎么用。"
Day 45 的你:
"大模型就是一个组件------我知道怎么控制它、度量它、替换它。"
这就是"从用户到开发者"的转变。
2. 技能转变
14 天掌握的具体技能:
| 类别 | 技能 |
|---|---|
| LLM 调用 | OpenAI SDK、多 provider、流式、工具调用、结构化输出 |
| Prompt | 四要素、六原则、Few-shot、CoT、Self-Consistency |
| 工程 | 重试、超时、降级、限流、抽象层、路由 |
| 成本 | Token 计算、成本监控、四大优化策略 |
| 部署 | 本地模型、Docker 化、混合模式 |
| 前端 | SSE 接收、流式渲染、工具可视化 |
每一项都是"生产级",不是"玩具级"。
3. 项目转变
项目体量:
| 阶段 | 代码行数 | 功能 |
|---|---|---|
| Day 30 结束 | 4000 行 | 完整后端 |
| Day 45 结束 | 12000 行 | 完整 AI 产品 |
功能清单(14 天新增):
- ✅ 真 LLM 调用(多 provider)
- ✅ 流式输出(打字机效果)
- ✅ 工具调用(Function Calling)
- ✅ 结构化输出(JSON Schema)
- ✅ Prompt 模板(版本管理)
- ✅ 成本监控(按调用/会话/用户)
- ✅ 模型路由(自动选模型)
- ✅ 多模型降级(主模型挂了切备用)
- ✅ 本地模型(Ollama 混合模式)
- ✅ 前端界面(React + 流式)
- ✅ 工具调用可视化
- ✅ 会话管理
这已经是一个"能演示、能讲、能写简历"的完整产品。
三、跨阶段回顾:Day 1-45 你学到了什么
把三个阶段连起来看:
1. 第一、二阶段:工程基础
| 阶段 | 核心能力 | 关键产出 |
|---|---|---|
| Day 1-15 | Python 语法 + 项目起步 | 命令行助手 |
| Day 16-30 | 后端工程化 | FastAPI 服务 + 上线 |
这两个阶段打的是"通用工程"基础:
- 数据:列表、字典、推导式
- 函数:参数、装饰器、异步
- 工程:测试、打包、部署
- 后端:FastAPI、数据库、Nginx
这些能力"不光 AI 用得上,任何后端都用得上"。
2. 第三阶段:AI 能力
| 阶段 | 核心能力 | 关键产出 |
|---|---|---|
| Day 31-45 | LLM 应用开发 | 完整 AI 产品 |
这个阶段打的是"AI 特有的工程能力":
- LLM 接入:调用、流式、工具
- Prompt:工程化、测试、版本
- 成本:监控、优化、路由
- 体验:流式、可视化
这是"AI 应用开发者"的核心竞争力。
3. 三个阶段的"复利"
关键观察:
第一、二阶段学的"通用工程",在第三阶段全部复用了。
- Day 8 学的 asyncio → Day 31 调 LLM 用上了
- Day 11 学的 Pydantic → Day 35 结构化输出用上了
- Day 14 学的记忆管理 → Day 43 Agent 用上了
- Day 22 学的中间件 → Day 44 流式处理用上了
- Day 27 学的 Docker → Day 40 本地模型部署用上了
没有白学的知识。
这就是"系统学习"的威力------不是"学了忘",是"越学越快"。
四、十项可复用工程实践
这 14 天从踩坑里提炼的。
1. 永远用异步客户端
python
from openai import AsyncOpenAI
client = AsyncOpenAI(...)
FastAPI 里必须异步,否则阻塞事件循环。
2. 分层超时 + 智能重试
python
timeout=httpx.Timeout(connect=5.0, read=30.0, write=10.0)
区分错误类型、指数退避、加抖动。
3. 流式响应加 X-Accel-Buffering: no
Nginx 默认缓冲会让流式失效------这一个 header 值一天。
4. Prompt 集中管理 + 版本化
python
# prompts/agent_v2.py
AGENT_SYSTEM_PROMPT_V2 = "..."
Prompt 是代码,要管理、要测试、要回滚。
5. 结构化输出用 strict: True
生产环境一律严格模式------"差不多就行"会出事故。
6. 把不变的内容放 Prompt 前面
python
messages = [
{"role": "system", "content": LONG_INSTRUCTION}, # 不变
{"role": "user", "content": user_question}, # 每次都变
]
这是 Prompt Cache 生效的前提。
7. 每次调用记录 token 和成本
没有数据就没有优化------"感觉便宜"和"实际便宜"是两回事。
8. 抽象层让模型"可替换"
python
client = router.get_client(TaskType.CHAT, Complexity.MEDIUM)
永远不在业务代码里写 model="deepseek-chat"。
9. 多模型降级 + 兜底
主模型挂了 → 备用 → 本地 → 兜底回复。层层保障。
10. 前端"展示过程"而不是"展示结果"
用户能看到"思考中...""正在调用工具..."------这才是"AI 体验"。
五、可复用代码工具箱
升级版的代码库(Day 41 的加强):
1. LLM 抽象层
python
class BaseLLMClient(ABC):
@abstractmethod
async def chat(self, messages, **kwargs) -> ChatResponse: ...
@abstractmethod
async def stream_chat(self, messages, **kwargs) -> AsyncIterator[str]: ...
所有 provider 都实现它,业务代码只依赖抽象。
2. 智能重试
python
async def retry_llm_call(func, max_attempts=3, base_delay=1.0):
for attempt in range(1, max_attempts + 1):
try:
return await func()
except Exception as e:
if not is_retryable(e) or attempt == max_attempts:
raise
delay = min(base_delay * (2 ** (attempt - 1)), 60.0)
delay += delay * 0.2 * (random.random() * 2 - 1)
await asyncio.sleep(delay)
3. 流式响应 SSE
python
async def event_gen():
async for chunk in llm_stream:
yield f"data: {json.dumps({'delta': chunk})}\n\n"
yield "data: [DONE]\n\n"
return StreamingResponse(event_gen(), media_type="text/event-stream",
headers={"X-Accel-Buffering": "no"})
4. Pydantic 严格模式
python
def to_strict_schema(model_cls):
schema = model_cls.model_json_schema()
def _process(obj):
if isinstance(obj, dict):
if obj.get("type") == "object":
obj["additionalProperties"] = False
if "properties" in obj:
obj["required"] = list(obj["properties"].keys())
for v in obj.values(): _process(v)
elif isinstance(obj, list):
for item in obj: _process(item)
_process(schema)
return schema
5. 成本计算
python
PRICING = {
"deepseek-chat": {"input": 0.5, "output": 2.0},
"gpt-4o-mini": {"input": 1.1, "output": 4.4},
}
def calc_cost(model, prompt_tokens, completion_tokens):
p = PRICING.get(model, {"input": 0, "output": 0})
return prompt_tokens/1e6 * p["input"] + completion_tokens/1e6 * p["output"]
6. 模型路由
python
ROUTING = {
("chat", "low"): ("ollama", "qwen2.5:7b"),
("chat", "medium"): ("deepseek", "deepseek-chat"),
("reason", "high"): ("claude", "claude-3-5-sonnet"),
}
7. Agent 循环
python
for iteration in range(max_iterations):
response = await llm.chat(messages, tools=tools)
if not response.tool_calls:
return response.content
messages.append(response)
for tc in response.tool_calls:
result = execute_tool(tc)
messages.append({"role": "tool", "content": result, ...})
8. 前端 SSE 接收
typescript
async function* streamChat(url, body) {
const reader = (await fetch(url, {method: "POST", body: JSON.stringify(body)})).body!.getReader();
const decoder = new TextDecoder();
let buf = "";
while (true) {
const { done, value } = await reader.read();
if (done) break;
buf += decoder.decode(value, { stream: true });
const msgs = buf.split("\n\n");
buf = msgs.pop() || "";
for (const msg of msgs) {
const line = msg.split("\n").find(l => l.startsWith("data: "));
if (line) yield JSON.parse(line.slice(6));
}
}
}
9. 工具注册器
python
@registry.register(name="get_weather", description="...", params_model=GetWeatherArgs)
def get_weather(city: str) -> dict:
return {"city": city, "temp": 18}
10. 统一错误处理
python
@app.exception_handler(AppError)
async def handle_app_error(request, exc):
return JSONResponse(status_code=exc.status_code, content={
"code": exc.code, "message": exc.message, "details": exc.details,
})
这 10 段代码是你的"AI 应用开发工具箱"。
六、项目进化史(Day 30 → Day 45)
从一个"后端服务"到"完整 AI 产品":
Day 30(第一阶段结束):
- 4000 行代码
- 假 LLM
- 完整后端 + 上线
Day 35(LLM 核心能力就绪):
- 5500 行
- 真 LLM + 流式 + 工具 + 结构化
- 能"思考"了
Day 40(工程化完成):
- 7200 行
- 成本监控 + 多模型 + 本地模型
- 能"扛生产"了
Day 43(Agent 成型):
- 10000 行
- 记忆 + 工具 + 循环
- 是"真 Agent"了
Day 45(前端就绪):
- 12000 行
- 完整前后端
- 是"产品"了
关键数字:
| 指标 | Day 30 | Day 45 |
|---|---|---|
| 代码行数 | 4000 | 12000 |
| Python 文件 | 30 | 60 |
| 前端文件 | 0 | 25 |
| 测试数 | 40 | 80+ |
| 覆盖率 | 90% | 85%+ |
| LLM 支持 | Mock | 6 家 + 本地 |
| 部署方式 | Docker | Docker + Nginx + HTTPS |
七、反思:做得好和做得差
做得好的
1. 抽象层做得早
Day 31 就设计了 BaseLLMClient------后面接多模型、接本地模型,调用方一行没改。
抽象前置,收益翻倍。
2. 用数据选模型
Day 42 跑了完整的跨模型评测------不是"听说 GPT-4o 好",是自己测出来。
数据驱动决策。
3. 前后端一体
Day 44 用 React 完整实现了界面------不只"能调 API",还"能给人用"。
从"Demo"到"产品",这一步很重要。
4. 成本意识早建立
Day 38 就开始记成本------很多人上线几个月才发现"账单爆炸"。
早监控,早优化。
做得差的
1. 流式 + 工具调用没做到"真流式"
Day 43 的 Agent 是"先决定,再流式回放" ------真正的 stream + tools 需要更复杂的实现。
这是技术难点,RAG 阶段会再挑战。
2. 前端会话管理没做完整
Day 44 的侧边栏是空的------后端没提供"会话列表"接口。
这是遗漏的工程点,后面补上。
3. RAG 铺垫不足
今天才发现 RAG 是个"大题目"------需要从向量、Embedding、相似度多个角度讲。
下次讲大主题,要提前规划更细。
4. 没做"Prompt 评估自动化"
虽然讲了测试框架,但没集成到 CI 里------每次改 Prompt 还是要手动跑。
Prompt 是代码,也要自动化测试。
调整方向
1. RAG 阶段要更系统
Day 46-60 是一个完整的"技术主题"------需要分层次讲:
- 概念(为什么需要 RAG)
- 基础(Embedding、向量、相似度)
- 工具(Chroma、Qdrant)
- 实战(完整知识库)
2. 补上"会话列表"接口
Day 46 开工前先补这个坑。
3. Prompt 测试进 CI
pytest + promptfoo 或自研框架------每天自动跑 Prompt 回归。
4. 每个"完整功能"配一个前端演示
后端能力 + 前端界面 = 完整产品。
八、下一阶段预告:RAG
Day 46-60:检索增强生成
核心任务:让 AI 读懂你的文档。
为什么需要 RAG?
当前 Agent 的局限:
- ❌ 不知道你的私有数据:公司的文档、产品手册、客服话术
- ❌ 上下文有限:128K 塞不下 1000 页的文档
- ❌ 每次都要重新发:贵,且慢
RAG 解决的:
用户问题
↓
[检索] 从知识库找相关片段
↓
[增强] 把片段塞进 Prompt
↓
[生成] LLM 基于片段回答
↓
有依据的回答
这一阶段会学:
| 天数 | 内容 |
|---|---|
| 46-47 | RAG 概念 + 工作流程 |
| 48-50 | Embedding 模型 + 相似度检索 |
| 51-53 | 向量数据库(Chroma / Qdrant) |
| 54-56 | 文档加载 + 切分策略 |
| 57-59 | 检索优化 + 重排 |
| 60 | 完整 RAG 项目实战 |
做完 RAG,你就能做"知识库问答"这类真实产品。
这是"AI 应用"进化到"AI 数据应用"的关键一跳。
之后的大纲
| 阶段 | 天数 | 核心 |
|---|---|---|
| RAG | 46-60 | 让 AI 懂你的文档 |
| Agent 进阶 | 61-80 | LangChain / ReAct / 多 Agent |
| 完整项目 | 81-100 | 上线真实产品 |
100 天后,你会有 3-4 个"能拿得出手"的项目。
九、简历怎么写这 14 天
这 14 天让你简历上多了这些亮点:
项目描述模板
AI Agent 助手(独立开发)
技术栈:Python / FastAPI / SQLAlchemy / Pydantic / React / TypeScript / Docker / Nginx
核心功能:
- 多模型路由:抽象层支持 DeepSeek / 通义 / OpenAI / 本地 Ollama,按任务类型 + 复杂度自动选模型
- 工具调用:基于 Function Calling 实现,支持天气查询、网络搜索、计算器等
- 流式输出:SSE 实时流式,首字节延迟 < 500ms
- 结构化输出:Pydantic + JSON Schema 严格模式,100% 符合 Schema
- 记忆管理:滑动窗口 + LLM 摘要,支持长对话
- 成本监控:按调用/会话/用户统计成本,多级告警
- 前端界面:React + Vite,工具调用实时可视化,支持会话管理
工程实践:
- 分层架构(API / Service / LLM 抽象)
- 生产级错误处理(重试 / 降级 / 限流)
- 可观测性(结构化日志 + Prometheus 指标)
- 完整测试(pytest,覆盖率 85%+)
- CI/CD(GitHub Actions)+ Docker 化部署
面试中能讲什么
面试官问:"介绍一个你最近做的项目"
你可以讲:
- 为什么做:想学 AI 开发 + 前端转后端的实践
- 架构设计:为什么选 FastAPI、为什么做抽象层
- 技术难点:流式 + 工具调用的组合、多模型降级
- 工程优化:成本从 X 降到 Y(有数据)
- 踩过的坑:Nginx 缓冲、Prompt Cache 顺序等
这种"有深度、有数据、有坑"的讲述,比"我做过 XX 项目"强 10 倍。
十、给跟我一起学的你
45 天了,感谢还在坚持的你。
1. 45 天是个"分水岭"
Day 1-30 是"打基础",Day 31-45 是"实战"。
如果你 Day 30 之前觉得"学到的东西不知道能干嘛" ------从 Day 31 开始,所有知识都串起来了。
有同学反馈:"Day 43 那天终于明白前面为什么学那些东西了。"
这就是"系统学习"的价值------前面的铺垫,后面的收获。
2. "做完"比"看懂"重要
这 14 天的代码量,如果是"跟着敲一遍",至少 2000 行。
如果是"看懂就行",可能一行没写。
两种人的差距,半年后会非常明显。
建议: 至少把 Day 43 的项目跑起来一遍。
3. 别怕"项目小"
有人会想:"我这个 Agent 比 ChatGPT 差远了,算什么?"
错。
ChatGPT 是 OpenAI 几百人的产品。
你的 Agent 是你一个人 45 天做的。
它的价值不是"比 ChatGPT 强",是"你从零做出它"------
这个能力,比任何项目本身都值钱。
4. 卡住的时候发评论
评论区是很好的交流场。
你卡住的地方,99% 别人已经踩过。
问一句,可能省你半天。
十一、今日总结
今天核心收获三件事:
- 14 天的知识全景:从 LLM 调用到完整 AI 产品
- 三个阶段的"复利":前面的通用工程能力,在 AI 阶段全部复用
- 十项最佳实践 + 10 段可复用代码:这是最值钱的沉淀
一个感受:
45 天前,你可能觉得"AI 开发"很神秘。
45 天后,你发现------它没有那么神秘。
- 调用 LLM = 发 HTTP 请求
- 流式输出 = SSE
- 工具调用 = 结构化的函数回调
- Prompt 工程 = 写清楚的说明书
- 成本优化 = 算术
- 多模型 = 适配器模式
都是"工程",不是"魔法"。
唯一的区别:LLM 是不可控的,所以工程要更扎实。
这就是"AI 应用开发者"------不是"训练模型的人",是"把模型变成产品的人"。
而这个人,你已经当上了。
Day 45 完成度:✅
明日预告(Day 46)
进入 RAG 阶段------让 AI 读懂你的文档。
- 为什么需要 RAG :
- LLM 的三个先天缺陷
- 上下文窗口的限制
- 私有数据的价值
- RAG 是什么:一句话解释 + 核心流程
- RAG 三大组件:检索、增强、生成
- 一个最小 RAG 示例:10 行代码跑通
从明天开始,你的 Agent 能"读文档"了。
最后
如果这篇对你有用,点个赞让我知道有人在看。
评论区互动: 这 14 天你最大的收获是什么?有没有"啊哈"时刻?下一阶段最期待学什么?欢迎分享。
有问题评论区见,我们第 46 天继续。
100 天,第 46 天见。
附录:系列目录
第一阶段:工程基础(已完成 ✅)
| 阶段 | 天数 | 内容 |
|---|---|---|
| Python 基础 | 01-15 | 语法 + 命令行助手 |
| 后端工程化 | 16-30 | 数据库/测试/FastAPI/Docker/上线 |
第二阶段:LLM 应用(已完成 ✅)
| 阶段 | 天数 | 内容 |
|---|---|---|
| LLM 基础 | 31-35 | 调用/流式/工具/结构化 |
| 质量提升 | 36-37 | Prompt 工程 + CoT |
| 工程化 | 38-40 | 成本 + 多模型 + 本地模型 |
| 项目整合 | 41-45 | 复盘 + 对比 + 综合项目 + 前端 |
第三阶段:RAG(即将开始 🎯)
| 阶段 | 天数 | 内容 |
|---|---|---|
| RAG 基础 | 46-50 | 概念 / Embedding / 向量 |
| 向量数据库 | 51-56 | Chroma / Qdrant / 文档处理 |
| RAG 优化 | 57-60 | 检索优化 + 重排 |
第四阶段:Agent 进阶(Day 61-80)
第五阶段:完整项目(Day 81-100)
45 天已过,55 天继续。
一起从切图仔变成 Agent 开发者。