作者归档:admin

RAG 优化常用的 5 种策略

做 RAG 经常会效果不行,就算是把模型换了更大的,回答依然飘;把向量库换了更贵的,召回还是不稳;把 Prompt 改了很多版,效果依然起起落落。

RAG 的瓶颈大多不在「生成」,而在「检索」。检索做不好,生成只能在不完整的输入上硬编;检索做得稳定,模型反而没那么挑。

今天我们聊讲 5 个在工程中里最常用、ROI 比较高的策略:

  1. 多向量检索
  2. 人工切分打标
  3. 标量增强
  4. 上下文增强
  5. 增加多类型向量

0. 优化什么

RAG 的检索链路,拆开看就两件事:

  • 召回:把“可能相关”的材料尽量找全
  • 排序:把“真正相关”的材料尽量排前

这两件事对应的常见失败模式也很固定:

  • 同义相似但不相关:语义像,但不是答案需要的证据
  • 关键词命中但语义不近:专有名词、编号、表格字段,向量不敏感
  • 被切碎:答案跨段、跨页,chunk 切断了前后依赖
  • 证据形态不对:表格、图片、公式、目录结构,直接 embed 很容易失真
  • 同一问题在不同时间答案不同:版本、日期、渠道不清,检索到旧材料

下面的 5 个策略,分别解决这些问题中的一个或多个。

1. 多向量检索

给同一份内容提供多种“检索入口”

1.1 核心思路

多向量检索的关键点不是「存更多向量」这么简单,而是把用于检索的表示和用于回答的原文解耦

  • 检索阶段:用更适合相似度搜索的表示去匹配(比如摘要、问题式描述、表格的自然语言总结、图片的文字说明)
  • 生成阶段:把原始内容(全文、原表格、原图片引用)交给模型做答案合成,避免摘要丢细节

这种逻辑可以用把 RAG 从「只适合纯文本」扩展到表格、图片等半结构化/多模态内容:
用总结去检索,用原始材料去回答(尤其表格场景很典型:总结容易被召回,但回答必须看原表格字段和数值)。 这种

1.2 什么时候最值

多向量检索在三类数据上收益很稳定:

  • 半结构化文档:表格 + 段落混在一起(财报、年报、审计报告、制度文件)
  • 多模态文档:图片、图表、扫描件(说明书、投标文件、报告 PDF)
  • 长文档:同一个主题分散在多个章节,单一 chunk embedding 容易错过

1.3 工程落地

落地要解决三件事:

  1. 拆分元素类型:把文档切成“文本块 / 表格 / 图片”等元素
    用 Unstructured 这类工具做 partition:先抽取图片块,再用布局模型拿到表格边界、标题候选,再把标题下面的文本聚合成块。

  2. 为每类元素生成可检索的文本表示

    • 文本块:可以生成更短的摘要、关键词式描述、可能的问题集合
    • 表格:生成“表格讲了什么”的自然语言摘要(用来检索)
    • 图片:常见的是「先用多模态模型把图片转成文字摘要,再当文本检索」
  3. docstore 里保留原件
    检索命中的是 summary,但最后喂给 LLM 的是原文/原表格/原图引用。

1.3 常见坑

  • 摘要写得太像原文:检索没变强,只是多存了一份噪声
    摘要应该更「检索友好」:更短、更结构化、包含实体名、指标名、时间范围。
  • 一个元素生成太多向量:向量数暴涨,召回变慢、成本变高
    做到「足够覆盖检索入口」即可,别追求花样。
  • docstore 的映射不稳定:summary 与原件的 id 对不上,线上会出现“召回到 A,返回了 B”的事故
    id 设计要从第一天就稳定,元素级别的主键要可复现。

2. 人工切分打标

用最便宜的方式把「结构」和「业务语义」补回来

2.1 为什么需要人工介入

很多团队一开始会追求「全自动 ingest」,但现实是:

  • 同一套自动切分规则,放到不同类型文档上效果差异很大
  • 文档里真正有用的结构信息,往往不在文本里,而在排版、目录、章节层级、表格布局里
  • 业务里最关键的“可用性信息”(版本、适用范围、地区、产品线、口径)不一定在正文可直接抽出来

人工切分打标解决的是:把检索需要的结构和语义先做扎实,后面的向量、排序、重写才有发挥空间。

2.2 切分的三个规则

  1. 按语义边界切,不按长度切
    章节、小节、条款、定义、流程步骤、FAQ 一问一答,是天然边界。
    “为了 token 均匀”硬切,很容易切断定义与约束条件。

  2. 切分粒度为「可引用证据」服务
    能够被引用、被追溯、被定位的最小单元更重要:

    • 条款编号
    • 表格标题 + 表格整体
    • 小节标题 + 小节正文
    • 定义段落(不要拆)
  3. 保留层级关系
    只存平铺 chunks,后面很难做「向上取整段/向下补上下文」。
    最少保留:文档 → 章节 → 小节 → 段落/表格。

2.3 优先打「可过滤、可路由」的标签

别一上来就做很细的本体论,先打最值钱的:

  • 文档类型:制度 / 产品手册 / 合同模板 / 会议纪要 / 财报
  • 业务范围:地区 / 产品线 / 客户类型 / 适用系统
  • 时效性:生效日期 / 版本号 / 是否废止
  • 可靠性:来源系统 / 审批状态 / 是否正式发布
  • 访问控制:部门、角色、密级

这些标签后面都能进入“标量增强”和“路由策略”,直接影响线上稳定性。

2.4 常见坑

  • 打标体系不收敛:每个人一套标签名
    解决办法很朴素:拉一张白名单表,允许的 key 固定,value 做枚举或正则。
  • 把「主题」当标签:主题不稳定,且和 embedding 重叠
    标签更适合放「硬约束条件」和「业务边界」。

3. 标量增强

让检索从「相似」走向「可控」

这里的「标量」指的是:时间、版本、来源权重、权限、质量分、业务线等可以过滤或打分的字段。它们不靠向量表达,靠规则或数值逻辑表达。

3.1 标量增强解决什么问题

  • 同一问题,不同时间答案不同:检索到旧版本会直接翻车
  • 同一概念,不同地区/产品线口径不同:向量相似度分不出来
  • 噪声文档混进知识库:相似度很高但质量很差
  • 需要可解释、可审计:为什么给出这条证据,要说得清

把这些交给向量相似度,基本靠运气;交给标量逻辑,结果更可控。

3.2 两种最常用的做法

做法 A:先过滤,再向量检索
先用 metadata 把候选集缩小到“可能正确的范围”,再做语义召回。
典型过滤条件:

  • 生效日期 <= 查询时间
  • 版本号 = 当前版本
  • 适用产品线包含用户所属产品线
  • 权限满足访问控制

做法 B:向量召回后,用标量重打分
向量给你 TopK,标量给「业务优先级」:

  • 新版文档加分,旧版扣分
  • 官方来源加分,草稿扣分
  • 被引用次数高/被人工验真过的内容加分

最后把两类分数合成一个总分再排序。

3.3 标量增强的关键点

  • 标量字段要可维护:自动抽取优先,其次半自动,再其次人工
  • 默认值要保守:缺字段宁可不加分,也别乱加分
  • 线上要留日志:每个命中结果,把过滤条件、加分项写清楚,排障会省很多时间

4. 上下文增强

补回 chunk 被切断的前后依赖

上下文增强不是「塞更多文本」,它指的是:让每个可检索单元在被 embed 或被召回时,带上必要背景,避免「孤句误读」。

4.1 你会在哪些场景明显感到缺上下文

  • 规章制度里一条规定引用了前面的定义
  • 财报里一个指标只在章节开头定义一次,后面全是缩写
  • 表格字段含义在表格上方说明里
  • 会议纪要里“同意/不同意”要回看讨论对象是谁

这些内容即便向量召回命中了,模型也很容易误解,因为证据不自洽。

4.2 上下文增强常用的三种实现

实现 1:Embedding 前拼接轻量上下文
把 chunk 的标题路径、章节名、文档名等拼到 chunk 前面,再去做 embedding。
目标是让向量表达里包含“这句话属于哪里”。

实现 2:Parent / Window 思路(召回后扩窗)
先召回一个小块,然后按层级关系取它的父节点(小节/章节)或前后窗口。
这样不会让向量库里每个 chunk 变得巨大,但模型看到的上下文更完整。

实现 3:结构化索引 / 树检索(长文档很常用)
这类方法直接承认“文档是有层级结构的”,检索时先在结构上定位,再下钻到具体段落。

以 PageIndex 为例:它会生成类似「目录」的树结构,然后用 LLM 在树上做推理式检索,强调 No Vector DBNo ChunkingHuman-like Retrieval,并且给出可追溯的页码/章节引用。

4.3 常见坑

  • 上下文拼太多:embedding 变“平均化”,相似度反而变差
    只拼最有区分度的:标题路径、定义短句、字段解释。
  • 扩窗没有边界:一扩就把整章塞给模型,成本和噪声都上来
    扩窗要有上限,优先拿“同小节”而不是“同文档”。

5. 稠密/稀疏两种向量一起用

使用 BM25 集成,把「关键词命中能力」补回来

稠密/稀疏向量是什么。

  • 稠密向量检索(Dense / Embedding)
    适合语义相近的表达,用户措辞变化大也能匹配到。
  • 稀疏检索(Sparse / BM25)
    适合精确词匹配,尤其是专有名词、编号、字段名、错误码、产品型号、合同条款号。

工程上最常见的现象是:
用户问了一个带编号/字段名的问题,向量检索给你一堆语义很像的段落,但就是没有那个编号对应的条款;BM25 往往一搜就中。

BM25 能给我们带来:

  • 召回包含关键字的证据,避免向量漏召
  • 对“必须精确命中”的问题更稳(例如政策条款号、表格字段、系统接口名)
  • 对混合语料更友好(中英混排、代码片段、缩写、符号)

5.1 集成方式

工程里常用两种

方式 A:并行召回 + 合并去重 + 重排

  • BM25 TopK 一份
  • 向量 TopK 一份
  • 合并成候选集,去重
  • 用统一的 rerank(或简单规则)排出最终 TopN

这个方式的优点是直观,问题也直观:候选集会变大,要控制 K 和 rerank 成本。

国内阿里云的向量数据库有多维向量的逻辑,可指定权重召回。

方式 B:BM25 做第一阶段召回,向量做第二阶段精排(两段式)
适合语料特别大、向量检索成本高的场景。BM25 先把范围缩小,再在小集合里做语义相似度和重排。

5.2 常见坑

  • 把 BM25 当主力:BM25 对同义改写不敏感,用户表达一变就丢召回
  • 权重拍脑袋:BM25 和向量的分数尺度不同,直接线性加权经常不稳定
    更稳的做法通常是:先归一化,再做合并;或者交给 rerank 做最终裁决。
  • 分词质量不过关:中文 BM25 的效果强依赖分词/词典
    词典里把产品名、缩写、字段名补齐,收益很实在。

6. 小结

以上的策略也不是一定要一起上,可以按阶段实施:

  1. 人工切分打标:先把结构、版本、权限、范围做干净
  2. BM25 集成:把关键字硬命中能力补齐,减少离谱失败
  3. 上下文增强:解决「切碎」和「孤句误读」
  4. 标量增强:把线上结果变得可控、可解释、可审计
  5. 多向量检索:针对表格/图片/长文档,把跨形态检索打通

这 5 个策略并不冲突,实际生产系统基本是叠加使用:
BM25 兜底精确命中,向量负责语义召回,标量负责边界条件,上下文负责可读证据,多向量负责多形态内容。

在这些策略的基础上,我们可以使用如下的一些评估方式来判断是否优化有效:

  • 召回层指标:TopK 是否包含正确证据(有无命中)
  • 排序层指标:正确证据在 TopK 的位置分布(越靠前越好)
  • 答案层指标:带引用的正确率、引用的可追溯性(页码/条款号/表格位置)
  • 线上指标:无答案率、澄清率、人工升级率、重复追问率

尤其建议把「无答案率」和「引用可追溯性」拉出来单独看,它们最能反映检索链路是否健康。

以上。

AI 编程:程序员变成了程序指导员

去年 Vibe Coding 突飞猛进,AI 编程已经逐渐普及。 很多团队对于写代码这件事的定义开始有一些变化。变化在于产出代码的方式:越来越多的代码来自模型,程序员更多时间花在和模型聊天,把问题说清楚、把边界卡住、把结果验明正身。

我愿意称之为「程序指导员」。写代码仍然在发生,但我们的动作从「逐行敲」转到「聊天与校验」。

1. 程序指导员在做什么

把一段需求交给 AI,得到一段能跑的代码,然后多聊几句,一个功能就完成了。但是这个功能是不是可维护、可上线、可回滚、可观测、可审计,就不太确定了。

程序指导员的核心工作通常包括这几件事:

  1. 把需求翻译成可执行的任务
    需求里混着业务语言、边界条件、历史包袱、隐含约束。模型的信息中这些可能是缺失的。我们要先做一次结构化翻译:输入是什么、输出是什么、失败怎么处理、性能底线是什么、兼容范围是什么。

  2. 把任务拆成模型能稳定完成的块
    一次性让模型写完一个完整功能,也可以,让 CC 多跑一段时间,但成功率不稳定。更稳的方式是拆成小块:数据结构、接口定义、核心逻辑、错误处理、测试、文档、迁移脚本,各自生成、各自验证,然后再组装。这种方式让我们更有掌控力,知道发生了什么,过程可控。

  3. 给足约束,减少「自由发挥」空间
    约束要可检验:必须用现有依赖、必须兼容某版本、必须遵守公司日志规范、必须不新增公网访问、必须在某条 SLA 内、必须覆盖某些用例。

  4. 验收与兜底
    模型会给出看起来合理的实现,也会在边界上“编”。程序指导员要像做 code review + 测试负责人那样工作:读关键代码、跑测试、补测试、压测、看日志、看回归风险、看安全风险。最后要能回答一句话:这段代码出问题,谁来修、怎么定位、怎么回滚。

这套工作方式和当前的 CC 一把梭相比,并不先进,甚至有些落后。

和以前相比,以前也有模板代码、脚手架、复制粘贴、搜索引擎。不同点在于:AI 把「生成」能力推到台前,生成速度极快,错误也更隐蔽,导致「指导与验证」的权重被迫上升。

2. 变了什么

2.1 输入从「代码」变成「任务说明书」

以前的输入主要是我们写的代码和我们改的代码。现在多了一种主要输入:我们写给模型的任务说明书。

这份说明书的质量,直接决定产出质量。写得好,模型像一个执行力强的中级工程师;写得差,模型像一个自信的实习生。

说明书里最重要的内容通常包括:

  • 目标:要解决什么问题,做到什么程度算完成
  • 环境:语言版本、框架版本、已有目录结构、现有依赖、运行方式(一般在规则上下文中给出)
  • 接口:入参、出参、错误码、异常策略、幂等、重试、超时
  • 约束:性能、资源、兼容、安全、合规、日志、监控
  • 验收:必须通过哪些测试,用哪些样例验证,输出应满足哪些断言

把这些写清楚,能把 80% 的返工挡在模型生成之前。

2.2 工作节奏从「连续编码」变成「短回路迭代」

传统编码经常是长回路:写一段、跑一遍、再改。AI 编程的高效来自短回路:AI 生成完成,自动编译构建,自行测试,然后马上验收,发现偏差、立刻补约束再生成。

短回路的关键在于每一轮都要带着明确的失败信息回去:哪条测试挂了、哪个接口不对、哪个边界漏了、哪个依赖版本冲突。模型对这种「可定位的反馈」反应更稳定。

2.3 代码量不再是效率指标

代码生成变快之后,代码量会失真。以前一个人一天写 500 行算多,现在模型十秒能吐 500 行,一天几千行可用的代码随随便便。

更有意义的度量指标会转向:

  • 需求到可用版本的周期
  • 线上缺陷率与回滚率
  • 变更影响范围(改动越小越好)
  • 可维护性(复杂度、重复度、依赖扩散)
  • 测试覆盖与回归效率

如果团队还用「写了多少行」「提了多少 PR」来衡量,会很快走偏:大家都能刷产出,系统质量却下降。

2.4 「看懂代码」变得更重要

模型写的代码往往「像那么回事」,也可能更长、更绕、更喜欢堆抽象。程序指导员必须能快速识别几类问题:

  • 关键路径上不必要的复杂度
  • 隐性性能问题(多余的拷贝、无界缓存、低效循环)
  • 错误处理缺失(吞异常、错误码混乱、重试风暴)
  • 并发与资源泄漏(锁、连接、文件句柄)
  • 安全问题(注入、越权、敏感信息日志、依赖风险)
  • 与现有系统契约不一致(字段含义、时序、幂等等)

以前也需要这些能力,但当代码产出速度暴涨时,「看懂与筛掉问题」的能力会直接决定我们能不能把速度兑现成质量。

3. 没变什么

变化再大,有些东西一直没变,而且变得更值钱。

3.1 对业务的理解仍然是门槛

模型可以补全语法、补齐样板、生成测试,但它很难替我们承担「业务正确性」。尤其在边界条件、例外流程、历史债务、灰度策略上,错误经常不是编译错误,而是业务事故

谁最懂业务,谁最知道「哪些地方不能动」「哪些数据不能算错」「哪些流程不能重试」,谁就更能驾驭 AI 编程。

换一个大家更常用的词语,就是领域知识要在线,否则错了你也不知道错了。

3.2 系统设计能力仍然决定上限

模型擅长在给定结构里填充实现,不擅长从零做合理设计。系统边界怎么划、数据怎么流、接口怎么稳、状态怎么管理、失败怎么收敛、观测怎么做,这些决定了系统能不能长久演进。

如果把“设计”也交出去,模型会给一个看似完整的方案,但常见问题是:

  • 组件拆得漂亮,运行链路混乱
  • 过度抽象,改一处牵一片
  • 忽略现有基建与规范
  • 缺少可观测与运维视角

当然,这些问题都可以通过提示词来解决,不过对于系统设计的认知还是需要我们来把握,至少我们得知道什么是好什么是坏。

系统设计这件事,仍然需要人来负责,并且要更早介入。

3.3 责任边界没有变化

代码是模型生成的,并不改变责任归属。线上出了事故,审计追责、复盘改进、长期治理,仍然落在团队身上。

在群里看到一个消息,最近有一个团队 AI 生成的导致线上数据全部被覆盖,团队绩效今年基本和他们没有关系了。

所以「让模型写」不是免责理由,反而要求流程更严:评审、测试、灰度、回滚、监控、告警、应急预案,一个都不能少。

4. 程序指导员需要哪些基础认知

4.1 对模型能力边界的认知

模型的强项:

  • 快速生成代码、接口定义、CRUD、数据转换
  • 根据已有代码风格补齐实现
  • 生成测试用例框架、mock、基础断言
  • 把自然语言需求翻译成「看起来像」工程方案

模型的弱项:

  • 对真实业务语义的可靠理解(尤其隐含规则,,因为其没有上下文,甚至有些隐含规则我们自己也没有意识到)
  • 对运行时约束的自发遵守(性能、资源、稳定性)
  • 对项目历史约定、隐性依赖的自动继承
  • 对安全与合规的默认正确
  • 对「细微但关键」的一致性(字段含义、状态机、时序)

程序指导员要把弱项当成默认风险。

4.2 任务拆解能力

拆解不是把大需求拆成很多小需求就结束了,而是拆成“可验证”的单元。

可验证的含义是:
每一块都能用编译、单测、静态检查、契约测试、跑一段 demo 来确认对不对。

拆解时常见的顺序:

  1. 先定接口与数据结构(契约优先)
  2. 再做核心逻辑(关键路径先跑通)
  3. 补错误处理与边界(把失败收敛)
  4. 加测试与观测(让后续修改可控)
  5. 最后做重构与清理(收敛复杂度)

这个顺序能减少返工,也更适合把生成结果分段纳入工程体系。

4.3 约束表达能力

约束要写成「可执行」的规则。

常见可执行约束:

  • 依赖:禁止新增依赖;必须使用项目已有库
  • 版本:必须兼容某版本运行环境
  • 性能:某接口在某数据量下耗时上限
  • 幂等:重复请求的处理方式
  • 日志:必须打哪些字段;禁止打印哪些字段
  • 错误:错误码范围;异常抛出策略;重试策略
  • 兼容:老接口字段不可删;新增字段默认值策略
  • 安全:输入校验、权限校验、敏感信息处理

当我们把这些写清楚,模型就可以更规范的交付了。

4.4 验证习惯与测试能力

验证还是要靠工程化手段。

最低配置的验证链路:

  • 静态检查:lint、类型检查、依赖扫描
  • 单元测试:关键逻辑与边界条件必须有断言
  • 集成测试:接口契约与关键链路
  • 回归策略:哪些模块必须跑全量,哪些可抽样
  • 观测:日志、指标、链路追踪的基本补齐
  • 灰度与回滚:发布策略与开关方案

把这些链路搭好,AI 才能变成稳定的生产力工具。否则它更像一个加速出错的发动机。

5. 小结

程序员变成程序指导员,不是职位变了,是工作重心变了:写代码的时间变少,把问题讲清楚、把系统守住、把风险挡住的时间变多。

最近阿里出来的 P10 毕玄,在其创办的公司贝联珠贯中宣布不再按传统的专业分工,所有的人都叫 Agent 全栈工程师。

我想象中的团队也是这样,通过合并工种,减少沟通,让 AI 发挥出更大的价值。

在做这些之前,我们需要问一下自己三个问题:

  • 我们的验收标准有没有变得更清晰
  • 我们的测试与观测有没有跟上生成速度
  • 我们有没有把隐含知识变成显性规则

答案越清楚,AI 带来的就越接近真实效率。否则只是把编码速度提上去,把返工和事故也一起提上去。

以上。

AI Agent 进阶架构:渐进式披露和动态上下文管理

当 Agent 做到一定复杂度,问题往往不在模型能力本身,而在上下文怎么给、工具怎么给、流程怎么控。同一套模型,有的团队能把它用成「能稳定交付的执行系统」,有的团队只能得到「偶尔灵光一现的聊天机器人」,差距就在架构。

早期提示词工程里,上下文基本是静态的:一次性把提示词写好,然后让 LLM 自己发挥。随着架构的演化,,上下文变成动态的,它会「收」和「放」:

收(Contract):渐进式披露。屏蔽无关信息,减少 Token 消耗,聚焦注意力。(解决“准确性”)
放(Expand):动态注入。根据交互状态,主动引入外部话题、记忆片段或世界观设定。(解决“丰富性”与“持续性”)

这是一种系统架构策略:用有限 Token 去管理无限信息,用非确定性模型去执行标准化流程

1. 三个典型瓶颈:Context、工具、SOP

复杂 Agent 基本都会遇到三个主要的问题:

  1. 上下文爆炸(Context Explosion)
    文档、代码、历史对话、用户画像、任务状态……你不可能全塞进 Prompt。硬塞进去也会出现“Lost in the Middle”,关键信息被淹没。

  2. 工具过载(Tool Overload)
    工具越多,定义越长,Token 越贵;更严重的问题是:工具选项越多,模型选择正确工具的概率越低,尤其是多个工具功能相近时。

  3. 执行不可控
    当我们希望它按 SOP 做事(先检查、再验证、最后提交),它却容易跳步、漏步,或者为了“把话说圆”而瞎编执行结果。

「渐进式披露 + 动态上下文管理」就是对这三件事的统一解法:不要一次把世界交给模型,而是让模型在每一步只看到它此刻需要看到的东西。

2. 渐进式披露

渐进式披露不是少给信息,是分阶段给信息

有人把渐进式披露理解成省 Token。省 Token 是结果,不是核心。

核心是:把一次性的大上下文,拆成多轮的决策—反馈—再决策。每一步只给与当前决策相关的最小信息面,减少噪音,让模型的注意力更集中,也让系统更可控。

一个直观的工程化表述:

  • 不是构建一个「全量 Context」
  • 而是维护一个「可增长的 Context」,并且增长受控

你会看到两个动作交替出现:

  • Contract(收缩):隐藏、裁剪、摘要、替换为索引
  • Expand(扩张):按需加载片段、工具子集、记忆、世界观、流程状态

3. 数据层

传统做法,使用 RAG 很容易走向粗暴:检索到的内容直接拼进 Prompt,能拼多少拼多少(可以配置)。结果通常是两种:

  • Token 变贵,延迟变长
  • 模型注意力被稀释,反而更不准

渐进式披露在数据层的落地方式,是把「获取信息」做成连续的动作序列,而不是一次性拉满。

参考 AI Conding 很贴近工程实际的步骤:

  • 初始 Prompt 只有任务描述
  • AI 发现信息不足,发起 lsgrep 请求
  • 系统只返回 ls 的结果(文件名列表),而不是文件内容
  • AI 选中目标,发起 read_file
  • 系统这时才披露文件内容

这里关键点不是 ls/grep/read_file 这些名字,而是信息披露粒度

  • 先给目录/索引(低成本,低噪音)
  • 再给片段(命中后才扩大)
  • 最后给全文(只在确认需要时才给)

3.1 披露层级建议:L0 到 L3

可以把上下文分成几层,这里定义的层级不是标准答案,但思路是这么个思路:

  • L0:任务和约束
    用户需求、输出格式、禁止事项、成功标准。L0 必须稳定,尽量短,长期驻留。

  • L1:证据索引
    文件列表、章节目录、数据库表名、日志摘要、搜索结果标题。只给“在哪里”。

  • L2:证据片段
    命中的段落、代码片段、表结构、关键日志区间。只给“相关部分”。

  • L3:证据全量
    全文档、完整文件、长对话历史。尽量少用,只在确实需要通读时开放。

系统要做的事是:让模型先用 L1 做定位,再用 L2 做判断,最后才允许 L3 进场。这样不仅省 Token,还可以减少模型在噪音里自我发挥的空间

3.2 动态注入

动态注入常见误区:用户问 A,你检索 A;用户又问 B,你把 A+B 都塞进去;几轮后上下文就乱了,且不可控了。

比较常用的做法是引入「上下文预算」和「淘汰策略」:

  • 每轮允许注入的 Token 上限(硬预算)
  • 驻留区(长期有效,例如用户身份、偏好、当前任务)
  • 工作区(当前步骤的证据片段)
  • 冷存区(旧证据移出,保留索引或摘要)

淘汰的对象通常是“旧证据全文”,不是“任务状态”。任务状态丢了,模型就会重复问、重复做;证据全文丢了,大不了重新检索。

4. 工具层

工具越多越强这件事,在 Agent 里是反的:工具越多,模型越容易犹豫、选错,甚至编造「我已经调用了某某 工具」。

渐进式披露在工具层的做法是:分层路由,按需可见

参考一个很实用的层级披露思路:

  • Root 层只披露 5 个大类工具:代码类文档类部署类数据库类通知类
  • 模型先选大类,例如“我要查数据”-> 数据库类
  • 下一轮 Prompt 才披露数据库相关的具体工具,例如 sql_query, get_table_schema

我们可以把它当成「工具菜单」:

  • 第一屏:只显示一级菜单
  • 点进去:才显示二级菜单
  • 系统控制可见性,而不是让模型在 100 个工具里裸选

4.1 工具披露带来的三个工程收益

  1. Token 控制更直接
    大量工具的 schema 描述会花费大量的 Token。层级分发能把「工具定义成本」分摊到多轮,而且只在需要时支付。

  2. 工具选择准确率提升
    选项少,模型更容易做对;更重要的是,减少「近义工具」同时出现。

  3. 安全策略更好落地
    不该给的能力,默认不可见。你不需要在 Prompt 里反复警告“不要调用某某工具”,直接让它看不见。

4.2 「工具可见性」本质是一种权限系统

很多团队权限做在网关、做在后端鉴权,但 Agent 的权限还应该做在“可见性”上:

  • 看不见:降低误用概率
  • 看得见但不可用:模型会反复尝试,浪费回合
  • 可用但有条件:需要把条件变成流程状态的一部分(下一节讲 SOP)

5. SOP 层

SOP 层就是当前很火热的 Skills,且不仅仅是 Skills,它是把流程写进披露逻辑,而不是写在提示词里

企业场景里,最怕的是「看似完成、实际没做」,而这在大模型的输出中很常见。让模型「请遵循 SO」”意义不大,它会漏步骤,而且它很擅长把漏掉的步骤用语言补上。

渐进式披露在 SOP 上的落地方式,是在我们的系统里做“流程锁”:上一步没通过,下一步的工具就不出现

参考一段很清晰的流程控制(关键点直接引用):

  1. 阶段一(Lint):系统只披露 Lint 工具和当前 Diff,隐藏 Commit 工具
  2. 阶段二(Test):Lint 返回 Success 后,系统才披露 Test 工具
  3. 阶段三(Commit):只有测试通过,系统才披露 git_commit

这套逻辑解决的是“话术不可信”的问题:模型可以说“我已经测试通过”,但系统的状态机不会因为它一句话就放行。放行只能来自可验证的工具回执

5.1 SOP 控制要点

把「检查点」设计成机器可判定

SOP 最容易失败的地方是检查点含糊,比如“确保无问题”“确认完成”。Agent 体系里要改成:

  • 有工具回执的:以回执为准
  • 没有工具回执的:以人工确认或外部系统状态为准
  • 不能验证的:不要当作放行条件

能自动化判定,就不要让模型自评。

6. 为什么要引入 Agent Skill

这里本质是一种是工程分层,当然也是概念包装。

很多人会问:这些用代码控制不就行了,为什么还要提 Agent Skill?

把 Skill 当成一个架构抽象,会更容易把系统做稳:它解决的是解耦、复用、状态感知

这里把关键逻辑说透:

6.1 Skill 是「上下文的容器」,用完即走

没有 Skill 时,你往往会得到一个越来越大的系统提示词:把所有话题、所有工具、所有规则都塞进去。结果就是注意力迷失、指令冲突、Token 爆炸。

有 Skill 后,你把「某一类任务需要的提示词 + 可用工具 + 知识入口」封装到一起:

  • 需要时加载
  • 不需要时卸载
  • 上下文保持干净

这和「渐进式披露」是同一件事:Skill 是披露的载体

6.2 Skill 是「动态注入」的边界

动态注入真正难的是边界:注入多少、注入什么、何时撤回。

Skill 让边界清晰:

  • 注入不是“往 Prompt 拼字符串”
  • 注入是“激活某个 Skill”,让它把需要的最小信息面带进来

系统因此更容易做预算、做审计、做回放。

6.3 Skill 让路由变成可维护的系统,而不是靠直觉写 prompt

复杂 Agent 一定会路由:用户一句话可能触发“查资料 / 写代码 / 安抚情绪 / 改流程 / 发通知”。

Skill 体系下,路由的输出是“激活哪些 Skill”,而不是“写一段更长的提示词”。这会直接改善维护体验:

  • 你能统计每个 Skill 的触发率、成功率、平均 Token
  • 你能对某个 Skill 单独迭代,而不牵一发动全身
  • 你能为不同用户、不同权限加载不同 Skill 组合

7. 动态上下文管理

动态上下文管理要管理「状态 + 证据 + 权限」。

把上下文当成一段文本来拼接,迟早失控。更合理的视角是:上下文是系统状态在模型侧的投影。

建议把上下文拆成四类对象,每一类有不同的生命周期:

  1. 任务状态
    当前处于哪个阶段、已完成哪些检查点、下一步允许做什么。它要短、稳定、结构化,尽量每轮都带。

  2. 证据
    检索片段、工具输出、外部信息。它要可引用、可追溯、可淘汰。

  3. 偏好与长期记忆
    能影响输出风格或长期策略的东西。它不该频繁变化,变化要可控,最好有写入门槛。

  4. 能力与权限
    工具可见性、工具可用性、流程放行条件。它是约束,不是参考建议。

8. 可执行的架构清单

按“先做什么更值”排:

  1. 先做工具可见性控制
    工具分层,默认只给 Root 类目;按分支披露具体工具。

  2. 把 SOP 变成状态机放行
    上一步成功回执出现,下一步工具才可见。失败就停在当前阶段,不要让模型口头放行。

  3. 把上下文分区:驻留区 / 工作区 / 冷存区
    驻留区短且稳定;工作区有预算;冷存区只保留索引/摘要。

  4. 先索引后片段的披露策略
    任何大文本资源都先给目录、标题、命中位置,再给片段,不要一上来就全文。

  5. Skill 化你的上下文与工具组合
    让“动态注入”从拼 Prompt 变成“加载/卸载 Skill”。一开始不需要 100 个 Skill,把高频的 5–10 个先做稳。

  6. 把观测补齐
    记录每轮:披露了哪些证据、开放了哪些工具、触发了哪些 Skill、用了多少 Token、是否命中检查点。没有这些数据,后面很难迭代。

9. 小结

一个成熟的 Agent 系统,外观上像在聊天,内部其实在跑一套受控的执行架构:

  • 信息不是一次塞满,而是按步骤披露
  • 工具不是全量开放,而是按层级开放
  • 流程不是靠自觉,而是靠状态机约束
  • 记忆不是越多越好,而是可写入、可淘汰、可追溯

把这四件事做好,Agent 会越来越像一个靠谱的执行系统:该问的问清楚,该查的查到证据,该做的按流程做完,做不到就停下来,不会硬编。

这就是「渐进式披露 + 动态上下文管理」的价值:不是让 Agent 说得更像,而是让它做得更稳。

以上。