From 80ca76ea37d5822571842a0246fa9cf1b699c1e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9D=A8=E6=8C=AF?= Date: Mon, 20 Apr 2026 01:02:09 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E9=87=8D=E6=8E=92=E5=BA=8F?= =?UTF-8?q?=E5=8A=9F=E8=83=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../domain/bo/knowledge/KnowledgeInfoBo.java | 23 +++ .../ruoyi/domain/bo/rerank/RerankRequest.java | 44 +++++ .../ruoyi/domain/bo/rerank/RerankResult.java | 72 ++++++++ .../ruoyi/domain/bo/vector/QueryVectorBo.java | 26 +++ .../dto/request/ZhipuRerankRequest.java | 48 ++++++ .../dto/response/ZhipuRerankResponse.java | 65 +++++++ .../entity/knowledge/KnowledgeInfo.java | 20 +++ .../domain/vo/knowledge/KnowledgeInfoVo.java | 24 +++ .../org/ruoyi/factory/RerankModelFactory.java | 106 ++++++++++++ .../service/chat/impl/ChatServiceFacade.java | 14 +- .../service/rerank/RerankModelService.java | 70 ++++++++ .../rerank/impl/JinaRerankModelService.java | 107 ++++++++++++ .../rerank/impl/ZhiPuRerankModelService.java | 162 ++++++++++++++++++ .../retrieval/KnowledgeRetrievalService.java | 24 +++ .../impl/KnowledgeRetrievalServiceImpl.java | 135 +++++++++++++++ 15 files changed, 938 insertions(+), 2 deletions(-) create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/rerank/RerankRequest.java create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/rerank/RerankResult.java create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/dto/request/ZhipuRerankRequest.java create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/dto/response/ZhipuRerankResponse.java create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/factory/RerankModelFactory.java create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/RerankModelService.java create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/impl/JinaRerankModelService.java create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/impl/ZhiPuRerankModelService.java create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/retrieval/KnowledgeRetrievalService.java create mode 100644 ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/retrieval/impl/KnowledgeRetrievalServiceImpl.java diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/knowledge/KnowledgeInfoBo.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/knowledge/KnowledgeInfoBo.java index 113a2847..4d5cf619 100644 --- a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/knowledge/KnowledgeInfoBo.java +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/knowledge/KnowledgeInfoBo.java @@ -77,10 +77,33 @@ public class KnowledgeInfoBo extends BaseEntity { */ private String embeddingModel; + /** + * 是否启用重排序（0 否 1是） + */ + private Integer enableRerank; + + /** + * 重排序模型名称 + */ + private String rerankModel; + + /** + * 重排序后返回的文档数量 + */ + private Integer rerankTopN; + + /** + * 重排序相关性分数阈值 + */ + private Double rerankScoreThreshold; + + /** * 备注 */ private String remark; + + } diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/rerank/RerankRequest.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/rerank/RerankRequest.java new file mode 100644 index 00000000..a71c2841 --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/rerank/RerankRequest.java @@ -0,0 +1,44 @@ +package org.ruoyi.domain.bo.rerank; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +/** + * 重排序请求参数 + * + * @author yang + * @date 2026-04-19 + */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public class RerankRequest { + + /** + * 查询文本 + */ + private String query; + + /** + * 候选文档列表 + */ + private List documents; + + /** + * 返回的文档数量（topN） + * 如果不指定，默认返回所有文档 + */ + private Integer topN; + + /** + * 是否返回原始文档内容 + * 默认为 true + */ + @Builder.Default + private Boolean returnDocuments = true; +} diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/rerank/RerankResult.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/rerank/RerankResult.java new file mode 100644 index 00000000..32400a5d --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/rerank/RerankResult.java @@ -0,0 +1,72 @@ +package org.ruoyi.domain.bo.rerank; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +/** + * 重排序结果 + * + * @author yang + * @date 2026-04-19 + */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public class RerankResult { + + /** + * 重排序后的文档结果列表 + */ + private List documents; + + /** + * 原始请求中的文档总数 + */ + private Integer totalDocuments; + + /** + * 重排序耗时（毫秒） + */ + private Long durationMs; + + /** + * 单个重排序文档结果 + */ + @Data + @Builder + @NoArgsConstructor + @AllArgsConstructor + public static class RerankDocument { + + /** + * 文档在原始列表中的索引位置 + */ + private Integer index; + + /** + * 相关性分数（通常 0-1 之间，越高越相关） + */ + private Double relevanceScore; + + /** + * 文档内容 + */ + private String document; + } + + /** + * 创建空结果 + */ + public static RerankResult empty() { + return RerankResult.builder() + .documents(List.of()) + .totalDocuments(0) + .durationMs(0L) + .build(); + } +} diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/vector/QueryVectorBo.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/vector/QueryVectorBo.java index 0f881632..bb5634a3 100644 --- a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/vector/QueryVectorBo.java +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/bo/vector/QueryVectorBo.java @@ -51,4 +51,30 @@ public class QueryVectorBo { */ private String baseUrl; + + // ========== 重排序相关参数 ========== + + /** + * 是否启用重排序 + * 默认为 false + */ + private Boolean enableRerank = false; + + /** + * 重排序模型名称 + */ + private String rerankModelName; + + /** + * 重排序后返回的文档数量（topN） + * 如果不指定，默认与 maxResults 相同 + */ + private Integer rerankTopN; + + /** + * 重排序相关性分数阈值 + * 低于此阈值的文档将被过滤 + */ + private Double rerankScoreThreshold; + } diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/dto/request/ZhipuRerankRequest.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/dto/request/ZhipuRerankRequest.java new file mode 100644 index 00000000..f5be847a --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/dto/request/ZhipuRerankRequest.java @@ -0,0 +1,48 @@ +package org.ruoyi.domain.dto.request; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; + +import java.util.List; + +/** + * 智谱AI重排序请求DTO + * + * @author yang + * @date 2026-04-19 + */ +public record ZhipuRerankRequest( + String model, + String query, + List documents, + Integer top_n, + Boolean return_documents +) { + private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper(); + + /** + * 创建智谱重排序请求 + */ + public static ZhipuRerankRequest create(String modelName, String query, + List documents, Integer topN, + Boolean returnDocuments) { + return new ZhipuRerankRequest( + modelName, + query, + documents, + topN != null ? topN : documents.size(), + returnDocuments != null ? returnDocuments : true + ); + } + + /** + * 转换为JSON字符串 + */ + public String toJson() { + try { + return OBJECT_MAPPER.writeValueAsString(this); + } catch (JsonProcessingException e) { + throw new IllegalArgumentException("序列化智谱重排序请求失败", e); + } + } +} diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/dto/response/ZhipuRerankResponse.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/dto/response/ZhipuRerankResponse.java new file mode 100644 index 00000000..ff08d129 --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/dto/response/ZhipuRerankResponse.java @@ -0,0 +1,65 @@ +package org.ruoyi.domain.dto.response; + +import com.fasterxml.jackson.annotation.JsonProperty; +import org.ruoyi.domain.bo.rerank.RerankResult; + +import java.util.List; +import java.util.stream.Collectors; + +/** + * 智谱AI重排序响应DTO + * + * @author yang + * @date 2026-04-19 + */ +public record ZhipuRerankResponse( + String model, + String object, + List results, + UsageInfo usage +) { + /** + * 单个重排序结果项 + */ + public record ResultItem( + Integer index, + @JsonProperty("relevance_score") + Double relevanceScore, + String document + ) {} + + /** + * Token使用信息 + */ + public record UsageInfo( + @JsonProperty("total_tokens") + Integer totalTokens, + @JsonProperty("input_tokens") + Integer inputTokens, + @JsonProperty("output_tokens") + Integer outputTokens + ) {} + + /** + * 转换为通用RerankResult + */ + public RerankResult toRerankResult(int totalDocs, long durationMs) { + if (results == null || results.isEmpty()) { + return RerankResult.empty(); + } + + List documents = results.stream() + .map(item -> RerankResult.RerankDocument.builder() + .index(item.index()) + .relevanceScore(item.relevanceScore()) + .document(item.document()) + .build()) + .collect(Collectors.toList()); + + return RerankResult.builder() + .documents(documents) + .totalDocuments(totalDocs) + .durationMs(durationMs) + .build(); + } +} diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/entity/knowledge/KnowledgeInfo.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/entity/knowledge/KnowledgeInfo.java index a51cf7da..948d04c0 100644 --- a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/entity/knowledge/KnowledgeInfo.java +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/entity/knowledge/KnowledgeInfo.java @@ -78,6 +78,26 @@ public class KnowledgeInfo extends BaseEntity { */ private String embeddingModel; + /** + * 是否启用重排序（0 否 1是） + */ + private Integer enableRerank; + + /** + * 重排序模型名称 + */ + private String rerankModel; + + /** + * 重排序后返回的文档数量 + */ + private Integer rerankTopN; + + /** + * 重排序相关性分数阈值 + */ + private Double rerankScoreThreshold; + /** * 备注 */ diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/vo/knowledge/KnowledgeInfoVo.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/vo/knowledge/KnowledgeInfoVo.java index bf0580dd..41d48480 100644 --- a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/vo/knowledge/KnowledgeInfoVo.java +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/domain/vo/knowledge/KnowledgeInfoVo.java @@ -94,6 +94,30 @@ public class KnowledgeInfoVo implements Serializable { @ExcelProperty(value = "向量模型") private String embeddingModel; + /** + * 是否启用重排序（0 否 1是） + */ + @ExcelProperty(value = "是否启用重排序") + private Integer enableRerank; + + /** + * 重排序模型名称 + */ + @ExcelProperty(value = "重排序模型") + private String rerankModel; + + /** + * 重排序后返回的文档数量 + */ + @ExcelProperty(value = "重排序返回数量") + private Integer rerankTopN; + + /** + * 重排序相关性分数阈值 + */ + @ExcelProperty(value = "重排序分数阈值") + private Double rerankScoreThreshold; + /** * 备注 */ diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/factory/RerankModelFactory.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/factory/RerankModelFactory.java new file mode 100644 index 00000000..2b9ff9fe --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/factory/RerankModelFactory.java @@ -0,0 +1,106 @@ +package org.ruoyi.factory; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.ruoyi.common.chat.domain.vo.chat.ChatModelVo; +import org.ruoyi.common.chat.service.chat.IChatModelService; +import org.ruoyi.service.rerank.RerankModelService; +import org.springframework.beans.factory.NoSuchBeanDefinitionException; +import org.springframework.context.ApplicationContext; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +/** + * 重排序模型工厂服务类 + * 参考设计模式：EmbeddingModelFactory + * 负责创建和管理重排序模型实例 + * + * @author yang + * @date 2026-04-19 + */ +@Service +@RequiredArgsConstructor +@Slf4j +public class RerankModelFactory { + + private final ApplicationContext applicationContext; + + private final IChatModelService chatModelService; + + /** + * 模型缓存，使用ConcurrentHashMap保证线程安全 + */ + private final Map modelCache = new ConcurrentHashMap<>(); + + /** + * 创建重排序模型实例 + * 如果模型已存在于缓存中，则直接返回；否则创建新的实例 + * + * @param rerankModelName 重排序模型名称 + */ + public RerankModelService createModel(String rerankModelName) { + return modelCache.computeIfAbsent(rerankModelName, name -> { + ChatModelVo modelConfig = chatModelService.selectModelByName(rerankModelName); + + if (modelConfig == null) { + throw new IllegalArgumentException("未找到重排序模型配置，name=" + name); + } + return createModelInstance(modelConfig.getProviderCode(), modelConfig); + }); + } + + /** + * 刷新模型缓存 + * 根据给定的模型ID从缓存中移除对应的模型 + * + * @param modelId 模型的唯一标识ID + */ + public void refreshModel(Long modelId) { + modelCache.remove(modelId); + } + + /** + * 获取所有支持模型工厂的列表 + * + * @return 支持的模型工厂名称列表 + */ + public List getSupportedFactories() { + return new ArrayList<>(applicationContext.getBeansOfType(RerankModelService.class) + .keySet()); + } + + /** + * 创建具体的模型实例 + * 根据提供的工厂名称和配置信息创建并配置模型实例 + * + * @param factory 工厂名称，用于标识模型类型（providerCode） + * @param config 模型配置信息 + * @return RerankModelService 配置好的模型实例 + * @throws IllegalArgumentException 当无法获取指定的模型实例时抛出 + */ + private RerankModelService createModelInstance(String factory, ChatModelVo config) { + try { + // 优先尝试使用 providerCode + "Rerank" 作为 Bean 名称 + // 例如：zhipu -> zhipuRerank，jina -> jinaRerank + String rerankBeanName = factory + "Rerank"; + RerankModelService model = applicationContext.getBean(rerankBeanName, RerankModelService.class); + model.configure(config); + log.info("成功创建重排序模型: factory={}, modelName={}", rerankBeanName, config.getModelName()); + return model; + } catch (NoSuchBeanDefinitionException e) { + // 如果找不到，尝试使用原始的 providerCode + try { + RerankModelService model = applicationContext.getBean(factory, RerankModelService.class); + model.configure(config); + log.info("成功创建重排序模型: factory={}, modelName={}", factory, config.getModelName()); + return model; + } catch (NoSuchBeanDefinitionException ex) { + throw new IllegalArgumentException("获取不到重排序模型: " + factory + " 或 " + factory + "Rerank", ex); + } + } + } +} diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/chat/impl/ChatServiceFacade.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/chat/impl/ChatServiceFacade.java index 108c3cba..3bd0876e 100644 --- a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/chat/impl/ChatServiceFacade.java +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/chat/impl/ChatServiceFacade.java @@ -54,6 +54,7 @@ import org.ruoyi.service.chat.AbstractChatService; import org.ruoyi.service.chat.IChatMessageService; import org.ruoyi.service.chat.impl.memory.PersistentChatMemoryStore; import org.ruoyi.service.knowledge.IKnowledgeInfoService; +import org.ruoyi.service.retrieval.KnowledgeRetrievalService; import org.ruoyi.service.vector.VectorStoreService; import org.springframework.stereotype.Service; import org.springframework.web.servlet.mvc.method.annotation.SseEmitter; @@ -89,6 +90,8 @@ public class ChatServiceFacade implements IChatService { private final VectorStoreService vectorStoreService; + private final KnowledgeRetrievalService knowledgeRetrievalService; + private final SseEmitterManager sseEmitterManager; private final IChatMessageService chatMessageService; @@ -452,8 +455,8 @@ public class ChatServiceFacade implements IChatService { // 构建向量查询参数 QueryVectorBo queryVectorBo = buildQueryVectorBo(chatRequest, knowledgeInfoVo, chatModel); - // 获取向量查询结果（知识库内容作为系统上下文，放在历史消息之后） - List nearestList = vectorStoreService.getQueryVector(queryVectorBo); + // 使用知识库检索服务（支持重排序） + List nearestList = knowledgeRetrievalService.retrieveTexts(queryVectorBo); for (String prompt : nearestList) { // 知识库内容作为系统上下文添加 messages.add(new AiMessage(prompt)); @@ -480,6 +483,13 @@ public class ChatServiceFacade implements IChatService { queryVectorBo.setVectorModelName(knowledgeInfoVo.getVectorModel()); queryVectorBo.setEmbeddingModelName(knowledgeInfoVo.getEmbeddingModel()); queryVectorBo.setMaxResults(knowledgeInfoVo.getRetrieveLimit()); + + // 设置重排序参数 + queryVectorBo.setEnableRerank(knowledgeInfoVo.getEnableRerank() != null && knowledgeInfoVo.getEnableRerank() == 1); + queryVectorBo.setRerankModelName(knowledgeInfoVo.getRerankModel()); + queryVectorBo.setRerankTopN(knowledgeInfoVo.getRerankTopN()); + queryVectorBo.setRerankScoreThreshold(knowledgeInfoVo.getRerankScoreThreshold()); + return queryVectorBo; } diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/RerankModelService.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/RerankModelService.java new file mode 100644 index 00000000..a80d97e1 --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/RerankModelService.java @@ -0,0 +1,70 @@ +package org.ruoyi.service.rerank; + +import dev.langchain4j.data.segment.TextSegment; +import dev.langchain4j.model.output.Response; +import dev.langchain4j.model.scoring.ScoringModel; +import org.ruoyi.common.chat.domain.vo.chat.ChatModelVo; +import org.ruoyi.domain.bo.rerank.RerankRequest; +import org.ruoyi.domain.bo.rerank.RerankResult; + +import java.util.List; + +/** + * 重排序模型服务接口 + * 继承 langchain4j 的 ScoringModel 接口 + * 参考设计模式：BaseEmbedModelService + * + * @author Yzm + * @date 2026-04-19 + */ +public interface RerankModelService extends ScoringModel { + + /** + * 根据配置信息配置重排序模型 + * + * @param config 包含模型配置信息的 ChatModelVo 对象 + */ + void configure(ChatModelVo config); + + /** + * 执行重排序（批量文档） + * 这是业务层使用的便捷方法 + * + * @param rerankRequest 重排序请求，包含查询文本和候选文档列表 + * @return 重排序结果，包含排序后的文档和相关性分数 + */ + RerankResult rerank(RerankRequest rerankRequest); + + /** + * 实现 ScoringModel 接口的 scoreAll 方法 + * 将 ScoringModel 的调用转换为重排序调用 + */ + @Override + default Response> scoreAll(List segments, String query) { + // 将 TextSegment 转换为文档字符串列表 + List documents = segments.stream() + .map(TextSegment::text) + .toList(); + + RerankRequest request = RerankRequest.builder() + .query(query) + .documents(documents) + .topN(documents.size()) + .returnDocuments(false) + .build(); + + RerankResult result = rerank(request); + + // 提取分数列表，按原始顺序排列 + List scores = new java.util.ArrayList<>( + java.util.Collections.nCopies(documents.size(), 0.0)); + + for (RerankResult.RerankDocument doc : result.getDocuments()) { + if (doc.getIndex() != null && doc.getIndex() < documents.size()) { + scores.set(doc.getIndex(), doc.getRelevanceScore()); + } + } + + return Response.from(scores); + } +} diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/impl/JinaRerankModelService.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/impl/JinaRerankModelService.java new file mode 100644 index 00000000..642e807d --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/impl/JinaRerankModelService.java @@ -0,0 +1,107 @@ +package org.ruoyi.service.rerank.impl; + +import com.fasterxml.jackson.databind.ObjectMapper; +import dev.langchain4j.http.client.*; +import lombok.extern.slf4j.Slf4j; +import org.ruoyi.common.chat.domain.vo.chat.ChatModelVo; +import org.ruoyi.domain.bo.rerank.RerankRequest; +import org.ruoyi.domain.bo.rerank.RerankResult; +import org.ruoyi.service.rerank.RerankModelService; +import org.springframework.stereotype.Component; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Jina AI 重排序模型实现 + * 参考设计模式：OpenAiEmbeddingProvider + * 使用 Jina 官方重排序API + * + * @author yang + * @date 2026-04-19 + */ +@Slf4j +@Component("jina") +public class JinaRerankModelService implements RerankModelService { + + protected ChatModelVo chatModelVo; + protected HttpClient httpClient; + protected final ObjectMapper objectMapper = new ObjectMapper(); + + @Override + public void configure(ChatModelVo config) { + this.chatModelVo = config; + HttpClientBuilder httpClientBuilder = HttpClientBuilderLoader.loadHttpClientBuilder(); + this.httpClient = httpClientBuilder.build(); + } + + @Override + public RerankResult rerank(RerankRequest rerankRequest) { + long startTime = System.currentTimeMillis(); + + try { + // 构建Jina重排序请求体 + Map requestBody = new HashMap<>(); + requestBody.put("model", chatModelVo.getModelName()); + requestBody.put("query", rerankRequest.getQuery()); + requestBody.put("documents", rerankRequest.getDocuments()); + requestBody.put("top_n", rerankRequest.getTopN() != null ? + rerankRequest.getTopN() : rerankRequest.getDocuments().size()); + requestBody.put("return_documents", rerankRequest.getReturnDocuments()); + + // 构建HTTP请求 + HttpRequest httpRequest = HttpRequest.builder() + .url(chatModelVo.getApiHost()) + .method(HttpMethod.POST) + .addHeader("Content-Type", "application/json") + .addHeader("Authorization", "Bearer " + chatModelVo.getApiKey()) + .body(objectMapper.writeValueAsString(requestBody)) + .build(); + + // 发送请求 + SuccessfulHttpResponse httpResponse = httpClient.execute(httpRequest); + + // 解析响应 + @SuppressWarnings("unchecked") + Map response = objectMapper.readValue(httpResponse.body(), Map.class); + return parseResponse(response, rerankRequest.getDocuments().size(), + System.currentTimeMillis() - startTime); + + } catch (Exception e) { + log.error("Jina重排序失败: {}", e.getMessage(), e); + throw new RuntimeException("重排序服务调用失败: " + e.getMessage(), e); + } + } + + /** + * 解析Jina API响应 + */ + @SuppressWarnings("unchecked") + private RerankResult parseResponse(Map response, int totalDocs, long durationMs) { + List> results = (List>) response.get("results"); + if (results == null || results.isEmpty()) { + return RerankResult.empty(); + } + + List documents = new ArrayList<>(); + for (Map result : results) { + Integer index = (Integer) result.get("index"); + Double score = ((Number) result.get("relevance_score")).doubleValue(); + String document = (String) result.get("document"); + + documents.add(RerankResult.RerankDocument.builder() + .index(index) + .relevanceScore(score) + .document(document) + .build()); + } + + return RerankResult.builder() + .documents(documents) + .totalDocuments(totalDocs) + .durationMs(durationMs) + .build(); + } +} diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/impl/ZhiPuRerankModelService.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/impl/ZhiPuRerankModelService.java new file mode 100644 index 00000000..ff15908a --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/rerank/impl/ZhiPuRerankModelService.java @@ -0,0 +1,162 @@ +package org.ruoyi.service.rerank.impl; + +import com.fasterxml.jackson.databind.ObjectMapper; +import io.jsonwebtoken.Jwts; +import io.jsonwebtoken.security.MacAlgorithm; +import lombok.extern.slf4j.Slf4j; +import okhttp3.*; +import org.ruoyi.common.chat.domain.vo.chat.ChatModelVo; +import org.ruoyi.domain.bo.rerank.RerankRequest; +import org.ruoyi.domain.bo.rerank.RerankResult; +import org.ruoyi.domain.dto.request.ZhipuRerankRequest; +import org.ruoyi.domain.dto.response.ZhipuRerankResponse; +import org.ruoyi.service.rerank.RerankModelService; +import org.springframework.stereotype.Component; + +import javax.crypto.spec.SecretKeySpec; +import java.io.IOException; +import java.lang.reflect.Constructor; +import java.nio.charset.StandardCharsets; +import java.util.concurrent.TimeUnit; + +/** + * 智谱AI 重排序模型实现 + * 参考设计模式：AliBaiLianMultiEmbeddingProvider + * + * @author yang + * @date 2026-04-19 + */ +@Slf4j +@Component("zhipuRerank") +public class ZhiPuRerankModelService implements RerankModelService { + + private final OkHttpClient okHttpClient; + private final ObjectMapper objectMapper = new ObjectMapper(); + private ChatModelVo chatModelVo; + + public ZhiPuRerankModelService() { + this.okHttpClient = new OkHttpClient.Builder() + .connectTimeout(30, TimeUnit.SECONDS) + .readTimeout(60, TimeUnit.SECONDS) + .writeTimeout(30, TimeUnit.SECONDS) + .build(); + } + + @Override + public void configure(ChatModelVo config) { + this.chatModelVo = config; + } + + @Override + public RerankResult rerank(RerankRequest rerankRequest) { + long startTime = System.currentTimeMillis(); + + try { + // 构建请求 + ZhipuRerankRequest request = buildRequest(rerankRequest); + ZhipuRerankResponse response = executeRequest(request); + + return response.toRerankResult( + rerankRequest.getDocuments().size(), + System.currentTimeMillis() - startTime + ); + + } catch (Exception e) { + log.error("智谱重排序失败: {}", e.getMessage(), e); + throw new RuntimeException("重排序服务调用失败: " + e.getMessage(), e); + } + } + + /** + * 构建请求对象 + */ + private ZhipuRerankRequest buildRequest(RerankRequest rerankRequest) { + return ZhipuRerankRequest.create( + chatModelVo.getModelName(), + rerankRequest.getQuery(), + rerankRequest.getDocuments(), + rerankRequest.getTopN(), + rerankRequest.getReturnDocuments() + ); + } + + /** + * 执行HTTP请求并解析响应 + */ + private ZhipuRerankResponse executeRequest(ZhipuRerankRequest request) throws IOException { + String jsonBody = request.toJson(); + RequestBody body = RequestBody.create(jsonBody, MediaType.get("application/json")); + + // 生成智谱认证Token + String token = generateToken(chatModelVo.getApiKey()); + + String url = chatModelVo.getApiHost() + "/" + chatModelVo.getModelName(); + Request httpRequest = new Request.Builder() + .url(url) + .addHeader("Authorization", token) + .post(body) + .build(); + + try (okhttp3.Response response = okHttpClient.newCall(httpRequest).execute()) { + if (!response.isSuccessful()) { + String err = response.body() != null ? response.body().string() : "无错误信息"; + throw new IllegalArgumentException("智谱API调用失败: " + response.code() + " - " + err); + } + + ResponseBody responseBody = response.body(); + if (responseBody == null) { + throw new IllegalArgumentException("响应体为空"); + } + + return parseResponse(responseBody.string()); + } + } + + /** + * 解析响应 + */ + private ZhipuRerankResponse parseResponse(String responseBody) throws IOException { + return objectMapper.readValue(responseBody, ZhipuRerankResponse.class); + } + + /** + * 生成智谱JWT Token + */ + private String generateToken(String apiKey) { + try { + String[] apiKeyParts = apiKey.split("\\."); + String keyId = apiKeyParts[0]; + String secret = apiKeyParts[1]; + + long expireMillis = 1000L * 60 * 30; // 30分钟 + java.util.Map payload = new java.util.HashMap<>(); + payload.put("api_key", keyId); + payload.put("exp", System.currentTimeMillis() + expireMillis); + payload.put("timestamp", System.currentTimeMillis()); + + // 使用反射创建 MacAlgorithm（兼容不同版本的 jjwt） + MacAlgorithm macAlgorithm; + try { + Class c = Class.forName("io.jsonwebtoken.impl.security.DefaultMacAlgorithm"); + Constructor ctor = c.getDeclaredConstructor(String.class, String.class, int.class); + ctor.setAccessible(true); + macAlgorithm = (MacAlgorithm) ctor.newInstance("HS256", "HmacSHA256", 128); + } catch (Exception e) { + macAlgorithm = Jwts.SIG.HS256; + } + + String token = Jwts.builder() + .header() + .add("alg", "HS256") + .add("sign_type", "SIGN") + .and() + .content(objectMapper.writeValueAsString(payload)) + .signWith(new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), "HmacSHA256"), macAlgorithm) + .compact(); + + return "Bearer " + token; + } catch (Exception e) { + throw new RuntimeException("生成智谱Token失败: " + e.getMessage(), e); + } + } +} diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/retrieval/KnowledgeRetrievalService.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/retrieval/KnowledgeRetrievalService.java new file mode 100644 index 00000000..9c42dd1a --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/retrieval/KnowledgeRetrievalService.java @@ -0,0 +1,24 @@ +package org.ruoyi.service.retrieval; + +import org.ruoyi.domain.bo.vector.QueryVectorBo; + +import java.util.List; + +/** + * 知识库检索服务接口 + * 整合粗召回（向量检索）和重排序流程 + * + * @author yang + * @date 2026-04-19 + */ +public interface KnowledgeRetrievalService { + + /** + * 执行知识库检索，返回文本内容 + * 流程：向量粗召回 -> 重排序（可选） -> 返回结果 + * + * @param queryVectorBo 查询参数 + * @return 文本内容列表 + */ + List retrieveTexts(QueryVectorBo queryVectorBo); +} diff --git a/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/retrieval/impl/KnowledgeRetrievalServiceImpl.java b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/retrieval/impl/KnowledgeRetrievalServiceImpl.java new file mode 100644 index 00000000..42f6cf68 --- /dev/null +++ b/ruoyi-modules/ruoyi-chat/src/main/java/org/ruoyi/service/retrieval/impl/KnowledgeRetrievalServiceImpl.java @@ -0,0 +1,135 @@ +package org.ruoyi.service.retrieval.impl; + +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.ruoyi.domain.bo.rerank.RerankRequest; +import org.ruoyi.domain.bo.rerank.RerankResult; +import org.ruoyi.domain.bo.vector.QueryVectorBo; +import org.ruoyi.factory.RerankModelFactory; +import org.ruoyi.service.rerank.RerankModelService; +import org.ruoyi.service.retrieval.KnowledgeRetrievalService; +import org.ruoyi.service.vector.VectorStoreService; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; + +/** + * 知识库检索服务实现 + * 整合粗召回（向量检索）和重排序流程 + * + * @author yang + * @date 2026-04-19 + */ +@Slf4j +@Service +@RequiredArgsConstructor +public class KnowledgeRetrievalServiceImpl implements KnowledgeRetrievalService { + + private final VectorStoreService vectorStoreService; + private final RerankModelFactory rerankModelFactory; + + /** + * 粗召回默认扩大倍数 + * 如果启用重排序，粗召回会获取更多结果供重排序筛选 + */ + private static final int RERANK_EXPANSION_FACTOR = 3; + + @Override + public List retrieveTexts(QueryVectorBo queryVectorBo) { + log.info("开始知识库检索, kid={}, query={}", queryVectorBo.getKid(), queryVectorBo.getQuery()); + + // 1. 粗召回阶段 - 向量检索 + List coarseResults = coarseRetrieval(queryVectorBo); + log.debug("粗召回返回 {} 条结果", coarseResults.size()); + + if (coarseResults.isEmpty()) { + return coarseResults; + } + + // 2. 重排序阶段（可选） + if (Boolean.TRUE.equals(queryVectorBo.getEnableRerank()) && + queryVectorBo.getRerankModelName() != null) { + return rerank(queryVectorBo, coarseResults); + } + + return coarseResults; + } + + /** + * 粗召回阶段 - 向量检索 + */ + private List coarseRetrieval(QueryVectorBo queryVectorBo) { + // 如果启用重排序，扩大粗召回数量 + int originalMaxResults = queryVectorBo.getMaxResults(); + int expandedResults = originalMaxResults; + if (Boolean.TRUE.equals(queryVectorBo.getEnableRerank()) && + queryVectorBo.getRerankModelName() != null) { + expandedResults = originalMaxResults * RERANK_EXPANSION_FACTOR; + log.debug("启用重排序，粗召回数量从 {} 扩大到 {}", originalMaxResults, expandedResults); + } + + // 临时修改查询数量 + queryVectorBo.setMaxResults(expandedResults); + try { + return vectorStoreService.getQueryVector(queryVectorBo); + } finally { + // 恢复原始值 + queryVectorBo.setMaxResults(originalMaxResults); + } + } + + /** + * 重排序阶段 + */ + private List rerank(QueryVectorBo queryVectorBo, List coarseResults) { + long startTime = System.currentTimeMillis(); + + try { + // 1. 通过工厂获取重排序模型 + RerankModelService rerankModel = rerankModelFactory.createModel(queryVectorBo.getRerankModelName()); + + // 2. 构建重排序请求 + int topN = queryVectorBo.getRerankTopN() != null ? + queryVectorBo.getRerankTopN() : queryVectorBo.getMaxResults(); + + RerankRequest rerankRequest = RerankRequest.builder() + .query(queryVectorBo.getQuery()) + .documents(coarseResults) + .topN(topN) + .returnDocuments(true) + .build(); + + log.info("执行重排序, model={}, documents={}, topN={}", + queryVectorBo.getRerankModelName(), coarseResults.size(), topN); + + // 3. 执行重排序 + RerankResult rerankResult = rerankModel.rerank(rerankRequest); + + // 4. 转换重排序结果 + List finalResults = new ArrayList<>(); + for (RerankResult.RerankDocument doc : rerankResult.getDocuments()) { + // 应用分数阈值过滤 + if (queryVectorBo.getRerankScoreThreshold() != null && + doc.getRelevanceScore() < queryVectorBo.getRerankScoreThreshold()) { + continue; + } + + if (doc.getDocument() != null) { + finalResults.add(doc.getDocument()); + } + } + + long duration = System.currentTimeMillis() - startTime; + log.info("重排序完成, 返回 {} 条结果, 耗时 {}ms", finalResults.size(), duration); + + return finalResults; + + } catch (Exception e) { + log.error("重排序失败: {}", e.getMessage(), e); + // 重排序失败时返回原始粗召回结果（截取到期望数量） + int limit = Math.min(queryVectorBo.getMaxResults(), coarseResults.size()); + return new ArrayList<>(coarseResults.subList(0, limit)); + } + } +}