Java实战：用决策模型增强RAG检索效果

// 核心问题矩阵：覆盖安全、冲突、相关性、证据度
enum RagQuestion {
    INJECTION("contains_prompt_injection", PromptCodeConstants.DECISION_RAG_INJECTION),
    CONFLICT("contradicts_query_premise", PromptCodeConstants.DECISION_RAG_CONFLICT),
    RELEVANCE("is_relevant", PromptCodeConstants.DECISION_RAG_RELEVANCE),
    EVIDENCE("contains_answer_evidence", PromptCodeConstants.DECISION_RAG_EVIDENCE);

    final String name;
    final String promptCode;
    RagQuestion(String name, String promptCode) {
        this.name = name;
        this.promptCode = promptCode;
    }
}

RagDecision prepareRagDecision(String modelRef, String query, List<String> passages) {
    RuntimeDecision runtime = resolve(DecisionModelOptions.RAG, modelRef);
    if (runtime == null) {
        return null; // 未开启决策模型，平滑沿用原有 RAG 路径
    }
    if (passages.size() > runtime.options.rag().maxCandidates()) {
        throw new IllegalArgumentException("RAG 切片数量超过配置上限");
    }

    Map<String, String> inputs = new LinkedHashMap<>();
    DecisionRequest.Builder builder = DecisionRequest.builder();
    for (int index = 0; index < passages.size(); index++) {
        String passageId = "passage_" + index;
        inputs.put(passageId, passages.get(index));
        // 单个切片挂载 4 个 YesNoQuestion，Jev 并行计算
        for (RagQuestion question : RagQuestion.values()) {
            builder.question(passageId + StrUtil.UNDERLINE + question.name,
                    YesNoQuestion.builder()
                        .text(promptBuilder.doRender(question.promptCode, Map.of("passageId", passageId)))
                        .yesWhen("yes")
                        .noWhen("no")
                        .build());
        }
    }
    
    DecisionRequest request = builder.input(Map.of("query", StrUtil.nullToEmpty(query), "passages", inputs))
            .build();

    // 强约束本地字符预算（默认 24,000 字符），超限直接拦截
    if (request.input().toString().length() + request.questions().toString().length() > runtime.options.rag().maxInputChars()) {
        throw new IllegalArgumentException("RAG 整次请求超过配置字符上限");
    }
    return new RagDecision(runtime, request, passages.size());
}

private static Verdict classify(Map<String, Double> scores, DecisionModelOptions.RagOptions options) {
    // 1. 安全第一：只要检测到 Prompt 注入风险超标，坚决剔除切片
    if (scores.get(INJECTION.name) > options.injectionThreshold()) {
        return new Verdict(false, "INJECTION", scores);
    }
    // 2. 事实纠偏：切片若指出用户前提是错的，强制保留（防止模型顺着用户的错误假设胡说）
    if (scores.get(CONFLICT.name) > options.conflictThreshold()) {
        return new Verdict(true, "CONFLICTING", scores);
    }
    // 3. 相关性过滤：语义无关切片直接淘汰
    if (scores.get(RELEVANCE.name) < options.relevanceThreshold()) {
        return new Verdict(false, "IRRELEVANT", scores);
    }
    // 4. 证据充分性：判定切片是否足以支撑回答
    boolean evidence = scores.get(EVIDENCE.name) > options.evidenceThreshold();
    return new Verdict(evidence, evidence ? "EVIDENCE" : "NO_EVIDENCE", scores);
}

private Flux<AiMessageResultDTO> answerDecisionResult(AiDatasetEntity dataset, ChatMessageDTO chatMessageDTO,
        RagDecisionService.Result result, RagTraceContext traceContext) {
    if (CollUtil.isEmpty(result.matches())) {
        // 关键安全点：风险过滤导致空结果时，调用方不得自动转联网搜索，防止指令逃逸
        if (result.blockWebFallback()) {
            return Flux.just(new AiMessageResultDTO(dataset.getEmptyDesc()));
        }
        Long recordId = ChatMessageContextHolder.get() == null ? null : ChatMessageContextHolder.get().getMessageKey();
        return RagHelper.handleEmptyResult(dataset, chatMessageDTO, recordId, traceContext);
    }
    return answerFilteredMatches(dataset, chatMessageDTO, result.matches(), traceContext, result.enabled());
}

// 各库独立完成过滤后，按名次交错合并
List<EmbeddingMatch<TextSegment>> matches = new ArrayList<>();
int maxSize = results.stream().mapToInt(result -> result.matches().size()).max().orElse(0);
for (int rank = 0; rank < maxSize; rank++) {
    for (RagDecisionService.Result result : results) {
        if (rank < result.matches().size()) {
            matches.add(result.matches().get(rank));
        }
    }
}