前端转 AI 100 天 Day 45:阶段复盘——从“会调 API”到“做出 AI 产品”

前端转 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 化部署

面试中能讲什么

面试官问:"介绍一个你最近做的项目"

你可以讲:

  1. 为什么做:想学 AI 开发 + 前端转后端的实践
  2. 架构设计:为什么选 FastAPI、为什么做抽象层
  3. 技术难点:流式 + 工具调用的组合、多模型降级
  4. 工程优化:成本从 X 降到 Y(有数据)
  5. 踩过的坑: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% 别人已经踩过。

问一句,可能省你半天。


十一、今日总结

今天核心收获三件事:

  1. 14 天的知识全景:从 LLM 调用到完整 AI 产品
  2. 三个阶段的"复利":前面的通用工程能力,在 AI 阶段全部复用
  3. 十项最佳实践 + 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 开发者。

相关推荐
Sakura_j_h_41 分钟前
MCP SDK 2.0 实战:用 MCPServer 搭本地笔记检索服务
开发语言·笔记·python·qt·ai工具·mcp·mcpserver
QuZhengRong1 小时前
【AI】Agent 全栈进阶|AgentScope 沙箱源码解析
python·学习·ai·agent·沙箱
Eider19982 小时前
Python基础语法之并发相关3
开发语言·python
M--Y3 小时前
LangGraph 架构基石:持久化与运行控制
python·langchain·大模型·llm·持久化·langgraph
用户019027581614 小时前
新浪财经 / 东方财富股票接口不稳、被限?稳定替代方案
python
七夜zippoe4 小时前
Nexent 知识库:调优靠 Chunk 与重排
开发语言·python·ai智能体·nexent·知识库与rag
承渊政道6 小时前
【Python编程—从入门到实践】(用户账户:给Django网站装上登录系统,让每个人拥有自己的学习笔记)
python·学习·pycharm·django
承渊政道8 小时前
【Python编程—从入门到实践】(设置样式并部署:给Django网站换新装,把学习笔记发布到互联网)
python·学习·pycharm·django
用户298698530148 小时前
使用 Python 将 JSON 转换为 Word 文档的实践指南
python·json·api