铃阅
❌

普通视图

Knowledge Wiki:面向 AI 的项目知识层建设实践

2026年4月7日 18:31

原创 有赞共享技术 2026-04-07 18:31 浙江

AI Coding 的上限,不只取决于模型,更取决于工程底座。本文结合 Harness Engineering,分享我们如何把隐性经验沉淀成 wiki 与 skill,让 AI 更快理解业务、更稳完成任务,并把知识真正变成团队资产。

每一次使用都是对知识库的投资,每一次沉淀都让下一次生成更精准。这不是线性增长,而是用得越多,效果越好;效果越好,用得越多的复利效应。


一、为什么要做知识库?

1.1 AI Coding 真正缺的不是模型能力

过去一年密集使用 AI Coding 下来,我越来越觉得:当前最大的瓶颈不是 AI 能不能写好代码,而是我们能不能把任务目标准确地传达给它。

套用信息论的概念来理解这件事——向 AI 传达一个任务目标,需要输入的信息量越大,任务成功的概率就越低。对比自动驾驶,人类给 AI 的输入极简(一个终点坐标),信息熵几乎为 0。但企业级软件研发呢?一个需求背后是领域模型、业务规则、技术约束、团队规范、历史决策……这些知识如果不被体系化沉淀,每一次与 AI 的交互都在重复"人肉手艺"式的上下文搭建。

所以本质上,知识库要做的事情就是降熵——把人脑中的专家知识提前结构化、外化,降低每次人机协作的信息传递成本。

1.2 Workspace 模式下的现实困境

在推进新的产研协作流程——将前端、后端、多个关联项目打包为一个 workspace,产研基于 workspace 进行协作。但实际用下来,遇到了两个很现实的问题。

第一个是跨项目的上下文断裂。业务域内的项目相互关联,很多功能需要跨项目调用。传统做法是在项目 A 中生成设计方案,再手动复制到项目 B 作为上下文——低效、易丢信息、体验很差。

第二个是代码膨胀导致 AI "降智"。当 workspace 内项目和代码量增多后,AI 不理解领域知识,只能靠关键字搜索代码。搜回来的片段往往彼此孤立、缺乏系统语义,上下文被低质量信息填满,AI 的输出质量肉眼可见地下降。更麻烦的是,上下文窗口会随着工作推进逐渐"腐烂"——前面的无效信息越积越多,后面即使是简单任务也开始出错。

1.3 真正的痛点藏在代码之外

实践中一个很深的感受是——关键知识不在代码里,而在飞书文档中、在人的大脑中。

同样一个线上问题,有人 5 分钟定位到根因,有人要折腾 2 小时。差距不在能力,在于经验能不能被沉淀和共享。那些"老员工知道但说不出来"的东西——太细节不适合放组件文档,太具体不适合放开发规范,知道的人一次性解决,不知道的人反复踩坑。这类知识的缺失,直接导致 AI 在排查问题、方案设计、代码实现时容易走偏。

说到底,上下文工程的核心挑战不在于怎么写提示词,而在于 Agent 在正确的时刻能拿到正确的信息。


二、Wiki 的内容定位:不做代码讲解稿

2.1 为什么不做 Code Wiki?

最初我们想做的是 Code Wiki——把代码翻译成文档。参考了一些业界方案,包括自动生成架构设计、功能模块说明的 RepoWiki 类工具,以及 deepwiki 等开源项目。

评估下来,觉得全量 Code Wiki 现阶段太重了:

  • 基模能力在快速增强,AI 理解代码的能力已经很强了。把代码再翻译一遍成文档,投入产出比不高

  • 代码变更频繁,wiki 与代码的同步本身就是个难题。AI 写代码的速度是以前的 10 倍,废弃的速度也是 10 倍,知识库按原来的节奏维护,必然跟不上

  • 过时的 wiki 比没有 wiki 更危险——AI 会把错误描述当作"先例"系统性地复用

所以我们走了一条更轻量的路:提炼代码中的关键概念、关键流程、关键逻辑,提供代码导航指引——帮 AI 快速理解领域知识、快速定位上下文和关键代码入口,具体实现细节交给代码本身。

2.2 五类知识

想清楚"什么该写进 wiki"比"怎么写"更重要。我们定义了五类允许沉淀的知识,核心标准是:AI 从代码中难以自动发现的信息。

反过来,以下内容不沉淀:纯实现细节、逐行代码说明、SQL 细节、一次性排查过程、没有复用价值的临时讨论、证据不足的猜测。

一句话概括:wiki 只提供认知、导航与稳定经验;具体分支、条件、异常、SQL、配置值这些,回到代码、日志或数据里去找。

2.3 外部知识怎么筛选

飞书文档、设计方案这些外部知识也值得沉淀,但要筛选。有些文档已经过时,有些和代码重复,直接搬进来反而是噪音。筛选标准四条:

  1. 结论稳定,不是一次性现象或临时猜测

  2. 后续理解、排障、变更时仍有复用价值

  3. 不是代码、日志、数据里一眼可见的事实

  4. 能明确对应到某段代码逻辑、链路职责或现有 wiki 缺口


三、我们是如何做的?

3.1 架构:知识库跟着 Workspace + Git 走

知识库放哪里,大致两条路:集中式管理,或者分布式跟着代码走。我们选了后者。

IDE 的 workspace 是个管理目录,本身不具备文件管理能力,所以引入了 git submodule——workspace 是一个独立的 git 工程,下面每个项目作为 submodule 引用。wiki 以 .wiki/ 目录存在于每个层级:

    <workspace>/
    ├── AGENTS.md                        # workspace 级 AI 指令,默认维护在这里,优先借助 knowledge-wiki 理解问题
    ├── .wiki/                           # workspace 级 wiki(领域级)
    │   ├── README.md                    # 总入口:应用清单 + 专题文件索引
    │   ├── cross-app-overview.md        # 固定:跨应用概念映射 + 应用协作边界
    │   ├── flows/                       # 跨应用业务流程(按业务域聚合,每个文件覆盖一个域的完整跨应用链路)
    │   │   └── <domain>.md              # 某业务域跨应用流程
    │   ├── global-conventions.md        # 固定:全局规范 / 默认约定
    │   ├── 90-tasks.md                  # 初始化临时任务清单(仅 init 过程存在,完成后删除)
    │   └── pending-confirmations.md  # 待确认事项汇总(阶段性持续更新)
    │
    ├── <app-a>/
    │   ├── .wiki/
    │   │   ├── README.md                # 应用总览:定位 + 汇总核心概念 + 上下文清单
    │   │   ├── <context-1>.md           # 上下文完整信息(定位 + 流程 + 异步链路 + 导航 + 排障/规范)
    │   │   └── <context-2>.md
    │   └── src/...
    │
    └── <app-b>/
        └── .wiki/
            └── ...

    为什么选这个方案?几个实际考量:

    • 知识和代码"近"。需求涉及知识变更时,wiki 和代码在同一分支一起提交,天然同步。当体系的核心资产从代码变成知识文本后,git 就是天然的升级机制,pull 完成升级,diff 看到每一行变化

    • 天然的业务隔离。"商品"在零售和教育里含义完全不同,workspace 级别的隔离避免了知识"串台"

    • workspace 级承载跨应用知识。概念映射、协作边界、跨应用主流程统一维护,AI 能快速掌握领域全貌

    • 开发者能直接看到。方便管理维护,也帮新人快速理解领域

    分布式方案也有不足——各域知识无法交叉检索、难以全局统计。这是个取舍,没有绝对正确的答案,我们也在持续评估。

    3.2 渐进式披露,而非向量检索

    知识库怎么让 AI 找到需要的内容?很多团队的第一反应是向量检索。我们没选这条路,而是用了渐进式披露(Progressive Disclosure)——wiki 的目录结构本身就是检索路径,AI 按 workspace → app → context 逐层下钻,每层只拿刚好够判断方向的信息。

    为什么不用向量? 项目知识是强结构、强边界的——"订单创建"和"订单复制"在向量空间里很近,但排障路径完全不同。向量检索返回的是脱离层级的碎片,AI 拿到一段 context 级的排障知识,却不知道它属于哪个 app、在领域里处于什么位置。而且对于跟着 git 走的轻量方案,额外部署 embedding 服务和向量库,架构上也不匹配。

    渐进式披露的核心:每个 wiki 文件开头都有 YAML metadata 的 description 字段,AI 读到摘要就能判断是否相关,不需要读完全文。一个只涉及单个 context 的问题,可能只需要读 3 个文件就够了——上下文占用最小,层级关系天然保留,确定性强,零基建依赖。

    3.3 初始化:多 Agent 协作的逆向工程

    image

    初始化是最关键也最难的一步——要基于代码逆向工程提炼有价值的知识,而每个项目的代码量动辄数十万行。

    我们设计了 Controller → Implementer → Reviewer 的多 Agent 协作模式。核心思想是化整为零——先按应用拆 Agent,再按上下文拆,知识层层收敛、层层汇聚。

    整个初始化严格遵循一个原则:先识别流程,再穷举概念,再归并流程,再划分上下文,最后收敛概念并写 wiki。 不是拿到代码就开始写,而是通过多轮扫描-穷举-归并-审视,确保不遗漏、不失真。

      Phase 0   全局扫描 ──→ 发现所有应用,提取全局规范候选
      Phase 1   逐应用建模
        ├── 扫描应用结构 ──→ 入口、消息、服务、实体、包结构
        ├── 应用表面盘点 ──→ 服务簇 / 消息簇 / 实体簇 / 概念锚点
        ├── 候选流程穷举 ──→ 所有可能的业务流程
        ├── 候选概念穷举 ──→ 所有可能的业务概念
        ├── 流程归并去重 ──→ 合并同类,拆分异类
        ├── 划分上下文   ──→ 基于流程簇,不是按 Maven 模块切
        ├── 上下文写作   ──→ 派发 Context Implementer(可并行)
        ├── 二次审视     ──→ 覆盖关系复核,防止遗漏
        └── 应用 README  ──→ 汇总核心概念与入口索引
      Phase 2   Workspace 聚合 ──→ 跨应用概念映射 + 协作边界 + 全局规范
      Phase 3   审查收尾 ──→ 质量门禁 + 清理过程产物

      这里有几个关键的设计决策,值得展开说:

      上下文 ≠ Maven 模块。 上下文是业务切面,不是技术分层。只能基于流程归并后的 Flow Cluster Map 来划分上下文,不能图省事直接按包名切。

      一个 SubAgent 只拿最小上下文。 每个 Context Implementer 只接收一个 context 的最小信息包,避免上下文过载。这本质上是一种"上下文防火墙"——Harness 思想在 Agent 编排层面的应用。就像驾驭一匹马,你不能把所有缰绳都交给它,而是要通过约束和引导让它走在正确的路上。

      异步链路是最高优先级。 Producer 和 Consumer 之间没有直接调用关系,AI 从代码里根本串不起来。这恰恰是 wiki 最大的价值——把 AI 看不到的"暗线"显式记录下来。以及 TSP 回调等异步链路。

      所有候选都必须有去向。 候选流程和概念不能"无声消失",每一项最终必须是保留、并入、排除三选一,且排除要有原因。这也是 Harness 思想——对过程的每一步施加可审计的约束,不允许不可解释的丢失。

      推荐在 claude code, codex, cursor 等支持 subAgent 的环境中执行。初始化过程比较耗时。

      3.4 持续更新:轻量级方案

      初始化只是起点,持续更新才是知识库的生命力。

      我们调研了几种方向:

      • Hook 驱动:基于 IDE 的 Hook 能力,知识层层累积,从观察到候选到提案到确认补丁。完整度很高,但依赖特定 IDE 能力

      • Commit 驱动:Git Commit 时自动分析增量代码语义,同步沉淀到 Wiki。自动化程度高,但准确率存疑

      考虑到团队使用的 AI IDE 多样(Cursor、Windsurf、Claude Code 等),存在兼容性问题,且上面几种方案实现都偏重,我们最终选了最轻量的方案——AGENTS.md + Skill 触达。

      AGENTS.md 是 IDE 级别的"常驻指令",在 workspace 级配置两个指令块:

      • Knowledge Wiki First:引导 AI 优先读取 wiki 补齐认知,遇到术语、边界、链路不清时,先查 wiki 再查代码

      • Knowledge Capture & Update:当分析过程中形成稳定、可复用的知识时,主动触发更新提案

      只依赖 skill 的 description 做触发,匹配率不够理想。AGENTS.md 是"始终在场"的指令,能确保 AI 在日常工作中始终保持两个习惯:遇事先查 wiki,有收获就提案沉淀。

      这里还有一个很重要的落点:最终交付的结果产物不是一篇方法说明,也不只是一套目录规范,而是一个可以被安装、复用、传播的 skill。 只有把方法论固化成 skill,它才不依赖某个人记得流程、记得提示词,才能真正进入团队的日常工作流。

      Skill 则定义了三种核心模式:

      • read:按 workspace → app → context 逐层下钻读取,命中后立即切回代码分析

      • init:执行上面说的多 Agent 初始化

      • update:生成更新提案,用户确认后写回

      这三种模式基本覆盖了知识库落地最常见的几个场景:首次建设、日常补齐认知、持续沉淀更新。 对使用者来说,不需要先完整理解底层设计,只需要在对应场景下触发 skill,就能获得相对一致的行为。

      这也是它更容易推广的关键。相比“先讲一遍理念,再要求大家按规范手工执行”,skill 把方法论封装成了可执行能力:团队可以直接安装、直接试用、直接复用;不同 IDE、不同项目组也更容易以统一方式接入。知识库因此不再只是一个局部实践,而更像一个可复制的工程组件。

      update 的闭环很短:

        判断是否值得沉淀 → 提炼候选 → 回看已有 wiki 确定落点
        → 当前回复输出提案 → 用户确认 → 写回 wiki

        每条提案必须说清"为什么写、写到哪里、依据什么、为什么不是别处"。遵循最小作用域原则——能写 context 不写 app,能写 app 不写 workspace。


        3.5 它实际带来了什么

        如果把这套机制放回日常研发场景里看,价值主要体现在四个层面。

        第一,AI 建立业务认知更快了。 过去每次开启一个新任务,都要先花很多轮对话给 AI “补课”;现在有了 wiki,AI 先读摘要和结构,再进入代码,建立基本认知的成本明显下降。

        第二,跨应用协作和异步链路第一次有了可复用的“地图”。 应用之间的职责边界、概念映射、上下游关系,以及 NSQ、TSP 这类代码中天然不连续的异步链路,都能被显式记录下来。没有这层知识时,AI 往往一到应用边界就停住,或者在异步链路上直接断线。

        第三,上下文利用效率更高了。 分层披露让 AI 只读取当前判断所需的那一层信息,减少噪音和无效上下文占用。不是把更多信息塞给 AI,而是把更合适的信息,在更合适的时刻给它。

        第四,它开始从“文档工程”变成研发基础设施。 一次沉淀,不只服务某一次对话。方案设计、代码审查、线上排障、需求分析,都会反复复用这层知识;而 skill 化之后,这套能力也更容易被复制到不同团队、不同项目、不同 IDE 中。知识被放进工程流程后,才会真正开始产生复利。


        四、走过的弯路和一些思考

        4.1 知识不是越多越好

        做知识库很容易陷入一个误区:觉得写得越全越好、覆盖得越细越安心。但实际用下来会发现,知识写多了反而是噪音,把真正重要的东西淹掉了。

        传统代码写了就确定性运行,但 Agent 的行为取决于上下文——它消费知识的方式和人不一样,需要的是精准的导航线索和清晰的边界声明,而不是面面俱到的"知识大全"。这个认知和 DDD 里的一个道理很像:限界上下文的价值不在于描述了什么,而在于明确了边界在哪里。知识库也是一样,边界比内容更重要。

        这也是 Harness Engineering 给我最大的启发。Harness 的核心不是给 Agent 更多能力,而是通过约束、反馈回路、可审计的过程控制,让 Agent 在正确的轨道上运行。知识库不是往里塞越多越好,而是要做好"准入控制"——每一条知识都必须有明确的价值和边界,否则就是在给 Agent 制造干扰。

        4.2 多用、多沉淀,复利才会来

        知识库最怕的不是写得不好,而是没人用、没人更新。结构可以迭代,内容可以修正,但如果团队没有形成"遇事先查 wiki、有收获就沉淀"的习惯,知识库就是个摆设。

        我们的经验是,前期一定要主动推——每次 AI 因为缺失知识走偏了,就是一次沉淀的信号。不要等"空下来再整理",那一天永远不会来。当场提炼、当场写回,哪怕只是一句话的排障线索,累积起来价值巨大。

        工程体系必须从自己的土壤里长出来,不存在一个"最佳配置"直接套用。别人的方案可以参考,但最终要适配自己的技术栈和团队习惯。每次沉淀不是在增加维护负担,而是在购买未来的效率。

        4.3 复利效应是真实存在的

        实践下来最直观的感受就是复利效应。一个典型的例子:某类配置问题的排查时间从 30-60 分钟降到 1-2 分钟。一开始团队对知识库的反馈问题每周能有 10 多个,坚持沉淀一段时间后,降到了 1-2 个。

        早期投入确实枯燥——花时间构建结构、沉淀知识、打磨模板。但随着模型能力增强和 Agent 框架成熟,前期积累的知识资产产生了疯狂的复合回报。在 1000 个文件以上的代码库中,效果尤其明显。

        这印证了一个判断:知识沉淀的价值随规模增长加速释放。 量变引发质变,不是空话。

        4.4 关于 Harness:驾驭 Agent,而不是放任它

        最近 Harness Engineering 的讨论很多。我理解它的本质是——在 AI 编程中,除了模型能力本身,更重要的是构建一个完整的"驾驭系统":约束、反馈、验证、治理。

        knowledge-wiki 其实就是 Harness 思想在知识层面的落地:

        • 约束:wiki 有明确的准入规则,不是什么都往里写

        • 反馈:AI 读取 wiki 后的行为质量,反过来验证知识的有效性

        • 验证:update 提案必须人工确认,不允许自动写入

        • 治理:最小作用域原则、分层结构、覆盖完整性审查

        有一句话总结得很到位:智能体的质量上限,由其所处工程底座的完善程度决定。 文档是否准确、架构约束是否可执行、知识库是否随代码同步演进——这些"基础设施"的质量,直接决定了 AI 能否持续、稳定地完成工程任务。

        当好的实践在代码库中占主导时,Agent 会放大好的实践;反之亦然。知识库就是确保"好实践"被显式记录、持续传播的机制。


        五、实践结论

        回过头来看,knowledge-wiki 做对了两件事。

        5.1 分层知识体系与知识工程应用

        knowledge-wiki 的本质不是"给项目写文档",而是把知识工程的方法论落地到了 AI Coding 场景。

        传统做法是把所有信息平铺给 AI——代码、文档、注释混在一起,靠模型自己理解。我们做的是在代码和 AI 之间建了一层结构化的知识层:定义了五类知识的准入边界(认知、导航、排障、隐形、规范),建立了 workspace → app → context 的三层披露结构,每层只回答那一层该回答的问题。

        这不是信息的简单搬运,而是知识的工程化治理——什么该写、写在哪里、谁来维护、何时淘汰,都有明确的规则。AI 不再需要从海量代码中"猜"上下文,而是沿着知识层的结构"走"到正确的位置。分层披露把每次交互的信息传递成本压到了最低,同时保留了完整的层级语义。

        5.2 子仓库构建领域级知识库,自底向上提炼

        传统的知识管理是自顶向下——先定义全局分类体系,再往里填内容。我们反过来走了一条自底向上的路径。

        每个子仓库(git submodule)独立构建自己的 .wiki/,这是最贴近代码、最具体的领域知识。app 级 wiki 记录的是"这个应用内部的概念、流程、排障路径"——这些是团队日常开发中最高频使用、最容易验证的知识,也是整个体系的基石层。

        workspace 级的跨应用知识——概念映射、协作边界、全局规范——不是凭空设计的,而是从各 app 的 wiki 中提炼、归并、收敛出来的。初始化过程中"先穷举再归并"的多轮扫描,本质上就是从具体到抽象的知识蒸馏。

        这条路径的价值在于:基础层的知识越扎实,上层的抽象就越准确;上层的抽象越清晰,AI 在跨应用场景下的导航就越高效。 而且因为每层知识都由最了解那个领域的团队维护,知识的新鲜度和准确性有天然保障。子仓库不只是代码的容器,更是领域知识的载体——代码和知识在同一个 git 分支里共同演进,这是比任何外部知识库都更短的反馈回路。


        六、后面要做什么

        6.1 近期:接入飞书,打通问答和排查

        我们在探索把 wiki 能力延伸到飞书。思路是:

          飞书咨询/问题 → 查公司业务知识库 + .wiki/ → 理解问题域
          → 查代码、查日志、查 RDS → 交叉验证
          → 输出结构化分析结果

          本质上是把 AI IDE 内的 wiki 读取 → 代码分析 → 日志/数据排查 闭环搬到飞书场景,让知识库的价值覆盖更多协作场景。

          6.2 中期:服务端统一管理

          wiki 在更多业务域落地后,会考虑服务端部署:

          • 统一管理各域知识库,支持跨域检索

          • 飞书流程自动化——工单→排查→沉淀全闭环

          • 引入向量检索,支持语义匹配而非只靠关键字

          当知识量足够大时,向量检索能发现关键字匹配不到的语义关联。量变带来质变。

          6.3 长期:从工具到范式

          说远一点,我觉得 knowledge-wiki 不只是一个工具,它代表了一种新的工程实践方向——AI Coding 场景下,研发团队的长远重点应当在专家知识的体系化沉淀上。

          方向是清晰的:记忆、学习、验证、复利。

          让工程环境足够好,智能体自然会足够好。这可能是推动未来研发效率持续提升最务实的路径。

          跳转微信打开

          从0到1:有赞AI客服的实践路径与落地思考

          2026年1月13日 15:18

          原创 有赞共享技术 2026-01-13 15:18 浙江

          本文将从研发视角出发,与大家一同回顾 AI 客服 0到 1 的历程。主要聚焦于AI客服系统从0到1实践的核心要点,剖析落地的关键步骤,以及过程中的一些思考。

          01 前言

          从行业趋势来看,由大模型驱动的智能客服系统,正在对传统客服工具进行深度变革。

          • 在线客服的工作有着较高的重复性,降本增效一直是客服工具提供给商家的最重要价值之一。

          • 基于大模型的智能客服,产品能力和用户体验得到提升,同时搭建和运维成本大幅下降。

          • AI Agent的应用使智能客服产品的成本更低,效率更高。

          有赞是一家提供电商SaaS服务的平台,商家对于客服系统存在较大需求。在大模型刚刚兴起之时,我们便开始关注该领域。自25年年初起,我们在这一领域投入了大量精力。本次将从研发视角出发,与大家一同回顾这一从0到1的历程。主要聚焦于AI客服系统从0到1实践的核心要点,剖析落地的关键步骤,以及过程中的一些思考。

          02 智能体开发平台和工程化代码

          AI客服系统的首个版本,是孵化于有赞内部的一场“黑客马拉松”,为了赶工期,在决策选择智能体化开发平台还是工程化代码之间,我们选择了前者。有赞内部独立部署了智能体开发平台-Dify,Dify 在迭代效率和工具集成上具有显著优势,帮助我们迅速完成了 PMF(产品市场契合度)验证。

          然而,随着业务量的增长,我们发现Dify这类智能体开发平台在生产环境面临以下挑战:

          • 性能瓶颈:观测到简单的 Python 代码节点,执行耗时有时高达 40ms至100ms。

          • 检索实时性:知识检索组件性能太差,在客服这种对实时性要求极高的场景下基本无法接受。

          • 运维规范:在发布流程管理和版本管理等方面,目前尚未建立起一套完整的规范。

          因此,我们推荐的落地方案是:

          • 验证期:利用Dify快速搭建MVP,验证商业模式和用户需求,此时速度是第一优先级。

          • 成长期:采用Dify+工程化混合架构,将核心的、高并发的和复杂的流程放在自研的工程化系统里,非核心流程保留在平台中。我们早期就把核心的知识召回检索放到自研系统中。

          • 成熟期:当性能、可定制程度、稳定性等方面,完全无法满足需求时,走完全工程化的道路。利用工具(如 Spring AI Alibaba Studio)支持将 Dify 上设计好的应用逻辑,直接导出为标准的 Spring AI 工程代码。

          03 模型的选择

          模型是AI客服的大脑,选一个合适的模型至关重要。在此过程中,我们积累的经验主要包括以下几点:

          • 选对模型非常关键,花好几天去优化Prompt,可能换一个模型就能直接解决问题。

          • 评估模型的能力很重要。刚开始,我们主要靠人工来验证,后来慢慢开始使用 langfuse 评测工具。

          • 越到后期越不想轻易更换模型,因为效果评估和提示词调整都需要成本,且结果的好坏存在极大不确定性。

          • 模型输出的内容越少,响应速度就越快,成本也越低。尽量减少模型返回的数据,如果能用常量,就别用 json。

          3.1 选择过程

          不同场景对模型选择的侧重点不同,基于AI客服的业务场景,我们模型选择的迭代历程如下:

          04 Workflow和Agent选型

          项目初期,除了要决定使用Dify还是工程化代码,开发模式也需要在Workflow和Agent中做出选择。我们认为Agent是具有高度自主性的智能体,结果的确定性、性能等都不占优势,所以我们选了比较保守的做法。先按照Workflow的方式,搭建稳定的流程,来追求确定的、能控制的结果。现在再看,当初选工作流程这种方式应该没错。从工作流程入手,逐步引入并解决每一个遇到的问题,同时兼顾效果、成本和可控制程度。

          05 工作流设计与迭代

          5.1、支持售前问题咨询

          在早期版本中,我们用当下效果较好且熟悉的模型,把几乎所有事情都交给这个模型去做,不考虑单个节点的复杂拆解,比如意图识别节点,它还负责问题改写、重复问题和负面情绪识别,然后快速完成 1.0 版本并上线。

          工作流v1

          5.2、降低成本

          1.0版本上线后,紧接着需要提高AI承接率并降低成本。在降低成本方面,除压缩提示词、知识分块和召回策略优化外,我们还将意图识别所用的GPT-4.1切换为Qwen模型,并对意图识别节点进行了拆分。此外,使用Qwen模型后,我们发现Dify的记忆机制对其较为敏感,导致幻觉现象加剧。因此,自行维护一个全局变量作为历史对话信息,并将该信息拼到重复问题、负面情绪和问题改写与意图识别节点的System提示词中。

          工作流v2

          5.3、提升AI承接率

          为提升AI承接率,一方面补充知识来源并提高知识质量,另一方面开始承接售后问题咨询。此时面临的首要决策是,售前和售后采用共用流程还是分开处理。基于业务特性分析,售前与售后问题的回复风格存在显著差异(售前主动,售后严谨),且所需知识也有所不同,同时考虑到单节点复杂度以及调整提示词所带来的影响,因此选择了分开处理。

          工作流v2

          5.4、过程总结

          我们采用的是意图识别和分发策略,这是一种较为保守的做法,宁可让AI不回答问题,也不能让它答错。这样一来,AI承接率到了一定阶段就会遇到瓶颈。如果我们想有所提升,就得拓展场景。

          同时,我们当前的流程也并非完美。如意图识别节点的职责并不单一,问题改写与意图识别仍共用一个节点。此外,还有一个售后问题分类节点,其功能与意图识别能力存在部分重叠。不过,工作流的设计应是一个渐进式的演进过程。随着业务的发展和复杂度的提升,流程也将逐步优化,例如:

          • 拆分意图识别和问题改写节点,进一步降低单节点的复杂度。

          • 深入优化意图识别节点,如完善业务规则、增加意图澄清和闲聊意图等功能。

          06 上下文工程

          有效的上下文管理对于AI系统至关重要,信息过载会导致AI出现失忆、重复或胡言乱语的情况,即使模型支持大窗口也不应随意填充信息。在AI客服的迭代过程中,我们在上下文优化方面迈出了第一步,开始做一系列尝试与验证。主要聚焦于信息获取、筛选提纯以及信息组装方面。

          6.1、信息获取

          信息的获取不仅是数量的堆叠,更是维度的扩展。我们构建了从静态到动态、从文本到视觉的全方位信息获取。

          • 多模态知识提取:借助多模态能力,提前对商品信息进行提取切片并入库。

          • 实时动态注入:区分静态知识与实时信息,动态信息不预存,对话时通过接口实时检索注入上下文。

          • 历史对话回溯:从历史高频问答中提取QA对并进行分类,以此补充文档中缺失的“隐性知识”。

          6.2、筛选提纯

          随着信息源增多,全量加载信息会导致模型由于扰而产生“幻觉”。我们通过一套路由和过滤机制,确保上下文的“信噪比”。

          • 基于入口场景定向检索

            • 商品详情页入口:定向检索该商品的相关信息,而非全店通用知识。

            • 售前/售后路由:根据意图分类,售前侧重引导性、商品参数知识;售后侧重严谨性、订单与物流政策知识。

          • 语义相关性过滤

            • 提升知识质量:依据当前问题与知识片段的相关性,过滤无关信息。

            • 引入权重加权计算:如商品知识在首页 / 详情页咨询的权重不同,采纳与否以相似度 × 权重的最终值为准。

          6.3、信息组装

          早期,我们把知识片段拼接成文本字符串,将其作为上下文信息提供给模型。随着业务持续迭代,我们发现即便对信息进行了筛选和提纯,依旧无法完全规避知识重叠、冲突以及信息过载的情况,进而导致线上出现Badcase反馈。因此,我们尝试采用结构化的方式组装信息,同时结合提示词来定义知识的优先级,以减少模型产生幻觉的情况。

          在该阶段,我们的上下文结构大致如下,我们发现采用这种方式能够显著控制模型,减少幻觉问题的出现。

            <知识库>
              <商品信息>
                <商品名称>知识片段x</商品名称>
                <商品详情>知识片段x</商品详情>
              </商品信息>
              <物流政策信息>
                  知识片段x
              </物流政策信息>
              <xxxx>知识片段x</xxxx>
            </知识库>

            07 知识工程

            7.1、商品知识

            商品知识主要包括两部分:预学商品信息和实时商品信息查询。这主要是为了让用户进线咨询商品相关信息时,模型能依据这些知识给出正确回答。

            预学商品信息

            预学习商品信息主要包含商品主图、商品规格以及商品详情。在图片信息提取方面,未采用传统的 OCR 方案,而是借助模型的多模态能力进行提取。该方式的优势在于能够处理结构化信息,就像具备常识的“图片解读者”,还可过滤冗余信息与图片中的无效内容。

            然而,使用模型提取知识也存在一些缺点。例如,商品详情存在错误或包含误导性信息,模型的回答可能会出错。如下图,商品规格中并无紫色的车,但商品详情的图片里却有,这致使模型回答错误。

            badcase

            对于这个问题,我们后面采用知识优先级的方法,来降低模型输出错误的情况。

            实时商品信息查询

            商品详情的相关静态信息将预先写入向量数据库。不过,商品状态、库存以及预售商品的物流等动态信息,均采用实时查询方式获取,并会在特定流程中将这些信息拼接到上下文中。

            7.2、历史对话知识

            为了补充知识,我们还从历史对话里学习,筛选高频的问答,以此提高AI承接率。不过,历史对话学习我们持续推进了很久,直到后期才有点进展。回顾整个过程,主要原因如下:

            • 刚开始用工程化代码对接 AIGC 服务,效果没达到预期,调试起来还很麻烦。

            • 历史对话信息数量庞大,难以确定有效知识的提取方法,且提取后还需进行去重处理。

            • 难以对知识质量进行判断,无法辨别对错,并且此过程的效率极为低下。

            后期,我们看到了一些效果,主要的实现路径有:

            • 我们把工程化代码对接AIGC 服务切到了 Dify,这样便于调试和迭代,而且产品也能更好地融合进去。

            • 将历史对话数据按照咨询维度提供给模型进行分析,随后利用现有的RAG能力对重复问题进行去重,同时对提取的QA对进行分类。

            • 历史对话知识,会进行单独召回,且提高分数和精准匹配,以此来减少线上Badcase产生。

            7.3 文档知识

            文档知识主要由商家在后台上传。技术上,通过优化文本切片的字符数(chunk_size)和重叠字符数(chunk_overlap),以在“上下文完整性”与“信息密度”之间的寻找动态平衡。其中,chunk_size 决定了信息承载量,chunk_overlap 则用于缓解边界断裂问题、保持语义连贯。经过多次测试与调整,目前我们设定的 chunk_size 为 600,chunk_overlap 为 100。

            08 评测和反馈优化

            8.1、为什么要评测

            Agent的开发测试与传统软件开发存在根本性差异。传统软件测试通常针对固定目标,流程标准化且结果可复现。而Agent的评测,则需应对其自身的不确定性、开放性与场景多样性等核心挑战。因此,AI项目中如模型更换、提示词调整或功能迭代时,我们是无法完全沿用传统的测试方法与标准。

            8.2、评测怎么落地

            我们认为一个有效的评测体系应涵盖几个关键要素:评测对象、评测数据集、评估指标,以及反馈优化机制。随后,对这些关键要素进行逐步细化,并推动其落地实施。

            • 评测对象

              可从以下角度切入:

              • 业务场景:覆盖不同入口进入咨询的路径,例如商品详情页、首页等。

              • 流程覆盖:包括端到端的全流程评测,以及单节点能力评估,如意图识别准确性。

              • 知识评测:不同业务场景对知识的需求各异,可对文档知识、商品知识等知识的质量进行评估。

            • 评估指标

            AI客服,确立评估指标是评测过程中最具挑战的一环。由于行业特性、商户需求与商品类目的差异,单纯依赖人工判断回复正确性难以全面覆盖。因此,我们还会依据历史对话数据,运用评估器来判断内容的相似度,以进行综合评估。

            • 评测数据集

            项目上线前,我们从历史对话中提取内容,并人工构造一部分,形成一小批测试集。项目上线后,我们会依据线上实际流量情况,筛选出Goodcase和Badcase,并将其作为数据集保存。

            • 反馈优化

            除了在单次评测后进行效果优化,我们还会对线上流量进行实时监控巡检,构建“问题识别 -> 根因分析 -> 优化迭代”的数据闭环,达成从Badcase到模型迭代的良性循环。

            8.3、过程总结

            AI评测至关重要,其本身是也是一个持续优化的过程。同时,还需要多个角色协同合作。基于实践下来,我们觉得产品和研发要做好把控好整个流程,重点关注指标和效果反馈。测试人员应将精力投入到评测的基础建设以及用例集方面,尽可能提升“评测 -> 优化 -> 再评测”这一循环的效率。

            09 协作与项目管理

            经过一段时间的体验,深切地感受到AI项目和传统软件研发有很大不同,主要表现在

            • Prompt、Contenxt和业务逻辑高度耦合,导致职责边界表得模糊。

              • 协作不再是“交付接口”,而是“共同迭代 Prompt + 逻辑 + 数据”。

            • Agent/Workflow 架构的灵活性带来责任分散 ,同时智能体开发平台(如Dify)的兴起加速了产品MVP的验证过程。

            • 大家对新事物的了解程度不一样,都是边干边学,而且项目结果有很大的不确定性。

            我们尝试去做的

            • 建立 AI 原生协作流程:比如 Prompt 评审机制、评估指标对齐、产研协作。

            • 文档化决策:比如记录选择 Workflow 而非 Agent 的原因、增加特定流程的考量因素等,即注重过程记录。

            10 总结与展望

            从最初“黑客马拉松”式的灵感碰撞,到如今步入稳定运行、持续进化的新阶段,有赞AI客服的从0到1,不仅是一次技术栈的升级,更是一场研发模式与思维方式的深度变革。

            未来,我们将重点聚焦在以下方向:

            • 从“单一职责”到“智能协同”:持续迭代进化工作流,探索并引入更具自主性的智能体(Agent)能力,以应对更复杂的交互场景。

            • 深挖多维知识潜力:将投入更多资源优化历史对话的自动化清洗、问答(QA)转化以及商品学习等,从而使沉淀的海量数据切实成为AI进化的驱动力。

            • 构建更敏捷的AI原生协作体系:通过建立 Prompt 评审机制和评估指标对齐,打破产研边界,实现提示词、逻辑与数据的共同迭代 。

            AI 浪潮下,智能客服的演进没有终点。我们将继续秉持“宁可不答,不能答错”的严谨态度,不断拓宽AI的应用边界,为商家提供更高效、更具温度的智能服务体验。

            阅读原文

            跳转微信打开

            AI 实践:Code Insight 代码搜索定位的实践分享

            2026年1月6日 17:54

            有赞技术中台 2026-01-06 17:54 浙江

            代码检索领域,本文结合团队半年实战,解析向量检索(RAG)与AST静态分析两大技术路径。分享了代码问答、TraceAI 排障、测试用例生成的应用场景。

            Code Insight 代码搜索定位的实践分享

            代码索引是为了帮助我们提高代码搜索和导航效率的技术。常见的使用场景:

            1. IDE 中代码跳转,当点击跳转到实现时,IDE 会在索引中找到对应变量类的对应文件和行数,执行跳转动作。

            2. 开发者可能想询问代码中某个具体的业务实现代码在哪个模块/文件中。

            3. 非开发者:如产品/技术支持等同学可能希望在不借助开发者中介的情况下,对代码的某块业务实现有较准确的了解。

            在AI编码工具普及的今天,"代码索引"已成为支撑研发流程的核心能力。无论是IDE中的快速跳转,还是AI助手的精准问答,都离不开高效的代码索引技术。本文将结合团队近半年的项目实践,探讨从语义检索到结构化分析的技术路径。

            01 初识代码索引

            提到代码索引,开发者们并不陌生。当我们在IntelliJ IDEA或VSCode中看到底部"Indexing..."的提示时,正是工具在后台构建代码索引。这些索引如同代码库的"智能地图",支撑着各类开发工具的运行。

            indexing
            indexing

            1.1 从常用工具看索引:每天都在用的技术

            不同开发工具采用的索引策略各有差异,这也反映出代码索引技术的多样性:

            • IDE工具:跳转、补全、引用分析等核心功能,都依赖代码索引的提前建立;

            index2
            index2
            • Cursor:聊天栏右侧提示可见其会使用 grep 等文本匹配方式,而系统配置中"Vector Index"选项表明还融合了向量索引能力;

            cursorcursor2

            • Claude Code:坚持采用grep纯文本匹配机制,而不考虑引入RAG方案。这也引发了社区关于两种技术路线的争议。

            claude
            claude

            1.2 代码索引的核心定义

            本质上,代码索引是通过特定技术快速定位目标代码的能力,它为庞大的代码库建立了高度智能的"目录"与"词典"。目前主流的实现方案包括向量嵌入索引、AST索引、ES全文索引等,本文将重点聚焦前两种在AI时代更常见的技术方案。

            1.3 为何要在公司内部自建代码索引

            在AI应用爆发的背景下,作为公司提供底层技术支撑的团队部门,我们对代码索引的需求主要来自三个方面:

            1. 支撑AI编码场景:AI编程、agent模式问题定位等相关工具需依赖精准的代码索引获取上下文,关联代码的准确性直接决定大模型输出质量;

            2. 保障代码安全:避免将包含密钥、密码等敏感信息的代码发送至外部大模型,通过自建索引实现敏感数据前置扫描;

            3. 降低使用成本:第三方AI编程工具单次问答成本可达数美元,而自研方案成本可控制在几毛钱人民币,落地得当可大幅降低长期投入。

            02 实现方案:从语义检索到结构分析

            团队在实践中重点探索了两种方案:基于向量嵌入的RAG方案和基于抽象语法树(AST)的方案。前者擅长语义理解,后者专注结构化分析,二者形成互补。下文将先探讨应用 RAG 方案。

            2.1 方案一:基于向量嵌入的RAG方案

            引入向量嵌入索引技术的核心目标,是构建支持语义理解的代码定位能力,结合大模型打造智能代码问答系统。

            2.1.1 RAG的核心原理

            RAG的核心逻辑是"先检索再生成":在大模型回答问题前,先从外部知识库(代码库)中检索最相关的信息,将这些信息与问题一同交给大模型,从而提升回答的准确性。业界绝大多数RAG实践均采用向量检索,因此下文以RAG代指。

            一个完整的RAG流程包含分块(Chunking)、嵌入(Embedding)、检索(Retrieval)三个步骤。

            2.1.2 分块——平衡精度与上下文

            分块是将代码或文本切分为更小处理单元的过程,直接决定后续检索质量。块过大易包含无关信息,块过小则会丢失上下文,常见分块方式有三类:

            • 固定大小分块:设定固定token数量(如512个),以滑动窗口方式切割,相邻块保留重叠区域(如50个token)。实现简单、计算高效,但可能破坏语义边界,适合项目初期快速验证;

            • 语义分块:对句子向量化后计算余弦相似度,当相似度低于阈值时进行切割,能保证块内语义连贯,分块质量更高,但实现复杂度增加;

            • 场景化分块:Markdown、PDF等采用章节分块,代码则按语法边界分块,需结合语法树解析,同时控制块大小避免过长。

            项目初期我们采用固定大小分块方案,在实现成本与效果间取得了平衡。

            2.1.3 嵌入——语义的向量化转换

            嵌入是将人类可理解的代码符号,转换为计算机可处理的多维向量的过程。在高维空间中,语义相近的代码片段,其向量距离也会更近。例如"用户登录验证"与"userAuthentication"的向量会呈现强关联性。

            嵌入说明
            嵌入说明

            这个转换过程由专门的嵌入模型完成,转换后的数据会连同原始文本、来源文件、行号等元数据,一同存储到向量数据库中,为后续检索做准备。

            2.1.4 检索——精准定位相关代码

            当用户提出问题(如"系统如何处理用户登录?")时,检索流程会按以下逻辑执行:

            1. 问题嵌入:使用相同嵌入模型将用户问题转换为向量;

            2. 相似度搜索:在向量数据库中查找与"问题向量"最接近的K个代码块向量(K通常设为5-10);

            3. 相似度度量:常用余弦相似度(关注向量方向差异)而非欧氏距离(关注绝对距离),更贴合语义关联需求;

            4. 高效搜索:采用HNSW等算法构建分层图结构,通过"顶层粗搜+底层精搜"提升检索效率,适配百万级或以上向量规模。

            HNSW
            HNSW

            2.1.5 工程实现

            在实际落地中,我们围绕框架、模型等方面选型了一套实践方案:

            • 框架选型:对比LangChain与LlamaIndex后,选择后者作为基础框架。因其基于RAG概念做了轻量化封装,同时对接多类大模型/嵌入模型厂商,调试更便捷;

            • 模型选择:通过设计内部业务逻辑测试集,横向对比国内外嵌入模型,最终选出相关代码召回率达95%的模型;大语言模型方面选用的是成本综合较低的deepseek-v3,效果也还不错。

            • 安全保障:所有代码片段在发送给模型前,均通过敏感信息扫描工具脱敏,避免密钥泄露;

            • 上下文策略:优先将召回的完整文件发送给大模型,超出上下文限制时再采用分次查询汇总,默认控制召回Top 5文件覆盖核心需求。

            2.1.6 RAG全流程梳理

            从全局视角看,RAG实现分为索引构建与查询两个阶段,形成完整的数据流转链路:

            • 索引阶段:原始代码 → 安全扫描与脱敏 → 分块 → 嵌入 → 存储到向量数据库;

            • 查询阶段:用户提问 → 问题预处理 → 问题嵌入 → 向量检索 → 召回Top K代码块/文件 → 组织Prompt上下文 → 提交大模型生成答案。

            RAG完整流程
            RAG完整流程

            2.2 方案二:基于AST的结构化索引方案

            RAG方案在语义理解上表现出色,但在处理结构化信息时存在明显短板,这促使我们开始探索基于抽象语法树(AST)的索引方案。

            2.2.1 RAG的技术瓶颈

            在实践中发现,向量索引工具擅长特定业务问题找回少数关联文件进行分析,但对于涉及多文件(超出上下文长度),跨仓库等场景难以发挥效果。难以捕捉调用关系、继承关系等长链条结构;无法完成"代码改动影响范围分析""调用链图谱生成"等跨大量文件、仓库的程序分析任务。于是我们把目光放回了语法结构分析的老鼻祖:静态分析。具体来说是抽象语法树解析、字节码解析等技术,下面从语法解析角度简要介绍。

            2.2.2 AST+符号表:构建代码的结构化认知

            以下面的源码为例:

              ounter(line
              let answer = 6 * 7;

              计算机理解这段代码分为两步:

              • 第一步:词法分析

              编译器/解释器会先把代码字符串“切碎”,变成一个个有意义的“单词”(称为 Token)。[ let, answer, =, 6, *, 7, ; ]

              • 第二步:语法分析

              然后,它会根据编程语言的语法规则,把这些 Token 组合成一棵结构化的树。这就是 AST。 一个简化版的 AST 结构可能长这样:(不同的解析器生成的 AST 节点类型可能略有不同)

                Program
                  |
                  └── VariableDeclaration (kind: 'let')
                        |
                        └── VariableDeclarator
                              |-- id: Identifier (name: 'answer')
                              └── init: BinaryExpression (operator: '*')
                                    |-- left: NumericLiteral (value: 6)
                                    └── right: NumericLiteral (value: 7)

                简而言之,AST 代表的是程序的骨架结构,而如果需要采集分析代码中的资产,我们还需要建立符号表。

                • AST的核心作用:将代码语句转换为树形结构,明确"哪里调用了某个函数",但无法定位函数定义位置与参数信息;

                • 符号表的价值:如同代码标识符的"注册表",在遍历AST时记录变量、函数、类的名称、类型、作用域、定义位置等信息。

                二者结合可构建程序调用关系图谱,实现精准的影响范围分析。例如当method 3修改后,能快速定位method 3→method 5→method 1的影响链路,其中method 1为Dubbo API。

                调用关系图谱
                调用关系图谱

                03 落地实践:代码索引的应用场景

                无论是RAG还是AST方案,最终价值都体现在业务落地中。目前我们已将代码索引能力集成到部分开发流程中,下面介绍几个应用场景。

                3.1 智能代码问答:提升业务理解效率

                该功能基于内部 OPS 平台的应用视角提供,核心是通过AI快速查询并总结应用的业务逻辑,下面是几类常见使用场景:

                • 前端接口与后端Dubbo接口的快速匹配,无需手动查询代码仓库,查问题再也不用从前端到后端拉一串人了;

                • 自动总结并绘制业务流程图,助力新人快速上手掌握陌生业务;

                • 较低的问答成本,作为 cursor 的日常平替。

                代码问答示例
                代码问答示例

                3.2 TraceAI问题定位:加速故障排查

                项目目标是结合大模型 Agent 的工具调用能力和规划能力,让 Agent 将代码问答能力与链路追踪(Trace)日志结合,自主进行线上问题定位。

                traceai
                traceai

                3.3 智能测试用例生成:适配代码改动

                基于AST解析得到代码改动关联的接口,自动生成对应的测试用例建议。该功能可推导出受影响的API接口,结合大模型对改动点的理解,确保测试覆盖核心改动点,提升测试效率与准确性。

                测试用例生成示例
                测试用例生成示例

                04 实践心得与业界对比

                在推进代码索引项目的过程中,团队积累了一些经验,也对比了一些业界方案,下面是一些心得分享。

                4.1 实践心得

                • 数据质量决定上限:遵循"GIGO"的机器学习原则,高质量的代码索引是AI编码辅助的前提,直接影响最终输出效果;

                • 拥抱不确定性:大模型存在固有随机性,相同问题与上下文可能产生不同输出,需通过多次运行汇总等工程手段弥补;我们对 AI 产出的预期也不能像程序运行那样去追求确定性。

                • 重视问题拆解:对于复杂任务,需将问题拆分至足够小的规模,通过大模型解决小问题后再组合成果。

                4.2 业界主流方案对比

                工具名称

                核心索引方案

                特点与优劣

                参考资料

                Cursor

                RAG方案

                基于Merkle Tree实现快速增量更新,分块引入语义化策略,检索精准度较高

                https://cursor.com/cn/docs/context/codebase-indexing

                ClaudeCode

                纯代码匹配方案

                实现简单,但易出现Token消耗多、上下文冗余的问题

                https://juejin.cn/post/7559836484209229843

                Aider

                repo-map方案

                早期方案有启发价值,但对大仓库处理能力不足,效果稳定性欠佳

                https://aider.chat/docs/repomap.html

                关于是否采用RAG,我们的感觉是:RAG方案前期索引成本高,但语义理解准、Token消耗少;纯文本匹配方案实现简单,但依赖大模型上下文能力,长期成本高。但是随着token成本长期的下降也许成本不再是关键因素。

                05 未来展望:从能用走向好用

                当前代码索引能力已在内部发挥价值,未来我们将继续探索以下方向,进一步释放技术价值:

                • 跨仓库分析能力:突破单仓库限制,适配微服务架构下多服务协同的业务场景,实现跨服务代码关联分析;

                • 问题定位Agent落地:将TraceAI等能力融入日常运维开发流程,降低平均故障修复时间,转化为实际业务收益;

                • 业务文档自动生成:基于代码与AST分析,自动生成并更新API文档、业务流程图等,减少文档维护成本。

                代码索引技术现在还在快速演进,我们实际做下来最深的感受是:各种技术擅长的方向不一样,取长补短融合后可能会有更好的效果,比如 RAG 和静态分析技术两种,前者擅长搞定“找相似逻辑”这类语义理解需求,比如问“用户登录在哪处理”;后者则专注解决调用链、改动影响范围这种需要精准分析的问题。把两者结合起来,才能覆盖开发的更多场景。接下来我们也会继续打磨这两种技术的融合方案,把代码理解做得更准、更高效,真正帮大家省下查代码、捋逻辑的功夫。

                阅读原文

                跳转微信打开

                有赞AI研发全流程落地实践

                2025年11月26日 16:45

                原创 有赞共享技术 2025-11-26 16:45 浙江

                本文介绍了有赞研发团队在 AI Coding、AI Test 及 Agent 评测体系的全流程落地实践。分享了从“人主导”向“算力驱动”转型的技术架构与实战经验。

                1. AI 时代的研发变革

                1.1 AI编程的火爆

                25年可以说是 AI 应用的元年,在编程领域从最基础的代码补全到辅助编程,到 AI 工程师,再到 AI 开发团队,各种概念层出不穷。

                编程工具迭代涌现,从老牌的 Github Copilot 到爆火的 Cursor,再到 Claude Code,和最新出的 Codex。

                对应的用户规模也爆发增长,Github Copilot 用户超过 2000 万,Cursor 用户超过 230 万,Claude Code 在短短 3 个月用户增长 10倍,Github Copilot 年度 ARR 超过 3 亿美元,而 Cursor 和 Claude Code 都超过了 5 亿美元。

                随着编程工具的发展,编程门槛被大幅降低,氛围编程(Vide Coding)开始兴起,让更多非专业开发者专注创意和结果。

                在有赞内部有产品同学开始用代码交付交互式的 PRD,在一些创新型项目中这会成为第一版代码。

                1.2 AI对企业研发的变革

                我们开始思考,AI 对企业研发意味着什么?

                首先,传统软件研发生产要素,由人力、技术、信息组成,核心逻辑是多招人,就能多做项目,就有更多产出。 围绕人这个要素存在一系列问题:好人才难招、新人要培养、人才会流失、个体的动性、人的协作效率。

                AI 时代人力开始向算力转移,增长逻辑编程多买显卡,获取更多算力,就能有更多产出。大部分体力工作向算力迁移,部分脑力工作可沉淀到算力中,算力能快速扩大。

                最近看到一些新闻,硅谷的大厂一边裁员,一边争相购买显卡。

                在这个过程中,人从直接产出转为对算力的设计与编排。

                “让子弹飞”是一部经典的电影,这里引用其中一张截图,模糊度恰到好处。

                远看是火车即将超越马,近看是马在拉着火车,这很有意思。和我们目前落地 AI 有点相似,“朋友圈”看起来各种炫酷,实际落地需要大批人马参与。

                但这就意味着火车不如马吗?

                显然不是,我们都知道最终火车一定会超越马,亦或,马拉火车的方式本身就错了。

                1.3 有赞研发的AI+

                出于对 AI 趋势的坚信,在有赞研发内部,我们有大量的 AI 探索与实践。

                横跨研发的完整流程,包括需求、设计、编码、测试、上线的各个阶段。

                所有这些实践可以,归纳为三类:AI Coding、AI Test、AI DevOps, 以及围绕 Agent 本身的研发与评测。

                1.4 AI编程小案例

                在 AI 探索的初期我们遇到了两个很有意思的小故事。

                1.4.1 一位产品的氛围编程之路

                第一个故事是,我们的一位产品同学用氛围编程做了一个简单的日常需求,他给了一个反馈:严重缺乏安全感。

                我们深入了解后发现来源于三点:

                • 心理不可接受:由于企业级工程规模大、系统复杂度高,系统/功能间依赖关系较深。非专业人员面对生产稳定性和大量线上用户压力时,心理负担急剧增加。本质是判断力缺失;

                • 效率不可持续:判断力缺失也导致效率不可持续,导致需要频繁的和开发者沟通,氛围编程变成了 AI 和开发者之间的传声筒。编程的耗时被极大的转换成了沟通确认的耗时,最终效率不升反降;

                • 质量不可信赖:虽然 AI 做对了效果,但是实现方案不合理,最后返工。现代企业级软件工程,除了完成需求外,还需考虑健壮性、可维护性、架构一致性等因素。AI 由于缺少上下文输入,这方面做得并不好;

                1.4.2 一位开发带领的编程团队

                第二个故事是,五月 Claude Code 发布后,我们看到一些开发者编程模式的变化,如图是一位同学的 Cli 工具:

                左侧是 4 个 Agent 分别在完成一个项目的 4 子需求,右侧是他在验证和提交代码。

                这种模式类似一位技术 Leader 带领一个小团队做项目,由 Leader 负责任务拆分、方案设计、过程把控和代码CR。

                过去需要几个人的小组,现在一位开发者加上多个 AI Agent 就可以做到了。

                这给了我们不少启发,我们开始思考如何把这种模式推广到更多项目中。

                1.5 企业级软件工程四大特点

                在经过了初步的观察和尝试后,我们总结了 AI Coding 落地需要解决的关键问题,归纳为四点:

                • 大规模:这对 LLM 的多仓库理解、上下文窗口提出了要求;

                • 高复杂:通常涉及多个业务系统、历史兼容等,需要解决 LLM 的注意力缺失问题、准召率低问题;

                • 多协作:一个项目往往涉及多职能、多部门的协作,不同团队间对 AI 的理解和应用有深浅,如何协同?以及,人在哪些环节以怎样的力度监督 AI?需要合理地规划 AI 落地的节奏以及人机协作模式;

                • 私有化:企业内部有大量分散在各处的信息,不透明、不标准,难以被 AI 检索,需要建设内部知识库、对接内部工具;

                1.6 AI落地的三个阶段

                明确关键问题后,我们将 AI 落地划分为了三个阶段:

                • AI 增强阶段:人主导 AI 辅助,此阶段重点聚焦用 AI 做单点提效;

                • AI 驱动阶段:AI 主导人监督,此阶段 AI 有能力接管单一研发环节;

                • AI 自主阶段:AI 自主人少量介入;

                对于不同的场景应该匹配适合的阶段,过度追求 AI 适得其反,我们踩过不少坑,AI 的落地无法一蹴而就,需要循序渐进。

                目前我们的实践大量在 AI 增强阶段,有少量能到 AI 驱动阶段。

                2. AI Coding:从个人助手到规模协同

                2.2 设计路线

                首先,是关于 AI Coding 的设计路线,我们有两个选择:以人为主 Agent 为辅、以 Agent 为主人监督。

                我们观察了一些开发者的辅助编程模式,我们发现以人为主的模式存在一些问题:

                • 协作还是以人为中心,相互沟通靠声音、工具调用靠手速,信息传递效率低;

                • 个人经验内化不共享,Agent 配置没有复用,信息分布式存储;

                • 另外,人的规模化需要时间;

                因此,我们选择了第二条路线,其可以系统化解决以上三个问题,并且“天花板”更高。

                2.3 构建框架

                明确了设计路线后,让我们开始构建 Coding Agent,这个过程类似从 0 到 1 搭建一个开发团队:

                • 它们都需要有好用的工具,无论是硬件、软件还是技术选型;

                • 它们都由专业的个体组成;

                • 并且这些个体能高效协同完成复杂的任务;

                让我们先从设计一个专业的 Agent 开始!

                2.4 设计演进

                通用 AI Agent 和计算机很相似:

                • 它们都有计算单元,一个是 CPU,一个是 LLM;

                • 它们都有短期存储,一个是内存,一个是上下文;

                • 它们都需要获取外部信息,一个通过网络,一个通过搜索工具;

                • 它们也都可以多节点进行协同,完成复杂任务;

                当我们把通用 AI Agent 细化到 Coding Agent,一些选型会更具体:

                • LLM 需要选用垂直的编程 LLM;

                • 上下文需要引入企业的开发规范/约束;

                • 长期存储需要对接企业内部知识库;

                • 搜索工具聚焦在代码仓库的搜索和理解;

                • 工具需要对接企业内部的工具链和平台;

                • 协同系统的拆分应该以企业内部的协作流程或领域分工来拆分;

                2.4.1 选型与选择

                在明确了核心模块后,需要先回答两个问题:方案的选型、自研的选择。

                在 AI 时代行业解决方案百花齐放,无论是大模型还是配套的技术,且迭代速度极快,比如近期的Gemini3(11月18日)、Nano Banana Pro(11月20日)。

                做的越多越容易陷入追赶的局面,最大程度的借助行业能力,并将其与企业内部资源串联是关键。

                我们的核心策略是将通识的交给行业,集中资源做私有部分,通过行业迭代来提升底层能力。

                2.4.2 Base Agent & System Prompt

                明确策略之后,首先是基础模型的选择,在25年初时我们基本有共识,LLM 应该交给大厂,我们则专注于应用。

                到了 5 月份我们发现 Agent 系统也有不错的行业实践,因此问题被延展成了选择基础模型还是选择基础 Agent? 也就是 Claude 还是 ClaudeCode?

                围绕这个问题我们做了一些研究,发现 Claude Code 作为通用编程 Agent,在子 Agent 调度、MCP 集成、通用开发工具、上下文压缩方面已经做得不错了。

                因此,我们选择了 Claude Code 作为基础 Agent 的底座,通过其强大的扩展能力,将其连接到我们内部的研发体系。

                首先是系统提示词,这方面 Claude Code 已经做的不错了,我们仅做了少量扩展,总共不到 200 行,主要是一些内部的编程规范、特定约束。

                2.4.3 Dev Tools

                接着是工具,和人一样,Agent 也需要开发工具。比如,当开发者让其参考历史需求,它需要能访问需求管理平台查看。又比如,它可以通过飞书文档创建一篇技术方案给开发者审阅。

                这些工具散落在内部的各个系统、平台,有些在外部,我们通过 MCP 将这些工具集成到一起,交由 Agent 决策使用。

                2.4.4 Codebase Search

                有了工具后,接着是代码理解能力,这也是 Coding Agent 的关键能力之一。

                我们将其分为了三层:目标仓库定位、跨仓库依赖代码召回、工作区代码理解。目标仓库定位比较简单,我们用的是知识库 RAG 的方案。

                在代码理解上,业内常见的方案有:向量索引检索(RAG)、抽象语法树(AST)、文本搜索(grep)、预生成文档(deepWiki),在实际应用中有不少组合的情况。

                Cursor 选择的是 RAG 方案,好处是速度快,适合大的单体仓库,缺点是精度丢失(向量化),实时性不高。

                Claude Code 则选择比较纯粹的文本搜索方案,和人很像,好处是精度高、实时性强,但性能会差一些。

                在有赞对于跨仓库依赖代码,由于仓库数量庞大,采用的是 RAG 方案,同时更新频率没有 Cursor 这么高,我们基于 Git 的提交记录进行增了更新。对于工作区代码理解,由于基础 Agent 是 Claude Code,直接采用它的文本搜索。

                另外,代码安全也十分重要,无论是发送给向量嵌入模型还是大模型的代码片段,都通过安全扫描进行脱敏。

                2.4.5 Knowledge Base

                有了代码,接着是内部知识,和开发者一样 Agent 需要理解业务知识,比如产品模块有哪些、业务术语是什么意思。也需要理解专业知识,比如技术选型用了什么、编程规范是怎样的,以及工程现状。

                这些额外的上下文可以让 Agent 的编码更符合预期,避免写出“与众不同”的代码。

                过往企业知识库建设有两大痛点,一是信息孤岛(无法统一检索/重复建设严重),二是内容老旧(因为缺少审核/运营机制,大量过期/错误内容)。

                为此,我们内部成立了专门做知识工程的团队,由他们推动知识透明和更新。他们围绕知识增长、内容质量、知识使用进行建设,为上层应用提供高质量的知识。

                至此,一个 MVP 版本的 Coding Agent 完成了。我们拿去做了一些需求,发现效果并不好,原因是还有大量经验在开发者的头脑中。

                2.4.6 Long-term Memory

                为此,我们会 Agent 打造了基于长期记忆的学习系统。简单来说,就是将开发者和 Agent 的监督对话提取为长期记忆,后续遇到类似场景时进行召回使用,这也可以实现跨会话的复用。

                这就如同一个经验丰富的老员工手把手带教实习生,整个过程分为:

                • 记忆提取,该阶段重点关注符合事实、保留细节、不归纳泛化。

                • 记忆储存,我们采用自然语言+标签的形式储存而非结构化,并且保留了原文引用。

                • 记忆合并,定期将类似记忆归纳合并。

                • 记忆检索,业内根据场景不同常见的有:向量数据库、知识图谱、分层存储,我们采用的是向量数据库。

                • 记忆遗忘,随着记忆数量的增加,根据时间和使用频次进行遗忘。对于高频使用的记忆经过泛化后转化为知识。

                虽然设定了很多提取规则和后处理,但在实际应用中,通过人工标注及修正的方式,可以较快加速记忆的可用性。

                我们在 AI Coding 做了测试,同类任务未接入记忆需要 5-10 轮对话修正,接入记忆后仅需 1-3 轮,有较大提升。

                2.4.7 Cloud Sandbox

                Agent 构建完成后,无论是运行、调用工具、拉取代码等等,都需要一个环境,如同为开发者配置一台电脑一样。

                通过对本地辅助编程的观察,我们发现本地运行存在一些问题:复杂环境导致额外上下文、工程化适配问题、安全与监管难解决。

                因此,我们选择了云端部署的方案,为每个 Agent 的每次会话分配了独立且标准化的沙箱(Sandbox),其中包含了开发环境,以实现交付结果预览。

                同时对会话及沙箱做了无状态化,实现水平扩容能力。我们将会话存储在共享存储中,当开发者开启或继续一个会话时,会动态分配随机沙箱,并从共享存储中恢复会话。

                这一切都需要通过统一网关,以解决安全和监管问题。

                2.4.8 Multi Agents System

                随着接入环节的增加,我们发现单一 Agent 面对个多环节,由于 LLM 上下文长度导致了遗忘、性能等问题。

                为此,我们引入了多 Agent 系统,将这些复杂度分而治之。

                • 在 Agent 的编排上有 Workflow 和 Agentic 两种方式。由于企业级工程对稳定性、观测性的要求较高,我们采用 Workflow 串联多个 Agent。在部分 Agent 内部通过 ReAct 模式发挥 LLM 的自规划能力。

                • 在 Agent 的拆分上有流程拆分和领域拆分两种方式。我们都做了尝试,从落地情况看按流程拆分基本可以解决大部分问题。

                同时,我们为每个 Agent 做了差异化的基模选择,主要根据 Agent 的任务特点、LLM 的优劣势以及成本。

                • 需求解析和仓库定位较简单用 GTP-4o;

                • 代码定位用向量嵌入模型 voyage-code-3 并配合 deepseek-v3 做一些后处理;

                • 方案和编码则用 Claude-sonnet-4.5,其中记忆用 GTP-5 效果出色;

                • 代码审查则用 Gemini 2.5 它的上下文窗口较大,可以把更多代码片段给到 LLM;

                2.4.9 人工监督(HITL)

                整个 Agent 系统的运行离不开人工监督(Human in the loop),我们面向开发者、管理者分别设计了两套监督系统。

                • 面向开发者的监督系统主要基于飞书 IM,它是一个天然的对话流,同时结合飞书文档、GitLab。开发者可以在 Agent 的每个阶段对产物进行审核,包括:需求清单、技术方案、改动代码、实际效果等,并通过多轮对话进行修正;

                • 面向控制者的监督系统主要基于多维表格及其仪表盘,管理者对每个需求的情况一目了然,包括:交付率、对话轮次、Token 消耗、对话明细等;

                其中,对话明细可以转化为评测集,用于后续 Agent 的评测。

                2.4.10 对接发布系统

                最后,我们通过部署发布 Agent,打通了发布系统。如图所示,通过对话就可以很方便的部署到预发,或发布至生产:

                2.5 产品形态

                这就是我们最终的产品形态,已经交付了不少需求。当然实际落地中,这种人机交互模式也有局限性,因此我们正在开发 Web 端,类似 manus 的效果。

                2.6 需求选择与落地

                在 AI Coding 落地的需求选择上,我们分了三个维度:多职能、多仓库、需求规模,和新人一样在 Agent 能力还不够时,先从单职能单仓库的日常需求开始。通过做小需求验证 Agent 并积累数据,同时小需求因优先级不高而积累,用 AI 来做具有提效价值。

                在我们将 AI Coding 推广到兄弟团队时,发现大家对 AI 期望很高,大家会给它做非常有挑战的需求,我们需要理解 AI 不是万能的,人做不了的它也是。

                目前我们的 AI Coding 已经可以实现单职能多仓库的日常需求,已交付近百个需求。综合提效 30%,包括人工监督的耗时,单个需求 Token 费用不到 100 人民币。

                接下来我们会重点向多职能多仓库、项目级需求两个方向迭代。

                2.7 实践案例

                2.7.1 翻译型事务

                在落地过程中,我们也发现了一些特别适合 AI 做的共性需求。

                第一类我们称之为:翻译型任务。 已经有明确方案且较为简单的任务,AI 可以快速完成,且质量还不错。比如:技术债务治理。

                有一个基础库升级的案例,涉及基础库、业务库和23个业务应用的升级,原本需要超过50人日,通过 AI 几十分钟就好了。

                2.7.2 降低开发门槛

                第二类是跨域编程,我们工作中经常会需要跨团队、跨领域支援,过往人的学习和熟悉过程会有额外的时间。通过 AI Coding 我们的开发者进行了不少的跨域编程,这部分时间几乎被抹平。

                2.7.3 小插曲:移动编程

                另外有个比较有意思的小插曲分享一下:

                相信程序员都有共鸣,随身携带电脑是大家的痛点之一。在我们落地 AI Coding 的过程中发生了另外一个小案例,有个开发同学出去聚餐没带电脑,这时候来了个 Bug:

                • 他掏出手机打开飞书用聊天唤起了一个 Agent

                • 把 Jira 和说明丢过去

                • 让 Agent 先改着,就先吃饭了

                • 过了几分钟 Agent 改完了

                • 他看了没问题就让 Agent 发布了

                这虽然只是很小很小很小的案例,但确实让我们看到了 AI 正在慢慢改变我们的编程方式。

                2.8 完整架构

                以上,就是我们在 AI Coding 方面的实践:

                • 首先,我们做了好用的工具,也就是云端 Sandbox;

                • 其次,基于上下文工程,我们打造了专业的 Agent 个体;

                • 最后,通过 MAS 让他们协同工作;

                • 另外我们也做了人机交互界面,让人可以监督 Agent;

                3. AI Test:从自动化到智能化

                3.1 传统测试的局限

                在开始之前,先简单回顾下传统测试的挑战:技术栈多样化、设备终端碎片化、工程规模增大,因此对测试效率提出了要求。

                自动化测试被引入,提升了一些效率,但有一些局限:编写有门槛、维护成本高、难扩展复用、失败排查困难。

                3.2 AI时代的新挑战

                在 AI 时代,随着编码效率提升,对测试效率提出了更高的要求。同时由于 AI 生成代码不确定,影响面和风险更大,对测试带来了新挑战。

                同样 AI 也对测试带来了新的可能:

                • 在测试设计阶段,能做 AI 用例生成、AI 用例优化、AI 用例选择(精准测试)等;

                • 在测试执行阶段,能做 AI 数据构造、AI 驱动执行、AI 增强录制、AI 无参考测试等;

                • 在评估优化阶段,能做 AI 失败归因、AI 用例修复、AI 分析报告等;

                我们在这方面踩了不少坑,也有些在部分场景落地了。

                3.3 AI用例标准化

                首先是,AI 用例标准化,在我们开始结合 AI 和测试时,碰到的第一个问题就是:用例。

                过往历史用例缺乏维护,质量参差不齐,如左图各种隐式步骤、断言缺失。另外用例还分散在各个平台,比如文本和自动化用例互不相通。

                这就导致了GIGO(Garbage in, Garbage out)的现象,你给 LLM 的输入质量低,它的输出质量也低,幻觉严重。

                于是,我们开始思考如何解决用例的问题,我们发现 LLM 本身有强大的自然语言理解能力。这让传统文本用例和自动化用例的融合成为可能,也就是自然语言用例,让用例兼具语意性和可执行性。

                我们探索了两个方向:AI 存量用例优化、AI 增量用例生成。

                首先是存量用例优化,根据已有的测试目标和测试步骤由 LLM 生成更规范的用例名、标签等,同时逐步优化用例步骤、补充断言。

                其次对于增量的用例,我们结合业务知识库,并参考现有用例进行生成。

                所有的这些自然语言用例放在一起,它们本身就是一个高质量的测试知识库。

                一个新的用例生成过程分为三步:

                • 填写基本信息:测试目标、开启 AI 规划;

                • 选择参考用例:从历史用例库选择供 LLM 参考;

                • 用例生成:LLM 会生成用例的基础信息,以及完整的测试步骤,这里的步骤是自然语言,一目了然,且可被执行;

                目前,用例生成的准确度和覆盖场景还有很大空间,仍处于探索阶段。

                3.4 AI增强录制

                我们还有不少用例是录制的,因此我们做了 AI 增强录制,下面看一段视频:

                视频中人在操作的同时,会先录制图片加坐标,交给多模态 LLM 去分析,生成自然语言的步骤。

                可以看到这个过程是并行的,不影响人工操作,一次生成大约5秒左右。

                录制完成后,回放执行也非常顺畅,AI 可以较快的执行几乎和人操作一样。

                我们是怎么做的?

                首先先简单回顾下传统录制的局限:定位不精确、录制步骤冗余、需要人工校准、维护成本高。如下图:

                通过 AI 增强后,测试步骤可以精确识别用户的意图:输入价格1、输入划线价2,且较为精炼:

                整个增强过程大致分为几步:

                • DOM+截图输入:首先是捕捉用户的操作,将完整 DOM 和截图丢给多模态 LLM,目前通用多模态 LLM 已经比较强大了,我们第一版就能做到 70% 准确率。即使不提供 DOM,LLM 也可仅依赖截图识别,从而支持跨平台录制。但这个方案的 Token 消耗是巨大的,且上下文太长会带来一些幻觉导致不稳定;

                • DOM 预处理:通过对 DOM 进行裁切,降低噪音和 Token 消耗,同时标注重要内容提升大模型注意力。另外一些敏感的信息和代码也会被过滤。做完这些后我们的上下文能裁切大约 99%;

                • 交互区域标注:接着我们把 70% 准确率进一步提升,遇到了一些问题。在用户操作无交互表现的情况下,LLM 无法很好的理解,如左图,这里点击“…”没有交互状态变化,LLM 只理解到“点击空白区域”。我们通过增加交互区域标注来解决,这让 LLM 可以准确理解用户交互的区域,效果如右图,LLM 可以理解到“点击更多按钮”;

                • 父级元素标注:虽然增加了交互标注,但在一些复杂业务,元素之间是有关联的。如左图,“?”的图标,LLM 可以理解到是“帮助”,但它并不理解是“退款资金状态的帮助”,如果一个页面中有多个类似图标就不准确了。为此,我们增加了父级元素标注,把交互区域前后的父级 DOM 元素一起给到 LLM,让其理解更多上下文关系。如右图,增加后 LLM 可以理解到“点击退款资金状态的帮助”;

                做完这些后,我们的准确率可以做到 89%,单次增强的耗时在 5-10 秒之间,这得益于模型能力的提升,从 Qwen2.5-VL 的 20 秒到 GTP-4o 的 10 秒以内。

                目前这套方案是跨全平台的,包括Web、Pad、桌面等设备,Android、iOS、鸿蒙等系统,以及各类小程序。

                3.5 AI用例执行

                有了用例之后,接下来是用例的执行。目前我们的用例执行都会统一注册到任务中心,由其下发到两大集群,分别执行浏览器任务、App任务(包括小程序)。

                AI 在执行方面有天然的优势,跨平台支持,具备一定自适应能力,比如一些设备有像素抖动的情况,LLM 可以识别提升用例稳定性。

                目前我们的用例执行量超过每天 10 万次,任务成功率 96%。

                当然,这个过程中也遇到了一些问题:模型执行速度慢、模型幻觉问题、模型识别精度问题。

                • 解决“模型执行速度慢”:我们先做了基于图像和 Prompt 的识别缓存。但未命中缓存时 AI 指令的秒级,和程序指令的百毫秒级差距依旧很大。因此我们做了 AI 提速,用例解析后首先程序执行,失败时 AI 兜底执行,执行成功后由 AI 进行自愈,提取成功的信息更新程序脚本;

                • 解决“模型幻觉问题”:幻觉问题不是太大,通过 LLM 二次优化步骤 Prompt,同时采用更准确的 AI 指令(如 Midscene 中用 AI Input 替代 AI Action)基本可以解决;

                • 解决“模型识别精确问题”:看下图中右上角的图,红框是 Qwen-vl-max,绿框是UI-TARS-1.5,它们对于小元素的识别精度差异很大。从我们时间来看 Qwen-vl-max 对小图标识别能力较差,开启 deepThink 有所改善。UI-TARS-1.5 具备较强的探索能力,它们在断言方面都不如 GTP-4o。我们也从元素定位、元素断言、内容提取、任务规划方面,测试了 5 个主流端,UI-TARS-1.5 在元素定位精度和移动端表现较好,也是我们目前的选型;

                3.6 AI无参考测试

                做了 AI 执行后,我们开始思考 LLM 本身具备常识,也知道企业内部知识,是否可以做 AI 无参考测试?

                我们做了探索,首先要做无参考测试,对模型精度要求较高,通用的多模态 LLM 较难满足。

                因此,我们引入了监督微调(SFT LoRA),主要让 LLM:具备更细化的任务定义、明确输出格式便于工程化对接、注入内部知识和评判标准。

                我们的算法团队做了不少建设,让业务团队可以聚焦在微调数据集。一条微调数据包括:Instruction、Input、Output,下图是一个最简单的案例:

                当然这条微调数据并不好,它的 Output 缺少了很多内容, 比如:作答风格、结构化输出、内部知识、分析的过程和原因。我们从指令微调、思维链微调两部分对这条数据进行优化,如下图:

                定义了数据结构,接着是如何生成大量的微调数据,一般需要训练集、验证集和测试集,前两者用于训练过程,后者用于最后的评估。

                整个数据集包括正样本、负样本和混合样本,一般比例为 1:3,避免模型过度偏向“总是发现问题”。

                数据集通过 LLM 合成,首先通过脚本抓取线上的原始样本(正样本),然后通过程序合成多个负样本。

                结合样本图片和特定的 Prompt 用 LLM 来生成 Output,Prompt 中包括我们的内部知识、预期输出结构、作答风格。

                目前我们的垂直模型正在微调中。

                3.7 AI归因归类

                当用例执行完成后,我们需要对失败用例进行分析,过往需要人工分析效率较低,100 条失败需要15分钟。

                我们通过 AI 来提速这个过程,首先由 LLM 将单个失败总结核心原因,然后将类似原因的分组归类。

                如右下图,一共 85 条失败用例,被快速归为了 3 组,且标明了核心原因。

                人工可以非常快速的进行分析,100 条仅需 1 分钟。

                整个归因归类过程,首先是对用例执行报告进行程序预处理。

                程序主要将失败图片进行切片、步骤进行拆分。前者解决多模态 LLM 在大图下的幻觉及不稳定性,后者解决性能问题。

                接着切片交给图片归因 Agent、步骤归因 Agent,进行并发分析。

                再由总结 Agent 对原因进行合并总结,最后归类 Agent 对原因类似用例进行分组。

                目前我们线上用例已 100% 覆盖 AI 归因归类,归因准确率为 85%。

                3.8 AI用例修复

                做了 AI 归因归类后,我们发现既然原因都知道了,何不让 LLM 自己修复?

                因此,我们正在探索了 AI 用例修复,目前主要针对像素差异率波动、非核心元素变化的场景实现了修复。

                如下图,AI 会对可修复场景进行建议,人工确认无误可一键修复。目前修复准确率 60%。

                3.9 与 AI Coding 结合

                以上就是我们在 AI Test 方向的实践,后续我们计划串联 AI Coding 和 AI Test。由 Coding Agent 生成测试目标,交由 Test Agent 对用例进行召回和生成,并完成后续的自动化测试工作。

                4. Agent 评测:从炫酷飞起到生产落地

                在 AI Coding 和 AI Test 中我们构建了大量的 Agent,需要一套 Agent 评测体系对它们进行评估反馈。

                4.1 为什么需要评测

                先看一张大家都很熟悉的图,我们看别人的 Agent 时都会觉得好炫酷跃跃欲试,然后自己也开始手搓 Agent。

                做完后在开发环境或者小范围测试中表现也不错。

                发布到生产后,各种奇奇怪怪的情况,用户提问的思路无法捉摸,最后还是要转人工。

                我们需要知道,Agent 和传统软件不同,没办法列举完整的用例来保障效果。

                软件测试目标固定、标准化、可复现,而 Agent 评测具有不确定性、开放性(比如用户提问)、多样化(比如模型回答)。

                发布标准上,传统软件主要看功能点完成度,测试通过与否。 Agent 则需要用评测集进行多维度的指标评估。

                Agent 开发完并不意味着达到生产发布标准,应该用评测指标作为依据。

                4.2 评测集

                开始 Agent 评测,首先需要准备评测集, 评测集的类型有:有参考、无参考、参考资料三种。

                接着是评测集的构造,常见的方法有:人工标注、LLM 泛化、线上采样。

                一个全新的 Agent 没有线上采样数据,我们可以通过人工标注 50-100 条的种子集,然后让 LLM 进行泛化。

                评测集根据场景不同,也可以划分为:种子集、Badcase集(一般来源于用户反馈)、扩展集、对抗集、场景集(一般由业务场景决定)。

                4.3 评测器

                有了评测集之后是评测器,评测可以分为两种:人工评测、自动化评测。新的 Agent 初期由于评测标准不确定,可结合人工评测,随着调用增加,将人工评测维度沉淀为自动化评测。相较于人工,自动化评判尺度统一、主观偏差少。

                自动化评测器包括: 托管(平台自带的评测器,可以快速启动评测项目)、 自定义(自行根据业务编写 Prompt 的裁判模型)、外部(由外部平台/服务提供)。自动化评测器可以由 LLM 作为裁判,可以是特定的算法验证(如 BLEU、CLIPScore等),也可以是业务逻辑验证。

                评测器设计一般包括:评估步骤、打分标准、推理指令、少样本提示(正例/反例)、边界案例、基于业务的判断要点(如合规、医疗等场景)。评测打分用 0-5 分制归一,可以兼顾可解释性和区分度,让不同评测维度可以横向对比。另外,为裁判模型添加 CoT 可以提升可解释性、一致性,便于后续人工分析和优化。

                4.4 评测指标

                接着是评测指标的设定,首先需要先明确评测主体,可以是:基础模型、提示词版本、工具版本、召回的记忆等。

                围绕主题设定评测指标,通常有四类:效果指标、技术指标、用户指标、业务指标。

                另外裁判模型自身需要有评测指标:

                • 人工一致性, 衡量模型评分与人工标注结果的一致程度;

                • 评分方差,衡量模型打分的稳定性;

                • 异常打分率;

                4.5 反馈系统

                除了人工评测、自动化评测外,生产中用户真实的反馈至关重要。能够帮助我们发现 Agnet 在实际应用中遇到的各种边界场景和潜在问题。

                一般有两种方式:

                • 显示反馈:需要用户明确操作(点赞/点踩)反馈,意图明确但反馈率较低;

                • 隐式反馈:是用户使用流程中的行为数据,被采集并解释为反馈,可以获得较高反馈率,比如 AIGC 生成多张图片时,用户选用其中一张图;

                对于反馈率低的问题,通过预设标签来减少用户行动成本,通过预设高评分来增加用户反馈意愿(人们更倾向吐槽而非夸赞)。

                4.6 评测体系

                以上这些组合在一起构成了我们完整的评测体系。

                • 项目启动:由专门的评测人员和项目组成员,共同设定评测维度、创建评测器、建立种子集、泛化评测集,基于评测不断迭代/验证/反馈 Agent;

                • 开发过程:在 Agent 迭代过程中,通过评测集和评测器进行线下实验;

                • 生产环境: Agent 会产生日志和反馈,日志会通过评测器进行线上评测,Trace 可采样沉淀到评测集,另外反馈的 Badcase 也会沉淀到评测集;

                所有 Agent 发布前都需要经过评测验证。

                5. AI落地的一些经验

                5.1 AI与程序的结合

                首先是 AI 与程序,常见构建 Agent 的模块包括:程序计算节点、单一 LLM 节点、Workflow、Agentic。

                可能有些人会觉得,Agentic 比 Workflow 好,Workflow 比单一 LLM 节点好,单一 LLM 节点比程序好。从我们实践来看,这四者之间没有绝对的优劣,通常需要根据业务场景进行多选和组合,其取决于场景对确定性、稳定性、创造性、自主性的侧重。

                另外,程序和 LLM 也并非替代关系,LLM 更适合理解、规划、生成类任务,程序更适合确定性、稳定性、高性能任务。通过程序规避 LLM 的弱项是必要的,避免过度追求 AI 含量

                5.2 AI与人的陷阱

                接着是,AI与人,需要警惕两个陷阱:

                • 在落地 AI Coding 的过程中,出现开发者对 LLM 生成代码的依赖,甚至出现不作判断直接提交的情况。保持开发团队的主观判断力非常必要。另外分场景追求 AI 生码,比如核心业务逻辑人写,非核心交由 AI 写;

                • 在落地 AI Agent 的过程中,需要人工监督,应该警惕人工监督大于迭代 Agent 的情况,将监督数据用于 Agent 迭代;

                5.3 AI落地经验

                最后总结下 AI 落地的关键经验:

                • 区分创造性和执行性工作,现阶段 LLM 可以较好的完成执行性工作,这类场景较为合适;

                • 落地从传统研发流程切入,寻求快速出 MVP 进行单点突破;

                • 现阶段 AI 仍需大量人参与,过程中充分考虑人机协作,比如人机交互(人好用)、知识外化(人转化)、责任归属(人敢用);

                • 同步建设私有化的 AI 基建,将行业能力与企业内部能力串联;

                • Agent 的迭代不能先方案再开发,应该基于测试集和上下文工程快速试错;

                • 最后在不同的场景分阶段落地,不要一蹴而就;

                6. AI实践全景

                以上是我们在研发全流程落地 AI 的实践:

                • 我们通过软件工程(Software Engineering)和上下文工程(Context Engineering),将程序与 LLM 结合;

                • 围绕研发的设计、编码、测试阶段落地 AI 能力;

                • 过程中建设了 Agent 评测体系,不断反馈,持续迭代;

                阅读原文

                跳转微信打开

                一个能用的 AI Agent,是怎么“长”出来的?-- Prompt 调优篇

                2025年11月21日 10:28

                原创 有赞共享技术 2025-11-21 10:28 浙江

                不是写一次提示词就完工,而是在反复测试、负优化、回滚、拆解中“长”出来的。本文来自一线团队的实战复盘:如何用量化评测驱动 Agent 迭代?为什么 Few-shot 用多了反而更差?怎样通过精简输入和职责拆分,让准确率和速度双双提升?

                01 背景

                最近几周,我们在 AITest 中增加了提速、归因等 Agent,目标是通过 AI 帮助测试人员提升效率、辅助决策。

                开发这些 Agent 是非常快的,我们的第一版几乎只花了一两天的时间就完成了。

                但是当我们开始真正评测这些 Agent,并且开始效果调优时,我们遇到了很多问题。 考虑到其他正在开发 Agent 时也会遇到类似问题,因此写这篇分享文档,希望能提供其他的开发者一些可借鉴的经验。

                02 开始前的准备

                2.1 定义成功的标准

                推荐阅读:《定义你的成功标准 - Claude Docs》[1]在开始之前,就应该知道我们本次所开发的 Agent

                1. 需要做的事情是什么?

                2. 什么样才是符合预期的?

                3. 需要哪些输入?

                4. Agent 的输出什么?

                2.2 准备评测用例集

                尽快去做,这一步应该在做 Agent 刚开始就应该被考虑,无论用什么方式,多维表格还是文档,还是 excel,还是 langfuse,可测量是做 Agent 非常关键的一步

                如果我们的 Agent 可被测量,那一定也同时意味着我们可以反复复现相同效果。

                只要当 Agent 可以反复被测试且达到预期值时,这个 Agent 才能算相对稳定,如果只是本地随便跑两下,一旦到线上真实环境运行的时候,大概率就是效果不佳的。

                量化效果不仅能帮我们冷静客观地找到问题,并且能在一堆失败 case 中找到共同点。

                那么如何建立这样的评估体系呢?

                第一步:我们需要清楚现在做的 Agent 要达到的目标是什么?效果是什么?他的输入信息是什么?

                以归因为例: 目的是:基于测试报告找到真正失败的测试步骤并且说清楚错哪里了; 效果是:1. 定位准确的失败步骤;2. 输出准确清晰简洁的错误原因 输入是:1. 测试报告;2. 操作快照;3. 测试步骤

                第二步:准备评测集

                因为第一步,我们已经知道,Agent 需要什么(输入),并且产出什么(定位失败步骤和原因说明)

                那么我们准备的评测集需要有:

                1. 一个失败的测试报告

                2. 人工提供预期定位的测试步骤和预期的错误原因

                第三步:立刻开发 Agent 第一版(只要有大概输出结构即可)

                第四步:把评测集用例挨个塞给 Agent(对错无所谓),输出第一版评估报告,创建多维表格

                第五步:分析报告

                主要需要分析几个问题

                1. 和预期是否相符?

                2. 失败的 case 原因是什么?有没有解决方案?

                重复 3 - 5 直到达成预期指标

                2.3 快速初始化提示词

                推荐使用 AI 快速生成第一版系统提示词(这也是 Claude 推荐的做法)

                我们手工编写系统提示词的第一版往往很低效,因为我们在初始阶段对目标结果是模糊的;另外,既然我们都已经在用 AI 了,那么应该更多的利用 AI 提升效率

                我们在初期,已经明确了大致的目标(只是还未细化),因此,我们可以简单的将目标扔给 AI 让 AI 帮我们完成第一版提示词,快速进行量化评估

                不必纠结第一版是否完美,跑通整个 Agent 流程(v0.1 Agent + 一个评测集 + 自动化跑评测数据)才是关键



                  我正在做测试用例失败分析的助手,这个agent
                  我会提供给这个agent 3个内容
                  1. report 测试用例执行失败的报告详情(json数据)
                  2. flow 测试用例的具体测试步骤(json数据)
                  3. analysis 基于对测试报告执行的每一步进行的分析(json数据)


                  ....

                  03 提示词调优

                  推荐阅读:《使用我们的提示词改进器来优化您的提示词 - Claude Docs》[2]

                  3.1 改进提示词的提示词

                  想不到吧?还有提示词的提示词 :) 我还是推荐用 AI 进行提示词改进(这种做法是目前社区中的主流),尽量不要手动调整系统提示词,原因有二: 一是系统提示词调优是快速多次的事情,可能从第一版到阶段性终版之间需要调几十轮提示词,如果人工调整,人力成本巨大费事费力 二是人工调整往往意味着效率低下,机加工往往比纯手工快很多倍,在快速迭代过程中,应该用机器的力量加速我们的 Agent 开发

                  3.2 调优提示词模板

                  回过头来继续聊改进系统提示词,在调整系统提示词的过程中,我们需要反复告诉 AI 几个内容:

                  1. 我们现在的系统提示词

                  2. 我们输入的内容

                  3. Agent 输出的内容

                  4. 需要调优的目标

                  在我多次调优 Agent 的过程中,我发现几乎每次都需要这些内容,AI 才能帮助我们调优,因此我准备了一个简单的调优提示词

                  以下提示词是万能模板,input 是输入的内容; output 是 Agent 输出的内容; system-prompt 是完整的系统提示词;存在的问题 部分可以描述当前存在的问题详细信息



                    ## 提供给 agent 的 input 如下


                    <input>
                    </input>


                    ## Agent 返回的 output 如下


                    <output>
                    </output>


                    ## 系统提示词如下


                    <system-prompt>
                    </system-prompt>


                    ## 存在的问题是

                    04 提示词调优实践技巧

                    4.1 经验一:结构性提示词

                    4.1.1 确定目标(角色设定)

                    推荐阅读:《通过系统提示给 Claude 赋予角色 - Claude Docs》[3]

                    通过目标设定/角色设定,我们可以将 Agent 的工作限定在某个范围内,增强 Agent 的表现 Claude 文档中所说的是给 AI 赋予角色,但是在实际开发 Agent 的过程中,基于我个人的经验和理解,我认为并不是说一定要为 Agent 赋予某个角色,因为在某些 Agent 上他做的事情就是非常单一单点的,此时我们强行赋予角色的含义其实并不是很合适。

                    更好的做法应该是将 Agent 的核心目标定义清楚即可,换句话说,并不是每个 Agent 都需要角色设定,角色设定只是为了帮助 Agent 更好的完成目标

                    他们都能达到很好的效果表现。

                      我会给你一个测试步骤执行的结果,以及他执行前后的快照(如果是打开页面的测试步骤可能只有一张快照)我希望你能帮我判断一下测试步骤执行是否符合预期。

                        你是一个专业的测试用例失败分析助手,负责分析自动化测试执行失败的根因,并输出标准化、结构化的失败摘要与改进建议。你的结论将用于下游系统的程序化处理,因此必须严格遵循输出格式与字段含义。

                        4.1.2 思维链(CoT)/任务拆分

                        推荐阅读:《让 Claude 思考(思维链提示)以提高性能 - Claude Docs》[4]

                        思维链和任务拆分的本质是帮助 Agent 将任务拆分成更小的颗粒度,逐步完成,这样有助于提升最终表现

                        以 失败原因总结 Agent 为例,由于入参是所有的测试步骤执行结果,我们需要告诉 AI 怎么样准确找到失败的步骤,并准确的描述失败原因,因此我们在提示词中加入了以下内容

                        这能帮助 Agent 更好地理解入参并进行失败原因分析,在实际测试中,它避免了 Agent 直接采用最后失败步骤作为失败原因的情况



                          ## 生成逻辑步骤(算法)


                          1. 遍历 analysis 数组(按已有顺序,不重排)。
                          2. 对于每个步骤,若 passed=false,需对比 refAnalysis 中同 index 步骤的 summary 和表现:
                             - 若本次表现与历史成功表现基本一致(如都为“前后截图一致”且历史被判定为通过),则该步骤判定为通过,继续下一个。
                             - 若本次表现与历史成功表现有明显差异(如历史成功时页面有变化/目标达成,本次未达成),则判定为失败,作为首个失败步骤。
                          3. 选取第一个实际失败步骤,提取:
                             - index -> startFailNumber
                             - 类型 -> startFailType(按前述优先级推断)
                             - simpleFailReason:结合本次与历史成功表现的差异,提炼为“未进入 XXX 页面”、“未显示 XXX 内容”等具体描述。
                             - summary:整合分析+建议,突出与历史成功表现的对比。
                          4. 返回 JSON。

                          4.1.3 使用 XML 格式

                          使用 XML 格式我个人最大的感受有几点:

                          1. 顺序无关,我们不再需要保证严格的提示词顺序,XML 通过标签包裹的形式,我们甚至可以将一些信息放在末尾,在其他位置引用

                          2. 更灵活的引用,例如提示词中可以写: 请根据 <input> 中所提供的内容进行分析...,而 <input> 部分,我们可以放在提示词的任意部位,可以是开头也可以是结尾

                          3. 局部更新,当我们开发了多个 Agent 之后,会发现一件很头痛的事情,即每次修改提示词就会改变整个提示词,那么通过 XML 我们可以将一些固定内容排除掉,比如说本次我们有 <examples> / <instructions> 这些 XML 标签时,我们可以避免更新里面的示例内容,专注与调整提示词的其他部分

                          4.1.4 使用示例(Few shot)

                          推荐阅读:《使用示例(多示例提示)来引导 Claude 的行为 - Claude Docs》[5]

                          使用示例可以帮助我们提升 Agent 表现,尤其是当我们的 Agent 已经能在评测中取得 60-70 分时,再往上提升发现通用提示词无法解决的边缘 case,可以通过示例在教 Agent 怎么做才是对的

                          比如我们之前在做提示词转测试步骤的 Agent 时,提供了一些示例来帮助 Agent 理解一些特殊场景



                            ## 处理示例


                            ### URL 操作处理


                            // 输入:打开 URL:https://store.youzan.com/v4/channel/xhs/dashboard
                            // ⚠️ 重要:必须使用 aiAction 类型,不能使用 nativeUrl 类型
                            {
                            "flows": [
                                {
                                "type": "aiAction",
                                "prompt": "打开 URL:https://store.youzan.com/v4/channel/xhs/dashboard",
                                "action": {
                                "type": "url",
                                "url": "https://store.youzan.com/v4/channel/xhs/dashboard",
                                "weappPath": ""
                                }
                              }
                              ]
                            }

                            4.1.5 精简提示词

                            上述提到的所有提示词技巧,不应该无脑加到提示词中,通过我个人的 Agent 开发经验来看,系统提示词上下文越大,Agent 响应速度越慢

                            比如说当你使用思维链时,的确能提升准确度,但是代价是响应变慢;当你使用示例时,的确能提升单个 Case 的表现,但是代价是过拟合的几率增加

                            因此,保持提示词精炼也是编写提示词的一个重要考虑

                            以下为测试用例提速 Agent 精简提示词前后的响应速度表现

                            优化前,平均响应时间都在 ~20s/次,tokens消耗 ~30k
                            优化前,平均响应时间都在 ~20s/次,tokens消耗 ~30k
                            优化后,平均响应时间降低至 <10s/次, tokens 消耗降低至 ~3k(表现相同)
                            优化后,平均响应时间降低至 <10s/次, tokens 消耗降低至 ~3k(表现相同)

                            4.2 经验二:减少系统提示词中的 Few shot

                            过多的 Few shot 会出现过拟合的问题,导致我们编写的系统提示词无法普适到更多的用例中。

                            也许我们增加了某个 Few shot 之后,马上之前失败的一个指定 case 立刻就会成功,但这不是真实的,当我们去跑更多的 case,会发现 Agent 出现很死板的回答。

                            4.2.1 具体案例

                            我们在 Agent 提示词中提供了一个 case,举例说明 SG781228015809656268 表示 操作编号

                            由于这个需要业务理解,Agent 才能知道 SGxxxx 是 操作编号,那么最快的方式就是添加 Few Shot 让 Agent 能理解

                            预期是希望 Agent 在发现 css 选择器如果是这样的值,则优化成 操作编号

                            4.2.2 问题表现

                            但实际情况是,我们发现,增加这个 Few Shot 之后,一旦 Agent 识别到 SG781228015809656268 无论他是不是在 选择器字段中,都无脑优化成 操作编号 ,甚至是操作步骤里输入内容的值都优化掉了。

                            但是我们并没有告诉 Agent 要优化 value 这个字段。

                            4.2.3 推荐做法

                            1. 0 Few shot: Agent 初期,系统提示词不应该有 Few shot 最好一个都不能有(尽量用逻辑表述让 Agent 理解怎么做才是对的)

                            2. 增加 Few shot 的时机: 当系统提示词已经能做对大部分 case 时,如果要再进一步提升,可以增加少量少量的 Few shot

                            3. 模糊具体名词: 在编写 Few shot 的时候,尽量不要模糊掉一些具体词汇,比如某某商品、xxxx 名称之类的具体词最好不要出现

                            4.3 经验三:精简输入

                            起初我们在做 提速 Agent 的时候,我们希望将完整的测试报告和测试步骤全部提供给大模型,希望大模型能自己定位到所有需要提速的步骤,然后一次性优化掉。

                            这里我们犯了一个很大的错误,我们希望 Agent 一次性完成整个任务 这样做的结果是:

                            1. 分析不全:有些测试用例,需要同时优化 5 个测试步骤,但实际上 Agent 只识别到 4 个测试步骤。

                            2. 说谎:当我们调整提示词,需要 Agent 先分析需要优化几个步骤,再对这几个步骤进行优化的时候,我们发现 Agent 会说已经优化好了,但实际上一个步骤都没有优化。

                            3. 注意力不集中:当 Agent 的确分析对了 5 个步骤,并且也优化了 5 个步骤之后,有时候 Agent 会出现根本没有基于测试报告的信息进行优化,比如需要优化的是第二步,他获取的是第三步测试报告中的信息,优化第二步

                            4. 捏造事实:当我们进行更严格的系统提示词限制时,Agent 认为他无法优化,但他又不能违背提示词规则,他会凭空创造一些选择器,填充到需要优化的步骤中

                            这些问题反复会出现,无论你调整多少轮提示词,都无法做好,给人的感觉就像是掺了水的沙子做的雕塑,看着是一个合理的形状,但是稍微一用力就碎了。

                            4.3.1 具体案例

                            自优化 Agent 输入:

                            1. 测试用例执行报告(report)

                            2. 测试步骤(flow) 预期输出: json 格式数据 { "summary": "<string, 对本次优化总结>", "needUpdate": "<boolean, 是否需要更新>", "newFlow": "<array, 优化后的 flow>", "fallbackAIFlow": "<array, 降级到 AI 执行的 flow>" }

                            4.3.2 问题表现

                            一:非 JSON 格式,Agent 输出时在末尾跟着一些解释性内容

                            二:从 output.summary 中可以看到 Agent 认为有 4 个降级步骤,但实际上有 7 个

                            三:从 output.summary 中可以看到 Agent 认为有两个可以优化,另外 2 个无法优化。但实际上对比 oldFlow 和 newFlow 我们发现 Agent 优化了 3 个步骤

                            4.3.3 推荐做法

                            之后我们开始思考如何解决这个问题,我们猜测应该是给的内容太多了,我们把需要优化的步骤和不需要优化的步骤都提供给了 Agent,在 Agent 的输入中掺杂了很多不必要的信息

                            那么,有没有可能进一步减小 input 呢?我们想到,因为测试步骤是一个数组,测试报告中的每个步骤也是一样。

                            那么,我们是否可以通过程序代码,先做一遍筛选,只将需要优化的步骤以及测试报告中对应的执行结果告诉 Agent。

                            这样,Agent 得到的必定是要优化的测试步骤,它再不需要判断得到的信息中哪些要优化,哪些不要优化,只要专注于做一件事情——把这个测试步骤尽可能优化好。

                            这样做了之后,我们发现 Agent 输出的质量有了明显的提升。 同时,我们惊喜的发现,不仅是质量提升,响应速度也有明显提升,从原先 > 60s 响应,锐减到 6s 响应,10x 提升

                            beforeafter

                            所以,精简输入是非常有用的方法,仅把最小必要信息提供给 Agent,不仅能提升输出质量还能提升响应速度。

                            所以,为什么会出现 ReAct,也是有迹可循的对吗?前人早已总结了经验,不应该企图让 Agent 一次性完成工作

                            4.4 经验四:拆分更小的 Agent

                            一个 Agent 只做一件事情,我的意思是说,一个 Agent 只做一个小点 刚才,我们已经表达了精简输入的收益很大,但是假如你的 Agent 做很多事情,它既要分析、又要生成、最后又要总结某些内容,那么可以基本断定,这个 Agent 很难调优。

                            缩小单一 Agent 的职责范围,已经是目前比较主流的一种做法

                            4.4.1 推荐做法

                            我们在做失败归因的时候(失败归因是指:通过使用 LLM 找到测试报告真正失败的测试步骤。一些情况下,上报失败的步骤并不是真正导致失败的根因,可能是之前的步骤点击没有生效导致的,我们尝试用 LLM 找到根因步骤,并告诉测试人员,减少测试人员人工检查失败原因的时间)

                            就将整个归因目标拆分为 4 个 Agent 实现,每个 Agent 做很小一块工作,最后我们通过代码将整个流程串起来

                            Agent

                            能力描述

                            分类师(Classifier)

                            失败错误分类

                            Diff 检查员 (Inspector)

                            Diff 步骤详细失败原因分析

                            分析师(Analyzer)

                            测试步骤执行结果分析

                            协调者(Coordinator)

                            基于 Diff 和测试步骤执行结果 -> 总结失败原因

                            这样做的好处是:

                            1. 单个 Agent 更容易调优

                            2. 响应速度更快

                            3. 提示词可以更加精准

                            4. 影响面可控(我们知道 Agent 系统提示词,一次改动就彻底推翻了,如果我们将所有工作都在一个 Agent 中完成,那么当我们需要迭代 Agent 的时候,就会非常困难)

                            4.5 经验五:考虑 Agent 回滚

                            4.5.1 保管好老版本的系统提示词

                            Agent 和写代码完全不一样,每一次系统提示词更新就是对上一次的全部推翻( 所以说量化效果很重要:( 上次对,这次不一定就对了 )

                            所以,务必要创建一个临时的文件,保存好上一次的提示词,这样我们在遇到负优化的时候可以轻松的回撤到上一个版本

                            4.5.2 接受无法做到 100 分的事实(甚至 80 分)

                            从我们的经验来看,绝对采纳率一旦上到 70 之后(可能 60+就开始了),后面的系统提示词调整,大概率会出现负优化,会反复卡在一个点位上优化不上去,加把劲就可能直接跌到 30%采纳率。

                            所以,说真的,Agent 开发,比 E2E 测试还要难,E2E 测试起码还能控制变量进行测试,对就是对,错就是错,我们可以做到整个用例集 100%通过。

                            但是 Agent 评测,我们会发现好的 Agent 大概能覆盖大部分常见场景,但是一旦试图让他全部做对的时候,一定会出现过拟合(其实有据可循的,要么就是加 Few shot,那就是思维僵化;要么就改更复杂的系统提示词,描述复杂不清晰后就开始负优化)

                            这时候,我们的重心不应该再局限于提示词调优上了,而是应该通过其他方法去提升效果比如说 ReAct 、 RAG

                            另外,在 Claude Docs 中有很多有用的方法,比如说提到过 N 次最佳验证 的方式进行准确率提升

                            N 次最佳验证:多次使用相同的提示运行 Claude 并比较输出。输出之间的不一致可能表明存在幻觉。

                            05 写在最后

                            提示词技术还在快速进化,每天都有新方法出现。我们要保持开放心态,多动手实践,多交流心得。

                            重点:好的 Agent 不是一次设计到位的,而是在不断测试、迭代、优化中“长”出来的。

                            参考资料

                            [1] 

                            《定义你的成功标准 - Claude Docs》: https://docs.claude.com/zh-CN/docs/test-and-evaluate/define-success

                            [2] 

                            《使用我们的提示词改进器来优化您的提示词 - Claude Docs》: https://docs.claude.com/zh-CN/docs/build-with-claude/prompt-engineering/prompt-improver

                            [3] 

                            《通过系统提示给 Claude 赋予角色 - Claude Docs》: https://docs.claude.com/zh-CN/docs/build-with-claude/prompt-engineering/system-prompts

                            [4] 

                            《让 Claude 思考(思维链提示)以提高性能 - Claude Docs》: https://docs.claude.com/zh-CN/docs/build-with-claude/prompt-engineering/chain-of-thought

                            [5] 

                            《使用示例(多示例提示)来引导 Claude 的行为 - Claude Docs》: https://docs.claude.com/zh-CN/docs/build-with-claude/prompt-engineering/multishot-prompting

                            阅读原文

                            跳转微信打开

                            有赞微信小程序接入Skyline的实践

                            2025年9月3日 11:19

                            原创 有赞共享技术 2025-09-03 11:19 浙江

                            本文讲述了有赞微信小程序接入 skyline 引擎,来实现我们的打开商详场景的“秒开”效果

                            有赞微信小程序接入Skyline的实践

                            小程序与移动端体验

                            移动端技术早期主要由两大平台主导:从 Web 演变而来的H5技术,以及手机厂商的原生(Native)技术。受限于当时的技术与开发效率,许多厂商依然选择 H5 承载业务,并借助 Hybrid 方案调用原生能力。微信小程序作为轻量化应用的早期探索者,为此提供了标准化的解决方案。

                            随着移动端技术持续进步,用户对体验的要求不断提高。习惯原生应用流畅体验的用户,对 Hybrid 等类 Web 方案体验感受越来越差。而微信小程序基于 Webview 引擎的原因,也没法实现更多 Native 的体验。为提升用户体验,微信小程序进行了技术革新,推出Skyline渲染引擎,显著提升了渲染性能与交互流畅度,使小程序的用户体验接近原生应用。

                            微信小程序
                            微信小程序

                            针对电商的高频场景,商品列表打开商详,我们从技术发展的角度,给大家一些案例,直观的感受下不同技术实现能带来的体验差别。

                            我们先对比 传统 Web 和 微信小程序,传统 Web 跳转切页有明显的 loading 加载过程。而微信小程序的技术架构,让整个切页加载体验有了大幅提升。

                            H5页面跳转
                            H5页面跳转
                            小程序跳转
                            小程序跳转

                            再看看,小红书、淘宝等原生 APP 的切页过程。

                            小红书
                            小红书
                            淘宝
                            淘宝

                            很明显,原生 APP 在同样的跳转交互下,做到了更优的体验。其中有几个关键的细节:

                            • 新页面在展开过程中,无白屏、闪动的现象。

                            • 整个展开过程,有过渡动画,由点击卡片向全屏展开

                            • 打开速度非常快,秒级直出。

                            有赞小程序在对部分页面接入 Skyline 引擎后,持续优化。最终实现了类似原生体验的路由切换效果,整个跳转过程做到了首帧无白屏,包含过渡效果,并且达到秒级直出。

                            先看效果:有赞小程序

                            接下来我们对整个优化的几个关键点做具体介绍。

                            如何实现页面切换首帧无白屏

                            什么是首帧?

                            有赞对于首帧的定义是切页出现后,用户看到的第一帧画面。

                            图中红色区域标记的为用户看到的第一帧画面,即为首帧。

                            切页首帧
                            切页首帧

                            哪些内容可以进入首帧渲染?

                            只要在组件 attached 生命周期前(含)通过 setData 设置上去,就会在首帧渲染。微信文档[1]

                            官方文档未明确说明数据注入的姿势,考虑大家实际的业务场景,我们这里需要对比同步数据和等待异步数据两种注入方式。



                              // 示例数据
                              const testContent = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit…………'; 


                              data() {
                                  content: '';
                              }


                              // 同步代码示例
                              attached() {
                                  this.setData({
                                      content: testContent
                                  });
                              }


                              // 异步代码示例
                              attached() {
                                  setTimeout(() => {
                                        this.setData({
                                          content: testContent
                                        });
                                  }, 200) // 200ms 模拟等待异步执行
                              }
                              同步注入
                              同步注入
                              等待异步注入
                              等待异步注入

                              关注切页后的【红色文字内容】,只有通过同步注入,才能在首帧进行渲染展示。而异步注入的内容,则会错过首帧渲染,直到页面打开之后才展示。

                              那是不是只要在 Webview 引擎下保证首屏数据在 attached 周期注入,就能确保“首帧无白屏”了呢?我们通过简单的实验来验证。

                              我们首先验证最简单的场景,在 Webview 下直接注入首屏数据,观测是否能实现首帧无白屏渲染。

                              实验一:Webview 下直接注入数据



                                // 示例数据
                                const testContent = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit…………';


                                data() {
                                    content: '';
                                }


                                // 同步代码示例
                                attached() {
                                    this.setData({
                                        content: testContent
                                    });
                                }
                                Webview 快速注入
                                Webview 快速注入

                                结论:Webview 在 attached 直接注入简单数据,可实现首帧无白屏。

                                少量的数据往往是在验证阶段编写 demo 采用的。但实际业务情况是,页面的首屏会有大量数据,并包含一系列的执行逻辑和计算过程。我们用实验二来模拟更接近实际的运行场景。模拟的方式是加一段阻塞代码,模拟业务逻辑执行等。

                                实验二:Webview 下模拟大量计算逻辑后注入



                                  // 示例数据
                                  const testContent = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit…………';


                                  data() {
                                      content: '';
                                  }


                                  attached() {
                                      function sleep(ms) {
                                        const start = Date.now();
                                        while (Date.now() - start < ms) {
                                          // 空循环,持续检查时间差
                                        }
                                      }
                                      sleep(1000); // 模拟计算逻辑阻塞
                                      this.setData({
                                          content: testContent
                                      });
                                  }
                                  Webview
                                  Webview

                                  结论:在 attached 中包含一定量的计算逻辑后,Webview 路由先完成,渲染后完成,会产生白屏闪一下的问题。

                                  实验三:Skyline 下模拟大量计算逻辑后注入



                                    // 代码同实验二
                                    Skyline
                                    Skyline

                                    结论:在同场景下,Skyline 切页过程是渲染先完成,路由动画后完成,整个过程无白屏。

                                    通过上面的实验,我们可以得出结论,Skyline 即使在有数据逻辑阻塞下,也能保证首屏内容的稳定输出。接下来,我们还可以继续对 首屏数据 和 路由动画这两个点进行深度优化。

                                    首屏数据准备

                                    首屏数据作为首屏渲染的关键依赖,想要更加顺畅的提升速度。可以有以下思路进行优化:

                                    • 在前一页面预加载下一页首屏数据,抽象一个预加载模块,专门用于商品信息预加载的逻辑。

                                    • 拆分下一页数据,仅保留首屏视窗内可见的数据。

                                    • 服务端承担部分计算逻辑,确保页面拿到数据可以直出。

                                    路由动画接入

                                    在 Skyline 引擎下,使用微信内置的 open-container 组件,可以轻松实现和原生页面切换一样的路由动画效果。还支持多种切换模式,以及自定义配置。官方文档[2]



                                      <open-container class="card-item" bind:tap="goDetail">
                                          <small-card class="card-item" />
                                      </open-container>
                                      路由动画
                                      路由动画

                                      从上面的分析中,我们发现 Skyline 包含诸多优秀的新特性,可以让用户体验进一步提升。接下来我们简单介绍下 Skyline 引擎如何接入,以及在接入过程中需要注意的地方。

                                      接入 Skyline 引擎

                                      Skyline 以性能为首要目标,因此 CSS 特性上在满足基本需求的前提下进行了大幅精简,目前 Skyline 只保留更现代的 CSS 集合。另一方面,Skyline 又添加了大量的特性,使开发者能够构建出类原生体验的小程序。小程序支持页面使用 WebView 或 Skyline 任一模式进行渲染,Skyline 页面可以和 WebView 页面混跳。 所有从 Webview 引擎的页面接入 Skyline 引擎后,页面大概率会出现样式结构错乱的。我们适配的重点,就在于 样式和结构上的调整。

                                      样式和结构的适配调整,包含诸多细节,这里只列举了常见的问题,更多细节调整可以参考官方文档。

                                      样式适配

                                      在 Skyline 下 text-overflow:ellipsis,仅用于 text 组件,原先如果是 view 组件实现的,会出现文字超长无法省略,可以用 text 重新实现。

                                      结构适配

                                      在 Skyline 下,overflow 不支持 scroll 属性,只能通过 scroll-view 实现;不支持单独设置 overflow-x/y。

                                      Skyline 配置

                                      小程序对于 Skyline 引擎的使用是具体到页面的,并不需要考虑整体小程序切换的影响,可以渐进式,对部分页面进行逐步升级。接入的话,需要分别 app.json 和页面的 index.json 写入配置代码。



                                        // app.json
                                        "rendererOptions": {
                                            "skyline": {
                                              "defaultDisplayBlock": true,
                                              "defaultContentBox": true,
                                              "tagNameStyleIsolation": "legacy",
                                            }
                                        },
                                        "lazyCodeLoading": "requiredComponents",



                                        // 页面 index.json
                                        "renderer": "skyline",
                                        "componentFramework": "glass-easel",

                                        灰度上线

                                        为保证线上商家小程序稳定,有赞 Skyline 小程序上线过程中,灰度控制是重要的一环。 我们的灰度包含两个环节控制

                                        • 有赞内部的小程序灰度机制,对商家进行分流,部分商家接入 Skyline 版本,部分接入Webview 版本。

                                        • 微信提供的 Skyline 灰度机制。针对终端用户的灰度筛选,控制项包含微信版本、基础库版本等。官方文档[3]



                                          // app.json
                                          // 可分别控制 基础库、iOS、Android、鸿蒙设备微信版本
                                          "rendererOptions": {
                                              "skyline": {
                                                "disableABTest": true,
                                                "sdkVersionBegin": "3.0.1", // 基础库最低版本
                                                "sdkVersionEnd": "15.255.255", // 填最大值,否则之后的新版本会不生效
                                                "iosVersionBegin": "x.y.z", // iOS 微信最低版本
                                                "iosVersionEnd": "15.255.255", // 填最大值,否则之后的新版本会不生效
                                                "androidVersionBegin": "x.y.z", // 安卓微信最低版本
                                                "androidVersionEnd": "15.255.255", // 填最大值,否则之后的新版本会不生效
                                                "ohosVersionBegin": "1.0.5", //  HarmonyOS 微信最低版本
                                                "ohosVersionEnd": "15.255.255" // 填最大值,否则之后的新版本会不生效
                                              }
                                          },

                                          结语:Skyline 特性在电商场景的更多探索

                                          有赞微信小程序目前在 Skyline 引擎方面目前只接入了路由切换这一场景,配合数据预加载和首屏数据的优化,实现了首帧无白屏的秒开效果,当然还有更多场景可以探索,比如分段半屏,搜索栏吸附,沉浸式商品浏览等。官方Demo[4]

                                          引用

                                          [1]https://developers.weixin.qq.com/miniprogram/dev/framework/runtime/skyline/share-element.html

                                          [2]https://developers.weixin.qq.com/miniprogram/dev/framework/runtime/skyline/open-container.html

                                          [3]https://developers.weixin.qq.com/miniprogram/dev/framework/runtime/skyline/migration/release.html#%E5%8F%91%E5%B8%83%E4%B8%8A%E7%BA%BF

                                          [4]https://developers.weixin.qq.com/miniprogram/dev/framework/runtime/skyline/experience.html

                                          文末福利

                                          有赞研发团队前端、后端、客户端、测试、AI开发、运维开发、数据开发等多个岗位招聘中,看机会的伙伴可以将简历发送至 zhuzhuyun@youzan.com。

                                          阅读原文

                                          跳转微信打开

                                          AI Test:AI 测试平台落地实践

                                          2025年8月27日 10:46

                                          原创 有赞共享技术 2025-08-27 10:46 浙江

                                          人工智能正在深度改变各行各业,软件测试也不例外。随着 AI 在自然语言理解、图像识别、意图规划等方面的成熟发展,测试方法正在从【人 + 代码驱动的传统测试】 向 【AI 驱动的智能测试】转型。

                                          AI Test:AI 测试平台落地实践


                                          一、AI 正在重塑软件测试领域

                                          人工智能正在深度改变各行各业,软件测试也不例外。随着 AI 在自然语言理解、图像识别、意图规划等方面的成熟发展,测试方法正在从 “人 + 代码驱动的传统测试” 向 “AI 驱动的智能测试” 转型。

                                          AI 的出现,使构建低门槛、高覆盖、强适应性的测试体系成为可能。

                                          AITest 项目的提出,正是为了探索如何解决测试领域长期存在的难题。


                                          二、AI 落地的现实挑战

                                          1. AI 模型的固有局限

                                          • 幻觉问题:模型可能输出看似合理却错误或编造的信息,在高精度场景中尤为致命。

                                          • 不确定性:LLM(大型语言模型)是概率生成模型,决策过程不透明,输出难以解释且结果不稳定。

                                          • 性能问题:大模型存在响应速度慢、吞吐能力有限的问题(多模态更严峻),在低延迟、高并发的场景中很难满足要求。


                                          2. 与系统/工作流的集成挑战

                                          系统集成误区

                                          误区一:AI = 聊天机器人
                                          简单地把 AI 理解为交互方式的变化,只关注对话体验,而忽视了 AI 在决策、规划、自动化上的潜力,人为限制了 AI 的价值发挥。

                                          误区二:AI 能力 = 产品能力
                                          把 AI 的生成能力直接当作产品能力,而忽视了完整的 产品化、工程化过程。这样做出来的往往只是一个 demo,不具备生产可用性。

                                          误区三:直接接入大模型 = 平台智能化
                                          低估工程化的投入。要使 LLM 具备业务理解力、稳定性和可控性,需要大量“辅助工程”,包括数据预处理、模型微调、知识图谱、反馈机制等。

                                          系统集成思路

                                          明确现有工作流

                                          • 梳理清楚现有系统的工作流,明确人、程序各自负责的节点,识别确实存在的痛点。

                                          • 探讨可行的技术方案,评估 AI 接入是否真正能解决问题。

                                          识别切入点

                                          • 哪些环节可以引入 AI?例如需求理解、环境搭建、用例调试、报告分析。

                                          • AI 能解决哪些痛点?主要聚焦于意图理解、模式识别、信息提取与生成等任务。

                                          集成策略设计

                                          • AI 的输入/输出与现有系统如何对接?

                                          • 执行闭环如何建立?如何通过反馈机制让 AI 持续改进?

                                          • 如何保证 AI 系统具备环境感知和自我调整的能力?

                                          AITest 工作流

                                          图片
                                          图片

                                          3. 与人的集成挑战

                                          AI 的落地不仅是技术问题,也涉及人机关系的再设计。

                                          AI 信心指数

                                          • 经验丰富的人员对确定性要求极高。

                                          • 一次小失误,就可能大幅削弱他们的信任,破坏其高效工作流。

                                          人机协同困境

                                          • 缺乏明确的人机协作边界。

                                          • 难以判断 干预时机、修改方式、对 AI 的合理预期。

                                          信息指数
                                          信息指数

                                          4. 产品交互与 AI 效果的优先级

                                          在 AI 项目中,产品交互的价值常被讨论,有两种观点:

                                          交互重要派

                                          • 好的产品交互是兜底手段,在 AI 出现不确定性时,引导用户修正;

                                          • 清晰的反馈、明确的状态、可控的流程;

                                          • 能够帮助用户降低门槛、增强信任。

                                          交互不重要派

                                          • AI 的核心价值在于能力,而不是外壳;

                                          • 如果 AI 效果不好,再好的交互也无济于事,无法真正解决用户目标。

                                          实践建议

                                          • 早期项目:优先打磨 AI 核心能力,确保核心流程跑通。

                                          • 中期项目:完善交互作为兜底,优化流程,保证最基础的用户体验。

                                          👉 总结:好的交互体验是必要条件,但真正的优先级应当给到 AI 核心能力。

                                          产品交互优先级
                                          产品交互优先级

                                          三、AI 驱动测试的理想与现实

                                          • 理想愿景:完全自动化测试 —— AI 能够独立理解需求、生成用例、执行验证,甚至自动修复。

                                          • 现实状态:目前的 AI 还难以独立承担复杂逻辑处理、数据初始化、状态追踪等任务。

                                          因此,在相当长的一段时间内,AI 测试必然处于 “AI + 人” 协同模式。
                                          人机协同,是当前价值最大化的可行路径。

                                          换句话说,AI 测试的未来方向很明确:走向完全自动化。但在能力尚未成熟之前,我们必须接受一个“AI + 人”共存的过渡阶段。

                                          什么时候能实现理想愿景?要么依赖大模型能力的重大突破,要么通过更强的工程化手段解决幻觉、不确定性、性能等问题。

                                          👉 所以,完全自动化是目标,但人机协同才是当下的现实与必经之路。


                                          四、AITest 的项目经验

                                          1. 核心经验总结

                                          • 经验一:模型 ≠ 系统
                                            模型只是具备单一能力的 Agent,应专注于特定任务。凡是可以由传统程序解决的,不必交给模型。

                                          • 经验二:差异化协同策略

                                            • 简单任务 → 由 AI 决策,人工审核;

                                            • 复杂任务 → 由 AI 辅助,人工决策;

                                            • 人始终保持最终控制权,并通过反馈机制修正 AI 的结果。

                                          • 经验三:AI Native ≠ 颠覆产品形态
                                            AI 的价值在于增强功能、优化工作流,而不是推翻既有产品形态。
                                            解决痛点 > 炫技式重构,这是更现实的落地路径。


                                          2. 实践要点

                                          模型定位与预期管理

                                          • 明确 LLM 的核心价值(意图理解、模式识别、原因分析等),不要期待它成为万能解法;

                                          • 避免过度依赖,把 AI 视为“辅助工具”更符合当前能力。

                                          人机职责划分与协作

                                          • 清晰定义边界:AI 负责用例生成、初步分析;人负责审核、决策、确认;

                                          • 设计便捷的人机交互界面,让用户能随时修改 AI 结果并提供反馈。

                                          工作流程闭环

                                          • 数据驱动:沉淀 AI 生成结果、执行数据、缺陷与反馈;

                                          • 效果评估:设定指标(用例生成效率、缺陷发现率、误报率、修正成本);

                                          • 持续迭代:定期优化 Prompt、模型与知识库,保证系统长期演进。


                                          五、AI × 程序的协同设计

                                          1. AI 与程序的角色

                                          AI 的角色

                                          • 负责理解、规划与探索,这些任务是传统程序难以胜任的;

                                          • 在这些场景中,AI 扮演了“人的能力”,能够处理模糊、非结构化信息。

                                          程序的角色

                                          • 具有高度准确性和一致性;

                                          • 在绝大多数标准化、重复性的任务中表现稳定可靠,效率高于 AI。

                                          协同原则
                                          在设计 AI 产品或 AI 驱动的测试系统时,应充分利用两者的互补优势:

                                          • 程序负责核心执行,确保稳定性和性能;

                                          • AI 在边界场景提供辅助、兜底与纠错能力;

                                          • AI 输出可用于订正程序配置,形成闭环优化。

                                          2. AITest 实践示例:用例执行

                                          1. 程序优先执行

                                            • 高性能执行标准化测试用例,保证效率与一致性。

                                          2. AI 兜底执行

                                            • 对程序执行失败或边界异常的用例进行补充执行,提升整体稳定性。

                                          3. 循环优化

                                            • AI 识别的信息反馈给程序配置,用于下一轮优化;

                                            • 形成 AI + 程序的闭环协同,持续提升测试质量与效率。


                                          六、反馈与优化的重要性

                                          AI 的输出天然存在不确定性,因此失败是优化的前提。在 AI 项目中,反馈与优化是持续提升系统能力、实现可控性的核心机制。

                                          闭环优化的核心目标
                                          让 AI “记住教训”、形成偏好、学习更优策略,构建可追踪、可学习、可演进的系统能力。

                                          关键步骤

                                          1. 案例数据沉淀

                                            • 收集失败案例和人工修正样本;

                                            • 将高价值数据沉淀,用于后续训练和改进。

                                          2. 提示词进化

                                            • 基于沉淀的案例数据持续优化 Prompt;

                                            • 提高生成结果的准确性和实用性。

                                          3. 质量度量

                                            • 建立关键指标,如生成准确率、修正率、误报率等;

                                            • 通过量化效果评估优化策略,确保 AI 输出可控和可预测。

                                          📌 核心理念
                                          反馈与优化不是一次性的修复动作,而是系统性能力的建设。
                                          持续沉淀数据、迭代优化提示、量化效果,形成闭环,让 AI 在实践中不断进化.

                                          信息指数
                                          信息指数

                                          七、未来展望

                                          AI 在软件测试中的演进将分为三个阶段:

                                          1. AI 辅助测试

                                            • 人主导,AI 辅助;

                                            • 聚焦单点突破。

                                          2. AI 驱动测试

                                            • AI 主导,人监督;

                                            • 接管大部分测试任务。

                                          3. AI 自主测试

                                            • AI 全面掌控测试流程;

                                            • 人仅在复杂场景中介入。


                                          结束语

                                          AI 在测试领域的应用,核心在于 工程化思维 + 人机协同模式。
                                          通过合理的模型定位、清晰的职责划分、完善的反馈机制,AI 才能逐步从辅助走向驱动,最终实现自主化测试。

                                          AITest 项目的实践表明:AI × 程序 × 人 的协同,是推动测试智能化的最佳路径。

                                          文末福利

                                          有赞研发团队前端、后端、客户端、测试、AI开发、运维开发、数据开发等多个岗位招聘中,看机会的伙伴可以将简历发送至 zhuzhuyun@youzan.com。

                                          阅读原文

                                          跳转微信打开

                                          智能体(Agent)全景拆解:核心模块、技术实现与业务落地指南

                                          2025年8月13日 17:28

                                          原创 有赞共享技术 2025-08-13 17:28 浙江

                                          本文解析智能体(Agent)的本质与核心架构,详解感知、记忆、规划、行动四大模块的技术实现(含LLM、RAG、ReAct、Plan-and-Solve等),结合真实案例(如蛋糕烘焙助手、商机挖掘)探讨落地挑战(评估、成本)与选型策略。

                                          1 什么是Agent

                                          智能体(Agent) 是指能够感知环境、进行决策并采取行动以实现某种目标的系统。

                                          现在我们把Agent想象成一个人,这样便于我们更好的理解,比如说我们走在路上,看到对面有辆车开过来了,这个时候我们本能的会去躲避,那整个过程是怎么发生的呢?

                                          看到对面有车开过来,这是通过眼睛看到信息,通过神经传递给大脑,大脑调动之前的记忆发现如果这个时候不躲开,就有可能会被车撞,然后驱动着脚走到旁边去。

                                          上面的过程就是感知路面环境、大脑决策最后采取行动的过程。基于上面的过程我们可以看出,Agent会包含以下核心模块。

                                          2 Agent核心模块

                                          见下图,不同的机构或团队对Agent的核心模块划分不同,但都包含了感知、记忆、规划和行动四个模块。
                                          Agent核心模块

                                          2.1 LLM(大语言模型)

                                          先简单说下大语言模型,它是智能体的核心,相当于人的大脑,背后的神经网络设计也是基于人类大脑的神经系统,尤其是神经元(Neuron)之间的连接与信号传递方式。

                                          关于大语言模型就不再详细说了,大家基本每天都在用。然后还是想着重说下深度学习,因为它与传统的软件研发流程不一样。就像AI大神卡帕西(斯坦福读书时的导师是李飞飞, OpenAI的创始成员之一,后面被马斯克亲自招募,出任特斯拉的AI总监,之后又回到OpenAI,去年,他正式宣布离开OpenAI)最近的一个演讲中,提到的一个概念,叫 “软件3.0”。

                                          • 软件1.0,是我们最熟悉的传统软件研发流程,指的是由人类程序员一行行编写代码的方式,我们之前的研发流程都属于软件1.0。

                                          • 软件2.0,是随着深度学习的兴起而出现的。它的核心已经不再是人工编写的代码,而是通过训练来控制神经网络的权重。这个阶段,很多事情不再依赖程序员去手动写逻辑,而是依靠数据驱动模型进行“学习”,而且泛化能力也很好。

                                          • 软件3.0,就是我们现在通过cursor、trae、winself等AI 开发工具用自然语言进行编程,它大大降低了软件创造的门槛。

                                          但仔细想想我们好像直接从1.0跳到了3.0,并没有经过2.0,但实际上软件2.0的应用其实还是蛮多的,尤其是一些垂直行业,如医疗健康,让机器学习看片子,帮助医生看病;如农业领域,能够预测作物产量和优化种植策略;还有教育行业,能够个性化学习路径和提高学习效率等等。

                                          所以我觉得大家有兴趣可以了解了解。推荐两本书:《深度学习革命》、《深入浅出神经网络与深度学习》。

                                          2.2 Perception(感知)

                                          即智能体对环境的感知,一个人可以通过眼睛、耳朵来感知环境,机器人可以通过雷达和摄像头感知环境,软件中主要是基于我们输入的上下文数据,可以是文本、图片、视频、语音、文件等等。

                                          2.3 Memory(记忆)

                                          大模型其实是没有记忆的,只能通过外部技术(如RAG、ES)模拟记忆效果,以增强任务表现和交互连贯性。

                                          分为短期记忆(Short-term) 和 长期记忆(Long-term)。个人认为记忆对于大模型来说非常重要,因为随着对模型的不断使用,如果模型厂商如果把这些使用的记录全部变成记忆,那模型就会越来越懂我们,使用起来也会越来越顺手,而不像现在,每次在提示词上要还很多时间,而且换个窗口后又得重来一次。

                                          2.3.1 短期记忆依赖模型上下文的token限制

                                          参考代码如下, 在每次调用大模型的时候,需要将工具返回的信息、人的反馈信息等都塞到messages中,然后去调用大模型接口。

                                            ounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(line
                                            interface ChatMessage {
                                              role: 'user' | 'assistant' | 'system' | 'tool';
                                              content: string;
                                              tool_calls?: xxx;
                                              call_id?: string;
                                            }
                                            class Memory {
                                              private messages: ChatMessage[] = [];


                                              constructor() {
                                                this.messages = [];
                                              }


                                              addMessage(message: ChatMessage) {
                                                this.messages.push(message);
                                              }


                                              getMessages() {
                                                return this.messages;
                                              }
                                            }

                                            2.3.2长期记忆依赖于外部组件(如RAG, elasticsearch)

                                            可以通过文件或数据库来做存储介质,可以搜索、更新, 长期记忆又可以继续分,如用户画像记忆,情景记忆,事实记忆等。

                                            • 接下来讲下在蛋糕烘培助手案例中是如何处理记忆的,实时的对话信息作为工作记忆,存在内存中,到达一定阈值后,由大模型来提取关键信息来作为短期记忆。然后上半年商机挖掘项目能够分析出客户画像,将这部分信息作为长期记忆存储起来,后续的对话,每次调用大模型的时候会进行召回并更新短期记忆的召回次数。这些短期记忆会进行周期性的评估(包括召回次数和重要性),重要的会合并进核心记忆,不重要的进行遗忘。

                                            • 整体会分三层:工作记忆、短期记忆、 长期记忆

                                            • 每次询问通过向量检索更新短期记忆召回次数

                                            • 短期记忆由大模型来进行提取为边缘记忆,并设置重要性评分

                                            2.4 Action(行动)

                                            行动很好理解,LLM相当于我们的大脑,但是光有大脑,没有手脚也做不成事,所以Agent就需要借助外部的工具进行行动。

                                            我们需要把我们的工具(包括名称、描述和需要的参数)告诉LLM,当LLM来决定是否用工具,以及什么时机用工具。

                                            介绍下案例中使用的商品查询工具,即用户通过一个问题或图片就能找到商家后台商品库的商品

                                            • 商品的关键词查找处理:

                                              • 将商家后台的商品图片和标题通过多模态模型提取出关键信息;

                                              • 大模型会提取出关键信息,然后让工具执行,在执行过程中将关键词和商家后台商品的关键信息项进行相似度检索,从而找出匹配的;

                                            • 图片的查找处理:

                                              • 将商家后台的商品图片向量化;

                                              • 模型提取出用户想要的蛋糕商品图片链接,然后和商家后台商品图片进行相似度匹配;

                                              ounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(line
                                              // 定义tools
                                              const tools = [
                                                  {
                                                      "type": "function",
                                                      "function": {
                                                        "name": "query_goods",
                                                        "description": "查询蛋糕商品信息",
                                                        "parameters": {
                                                          "type": "object",
                                                          "properties": {
                                                            "keywords": {
                                                              "type": "array",
                                                              "items": {
                                                                "type": "string",
                                                                "description": "蛋糕商品关键信息项",
                                                              },
                                                              "description": "蛋糕商品关键信息,包含适用场合、目标人群、风格、口味、主题、颜色等",
                                                            },
                                                            "image_url": {
                                                              "type": "string",
                                                              "description": "蛋糕商品图片链接",
                                                            },
                                                          }
                                                        },
                                                     }
                                                  },
                                                  ...
                                              ];

                                              2.5 Planning(规划)

                                              规划这部分相对会复杂点,接下来主要将常见的两种规划模式,分别是ReAct和Plan-and-Resolve,除了这两种模式还有多Agent模式等。

                                              2.5.1 ReAct(Reason + Action 推理 - 行动 - 反馈)

                                              通过不断的推理、行动和反馈来最终完成用户的目标。

                                              蛋糕烘培助手的流程如下图:蛋糕烘培助手

                                              2.5.2 Plan-and-Solve

                                              将任务分解成子目标并分布执行,这个和ReAct的区别是:Plan-and-Solve是先通过大模型将任务拆解,然后再分布执行,和ReAct是一步一步的去执行,两种模式适用的场景不一样。

                                              比如说旅游规划的agent,就可以用Plan-and-Solve模式,先生成计划(如要了解天气、要了解住宿等),然后再解决计划, 最终整合让大模型完成回答, 当然中间也可以加反思,对计划进行反思等。

                                              下面是基于Plan-and-Solve的流程图:

                                              3 Agent评估报告

                                              评估报告是Agent开发过程中不可或缺的环节,包括响应时间、完成度、工具使用情况、后续优化等,它能够系统性地收集和分析Agent的运行数据,为后续的优化和迭代提供科学依据。

                                              所以在agent的设计环节都需要将这些数据都记录下来。

                                              4 Agent成本分析

                                              在做AI应用的过程中,我们经常会被问到一个问题,做个东西的成本怎么样?

                                              AI相关应用与传统的应用之间的计费方式完全不一样了,所以Agent中每次的模型调用,所以针对Agent需要做成本分析。

                                              基于成本分析可以进行价值回顾和agent的优化。

                                              5 Agent vs Workflow

                                              用一句话来概括它们之间的区别就是:Agent是你只需要告诉我你要什么,不需要告诉我怎么做,而workflow就是你要按照我编排好的路径来执行。一个是基于大模型来规划,一个是基于人来规划。

                                              如何选择?

                                              • 选Workflow

                                                • 数据处理管道

                                                • 文档审批流程

                                                • 任务流程相对固定,步骤可预定义

                                                • 需要严格的执行顺序和质量控制

                                                • 要求高可靠性和可重复性

                                                • 涉及多个系统集成,需要标准化流程

                                                • 合规要求严格,需要审计追踪

                                                • 如:数据处理管道、文档审批流程

                                              • 选Agent

                                                • 智能客服助手

                                                • 个人AI助理

                                                • 复杂问题诊断

                                                • 任务需要动态决策和灵活应对

                                                • 环境不确定性高,需要自主判断

                                                • 要求个性化和上下文理解

                                                • 需要创造性解决问题

                                                • 用户交互频繁,需要对话式体验

                                                • 如:智能客服助手、个人AI助理、复杂问题诊断

                                              6 FM Agent 与 RL Agent

                                              以上讲的都是FM Agent,是基于大型预训练模型(Foundation Model) 的智能体,比如基于 GPT-4、Claude、Gemini 等大模型构建的智能体。

                                              核心能力是利用大语言模型(LLM)的理解、推理、规划和生成能力来感知世界、做决策、执行任务。

                                              除了FM Agent,还有RL Agent,它是基于强化学习(Reinforcement Learning) 原理构建的 Agent。

                                              它与环境交互,根据奖励信号学习最优策略,以最大化长期累计奖励。如DeepMind的AlphaGo Zero,在围棋游戏中击败了世界顶级选手,就是一个RL Agent。

                                              7 最后

                                              今天的分享只是掀开了 Agent 世界的一角。它的深度与潜力远不止于此,新的思路、框架与落地案例正层出不穷。希望这份经验与尝试,能为大家点亮一条更高效、更有趣的道路。

                                              回过头来看,不论是 LLM、Workflow 还是 Agent,终究只是工具。只有当它们与真实业务场景发生化学反应,切实解决痛点,创造价值时,技术的光芒才会真正被点亮。愿我们带着好奇与敬畏,把技术的锋利,打磨成改变世界的钥匙。

                                              文末福利

                                              有赞研发团队前端、后端、客户端、测试、AI开发、运维开发、数据开发等多个岗位招聘中,看机会的伙伴可以将简历发送至 zhuzhuyun@youzan.com。

                                              阅读原文

                                              跳转微信打开

                                              文生图质量评估实战:有赞电商场景的量化评测体系

                                              2025年8月4日 14:12

                                              原创 有赞共享技术 2025-08-04 14:12 浙江

                                              当 AI 生图成为刚需,我们如何定义“好图”?

                                              破局思路:解耦评估与流程,通过构建一套独立于生成链路的第三方质量评估体系。

                                              1. 当 AI 生图成为刚需,我们如何定义“好图”?

                                              在电商经营的核心战场,商品主图与营销海报的生成质量直接联动商家点击率。有赞 AIGC 项目应需而生,聚焦服务门店运营者、店长等非专业设计人群,通过移动端提供「上传商品图 → 智能抠图 → 背景生成」的一站式解决方案,大幅降低创作门槛。

                                              然而,随着文生图技术深度融入业务,一个核心矛盾日益凸显:

                                              传统测试擅长验证流程逻辑,却在“生成内容质量”评估上捉襟见肘——

                                              • 图像是否足够清晰专业?

                                              • 内容是否精准匹配文案描述?

                                              • 风格是否符合商家需求场景?

                                              这些关乎转化率的关键维度,长期依赖主观、耗时的人工判断,缺乏客观、可量化的评估标准。业务的最终价值落在图像效果上,传统工具却对此无能为力。

                                              由此我们想到了破局思路:解耦评估与流程。通过构建一套独立于生成链路的第三方质量评估体系——

                                              • 不干预生产过程:专注于生成结果的客观评价;

                                              • 输出量化质量分数:为每张图提供一致、可比较的“质量标尺”,填补 AI 内容自动化测试的关键空白。

                                              这套体系的价值在于:

                                              • 辅助模型选型:通过量化对比不同模型在电商真实场景下的表现(如语义匹配度、图像清晰度),避免盲目采购“最贵模型”,实现资源精准投入;

                                              • 驱动 Prompt 优化迭代:为系统自动改写策略提供数据反馈,清晰判断每次调整是优化了语义对齐,还是偏离了目标;

                                              • 跨项目通用质检:核心评估逻辑(图文语义匹配、基础图像质量)与具体业务解耦,可快速复用于各类文生图场景,沉淀为通用工具。

                                              更深远的意义在于它将模糊的“审美判断”转化为可行动的数据信号——从自动拦截劣质图,到智能推荐高分模板,切实降低商家操作成本,护航每一张生成图片。


                                              2. 指标选型与系统结构:如何实现图像评估?

                                              在推进图像质量评估的过程中,首先思考了两个问题:

                                              1. 我们如何定义一张“好图”?

                                              2. 如何让系统具备这样的判断能力?

                                              围绕这两个方向,我们逐步明确了指标选型的原则,并搭建了一套轻量可扩展的系统结构,以满足评估的稳定性与通用性需求。

                                              在实际使用文生图模型的过程中,图像“好不好”常被作为效果评估的依据,但这类判断高度依赖人工主观评价,缺乏统一标准。

                                              尤其当业务需要对多模型、多版本进行横向对比,或对大批量生成结果进行筛选时,仅靠“看图说话”存在明显局限:

                                              • 缺乏一致性:不同人评价标准不一,容易产生偏差;

                                              • 无法复用:历史评价无法转化为结构化数据,难以支持模型迭代;

                                              • 不具备规模性:难以处理成千上万张图的批量评估任务。

                                              为了尽量减少这种“说不清、评不准”的问题,我们尝试搭建了一套可量化的评估机制,作为文生图模型测试的第三方参考。

                                              这一机制不仅能支持跨模型、跨版本的客观对比,也能辅助日常质量筛选与 Prompt 的优化反馈。

                                              在初期设计阶段,我们调研了市面上主流的图文质量评价指标,包括 CLIPScore、IS(Inception Score)、FID、BLIPScore、PickScore 等,并基于以下三项原则进行了指标选型:

                                              • 开源可用性:指标是否有成熟的、开源的实现版本,便于快速部署;

                                              • 经典性与验证度:是否在学术与工业界被广泛使用;

                                              • 落地适配性:是否易于系统集成,计算资源要求是否合理。

                                              最终,我们选择了以下两个指标作为第一阶段的核心评估手段:

                                              • Inception Score(IS):衡量图像本身的质量与多样性,广泛用于 GAN 模型评估,尤其适用于无 Ground Truth 场景;

                                              • CLIPScore:基于 CLIP 模型计算图文匹配度,适用于文生图任务,可衡量图像是否准确表达文本信息。

                                              这两个指标分别覆盖了“图像质量”与“语义契合”两个关键维度,构建起一套基础但有效的自动化评估框架,为模型优化提供了可落地、可复用的支撑。

                                              2.1 CLIPScore

                                              第一个选用的评估指标是 CLIPScore,用于衡量生成图像与 Prompt 之间的语义一致性,也就是“你画的到底是不是我说的那回事”。

                                              该指标基于 OpenAI 提出的 CLIP 模型。CLIP 可以同时编码图像与文本,将它们各自转化为语义向量,再通过余弦相似度(cosine similarity)计算图文匹配程度,也就是看它俩在“意思”上有多接近:

                                              其中:

                                              • CLIP_image:图像的向量表示;

                                              • CLIP_text:文本的向量表示。

                                              CLIPScore 的取值范围理论上为 [-1, 1],但在实际应用中,分数主要集中在 [0, 0.6] 区间内(以 MUGE 数据集为例)。

                                              CLIPScore 的取值范围
                                              CLIPScore 的取值范围

                                              在本系统中,我们使用的是中文版本的 CLIP 模型 OFA-Sys/Chinese-CLIP,它在约 2 亿对中文图文数据上进行训练,显著提升了对中文 Prompt 的理解能力。

                                              相比原始英文 CLIP 模型,它更适配中文表达特点,适合我们这种电商类场景。比如 Prompt 是 “草地上的红色自行车”

                                              • 如果红色的自行车、背景就是草地,那分数可能在 0.55 到 0.6 之间;

                                              • 如果画对了自行车,但草地背景缺失或者模糊,可能就掉到 0.4 左右;

                                              • 如果生成了一辆黄色的卡车,那分数可能会掉到 0.2 以下,这说明它跟 prompt 就几乎没对上。

                                              通过我们实测的这个例子,Prompt 为“一只金色的蓝眼睛猫”,能够直观地感受到图像、文本和分数之间的联系。

                                              不同模型的 CLIP 分数表现
                                              不同模型的 CLIP 分数表现

                                              简单来说 CLIPScore 这个分数并不看图好不好看、画风漂不漂亮,它只关心这幅图是不是够切题。那它到底是怎么“知道”这回事的?这就要讲讲现代 AI 系统里很核心的一个概念:向量表示。

                                              在多模态模型里,不管是一张图,还是一句话,都会被“翻译”成一组很长的数字,也就是向量。然后模型就拿图的向量和词的向量去比对,看它们在语义空间里靠不靠近。越近,代表意思越像,分就越高。这就是 CLIPScore 背后的机制。

                                              2.2 Inception Score(IS)

                                              如果说 CLIPScore 评估图像与文本是否语义一致,那么 Inception Score(IS)更关注图像本身的可识别性与多样性,也就是“图画得清不清楚、够不够丰富”。

                                              • 图像的可识别性(Recognizability):图像是否清晰、结构完整,能被分类器准确识别;

                                              • 图像的多样性(Diversity):图集中图像是否风格各异、覆盖多个类别,避免“批量复制”。

                                              IS 借助一个在 ImageNet 上训练好的分类器(Inception v3),对每张图像输出类别的预测分布 ,再通过下式计算整体得分:

                                              其中:

                                              • :图像  被识别为各类别的概率,反映置信度是否集中;

                                              • :所有图像预测分布的平均值,衡量整体是否具备多样性;

                                              • :KL 散度,用于衡量两个分布(如预测分布与平均分布)之间的差异。

                                              IS 的取值范围理论上为 ,没有固定上限,但在常见实际任务中通常集中在 1~15 之间。

                                              IS 的取值范围
                                              IS 的取值范围

                                              注意 IS 是一个整体指标,不能用于评估单张图像,必须对整批图片计算才可靠。如果每张图都很容易被分类,而整批图又能覆盖多个类别,这表明生成的图像既清晰、又多样,那么 IS 就会很高。

                                              比如:假设三个模型分别生成一组 3000 张图片的动物图集

                                              不同模型的 IS 分数表现
                                              不同模型的 IS 分数表现

                                              IS 就像一次“阅图比赛”的评委:

                                              • 清晰吗? 图像模糊无比、结构差,评委根本看不清,自然评分低;

                                              • 有新意吗? 全是一模一样的猫?即使都好看,评委也会觉得没劲。

                                              而参赛的模型选手大致分三类:

                                              • 低 IS:你给我看了 5 张模糊图,全是迷雾,我看不出是什么 —— 评分低;

                                              • 中 IS:你给我看了 5 张清楚的猫,我都认出来了,但全是猫,看得我有点腻 —— 评分一般;

                                              • 高 IS:你给我看了 5 张清晰又各不相同的图,有猫、有狗、有鸟、有兔 —— 评分高!

                                              所以为什么我们要引入 IS?因为 CLIPScore 虽然能判断“画得对不对题”,但它有两个天然盲点:

                                              1. 不看图像本身的清晰度:画面模糊也可能得高分,比如生成了“四不像”的模特;

                                              2. 不看图集的多样性:只要语义对题,每张图片复制粘贴也能得分。

                                              IS 恰好弥补这两个盲区,因此我们可以将 IS 应用于两个场景:

                                              • 多模型对比:判断哪个模型在特定业务场景的“视觉”输出更优秀;

                                              • 调参验证:辅助判断参数调整(如 temperature)是否提升了生成图像的多样性。

                                              2.3 系统架构概览

                                              系统架构图
                                              系统架构图

                                              1. NSQ 消费者监听模块

                                              功能概述:订阅 NSQ 队列主题 generate_img_data_collect_topic,实时消费生成数据并写入本地 CSV 文件。

                                              核心脚本:

                                              • message_listener.py:接收启动参数并拉起消费者。

                                              • consumer_util.py:封装具体消费者逻辑。

                                              启动示例:

                                                ounter(lineounter(lineounter(lineounter(lineounter(line
                                                # 使用默认输出文件 output.csv
                                                python message_listener.py


                                                # 自定义输出文件
                                                python message_listener.py --output output_sample.csv

                                                2. 批量接口调用模块

                                                功能概述:读取本地 CSV 文件,批量调用 Dubbo 接口生成图像,记录调用结果及异常信息,形成错误记录文件方便后续重试。

                                                核心脚本:

                                                • generate_request.py:接收命令行参数,读取输入 CSV,执行批量接口调用,并输出错误记录。

                                                • dubbo_util.py:封装 Dubbo HTTP 接口调用及重试、日志、异常捕获。

                                                启动示例:

                                                  ounter(lineounter(lineounter(lineounter(lineounter(line
                                                  # 使用默认输入 data.csv,输出错误记录 error.csv
                                                  python generate_request.py


                                                  # 自定义输入文件与错误记录文件
                                                  python generate_request.py --input data_sample.csv --error error_sample.csv

                                                  3. 图像质量评估模块

                                                  功能概述:对已生成的图像进行质量评估,计算文本一致性分数(CLIPScore)及多样性/真实感分数(Inception Score),可配置权重计算加权总分。

                                                  核心脚本:

                                                  • evaluate_clipscore.py:下载图像并使用中文 CLIP 模型计算图像与 prompt 的语义相似度。

                                                  • evaluate_is.py:下载图像后基于 Inception 模型计算图像集合的 IS,反映生成样本的多样性和可信度。

                                                  • main.py:并行调用上述两个模块,计算 CLIPScore 与 IS 并合并结果,支持自定义加权输出总分。

                                                  启动示例:

                                                    ounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(line
                                                    # 计算 CLIPScore
                                                    python evaluate_clipscore.py                         # 默认 output.csv -> result_clip.csv
                                                    python evaluate_clipscore.py --input output_model.csv --output result_model_clip.csv --batch_size 64


                                                    # 计算 Inception Score
                                                    python evaluate_is.py                                # 默认 output.csv -> result_is.csv
                                                    python evaluate_is.py --input output_model.csv --output result_model_is.csv


                                                    # 并行计算 CLIPScore + IS 并输出加权分
                                                    python main.py                   # 默认 output.csv -> result.csv
                                                    python main.py --input output_model.csv --output result_model.csv --clip_weight 0.6 --is_weight 0.4

                                                    3. 项目实例验证:如何确认系统真的有用?

                                                    3.1 验证方法与数据治理

                                                    3.1.1 监听链路数据

                                                    本次尝试使用真实业务链路监听数据作为评估输入,对现有文生图模型评估方案(CLIPScore + Inception Score)进行了验证。得到的结果如下:

                                                    原始数据结果表格-节选
                                                    原始数据结果表格-节选

                                                    该类数据高度贴近真实场景,但也暴露出如下三类问题:

                                                    1. prompt 结构混乱,无法直接使用监听到的 prompt 往往是完整的 JSON 调用体,其中包含:

                                                      ounter(lineounter(lineounter(lineounter(lineounter(line
                                                      {
                                                        "messages": [{"role": "user", "content": "这张图不行,重  新来一张好看的"}],
                                                        "temperature": 0.7,
                                                        ...
                                                      }
                                                      • 多轮对话历史;

                                                      • 系统参数(如 temperature, max_tokens 等);

                                                      • 工具调用记录、流程控制语句。

                                                      这类结构不具备图像描述能力,导致测试输入不符合 CLIPScore 评估工具的要求,造成分数虚低或失真(本次 clip_score 全部在 0.30 左右,最低仅 0.303)。

                                                      2. 非描述性语言占主导,缺乏视觉语义信息

                                                      大量用户交互数据本质上属于无效测试输入,用户 prompt 多为指令性、反馈性表达,如:

                                                      • “不满意,再来一张”

                                                      • “换个背景吧”

                                                      • “帮我重新生成”

                                                      这些语句无法建立有效的图像-文本语义关联,因此即便系统生成了一张视觉质量较高的图,也无法与 prompt 建立合理语义联系,CLIPScore 无法准确反映效果。

                                                      3. 图像样本数量有限且主体同质化,IS 分数失效

                                                      项目初期仅使用了 44 张图像样本,所有图像均采用“商品抠图 + 背景合成”的生成方式,说明

                                                      • 主体高度一致,多为蛋糕抠图商品;

                                                      • IS 并不适合用于几十张图的小规模评估。

                                                      Inception Score 指标适用范围补充说明

                                                      在当前验证中,IS 分数在约 2.0 左右,未能充分反映多样性,主要受限于样本规模过小(约 40 张),与 IS 理论要求的统计规模存在较大差距。根据业界经验与论文实践:

                                                      • IS 理论上需要基于大样本分布来评估图像的多样性与可识别性,通常推荐最少在 >500 张 的图像集合上计算,理想情况下在 >1000 张 的规模才能得出稳定、可比较的分值;

                                                      • 小于 100 张时,IS 往往会因为分布稀疏,导致 KL 散度统计不充分,从而输出失真的过低分值,并且波动较大,不具备有效的判别意义。

                                                      因此后续在文生图质量体系中:

                                                      • < 100 张 的测试集合不建议采用 IS 进行有效性评估;

                                                      • 100 ~ 500 张 可用于初步 sanity check(检查是否完全失效),但不用于模型间对比或回归基线判断;

                                                      • ≥ 500 张 可用于阶段性对比和优化验证;

                                                      • ≥ 1000 张 适合作为稳定的跨版本基准测试集。

                                                      这样能更好地保障 IS 对多样性与质量的检测具备统计意义,避免因样本不足导致的虚低或虚高现象。

                                                      3.1.2 清洗后的数据

                                                      针对上一节中暴露的问题,我们对监听数据进行了系统清洗,主要包括:

                                                      • 排除系统消息、系统提示语、流程控制语句,仅保留用户主动表达的图像语义;

                                                      • 删除用户指令性语言(如“帮我生成一张”“换一个背景”)等干扰表达;

                                                      • 提取可直接用于生成图像的短语(如“绿色森林”“芋泥薰衣草”)。

                                                      以下是在清洗数据集上测试得到的结果:

                                                      清洗数据结果表格-节选
                                                      清洗数据结果表格-节选

                                                      清洗后构建的测试集具有以下特征:

                                                      • 清洗后的 prompt 恢复为可用的视觉语义,语义明确,结构统一;

                                                      • 允许 CLIPScore 成为有效的文本对图评估标准;

                                                      • 数据结构统一,方便后续批量处理和回归测试。

                                                      洗后 clip_score 最高提升至 0.486,平均分提升约 0.06(由 0.328 提升至 0.388),说明语义对齐明显改善;IS 分数固定略降为 1.996,缺乏区分力。

                                                      3.1.3 打标后的数据

                                                      由于最终成品图片为商品主体和生成背景的融合图片,主体占比较大,因此在清洗 prompt 的基础上,我们进一步引入了图像主体打标,即识别图像中的核心物体(如蛋糕、饮品)并将其添加至 prompt 中,从而增强 prompt 与图像内容的语义关联:

                                                      • 原 prompt 示例:芋泥 薰衣草

                                                      • 打标后 prompt :蛋糕 芋泥 薰衣草

                                                      通过这一操作,CLIPScore 得分明显提升,语义匹配能力更强。以下是在打标数据集上测试得到的结果:

                                                      打标数据结果表格-节选
                                                      打标数据结果表格-节选

                                                      以下是三阶段数据的评分变化趋势与原因分析:

                                                      三个阶段的数据
                                                      三个阶段的数据

                                                      1. CLIPScore 显著上升(均值 0.328 → 0.388 → 0.449)

                                                      • 趋势说明:三阶段中 CLIPScore 持续提升,极差扩大,表明评估结果区分度增强。

                                                      • 归因分析:

                                                        • 原始数据因混杂指令性语言(如“换一张图”),语义噪声大,导致得分低且集中;

                                                        • 清洗后保留核心视觉语义(如“梦幻紫色羽毛”),使模型意图理解与图像对齐;

                                                        • 打标环节补充主体标签(如“蛋糕 芋泥 薰衣草”),直接强化图文一致性,推动分数二次跃升(+15.7%)。

                                                      2. IS 分数小幅下降(平均值从 2.017 → 1.996 → 1.935)

                                                      • 趋势说明:IS 值小幅降低且波动收窄,反映图像多样性未显著改善(受限于样本规模)。

                                                      • 归因分析:

                                                        • IS 依赖大样本统计,样本量 <100 时分数严重失真;

                                                        • 当前样本量远未达到 IS 有效判别阈值,其微幅波动属统计噪声,不具备模型能力指示意义。

                                                      本次结构化改进证明:数据质量决定了评估指标是否能“说人话”。在评估体系真正开始发挥作用之前,构建高质量的测试输入数据很重要。

                                                      3.2 数据驱动的测试数据集

                                                      为使图文评估系统更贴近实际业务需求,我们构建了一个结构化、具备代表性的评估数据集,用于系统性测试及指标响应验证。该数据集由商品主图 × Prompt 控制指令组成,分别模拟业务中真实的视觉输入与语言输入分布。

                                                      3.2.1 prompt 构造

                                                      为测试系统在真实场景中对用户意图的响应能力,我们设计了结构化的 Prompt 构造方案,兼顾业务语言的真实性与评估指标的敏感性。

                                                      Prompt 的目标并非“提升模型得分”,而是确保分数具有业务可参考的意义。因此坚持两项原则:

                                                      • 贴近真实业务语境:语言风格符合电商、运营的实际使用场景,避免过度技术化或模板化;

                                                      • 具备结构表达能力:以结构化方式模拟真实复杂的人类输入,尽量具备一定的多样性。

                                                      基于此,我们设计了控制 LLM 自动批量生成 Prompt 的输入模板示例如下:

                                                        ounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(lineounter(line
                                                        # 角色
                                                        你是一个专业的电商运营,正在为{product_type}类目生成{number}条商品背景图提示词。请按照以下步骤操作:


                                                        # 指令要求
                                                        1. 语言风格:
                                                           - 使用电商运营日常的短句,直白、带轻松感
                                                           - 可适度带点情绪(如“别太…”、“要有点…”)
                                                           - 可融入1~2个{product_type}类目的常见词汇
                                                        2. 内容聚焦:
                                                           - 专注描述背景、氛围、环境、布置
                                                           - 可融合 {product_type} 在电商常见的场景/展示风格,比如服饰类常见 “法式”、“ins风”、“街拍感”
                                                           - 不要出现{product_type}的内容/主体,专注背景生成
                                                        3. 生成比例:
                                                           - 60% 明确指令:直接给出具体背景场景、画面、色调
                                                             例:草地背景,上面有一些鲜花,色调明亮
                                                           - 20% 矛盾指令:有轻微冲突语义,激发生成更多样
                                                             例:简约但别太素,可以有点木纹
                                                           - 10% 模糊指令:只说感觉或氛围
                                                             例:搞点ins感
                                                           - 10% 元素指令:只说元素,可单个可多个
                                                             例:柠檬、薰衣草 海浪
                                                        4. 输出格式:
                                                           - 仅输出提示词文本,不包含任何编号、解释说明和生成类型
                                                           - 请严格生成{number}条提示词,每条占一行


                                                        # 输出结果
                                                        请生成 {number} 条针对 {product_type} 的背景图提示词。

                                                        3.2.2 商品主图选取

                                                        为确保图像评估具备业务代表性,我们首先统计了店铺 Top9 主流商品品类的实际占比,这些品类合计覆盖了约 66% 的场景(其余品类占比均低于 2%,因此未纳入此次数据集)。随后,我们根据占比按比例归一化分配样本量,并为每类商品选取 8~20 张主图,最终完成了数据集的构建。整体分布如下表所示:

                                                        构造的数据分布
                                                        构造的数据分布

                                                        通过上述方法,我们构建了覆盖主要业务场景的测试数据集,为后续的系统指标验证与对比提供了可靠基础。

                                                        3.3 调用接口得到批量结果

                                                        3.3.1 业务测试结果

                                                        Business 数据集(贴近真实业务分布)

                                                        • 共 1000 条数据,类型比例接近生产实际:蛋糕烘焙占比约 40%(400 张),其余如生鲜果蔬、茶叶酒水、服饰箱包等按真实占比逐级递减。

                                                        • 本次 IS 计算以完整的 1000 张集合为输入,输出单一分数。从结果看,数据集已达到 IS 所需的最小数量门槛,分值符合高质量生成预期。

                                                        业务数据集结果表格-节选
                                                        业务数据集结果表格-节选

                                                        提示:如果改为按不同业务类别(如蛋糕、果蔬、服饰)拆分子集,单独计算 IS,将能更明显看出分布不同导致的多样性差异。

                                                        3.3.2 模型测试结果

                                                        Model 数据集(偏均衡分布):

                                                        • 同样为 1000 条数据,但类别分布更均匀:蛋糕约占 20%(200 张),其余类别均约 100 张。

                                                        模型数据集结果表格-节选
                                                        模型数据集结果表格-节选

                                                        以下是两份数据集的评分与原因分析:

                                                        两份数据集的结果
                                                        两份数据集的结果

                                                        1. 和监听得到的少量数据相比

                                                        • CLIPScore 的平均分下降

                                                          • 因为这次数据量太大,无法对 prompt 打标,导致主体描述弱化;

                                                          • 改写 prompt 透出,使得语义一致性受影响。

                                                        • IS 分数显著提升,进入正常范围内:

                                                          • 由于商品主体图像均为真实图,高质量、清晰度好,提升 IS;

                                                          • 商品与背景语义匹配(如蛋糕置于厨房台面),有助于 Inception v3 分类准确,从而提高 IS。

                                                        2. 业务数据集 vs 模型数据集

                                                        • CLIPScore:模型数据集略优

                                                          • business 集合中蛋糕类图片占比偏高,导致 prompt-图像集中在类似语义(如大量蛋糕场景),平均 CLIPScore 略降;

                                                          • model 集合中各类均衡,prompt 与生成图像在语义分布上更分散,整体表现更好。

                                                        • IS:模型数据集显著更高

                                                          • Business 集合蛋糕占比高(40%),使大量图像被归入相近视觉类别,拉低整体多样性;

                                                          • Model 集合的类别比例更均衡,使各类别被充分采样,判别网络输出分布均匀,导致 IS 显著上升。

                                                        3.3.3 Jira 优化案例

                                                        1. CSWT-173889:生成的商品图,商品主体不在中间且只展示一部分

                                                        问题现象:生成的商品图中,主体偏离中心且仅部分展示(如蛋糕仅显示 1/2)。评估系统的作用:

                                                        a. 自动化识别

                                                        • 通过图像分类模型的置信度分布可有效检测主体是否缺失或偏离预期,例如当预测为“蛋糕”的置信度低于 0.3 时,往往意味着图像未能被明确识别为完整的蛋糕,提示主体可能不完整或被其它元素干扰。

                                                        b. 测试流程闭环

                                                        • 测试阶段:构造“非常规构图”测试集 → 系统评分低于阈值 → 主动发现 Bug;

                                                        • 线上兜底:部署分数监控策略(CLIPScore < 0.3 时自动触发重生成),拦截劣质图上线;

                                                        • 业务价值:使构图缺陷拦截率提升。

                                                        2. 用户描述生成的背景提示词,需要经过润色

                                                        问题需求:用户输入的模糊 Prompt 需经系统改写(如“高大上一点” → “极简大理石背景,金色装饰”),需验证改写策略是否有效。 评估系统的应用:

                                                        a. AB 测试验证

                                                        • 对比改写前后生成图的 CLIPScore:

                                                        • 改写前:0.38(语义弱相关,如生成“普通白色背景”)

                                                        • 改写后:0.51(明确匹配“大理石+金色”元素)

                                                        b. 持续监控机制

                                                        • 回归测试:模型升级后,批量生成测试集 → CLIPScore 均值下降> 0.05 自动告警;

                                                        • 兜底策略:低分图(CLIPScore < 0.35)自动丢弃并重试,保障输出质量;

                                                        • 业务价值:Prompt 改写策略经 3 迭代,商户“重生成”操作率减少。


                                                        4. 未来:构建更智能、更懂业务的评估引擎

                                                        文生图评估体系的建设并非终点。展望未来,我们将在技术弹性、业务贴合与系统扩展三大维度持续进化,让评估真正成为驱动 AI 内容质量提升的核心引擎:

                                                        1. 技术进化:打造灵活、多维的评估框架

                                                        • 指标持续扩展,深入业务核心:在现有基础上逐步引入更多图像指标,建立更贴近业务目标的评估指标库;

                                                        • 模块化设计,按需组合:不同指标将以模块化方式组合,按需启用,适配不同生成场景的质检重点;

                                                        • 动态权重,聚焦业务重点评估维度权重不再固定,而是根据业务阶段智能调整。

                                                        2. 业务赋能:数据驱动,闭环落地

                                                        • 构建动态业务数据池:建立覆盖服饰、食品、家居等主流类目的真实业务数据池,使评估输入更具代表性;

                                                        • 分数驱动问题定位,形成改进闭环:基于评估结果自动溯源,建立“分数-问题-改进”机制;

                                                        • 多角色赋能:为不同角色提供可视化与决策依据。

                                                          • 运营:高分样例库助力推广

                                                          • 产品:支撑模型版本 A/B 效果比对

                                                          • 商户:快速生成可用素材

                                                        3. 系统扩展:轻量可复用的架构

                                                        • 标准化 API,无缝集成:将评估系统作为独立服务,通过标准 API 无缝接入电商、营销、设计等不同业务链路;

                                                        • 多场景赋能: 核心场景执行全维度精评(如电商主图/详情页);边缘场景仅运行必要核心指标(如只做图文匹配)。

                                                        我们希望通过这套持续演进的评估体系,为 AI 生成内容建立客观、可量化的质量标尺,将模糊的经验判断转化为可靠的数据洞察。

                                                        推动生成结果从“能用”迈向真正的“实用、稳定、可控”,最终赋能每一位商家,高效、自信地驾驭 AI 创作,释放其商业潜能。

                                                        阅读原文

                                                        跳转微信打开

                                                        打破资源竖井:有赞在离线混部的实践

                                                        2025年7月18日 17:02

                                                        原创 有赞技术中台 2025-07-18 17:02 浙江

                                                        背景随着有赞业务的高速发展,业务对计算资源的需求日益增长,成本管控和资源供给面临着较大的压力。通过在离线混部,在保证业务稳定的情况下,大幅提高资源使用效率。

                                                        点击关注“有赞coder”

                                                        获取更多技术干货哦~

                                                        背景

                                                        随着有赞业务的高速发展,业务对计算资源的需求日益增长,成本管控和资源供给面临着较大的压力。与此同时,集群的整体资源使用率一直保持在比较低的水平,有很明显的提升空间。

                                                        造成这一现象的主要原因有以下几点:

                                                        • 在线业务主要业务集中在国内,集中在白天。在线服务部分,资源使用量呈现稳定的潮汐现象,夜间 CPU 利用率极低,从而导致整个集群的均值 CPU 利用率降低。

                                                        • 离线业务集中在晚上。离线业务0点开始计算商家经营报表,上午完成绝大多数任务,导致夜间 CPU 利用率高,白天基本闲置。

                                                        • 突发流量毛刺采用硬扛的方式。为了这些突发流量,往往需要预备更多的资源,以避免突发流量使系统满载而影响业务可用性,继而进一步降低了CPU使用率。

                                                        • 在线集群静态调度策略导致节点水位不均。通过超卖方式提升CPU 利用率会因为部分热点节点而触发短板效应,集群整体CPU 利用率无法继续提高。

                                                        在线业务一天的Cpu使用整体情况
                                                        在线业务一天的Cpu使用整体情况
                                                        离线用整体情况
                                                        离线用整体情况

                                                        随着云原生化的逐步推进,K8s 社区相继涌现出多个与混部相关的开源项目。在此背景之下,容器资源的管理模式由“静态超卖”的方式,转变为“负载均衡调度 + 在离线混部”的方式。为了更为深入地优化资源使用状况,最大程度地优化成本,运维开发团队自 2022 年起尝试落地混部技术,以提升集群 CPU 利用率。截至目前,混部集群 CPU 利用率的均值可达 40%左右。

                                                        方案设计

                                                        基于Koordinator + 龙蜥Linux内核混部架构图:混部架构

                                                        调度层面:

                                                        1. 负载均衡调度,确保新的Pod调度到空闲节点。

                                                        2. 重调度,随着时间变化,业务流量变化,持续保证集群节点水位均匀。

                                                        3. 大数据任务调度Spark thriftserver 主动感知离线资源数量,避免超量使用。

                                                        Qos保障:

                                                        1. 划分资源池,在线LS级别,离线BE级别。

                                                        2. 在线定时伸缩容,离线定时驱逐控制器(主动让出资源)。

                                                        3. 离线Cpu满意度驱逐,保障离线任务质量,内存压力驱逐(被动保护让出资源)。

                                                        4. Cpu抑制,Cpu burst 保障在线服务质量。

                                                        5. 容器内存异步回收,以及回收保护水线。

                                                        集群资源保障:

                                                        1. 基于负载的集群节点伸缩容。

                                                        2. 龙蜥内核节点内存异步回收特性。

                                                        策略演进

                                                        大数据和在线业务的混部经历了多个阶段的技术演进,主要是节点分时复用、负载均衡调度、常态混部。

                                                        节点分时复用

                                                        A集群通过VK挂载B集群节点,通过控制B集群节点以及A集群VK节点调度状态,控制调度策略。

                                                        节点分时复用
                                                        节点分时复用

                                                        通过定时驱逐共享节点上的Pod,以及调整共享节点的调度标签,复用部分节点,一定程度上可以在离线的资源利用率。

                                                        负载均衡调度

                                                        基于Koordinator负载感知调度的能力,以及内部对应用精确的资源画像,将在线集群由静态调度转变为基于水位负载的动态调度,在线集群的平均cpu水位由10%提升到25%左右。

                                                        调度

                                                        使用Koordinator负载感知调度与重调度能力,将集群由静态调度转向基于节点真实水位的调度。与Kubernetes原生调度策略不同的是,原生调度器主要基于资源的分配情况进行调度,而该调度器可以感知节点实际的资源负载情况。通过参考节点负载的历史统计并对新调度Pod进行预估,调度器会将Pod优先调度到负载较低的节点,实现节点负载均衡的目标,集群节点水位更加均匀,避免集群水位提升过程中”短板“节点。

                                                        重调度

                                                        Kubernetes调度器会根据当前的集群状态决定如何将一个Pod调度到合适的节点上。但集群的状态会不断变化,出于资源水位的原因,可能需要将运行中的Pod移动到其他节点,例如:

                                                        • 集群的工作负载分布不均,造成某些节点过载,影响这些热点节点上的工作负载性能。

                                                        • 集群的总体资源利用率较低,期望下线部分节点以节约成本。这些节点上的Pod需要重新调度到其他节点上。

                                                        • 集群存在大量资源碎片,导致集群资源总量充足,但单节点上资源不足。此时一些较大规格的Pod无法调度,增加了集群资源成本。

                                                        业务应用画像

                                                        在负载均衡调度和重调度之后,集群节点间水位差有了明显改善。在业务负载爬坡时,由于应用的核心程度不一样,拥有较多核心应用的节点负载变高,会出现热点节点,这个时候需要重调度组件介入,把 Pod 重新调度到其他节点上,重调度的效率有限,甚至来不及重调度节点Cpu负载超高甚至内存OOM。

                                                        通过应用画像的方式,找出业务高峰时负载较高的应用,在调度过程中提前打散,均匀分散在节点上,前置解决或者减少热点节点问题。

                                                        业务应用画像
                                                        业务应用画像

                                                        常态混部

                                                        为了降低资源碎片率和业务资源持有成本,将业务从独占的kubernetes集群合并到一个大的混部kubernetes集群。

                                                        常态混部
                                                        常态混部

                                                        离线感知离线资源池

                                                        大数据任务调度程序改造,支持动态感知Koordinator BE资源池,控制创建离线Pod规模。

                                                        离线感知离线资源池
                                                        离线感知离线资源池

                                                        驱逐

                                                        为控制在离线在不同时间段资源规模以及集群的整体水位,通过主动驱逐和被动驱逐的方式保证在不同业务高峰期资源得到满足,服务质量得到保障。

                                                        驱逐
                                                        驱逐
                                                        主动驱逐
                                                        • 在线业务定时伸缩容 由于在线业务应用主要是Java类型应用,在流量低峰期时,虽然Cpu利用率降低,但是内存仍然被大量占用,因此根据业务的资源使用画像,定时伸缩容在线应用,流量低峰期释放内存资源。

                                                        • 离线业务定时伸缩容 通过离线定时驱逐控制器,主动驱逐空负载离线Pod(尽量避免任务重试),出让资源给在线业务。

                                                        被动驱逐

                                                        在极端场景下,如整机内存使用率较高、有触发 OOM 风险,或者离线业务 CPU 长期得不到满足时,可以采取离线驱逐策略。单机侧支持按照离线服务内部定义的优先级配置、资源用量和运行时长等多维度综合算分排序后,按序驱逐离线服务,以达到最优的资源利用效果。

                                                        • 离线Cpu满意度驱逐:让离线业务尽快重新调度到资源充足节点上去。

                                                        • 内存压力驱逐:保护节点避免OOM风险。

                                                        效果

                                                        截止目前,有赞混部能力覆盖主要业务集群,核心业务的在线、离线场景服务的资源调度。通过大规模容器混部的落地,在资源成本效能等方面都取得了显著收益,具体包含以下三方面:

                                                        • CPU 利用率:在保证在线服务服务质量的前提下,在线混部集群天均 CPU 利用率提升至 40% 以上。

                                                        • 资源成本:在保证离线业务稳定性的前提下,混部集群的落地相较于之前成本下降20%左右。

                                                        • 活动成本降低:在购物节活动或者大客活动时,在线临时使用离线资源,避免扩容带来的额外成本。

                                                        阅读原文

                                                        跳转微信打开

                                                        ❌