通过Spring AI Alibaba检索阿里云百炼知识库

import org.springframework.web.bind.annotation.*;

import com.alibaba.cloud.ai.example.rag.knowledge.service.RagService;
import reactor.core.publisher.Flux;

@RestController
@RequestMapping("/ai")
public class CloudRagController {

    /** 注入CloudRagService */
    private final RagService cloudRagService;

    public CloudRagController(RagService cloudRagService) {
        this.cloudRagService = cloudRagService;
    }

    @GetMapping(value="/bailian/knowledge/generate", produces="text/event-stream")
    public Flux<String> generate(@RequestParam(value = "message",
                    defaultValue = "你好，请问你的知识库文档主要是关于什么内容的?") String message) {
        return cloudRagService.retrieve(message).map(x -> x.getResult().getOutput().getText());
    }
}

import com.alibaba.cloud.ai.advisor.DocumentRetrievalAdvisor;
import com.alibaba.cloud.ai.dashscope.api.DashScopeApi;
import com.alibaba.cloud.ai.dashscope.rag.*;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.prompt.SystemPromptTemplate;
import org.springframework.ai.document.Document;
import org.springframework.ai.document.DocumentReader;
import org.springframework.ai.rag.retrieval.search.DocumentRetriever;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;

@Service()
public class CloudRagService implements RagService {
    /** 此处INDEX_NAME的值为待检索知识库的名称，知识库需要提前创建好 */
    private static final String INDEX_NAME = "测试知识库";

    /** 提示词模板 */
    private static final String retrievalSystemTemplate = """
        {query}

        以下是上下文信息。
        ---------------------
        {question_answer_context}
        ---------------------
        请根据上下文，而不是先验知识，回复用户评论。如果答案不在上下文中，告知用户认为你不能回答这个问题。
        """;

    private final ChatClient chatClient;

    private final DashScopeApi dashscopeApi;

    public CloudRagService(ChatClient.Builder builder, DashScopeApi dashscopeApi) {
        // 以下字段和值仅为示例，请替换为知识库中实际可检索的字段和值。
        Map<String, Object> orGroup = Map.of(
            "_operator", "OR",
            "_conditions", List.of(
                Map.of("department", "Corporate"),
                Map.of("department", Map.of("like", "%Research%")),
                Map.of("document_type", Map.of("like", "%Policy%"))
            )
        );
        DashScopeDocumentRetrieverOptions retrieverOptions =
            DashScopeDocumentRetrieverOptions.builder()
                .indexName(INDEX_NAME)
                .searchFilters(List.of(orGroup))
                .build();
        DocumentRetriever retriever = new DashScopeDocumentRetriever(
            dashscopeApi,
            retrieverOptions
        );

        this.dashscopeApi = dashscopeApi;
        // 初始化ChatClient，此处设置待检索知识库和待调用的模型
        this.chatClient = builder
            .defaultAdvisors(new DocumentRetrievalAdvisor(retriever, new SystemPromptTemplate(retrievalSystemTemplate)))
            // 模型默认使用qwen-max，可通过如下代码设置不同的模型
            //.defaultOptions(DashScopeChatOptions.builder().withModel("qwen-plus").build())
            .build();
    }

    @Override
    public Flux<ChatResponse> retrieve(String message) {
        return chatClient.prompt().user(message).stream().chatResponse();
    }
}

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.springframework.ai.document.Document;
import org.springframework.ai.rag.Query;
import org.springframework.ai.rag.retrieval.search.DocumentRetriever;
import org.springframework.http.MediaType;
import org.springframework.web.client.RestClient;

import java.util.List;
import java.util.Map;

public class RagApiDocumentRetriever implements DocumentRetriever {
    private final RestClient client;
    private final String indexId;
    private final List<Map<String, Object>> searchFilters;

    public RagApiDocumentRetriever(RestClient client, String indexId,
                                   List<Map<String, Object>> searchFilters) {
        this.client = client;
        this.indexId = indexId;
        this.searchFilters = searchFilters;
    }

    @Override
    public List<Document> retrieve(Query query) {
        Map<String, Object> body = Map.of(
            "index_id", indexId,
            "query", query.text(),
            "search_filters", searchFilters
        );
        RetrievalResponse response = client.post()
            .uri("/api/v1/indices/rag/index/retrieve")
            .contentType(MediaType.APPLICATION_JSON)
            .body(body)
            .retrieve()
            .body(RetrievalResponse.class);

        if (response == null || !response.success() || response.data() == null
                || response.data().nodes() == null) {
            String requestId = response == null ? null : response.requestId();
            throw new IllegalStateException("Knowledge base retrieval failed; request_id=" + requestId);
        }
        return response.data().nodes().stream()
            .map(node -> Document.builder()
                .text(node.text())
                .metadata(node.metadata())
                .score(node.score())
                .build())
            .toList();
    }

    @JsonIgnoreProperties(ignoreUnknown = true)
    public record RetrievalResponse(boolean success, RetrievalData data,
                                    @JsonProperty("request_id") String requestId) {}

    @JsonIgnoreProperties(ignoreUnknown = true)
    public record RetrievalData(List<RetrievalNode> nodes) {}

    @JsonIgnoreProperties(ignoreUnknown = true)
    public record RetrievalNode(String text, Map<String, Object> metadata, Double score) {}
}