跳到主要内容
Ed. notes

09 目标架构与落地路线

长文 · 2026-11-17 · 合集第 10 / 10 篇

  • RAG
  • 架构
  • 落地路线
第 10 / 10 篇 · 查看全部章节 → 当前:09 目标架构与落地路线

一句话结论

目标架构不是「节点越多越好」,而是用最少的额外调用,把确定性尽量前移:规则处理封闭输入,检索分数处理明显越界,LLM 只处理模糊带,引用由服务端统一编号。落地按 P0/P1/P2 分批,每一步都能单独验证。

它解决什么问题

前八篇分别讲了查询、上下文、失败、引用、延迟、路由、状态和评测。单独看每一篇都成立,合在一起容易出现两个问题:

  • 节点越加越多,首 token 越来越慢;
  • 改动互相依赖,无法判断是哪一步起了作用。

所以最后需要一张总图和一份有顺序的清单。

目标图

┌──────────────────────────────────────────────────────────────┐
│ 图外:参数校验 → limiter.check() → ensure_index_ready()       │
│ 任一失败:4xx/503 JSON,不进入图、不开始流                    │
└───────────────────────────┬──────────────────────────────────┘
                            ▼
                 ┌─────────────────────┐
                 │       triage        │  规则,~0ms
                 └──────────┬──────────┘
                            │
          ┌─────────────────┴──────────────────┐
          │ 非 content                          │ content
          ▼                                     ▼
  ┌───────────────┐                   ┌──────────────────┐
  │    respond    │                   │     rewrite      │  可选
  │  固定文案      │                   │  无历史则透传     │
  └───────┬───────┘                   └────────┬─────────┘
          │                                    ▼
          │                          ┌──────────────────┐
          │                          │     retrieve     │  embed + 检索
          │                          │  min_score 过滤   │  + select_context
          │                          └────────┬─────────┘
          │                                   ▼
          │                          ┌──────────────────┐
          │                          │      assess      │  按分数分级
          │                          └────────┬─────────┘
          │                                   │
          │            ┌──────────────┬───────┴───────┬──────────────┐
          │            │ good/weak    │ ambiguous      │ empty        │
          │            ▼              ▼                ▼              │
          │      ┌───────────┐  ┌───────────┐  ┌──────────────┐     │
          │      │ generate  │  │   judge   │  │ out_of_scope │     │
          │      │ 流式生成   │  │ LLM 裁判   │  │  范围说明     │     │
          │      └─────┬─────┘  └─────┬─────┘  └──────┬───────┘     │
          │            │        in_scope│  off_topic    │             │
          │            │              └──→ generate     │             │
          └────────────┴───────────────────────────────┴─────────────┘
                                       ▼
                                      END

三条路径:

路径 触发条件 节点 embedding LLM 输出
快速路径 triage != content triage → respond 否 否 固定文案
越界路径 chunks 为空 triage → retrieve → out_of_scope 是 否 范围说明
正常路径 chunks 非空 triage → retrieve → assess → generate 是 是 流式回答 + sources

关键点:问候连 embedding 都不花;越界只花 embedding,不花生成。

状态与节点

class RagState(TypedDict, total=False):
    query: str                 # 用户原话,给生成和日志
    search_query: str          # 改写后的问题,给检索
    triage: str                # greeting / thanks / identity / capability / content
    grade: str                 # good / weak / empty / ambiguous / off_topic
    history: list[dict[str, str]]
    top_k: int
    chunks: list[RetrievedChunk]
    answer: str
节点 读取 写入 成本
triage query triage 0
respond triage answer 0
rewrite query, history search_query 0 或 1 次 LLM
retrieve search_query, top_k chunks embedding
assess chunks grade 0
judge query grade 1 次 LLM(仅模糊带)
generate query, history, chunks, grade answer 1 次 LLM
out_of_scope — answer 0

代码骨架

def make_rag_graph(*, retriever, chat_model, judge_model, settings):
    async def triage(state): ...
    async def respond(state): ...
    async def rewrite(state): ...
    async def retrieve(state): ...
    async def assess(state): ...
    async def judge(state): ...
    async def generate(state): ...
    async def out_of_scope(state): ...

    def after_triage(state):
        return "respond" if state["triage"] != "content" else "rewrite"

    def after_assess(state):
        return {
            "good": "generate",
            "weak": "generate",
            "empty": "out_of_scope",
            "ambiguous": "judge",
        }[state["grade"]]

    def after_judge(state):
        return "generate" if state["grade"] == "good" else "out_of_scope"

    builder = StateGraph(RagState)
    builder.add_node("triage", triage)
    builder.add_node("respond", respond)
    builder.add_node("rewrite", rewrite)
    builder.add_node("retrieve", retrieve)
    builder.add_node("assess", assess)
    builder.add_node("judge", judge)
    builder.add_node("generate", generate)
    builder.add_node("out_of_scope", out_of_scope)

    builder.add_edge(START, "triage")
    builder.add_conditional_edges(
        "triage", after_triage, {"respond": "respond", "rewrite": "rewrite"}
    )
    builder.add_edge("respond", END)
    builder.add_edge("rewrite", "retrieve")
    builder.add_edge("retrieve", "assess")
    builder.add_conditional_edges("assess", after_assess, {
        "generate": "generate",
        "judge": "judge",
        "out_of_scope": "out_of_scope",
    })
    builder.add_conditional_edges("judge", after_judge, {
        "generate": "generate",
        "out_of_scope": "out_of_scope",
    })
    builder.add_edge("generate", END)
    builder.add_edge("out_of_scope", END)

    return builder.compile()

事件协议

快速路径:  token(固定文案) → done
越界路径:  token(范围说明) → done
正常路径:  sources → token… → done
可选:      phase(等待期间)、citationWarning(引用越界)

三条路径共用同一个 _stream_answer,所以结算和错误处理只有一份。这也是不要把分流提前到 /api/chat 里短路的原因——否则预占额度会泄漏。

落地路线

P0:不改 schema,1~2 天

顺序 改动 验收
1 评测集与检索评测脚本 有 recall@5 / MRR 基线
2 triage + respond + out_of_scope 问候不调用 retriever 和 model
3 历史剥引用 + 预算裁剪 prompt 长度下降,引用不串轮
4 引用范围约束 + 警告 引用合法率可统计
5 phase 事件 等待时有阶段文案
6 阈值标定 站外问题走 out_of_scope
7 追问改写(先拼接,后 LLM) 多轮追问 recall@5 提升

P1:需要改 schema 或配置,3~5 天

顺序 改动 验收
8 pg_trgm + 混合检索 + RRF 精确标识符组 recall 提升
9 assess 分级 + 模糊带 judge 正常路径延迟不变
10 去重与邻接扩展 上下文连续性改善

P2:独立 change

顺序 改动 验收
11 checkpointer + 服务端会话 客户端不再传历史
12 长对话摘要 超长对话不丢早期信息
13 鉴权、配额、多副本限流 可公开部署

我怎么试的

这份路线本身就是实验设计。每一步都遵循同一个模板:

  1. 改一个变量:例如只把 min_score 从 0 调到标定值;
  2. 跑固定评测集:记录 recall、误拒率、越界率;
  3. 看分阶段延迟:确认正常路径的 p50 / p95 没有变差;
  4. 写清楚没有证明什么:例如只证明了检索变好,没证明回答更正确。

建议在仓库里固定一个 backend/eval/ 目录,问题和期望 slug 都进版本控制。这样每次改动前后都能复跑,而不是靠聊天记录回忆。

坑和限制

  • 不要一次全上。 节点越多,越难判断哪一步有效;按 P0 逐项验证。
  • 不要让额外调用进入多数路径。 规则和分数应该覆盖绝大多数请求,LLM 裁判只处理模糊带。
  • 不要让模型自己编号。 编号必须由服务端分配,引用才能稳定。
  • 不要在流开始后再想返回错误码。 状态码和响应头在第一个字节发出时就固定了。
  • 不要忘记失败路径的预算结算。 提前返回不 settle(),额度会慢慢泄漏。
  • 不要把某次分数写成通用结论。 阈值、延迟和召回都依赖模型、内容和硬件。

适合谁

适合准备把这一系列真正落到代码里的人,或者正在评审一个 RAG 方案的人。你可以不采纳全部节点,但建议保留三个顺序:先测量,再修失败路径,最后才考虑增加模型调用。