SpringBoot实现向量数据库优化检索的方案及示例

java复制代码
// 1. 文本向量检索（Milvus）
List<Float> textVector = openAIService.vectorize(queryText);
SearchParam textSearchParam = buildTextSearchParam(textVector);

// 2. 图像特征检索（CLIP模型）
float[] imageVector = clipService.vectorize(uploadedImage);
SearchParam imageSearchParam = buildImageSearchParam(imageVector);

// 3. 结果融合（加权平均）
List<Document> textResults = milvusClient.search(textSearchParam);
List<Document> imageResults = milvusClient.search(imageSearchParam);
List<Document> fusedResults = FusionUtil.weightedFusion(textResults, imageResults, 0.6, 0.4);

java复制代码
public String expandQuery(String originalQuery) {
    String prompt = """
        你是一个专业的搜索优化助手，请根据以下查询生成3个语义相关的扩展查询：
        原始查询：%s
        输出格式：JSON数组，字段为"queries"
        """.formatted(originalQuery);

    String response = openAIService.chatCompletion(prompt);
    List<String> expandedQueries = parseExpandedQueries(response); // 解析JSON
    return String.join(" ", expandedQueries);
}

// 检索时使用扩展后的查询
String enhancedQuery = expandQuery(userQuery);
float[] vector = vectorizationService.vectorize(enhancedQuery);

java复制代码
@RestController
public class FeedbackController {
    @PostMapping("/feedback")
    public void handleFeedback(@RequestBody FeedbackRequest request) {
        // 根据用户标注的相关性分数调整模型
        retrainingService.adjustWeights(
            request.getQueryVector(),
            request.getDocId(),
            request.getRelevanceScore()
        );
    }
}

java复制代码
public String compressContext(String rawContext) {
    String prompt = """
        请从以下文本中提取与问题相关的核心事实，忽略无关细节：
        问题：%s
        文本：%s
        输出要求：用简洁的Markdown列表呈现
        """.formatted(userQuestion, rawContext);

    return openAIService.chatCompletion(prompt);
}

java复制代码
public String generateWithReflection(String question) {
    // 第一阶段：初步回答
    String initialAnswer = openAIService.chatCompletion(question);
    
    // 第二阶段：反思修正
    String reflectionPrompt = """
        请检查以下回答是否存在事实错误或不完整之处：
        问题：%s
        初版回答：%s
        输出格式：{"errors": [错误1, 错误2], "improved_answer": "修正后的回答"}
        """.formatted(question, initialAnswer);
    
    String reflectionResult = openAIService.chatCompletion(reflectionPrompt);
    return parseImprovedAnswer(reflectionResult);
}

java复制代码
public List<Document> rerankDocuments(String query, List<Document> candidates) {
    String promptTemplate = """
        请根据问题相关性对以下文档排序（最相关在前）：
        问题：%s
        文档列表：
        %s
        输出要求：返回排序后的文档ID列表，如[3,1,2]
        """;
    
    String docList = candidates.stream()
        .map(doc -> "ID:%d 内容:%s".formatted(doc.getId(), doc.getContent()))
        .collect(Collectors.joining("\n"));
    
    String response = openAIService.chatCompletion(promptTemplate.formatted(query, docList));
    return applyReordering(candidates, parseOrderedIds(response));
}

//java复制代码
@Cacheable(value = "ragCache", key = "#query.hashCode()")
public RAGResponse cachedRetrieve(String query) {
    // 正常检索生成流程
    List<Document> docs = retrieveDocuments(query);
    String answer = generateAnswer(query, docs);
    return new RAGResponse(docs, answer);
}

//java复制代码
@Async
public CompletableFuture<RAGResponse> asyncProcess(String query) {
    CompletableFuture<List<Document>> retrievalFuture = CompletableFuture.supplyAsync(
        () -> retrieveDocuments(query), 
        retrievalExecutor
    );
    
    return retrievalFuture.thenApplyAsync(docs -> {
        String answer = generateAnswer(query, docs);
        return new RAGResponse(docs, answer);
    }, generationExecutor);
}

//java复制代码
@Aspect
@Component
public class MonitoringAspect {
    @Around("execution(* com.example.service.RAGService.*(..))")
    public Object logMetrics(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        
        Metrics.gauge("rag.latency", System.currentTimeMillis() - start);
        if (result instanceof RAGResponse resp) {
            Metrics.counter("rag.doc_count").increment(resp.getDocuments().size());
        }
        
        return result;
    }
}

//java复制代码
@PostMapping("/query")
public RAGResponse handleQuery(@RequestBody QueryRequest request) {
    if (experimentGroup.isInGroup(request.getUserId(), "V2_ENHANCED")) {
        return enhancedRetriever.process(request.getQuery());
    } else {
        return baselineRetriever.process(request.getQuery());
    }
}

//java复制代码
public class Evaluator {
    // 计算MRR（平均倒数排名）
    public double calculateMRR(List<TestCase> testCases) {
        return testCases.stream()
            .mapToDouble(tc -> 1.0 / (getFirstRelevantRank(tc)+1))
            .average().orElse(0);
    }
    
    // 生成质量人工评估
    public void humanEvaluation(List<RAGResponse> samples) {
        // 与标注平台集成
    }
}