什么是 RAG 假设性文档嵌入（ HyDE）？它的工作原理是什么？

import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.rag.query.Query;
import dev.langchain4j.rag.query.transformer.QueryTransformer;

/**
 * HyDE 查询转换器：让 LLM 先生成一个假设性答案文档，
 * 再用这个假设文档作为新的 Query 去做向量检索。
 */
public class HyDEQueryTransformer implements QueryTransformer {

    private final ChatLanguageModel model;

    // HyDE 的核心 Prompt：让 LLM 给出一段 "看起来像答案" 的文档
    private static final String HYDE_PROMPT = """
            请根据下面的问题，写一段 200 字左右的假设性答案文档。
            这段文档将用于向量检索，所以请用正式、文档化的语言，
            不要说 "我不知道"，直接给出你认为合理的答案内容。

            问题：%s
            """;

    public HyDEQueryTransformer(ChatLanguageModel model) {
        this.model = model;
    }

    @Override
    public Query transform(Query query) {
        String userQuery = query.text();

        // 1. 让 LLM 生成假设性文档
        String hypotheticalDoc = model.generate(
                UserMessage.from(String.format(HYDE_PROMPT, userQuery))
        ).content().text();

        // 2. 用假设文档替换原始 Query 作为检索输入
        return Query.from(hypotheticalDoc, query.metadata());
    }
}

import dev.langchain4j.rag.DefaultRetrievalAugmentor;
import dev.langchain4j.rag.RetrievalAugmentor;
import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;

ContentRetriever contentRetriever = EmbeddingStoreContentRetriever.builder()
        .embeddingStore(embeddingStore)
        .embeddingModel(embeddingModel)
        .maxResults(5)
        .build();

// 把 HyDE 作为 QueryTransformer 注入到 augmentor
RetrievalAugmentor augmentor = DefaultRetrievalAugmentor.builder()
        .queryTransformer(new HyDEQueryTransformer(chatModel))  // HyDE 关键
        .contentRetriever(contentRetriever)
        .build();

// 应用到 AI Service
Assistant assistant = AiServices.builder(Assistant.class)
        .chatLanguageModel(chatModel)
        .retrievalAugmentor(augmentor)
        .build();

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.rag.Advisor;
import org.springframework.ai.rag.Query;
import org.springframework.ai.rag.RetrievalAugmentationAdvisor;
import org.springframework.ai.rag.query.transformer.QueryTransformer;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.ai.vectorstore.retrieve.VectorStoreDocumentRetriever;
import reactor.core.publisher.Flux;

public class HyDEQueryTransformer implements QueryTransformer {

    private final ChatClient chatClient;

    // HyDE Prompt 模板：要求模型给出假设性答案文档
    private static final String HYDE_TEMPLATE = """
            请基于下面的问题，写一段 200 字左右的假设性答案文档。
            这段文档将用于向量检索，请用正式、文档化的语言，
            直接给出你认为合理的答案内容。

            问题：{question}
            """;

    public HyDEQueryTransformer(ChatClient.Builder chatClientBuilder) {
        this.chatClient = chatClientBuilder.build();
    }

    @Override
    public Flux<Query> apply(Query query) {
        String userQuery = query.text();

        // 1. 调用 LLM 生成假设性文档
        String hypotheticalDoc = chatClient.prompt()
                .user(spec -> spec.text(HYDE_TEMPLATE).param("question", userQuery))
                .call()
                .content();

        // 2. 用假设文档构造新的 Query 用于后续检索
        return Flux.just(Query.builder()
                .text(hypotheticalDoc)
                .metadata(query.metadata())
                .build());
    }
}

@Bean
public Advisor ragAdvisor(VectorStore vectorStore, ChatClient.Builder chatClientBuilder) {
    return RetrievalAugmentationAdvisor.builder()
            .queryTransformers(new HyDEQueryTransformer(chatClientBuilder))  // HyDE
            .documentRetriever(VectorStoreDocumentRetriever.builder()
                    .vectorStore(vectorStore)
                    .topK(5)
                    .build())
            .build();
}