🎯 今日核心问题

  1. 模型输出的每一句话,哪些是「工具返回的」、哪些是「它自己补的」,怎么在运行时区分?
  2. 为什么让模型「自我检查一下」几乎没用,而拿输出回去做一次实体比对就有用?
  3. 在 Spring Boot 里怎么把幻觉检测做成一个拦截器,而不是散落在每个 Service 的 if 里?

📖 精读提纲

【一】幻觉分四类,代价差三个数量级

把幻觉当成一个笼统的问题,就没法动手。工程上必须拆开:事实型(编了一个不存在的订单号、政策条款)、引述型(结论对但引用的文档和原文对不上)、数值型(金额、比例、日期算错或篡改)、越权型(声称「已为您退款」,而退款工具压根没被调用)。前三种会让用户拿到错信息,第四种会让用户相信一个根本没发生的动作——这是唯一一类必须硬拦截、不允许「概率容忍」的。

区分方式很直接:看它有没有「可核验的真值源」。工具返回的 Observation 就是真值源,数据库里的订单也是真值源。凡是能对上的,用代码比对;对不上的(比如「这项政策适用于您」),只能靠检索结果做支撑度判断,不能靠模型自评。

【二】最有效的检测不是检测模型,是检测「引用」

让模型输出结构化引用,是性价比最高的一招。具体做法:在 Prompt 里要求模型的每个事实性断言后面带一个来源标记 [S1],而你维护一张 stepId → Observation 的表。拿到答案后做三件事:① 抽取所有 [Sn],检查编号是否存在于本轮 trace;② 对每个断言做数字/实体抽取,检查出现在哪个 Observation 里;③ 计算「无引用断言占比」,超过阈值(比如 30%)直接降级为保守答复。

这一步能抓掉大部分硬幻觉,因为模型编造一个订单号很容易,编造一个「同时出现在 Observation 里、编号又合法」的订单号要难得多。注意不要指望向量相似度做精确判断:0.87 的相似度既可能是同义改写,也可能是关键数字被改了,只能用于粗筛。

【三】Prometheus 式的自评要在「有真值」时用

业界常用的做法是让另一个模型当裁判(LLM-as-judge),给出 faithfulness 分数。它的适用边界很清楚:裁判必须拿到 Observation 原文,否则它评的是「这段话像不像真的」,而不是「这段话是否有据」。线上更省的做法是二段式:先用规则做廉价筛(数字不在 Observation 里、引用编号越界、出现「已成功」「已退款」等动作完成词但对应工具未调用),只把可疑样本送裁判模型。

另外,「动作完成词」必须由系统生成。正确设计是工具执行成功后,把结果以固定模板注入最终答复,而不是让模型自由描述。这条改动能把越权型幻觉压到接近零,成本几乎为零。

【四】常见误区

💻 代码示例

一个可插拔的幻觉检测器:校验引用编号、核对数字是否出自 Observation、拦截未执行动作的完成声明。

@Component
public class HallucinationGuard {

    private static final Pattern CITATION = Pattern.compile("\\[S(\\d+)\\]");
    private static final Pattern NUMBER = Pattern.compile("\\d+(?:\\.\\d+)?");
    private static final List<String> ACTION_CLAIMS =
            List.of("已退款", "已发货", "已取消", "已为您办理", "已补偿");

    /** observations: stepId -> 工具返回原文 */
    public GuardResult check(String answer, Map<Integer, String> observations) {
        List<String> issues = new ArrayList<>();

        // 1) 引用编号必须存在
        Set<Integer> cited = new HashSet<>();
        Matcher m = CITATION.matcher(answer);
        while (m.find()) {
            int id = Integer.parseInt(m.group(1));
            if (!observations.containsKey(id)) {
                issues.add("引用越界:S" + id);
            }
            cited.add(id);
        }

        // 2) 数字必须能在某个 Observation 中找到(允许千分位后的等价形式)
        StringBuilder facts = new StringBuilder();
        observations.values().forEach(facts::append);
        String corpus = facts.toString().replace(",", "");
        Matcher nm = NUMBER.matcher(answer.replace(",", ""));
        while (nm.find()) {
            String num = nm.group();
            if (num.length() < 2) continue;          // 忽略 1-9 这类量词
            if (!corpus.contains(num)) {
                issues.add("数值无出处:" + num);
            }
        }

        // 3) 动作完成声明必须有对应的成功工具调用
        for (String claim : ACTION_CLAIMS) {
            if (answer.contains(claim) && cited.isEmpty()) {
                issues.add("动作声明无工具支撑:" + claim);
            }
        }

        double unsupported = answer.isBlank() ? 0d
                : (double) issues.size() / Math.max(1, countSentences(answer));
        return new GuardResult(issues.isEmpty(), unsupported, issues);
    }

    private int countSentences(String s) {
        return (int) Arrays.stream(s.split("[。!?;]")).filter(x -> !x.isBlank()).count();
    }

    public record GuardResult(boolean pass, double riskScore, List<String> issues) {}
}

接入 ReAct 循环时只在终止分支调用一次,命中问题就改写答复而不是丢弃:

GuardResult g = guard.check(finalAnswer, trace.observations());
if (!g.pass()) {
    log.warn("hallucination suspected, issues={}, score={}", g.issues(), g.riskScore());
    metrics.counter("agent.hallucination." + classify(g.issues())).increment();
    if (g.riskScore() > 0.3) {
        finalAnswer = "已查到部分信息,但存在需人工确认的细节:" + safeSummary(trace);
    }
}
return AgentResult.ok(finalAnswer, trace);

把它做成 Spring 的 ResponseBodyAdvice,所有 Agent 接口统一过一遍,业务代码零改动:

@RestControllerAdvice
@RequiredArgsConstructor
public class HallucinationAdvice implements ResponseBodyAdvice<AgentResult> {

    private final HallucinationGuard guard;
    private final AgentTraceStore traceStore;

    @Override
    public boolean supports(MethodParameter rt, Class<? extends HttpMessageConverter<?>> c) {
        return AgentResult.class.isAssignableFrom(rt.getParameterType());
    }

    @Override
    public AgentResult beforeBodyWrite(AgentResult body, MethodParameter rt, MediaType mt,
                                       Class<? extends HttpMessageConverter<?>> c,
                                       ServerHttpRequest req, ServerHttpResponse res) {
        if (body == null || body.answer() == null) return body;
        Map<Integer, String> obs = traceStore.observations(body.traceId());
        HallucinationGuard.GuardResult g = guard.check(body.answer(), obs);
        if (g.pass()) return body;
        log.warn("guard hit traceId={} issues={}", body.traceId(), g.issues());
        return g.riskScore() > 0.3
                ? body.withAnswer("已查到部分信息,其余细节需人工确认,请稍后由客服跟进。").flagged()
                : body.flagged();
    }
}

✏️ 今日动手

拿 W3 的售后工单 Agent 做靶子:① 让 Prompt 强制输出 [Sn] 引用,改 AgentTrace 记录每轮 Observation 的 stepId;② 接上 HallucinationGuard,人工构造 10 条幻觉样本(编订单号、改金额、声称已退款)验证全部被拦;③ 用 30 条真实历史工单跑一遍,统计误报率——如果超过 10%,说明数字校验太严,需要给「金额」建立允许的换算集合(如 100 元与 10000 分)。

🔖 明日预告

今天解决的是「内容有没有据」,明天解决「格式和业务规则对不对」:用 JSON Schema 挡住结构性错误,用业务校验挡住语义错误(金额为负、状态跳变、日期越界),并给出 LangChain4j 输出解析器的失败兜底方案。