Day 007 — Agent 系统设计 + 算法冲刺 + Python 方向总复习

speaking_me

302人浏览 · 2026-07-19 00:07:44

speaking_me · 2026-07-19 00:07:44 发布

📅 2026-07-21　|　🏷️ Python · AI Agent 方向　|　⏱️ 建议 5-6h　|　🎯 Python 方向收官——系统设计 + 算法 + 面试软技能

📌 今日知识地图

Python AI/Agent 方向收官日
│
├── 模块一：Agent 系统设计 5 大题
│   ├── ① 多 Agent 智能客服系统
│   ├── ② 企业级 RAG 知识库平台
│   ├── ③ 可扩展 Agent 开发平台
│   ├── ④ Agent 安全体系设计
│   └── ⑤ Computer Use Agent
│
├── 模块二：LeetCode 算法 30 题速刷
│   ├── 数据结构：数组/哈希/链表/栈/堆/树
│   ├── 算法：双指针/滑动窗口/二分/DFS+BFS/DP
│   └── 每类一道代表题 + 思路 + 代码
│
├── 模块三：项目深挖 & 行为面试
│   ├── STAR 法则 + 量化指标模板
│   ├── 常见追问 & 预设答案
│   └── 反问面试官的话术
│
└── 模块四：Python 方向 7 天总复习
    └── 完整知识图谱 + 自测清单

模块一：Agent 系统设计 5 大题

系统设计是面试中区分"会用工具"和"能设计系统"的分水岭。每道题按 需求分析 → 架构设计 → 技术选型 → 关键细节 → 容量估算 五步展开。

题目 1：设计多 Agent 智能客服系统（字节/阿里/腾讯高频）

需求分析：

功能需求：
  - 用户通过 Web/App/企微/飞书 等多个渠道接入
  - 支持售前咨询、售后支持、投诉处理等场景
  - 复杂问题自动升级到人工客服
  - 支持文本、图片、文件等多种消息类型

非功能需求：
  - 响应延迟 < 2s（非流式）/ 首 token < 500ms（流式）
  - 支持 10,000+ 并发用户
  - 准确率 > 90%（自动解决的工单比例）
  - 7×24 小时可用

架构设计：

┌─────────────────────────────────────────────────────┐
│                    接入层                             │
│   Web Chat │  App SDK  │  企微/飞书  │  API         │
└──────────────────────┬──────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│                   路由层（Router Agent）              │
│   意图识别 → 场景分类 → 路由到对应的子 Agent          │
│   • 售前咨询 → Sales Agent                          │
│   • 售后支持 → Support Agent                        │
│   • 投诉处理 → Complaint Agent（+ 人工审核）          │
│   • 查订单/查物流 → Order Agent（直接调 API）         │
└──────────────────────┬──────────────────────────────┘
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
   Sales Agent   Support Agent   Complaint Agent
   (商品/价格)    (退换/维修)     (投诉/升级)
        │              │              │
        └──────────────┼──────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│                  共享能力层                            │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐    │
│  │ RAG 知识库│ │ 订单 API │ │ Human Handoff    │    │
│  │(产品文档) │ │(CRM对接) │ │ (飞书/企微通知)   │    │
│  └──────────┘ └──────────┘ └──────────────────┘    │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐    │
│  │ 用户画像  │ │ 对话记忆  │ │ 监控 & 评估       │    │
│  │(Redis)   │ │(向量库)   │ │ (LangFuse)       │    │
│  └──────────┘ └──────────┘ └──────────────────┘    │
└─────────────────────────────────────────────────────┘

关键设计决策：

1. Router Agent 怎么做意图识别？
   → 轻量模型（GPT-4o-mini）+ Few-shot Prompt 做快速分类
   → 分类结果置信度 < 0.8 时追问用户确认
   → 规则兜底：关键词匹配（"退款" → 售后，"多少钱" → 售前）

2. 怎么处理 Agent 回答不了的问题？
   → 三级升级策略：
     Level 1: Agent 自查（换关键词重新检索 RAG）
     Level 2: 追问用户（"您是指订单编号 TK2024 吗？"）
     Level 3: 升级人工（转接真人客服，附带对话摘要）

3. 怎么保证 RAG 检索的时效性？
   → 商品/价格/政策等信息：定时同步到向量库（5分钟增量更新）
   → 订单/物流等实时信息：不经过 RAG，Agent 直接调 API 查询
   → 知识库更新后自动触发 Re-index

4. 怎么评估客服 Agent 的质量？
   → 自动解决率 = 未升级人工的工单 / 总工单
   → 用户满意度评分（对话结束后打分 1-5）
   → LLM-as-Judge 抽样评估（准确性、礼貌度、效率）

容量估算：

假设：10,000 并发用户，平均每用户 5 轮对话

QPS = 10,000 × 5 / 60s ≈ 833 requests/s

LLM API 调用：
  每次对话 = 1 次 Router + 3 次 Agent 决策 + 1 次生成 ≈ 5 次 LLM 调用
  总 LLM 调用 = 833 × 5 ≈ 4,165 次/s
  → 需要 LLM API 的并发限额 > 1,000 RPM

向量检索：
  每次对话 = 2 次 RAG 检索
  每次检索 < 100ms
  → 检索 QPS ≈ 1,666，单节点 ChromaDB/Milvus 可支撑

带宽：
  流式输出，每用户 < 1KB/s → 总带宽 < 10 MB/s

题目 2：设计企业级 RAG 知识库平台（字节/阿里）

┌─────────────────────────────────────────────────────┐
│               数据摄入管道（Ingestion Pipeline）       │
│                                                      │
│  PDF/Word/HTML → 解析器 → 清洗 → Chunking → Embedding│
│                                  │                   │
│                           ┌──────▼──────┐           │
│                           │  父子文档    │           │
│                           │ 子(检索用)   │           │
│                           │ 父(生成用)   │           │
│                           └──────┬──────┘           │
│                                  │                   │
│                    ┌─────────────┼──────────┐       │
│                    ▼             ▼          ▼       │
│              Milvus(向量)   ES(全文)   PostgreSQL   │
│              Dense检索     Sparse检索   (元数据)     │
└─────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────┐
│                   在线查询管道                        │
│                                                      │
│  Query → 改写(HyDE) → Dense检索 → Sparse检索         │
│              │              │            │           │
│              └──────────────┼────────────┘           │
│                             │                        │
│                    RRF 融合 → Top-50                  │
│                             │                        │
│                    Cross-Encoder Rerank → Top-5       │
│                             │                        │
│                    Prompt组装 → LLM生成 → 引用标注    │
└─────────────────────────────────────────────────────┘

关键设计点：

1. 多租户隔离：
   → 每个企业/团队一个 Collection（Milvus）/ Index（ES）
   → API Key 绑定租户，检索时只查自己的数据
   → Embedding 模型可租户级别自定义

2. 知识更新策略：
   → 全量更新：周级（适合不频繁变更的知识库）
   → 增量更新：分钟级（适合FAQ、政策文档）
   → 版本管理：每次更新创建新版本，可回滚

3. 权限控制：
   → 文档级别权限（某些文档只有特定部门可检索）
   → 检索时注入权限过滤条件（WHERE department IN (...)）
   → 生成时标注来源和权限级别

4. 评估闭环：
   → 离线评估：Recall@K, MRR, NDCG（用标注数据集）
   → 在线评估：用户反馈（点赞/踩）、Ragas Faithfulness
   → A/B 测试：不同 Chunking 策略的效果对比

题目 3：设计可扩展 Agent 开发平台（字节 Coze / 阿里百炼类）

┌─────────────────────────────────────────────────────┐
│                   用户层                              │
│   Web IDE (低代码)  │  API/SDK  │  CLI              │
└──────────────────────┬──────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│                  Agent 构建层                         │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐    │
│  │ Prompt   │ │ 工具绑定  │ │ Memory 配置       │    │
│  │ 编辑器   │ │ (MCP/API)│ │ (短期/长期)       │    │
│  └──────────┘ └──────────┘ └──────────────────┘    │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐    │
│  │ 工作流    │ │ 知识库    │ │ 发布 & 版本管理   │    │
│  │ (DAG)    │ │ (RAG)    │ │                  │    │
│  └──────────┘ └──────────┘ └──────────────────┘    │
└──────────────────────┬──────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│                  运行时引擎                           │
│  ┌──────────────────────────────────────────────┐   │
│  │              Agent Executor                    │   │
│  │  ReAct循环 │ 工具调度 │ 记忆管理 │ 错误处理    │   │
│  └──────────────────────────────────────────────┘   │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐    │
│  │ 模型路由  │ │ 工具网关  │ │ 上下文管理器      │    │
│  │(多模型)  │ │(限流/鉴权)│ │(Token预算)       │    │
│  └──────────┘ └──────────┘ └──────────────────┘    │
└──────────────────────┬──────────────────────────────┘
                       │
┌──────────────────────▼──────────────────────────────┐
│                  基础设施层                           │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐    │
│  │ LLM 网关  │ │ 工具市场  │ │ 可观测性          │    │
│  │(多Provider)│ │(MCP集成) │ │(Trace/Cost)      │    │
│  └──────────┘ └──────────┘ └──────────────────┘    │
└─────────────────────────────────────────────────────┘

关键设计点：

1. 工具热插拔：
   → 工具注册中心：每个工具独立 Docker 容器
   → MCP Server 标准化接入（本地 stdio / 远程 SSE）
   → 工具发现：Agent 启动时自动拉取可用工具列表

2. 多模型支持：
   → 模型路由层：根据任务类型自动选模型
     （简单问答→GPT-4o-mini, 复杂推理→Claude Opus, 代码→DeepSeek）
   → Fallback 链：主模型不可用时自动切换备用模型

3. Token 预算管理：
   → 每个 Agent 实例设置 Token 上限（如 100K tokens/次）
   → 接近上限时触发压缩（摘要旧消息）
   → 硬上限到达时优雅终止并返回部分结果

4. 多租户 & 安全：
   → Agent 实例隔离（每个租户独立的执行环境）
   → 工具权限绑定租户（租户A不能调用租户B的数据库工具）
   → 速率限制（每租户每分钟最多 N 次 LLM 调用）

题目 4：Agent 安全体系设计

┌─────────────────────────────────────────────────────┐
│                  Agent 安全体系                       │
│                                                      │
│  第一层 · 输入安全                                    │
│  ┌──────────────────────────────────────────────┐   │
│  │ 输入净化 → 注入检测 → 敏感信息脱敏 → 长度限制  │   │
│  └──────────────────────────────────────────────┘   │
│                         │                            │
│  第二层 · 权限控制                                    │
│  ┌──────────────────────────────────────────────┐   │
│  │ RBAC(角色权限) → 工具分级(读/写/管理)           │   │
│  │ 最小权限原则 → 动态权限(按需申请)               │   │
│  └──────────────────────────────────────────────┘   │
│                         │                            │
│  第三层 · 执行安全                                    │
│  ┌──────────────────────────────────────────────┐   │
│  │ 沙箱隔离(Docker/E2B) → 网络白名单              │   │
│  │ 参数校验(Pydantic) → 操作审计日志               │   │
│  └──────────────────────────────────────────────┘   │
│                         │                            │
│  第四层 · 人工兜底                                    │
│  ┌──────────────────────────────────────────────┐   │
│  │ HITL(高危操作确认) → 异常行为告警              │   │
│  │ 熔断机制(连续失败自动停止) → 回滚能力          │   │
│  └──────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────┘

安全设计自检清单：

□ 用户输入是否和 System Prompt 分离？
□ 外部数据（网页/文档）是否经过沙箱解析？
□ 敏感操作（删/改/付费）是否有人工确认？
□ Agent 用的 API Key 是否有最小权限？
□ 日志中敏感信息是否已脱敏？
□ 是否有速率限制防止滥用？
□ 是否有熔断机制（连续 N 次失败 → 停止）？
□ 代码执行是否在独立沙箱中？

题目 5：Computer Use Agent

设计一个能自动操作电脑的 Agent（类 Anthropic Computer Use / OpenAI Operator）

核心流程：
  截图(屏幕状态) → 视觉理解(定位元素) → 操作规划(决定动作)
  → 执行动作(点击/输入/滚动) → 等待结果 → 截图 → 循环

┌──────────────────────────────────────────────┐
│              Computer Use Agent               │
│                                               │
│  ┌──────────┐    ┌──────────┐   ┌─────────┐ │
│  │ 截图模块  │ →  │ 视觉理解  │ → │ 操作规划 │ │
│  │(全屏/区域)│    │(VLM定位) │   │(动作序列)│ │
│  └──────────┘    └──────────┘   └────┬────┘ │
│                                      │       │
│  ┌──────────┐    ┌──────────┐   ┌───▼────┐ │
│  │ 结果验证  │ ←  │ 动作执行  │ ← │ 安全检查 │ │
│  │(是否达成) │    │(pyautogui)│   │(敏感操作)│ │
│  └──────────┘    └──────────┘   └────────┘ │
└──────────────────────────────────────────────┘

关键挑战：
  1. 元素定位：VLM 需要识别屏幕上的按钮/输入框/文字
     → 方案：Set-of-Mark（在截图上叠加可交互元素的标记）
  2. 操作精度：点击坐标偏差几个像素可能点错
     → 方案：Accessibility Tree + 截图双重定位
  3. 安全边界：不能让它随便删文件/发邮件/访问敏感网站
     → 方案：操作白名单 + 敏感操作暂停确认 + 虚拟机隔离
  4. 异步等待：点击后页面加载需要时间
     → 方案：视觉变化检测（等待页面稳定后再截图）

模块二：LeetCode 算法 30 题速刷

AI/Agent 开发的算法面试通常考察中等难度，重点是字符串、哈希表、树、DFS/BFS。以下按类别各选一道代表题。

数据结构类

1. 两数之和 (Two Sum) — 哈希表

def twoSum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
# 时间 O(n), 空间 O(n)

2. LRU 缓存 — 哈希表 + 双向链表

class Node:
    __slots__ = ('key', 'value', 'prev', 'next')
    def __init__(self, k=0, v=0):
        self.key = k; self.value = v; self.prev = self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.cap = capacity
        self.cache = {}
        self.head = Node(); self.tail = Node()
        self.head.next = self.tail; self.tail.prev = self.head

    def _remove(self, node):
        node.prev.next, node.next.prev = node.next, node.prev

    def _add_to_head(self, node):
        node.next = self.head.next; node.prev = self.head
        self.head.next.prev = node; self.head.next = node

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self._remove(node); self._add_to_head(node)
        return node.value

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self._remove(self.cache[key])
        node = Node(key, value)
        self.cache[key] = node
        self._add_to_head(node)
        if len(self.cache) > self.cap:
            removed = self.tail.prev
            self._remove(removed); del self.cache[removed.key]

3. 反转链表 — 链表基础

def reverseList(head):
    prev, curr = None, head
    while curr:
        nxt = curr.next; curr.next = prev
        prev = curr; curr = nxt
    return prev

4. 有效的括号 — 栈

def isValid(s):
    pairs = {')': '(', ']': '[', '}': '{'}
    stack = []
    for c in s:
        if c in pairs:
            if not stack or stack.pop() != pairs[c]:
                return False
        else:
            stack.append(c)
    return not stack

5. 二叉树的层序遍历 — BFS

from collections import deque

def levelOrder(root):
    if not root: return []
    result, q = [], deque([root])
    while q:
        level = [node.val for node in q]
        result.append(level)
        for _ in range(len(q)):
            node = q.popleft()
            if node.left: q.append(node.left)
            if node.right: q.append(node.right)
    return result

算法类

6. 无重复字符的最长子串 — 滑动窗口

def lengthOfLongestSubstring(s):
    seen, left, max_len = {}, 0, 0
    for right, c in enumerate(s):
        if c in seen and seen[c] >= left:
            left = seen[c] + 1
        seen[c] = right
        max_len = max(max_len, right - left + 1)
    return max_len

7. 三数之和 — 排序 + 双指针

def threeSum(nums):
    nums.sort()
    res, n = [], len(nums)
    for i in range(n - 2):
        if i > 0 and nums[i] == nums[i-1]: continue
        left, right = i + 1, n - 1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total < 0: left += 1
            elif total > 0: right -= 1
            else:
                res.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left+1]: left += 1
                while left < right and nums[right] == nums[right-1]: right -= 1
                left += 1; right -= 1
    return res

8. 岛屿数量 — DFS/BFS

def numIslands(grid):
    if not grid: return 0
    rows, cols, count = len(grid), len(grid[0]), 0

    def dfs(r, c):
        if 0 <= r < rows and 0 <= c < cols and grid[r][c] == '1':
            grid[r][c] = '0'
            for dr, dc in [(1,0),(-1,0),(0,1),(0,-1)]:
                dfs(r+dr, c+dc)

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == '1':
                count += 1; dfs(r, c)
    return count

9. 爬楼梯 — 动态规划

def climbStairs(n):
    if n <= 2: return n
    a, b = 1, 2
    for _ in range(3, n + 1):
        a, b = b, a + b
    return b

10. 全排列 — 回溯

def permute(nums):
    res = []
    def backtrack(path, used):
        if len(path) == len(nums):
            res.append(path[:]); return
        for i, n in enumerate(nums):
            if used[i]: continue
            used[i] = True; path.append(n)
            backtrack(path, used)
            path.pop(); used[i] = False
    backtrack([], [False] * len(nums))
    return res

速刷清单（30 题）

必刷（按出现频率排序）：
□ 1. 两数之和           □ 11. 最大子数组和
□ 2. LRU 缓存           □ 12. 合并区间
□ 3. 反转链表           □ 13. 二叉树的最近公共祖先
□ 4. 有效的括号         □ 14. 二分查找
□ 5. 层序遍历           □ 15. 岛屿数量
□ 6. 最长无重复子串     □ 16. 爬楼梯
□ 7. 三数之和           □ 17. 全排列
□ 8. 接雨水             □ 18. 环形链表
□ 9. K 个一组翻转链表   □ 19. 最长回文子串
□ 10. 买卖股票最佳时机  □ 20. 搜索旋转排序数组

选刷（有余力）：
□ 21. 字符串相加        □ 26. 二叉树的直径
□ 22. 比较版本号        □ 27. 打家劫舍
□ 23. 最小栈            □ 28. 零钱兑换
□ 24. 前 K 个高频元素   □ 29. 课程表（拓扑排序）
□ 25. 二叉树的右视图    □ 30. 单词搜索

模块三：项目深挖 & 行为面试

3.1 STAR 法则

S — Situation（背景）  ：项目背景，解决什么问题
T — Task（任务）       ：你的角色和职责
A — Action（行动）     ：你做了什么，技术决策和理由
R — Result（结果）     ：量化成果（数字！）

错误示例（没有 STAR）：
  "我做过一个智能客服系统，用了 LangChain 和 RAG。"

正确示例（STAR + 量化）：
  "S: 公司客服团队 50 人，每天处理 2000+ 工单，人工成本高且响应慢。
   T: 我作为项目技术负责人，负责设计和实现智能客服 Agent 系统。
   A: 我设计了 Router + 子 Agent 的多 Agent 架构，Router 用轻量模型做意图分类，
      子 Agent 各自绑定专属工具和 RAG 知识库。RAG 采用父子文档策略提升检索精度，
      引入 Rerank 精排，关键操作（退款、删单）加了 Human-in-the-loop。
   R: 上线后自动解决率 73%，人工工单减少 60%，用户满意度从 3.8 提升到 4.3，
      Token 成本控制在 ¥0.15/对话。"

3.2 常见追问 & 预设答案

追问	回答方向
“为什么用 X 而不用 Y？”	场景对比：X 在 A 方面比 Y 好，我们的核心需求正是 A。提一下 Y 在其他场景的适用性表示了解。
“遇到的最大挑战是什么？”	技术挑战（不是"需求变更"这种万金油）+ 你的解决思路 + 反思收获
“如果重新做，会怎么改进？”	展示成长：现在知道了 X，当时如果有 Y 会更好，具体说哪里会不一样
“怎么衡量项目效果？”	上线前后的数据对比 + 用户反馈 + 业务指标
“团队有分歧怎么办？”	数据驱动决策（做 A/B 测试对比），而非谁职位高听谁的

3.3 反问面试官的话术

不要问：
  ✗ "公司福利怎么样？"（问 HR，别问面试官）
  ✗ "我能拿多少钱？"（问 HR）
  ✗ 官网能查到的问题

可以问：
  ✓ "团队目前的技术栈是怎么样的？Agent 相关的技术债主要在哪些方面？"
  ✓ "团队目前在 Agent 方向上最大的技术挑战是什么？"
  ✓ "团队是怎么评估 Agent 产品的效果的？有专门的评估体系吗？"
  ✓ "这个岗位前 3 个月的预期产出是什么？"

模块四：Python AI/Agent 方向 7 天总复习

4.1 完整知识图谱

Python AI/Agent 面试知识体系（7天）
│
├── Day 1 · Python 基础
│   ├── GIL / GC / is vs == / 深浅拷贝 / 可变vs不可变
│   ├── 装饰器(手写) / 闭包陷阱 / *args **kwargs
│   ├── MRO & super / __new__ vs __init__ / 元类
│   ├── 迭代器 vs 生成器 / yield from
│   ├── asyncio (gather/create_task/as_completed)
│   └── Pydantic BaseModel / typing
│
├── Day 2 · 工程化
│   ├── FastAPI (路由/Depends/中间件/生命周期)
│   ├── SQLAlchemy 2.0 async (selectinload防N+1)
│   ├── Redis (5结构/穿透击穿雪崩/分布式锁Lua)
│   ├── Docker多阶段构建 / Gunicorn+Nginx
│   └── pytest (fixture作用域/TestClient/mock)
│
├── Day 3 · LLM 基础
│   ├── Self-Attention推导(手写) / MHA→MQA→GQA
│   ├── RoPE (旋转位置编码+长度外推)
│   ├── Pre-Norm vs Post-Norm / SwiGLU
│   ├── RLHF三阶段 / DPO / GRPO
│   ├── KV Cache / Flash Attention / 量化
│   ├── MoE(稀疏激活) / Top-P+Temperature
│   └── 评估 (MMLU/HumanEval/AgentBench)
│
├── Day 4 · Agent 核心
│   ├── ReAct = Reasoning + Acting (手写实现)
│   ├── Function Calling (LLM输出JSON→代码执行)
│   ├── Planning(分解/反思/自适应)
│   ├── Memory(短期/工作/长期三层)
│   ├── Tools(六大设计原则)
│   └── 决策策略对比 (ReAct/P&E/Reflexion/LATS)
│
├── Day 5 · RAG
│   ├── RAG流水线 / vs微调 / vs Long Context
│   ├── Chunking五策略 / 父子文档(生产推荐)
│   ├── Embedding选型 / 向量库对比
│   ├── 混合检索(Dense+Sparse+RRF)
│   ├── Rerank(Cross-Encoder) / HyDE
│   ├── Lost in the Middle / 上下文压缩
│   └── Agentic RAG (Self-RAG/Corrective RAG)
│
├── Day 6 · 进阶
│   ├── Multi-Agent四模式 / CrewAI/AutoGen/LangGraph
│   ├── MCP (Tool/Resource/Prompt三层)
│   ├── A2A (Agent↔Agent vs MCP的LLM↔工具)
│   ├── Prompt Injection (三层攻击+五层防御)
│   ├── 可观测性 (Trace/Metrics/Logs)
│   └── SSE流式输出 (StreamingResponse+Nginx配置)
│
└── Day 7 · 收尾
    ├── 系统设计5大题
    ├── LeetCode 30题速刷
    ├── STAR法则 + 追问应对
    └── 完整知识图谱自测

4.2 自测清单（面试前一天对着过一遍）

Python 基础
□ GIL 是什么？CPU 密集和 IO 密集分别怎么处理？
□ is vs == 区别？什么时候必须用 is？
□ 深拷贝和浅拷贝区别？默认参数陷阱怎么修复？
□ 装饰器怎么写？带参数和不带参数的有什么区别？
□ asyncio 的 gather 和 create_task 有什么区别？
□ Pydantic 的 model_validator 和 field_validator 有什么区别？

LLM 基础
□ 推导 Self-Attention，为什么除以 sqrt(d_k)？
□ MHA / MQA / GQA 的区别？LLaMA 为什么用 GQA？
□ RoPE 为什么能外推到更长序列？
□ RLHF 三阶段流程？KL 惩罚项为什么重要？
□ DPO 和 PPO 的区别？GRPO 的创新点？
□ KV Cache 和 Flash Attention 各自解决什么问题？
□ MoE 的核心思想？DeepSeek MoE 有什么创新？

Agent 核心
□ ReAct 框架的 Thought → Action → Observation 循环？
□ Function Calling 中 LLM 真的调用了函数吗？
□ Agent 四要素（Planning/Memory/Tools/Action）各自职责？
□ 记忆系统的三层设计？什么时候触发压缩？
□ 工具调用失败怎么处理？（校验→重试→Fallback）
□ 怎么防止 Agent 死循环？

RAG
□ Chunking 五种策略？父子文档为什么是生产推荐？
□ 混合检索是什么？为什么需要 Rerank？
□ Lost in the Middle 怎么缓解？
□ Self-RAG 和传统 RAG 的核心区别？

进阶
□ Multi-Agent 四种协作模式及框架选型？
□ MCP 和 A2A 分别解决什么问题？本质区别？
□ Prompt Injection 的防御体系？
□ SSE 流式输出 Nginx 需要注意什么？

系统设计
□ 多 Agent 客服系统的架构能画出来吗？
□ RAG 知识库平台的数据流能讲清楚吗？
□ STAR 法则准备好了吗？每个项目有量化数据吗？

面试题精选（系统设计 + 行为 5 道）

Q1. 设计一个多 Agent 客服系统（字节系统设计高频）

见上文题目 1。核心考察：Router 设计、升级策略、评估体系。

Q2. RAG 系统的 Chunking 策略怎么选？父子文档怎么实现？

标准回答：

通用场景用递归分割（RecursiveCharacterTextSplitter）做 baseline。对精度要求高 → 父子文档：子文档 200 字符用于检索（精确匹配），父文档 1000 字符用于生成（完整上下文）。实现上，检索时用子文档的 Embedding 做向量匹配，返回对应的父文档给 LLM。存储时建立 child_chunk_id → parent_chunk_id 的映射。

Q3. Agent 的可扩展性怎么设计？（字节/阿里）

标准回答：

三个层面：① 工具热插拔（MCP 标准化接入，注册中心自动发现）；② 模型路由（按任务类型+成本+延迟自动选模型，主模型挂掉自动 Failover）；③ 多租户隔离（每租户独立的 Agent 实例、工具权限、速率限制、Token 预算）。

Q4. 如果让你重新做这个项目，会怎么改进？

标准回答：

以 RAG 系统为例：“当时用的是固定大小 Chunking，现在我会用父子文档策略提升检索精度。当时没有 Rerank，检索到的 Top-5 里有 30% 是不相关的噪声，现在会加 Cross-Encoder 精排。当时没有评估体系，上线后才发现检索质量在中文文档上比英文差很多——现在会先建标注数据集，每次变更前跑离线评估。”

Q5. 介绍一下你最自豪的项目？

标准回答：

STAR 法则 + 量化数据 + 技术决策的 trade-off。重点不是项目有多大，而是你为什么做那些技术选择。面试官想听到的是"我选了 X 因为 A，放弃了 Y 因为 B，最终数据证明这个选择是对的/如果再来一次我会选 Z"。

📊 Python AI/Agent 方向 7 天总数据

总博客行数：5,500+ 行
总内容量：约 120,000+ 字
覆盖面试题：60+ 道（含公司标签）
代码实战练习：25+ 道
系统设计题：5 道完整方案
知识图谱节点：200+ 个

🔜 明日预告

Day 8 — Java 基础 + 集合框架全通

Python 方向完结！明天开始 Java 后端 7 天速通：

Java 语言特性 + 8 种基本类型 + 自动装箱拆箱（IntegerCache）
String/StringBuffer/StringBuilder + 字符串常量池
OOP（封装/继承/多态）+ 重载 vs 重写 + 抽象类 vs 接口
集合源码深挖：ArrayList/HashMap 1.8/ConcurrentHashMap/LinkedHashMap(LRU)
泛型类型擦除 + 反射 + 动态代理 + 注解
IO/NIO（BIO/NIO/AIO 区别 + Buffer/Channel/Selector）
10 道 Java 基础 + 集合高频真题

💡 7 天 Python 方向收官：从 Python 基础语法到企业级 Agent 系统设计，这 7 天你走完了别人 3 个月的自学路径。关键不在于记住了多少细节，而在于建立了完整的知识框架——面试官问任何一个点，你都能定位到它在知识图谱中的位置，并展开说 3-5 分钟。明天 Java 方向，同样的方法，7 天速通！