SpringBoot implements vector database optimization retrieval plan and example

javaCopy the code
// 1. Text vector search (Milvus)List<Float> textVector = (queryText);
SearchParam textSearchParam = buildTextSearchParam(textVector);

// 2. Image feature search (CLIP model)float[] imageVector = (uploadedImage);
SearchParam imageSearchParam = buildImageSearchParam(imageVector);

// 3. Results Fusion (weighted average)List<Document> textResults = (textSearchParam);
List<Document> imageResults = (imageSearchParam);
List<Document> fusedResults = (textResults, imageResults, 0.6, 0.4);

javaCopy the code
public String expandQuery(String originalQuery) {
    String prompt = """
         You are a professional search optimization assistant. Please generate 3 semantic-related extended queries based on the following queries:
         Original query: %s
         Output format: JSON array, field is "queries"
        """.formatted(originalQuery);

    String response = (prompt);
    List<String> expandedQueries = parseExpandedQueries(response); // parse JSON    return (" ", expandedQueries);
}

// Use extended query when searchingString enhancedQuery = expandQuery(userQuery);
float[] vector = (enhancedQuery);

javaCopy the code
@RestController
public class FeedbackController {
    @PostMapping("/feedback")
    public void handleFeedback(@RequestBody FeedbackRequest request) {
        // Adjust the model according to the correlation score marked by the user        (
            (),
            (),
            ()
        );
    }
}

javaCopy the code
public String compressContext(String rawContext) {
    String prompt = """
         Please extract the core facts related to the problem from the following text, ignoring irrelevant details:
         Question: %s
         Text: %s
         Output requirements: rendered with a simple Markdown list
         """.formatted(userQuestion, rawContext);

    return (prompt);
}

javaCopy the code
public String generateWithReflection(String question) {
    // Phase 1: Preliminary answer    String initialAnswer = (question);
    
    // Stage 2: Reflection and correction    String reflectionPrompt = """
        Please check if there are any factual errors or incomplete answers below：
        question：%s
        First edition answer：%s
        Output format：{"errors": [mistake1, mistake2], "improved_answer": "Revised answer"}
        """.formatted(question, initialAnswer);
    
    String reflectionResult = (reflectionPrompt);
    return parseImprovedAnswer(reflectionResult);
}

javaCopy the code
public List<Document> rerankDocuments(String query, List<Document> candidates) {
    String promptTemplate = """
         Please sort the following documents according to the relevance of the question (most relevant first):
         Question: %s
         Document list:
         %s
         Output requirements: Return the sorted document ID list, such as [3,1,2]
         """;
    
    String docList = ()
        .map(doc -> "ID:%d Content:%s".formatted((), ()))
        .collect(("\n"));
    
    String response = ((query, docList));
    return applyReordering(candidates, parseOrderedIds(response));
}

//java copy code@Cacheable(value = "ragCache", key = "#()")
public RAGResponse cachedRetrieve(String query) {
    // Normal search and generation process    List<Document> docs = retrieveDocuments(query);
    String answer = generateAnswer(query, docs);
    return new RAGResponse(docs, answer);
}

//java copy code@Async
public CompletableFuture<RAGResponse> asyncProcess(String query) {
    CompletableFuture<List<Document>> retrievalFuture = (
        () -> retrieveDocuments(query), 
        retrievalExecutor
    );
    
    return (docs -> {
        String answer = generateAnswer(query, docs);
        return new RAGResponse(docs, answer);
    }, generationExecutor);
}

//java copy code@Aspect
@Component
public class MonitoringAspect {
    @Around("execution(* .*(..))")
    public Object logMetrics(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = ();
        Object result = ();
        
        ("", () - start);
        if (result instanceof RAGResponse resp) {
            ("rag.doc_count").increment(().size());
        }
        
        return result;
    }
}

//java copy code@PostMapping("/query")
public RAGResponse handleQuery(@RequestBody QueryRequest request) {
    if (((), "V2_ENHANCED")) {
        return (());
    } else {
        return (());
    }
}

//java copy codepublic class Evaluator {
    // Calculate MRR (Average Reciprocal Ranking)    public double calculateMRR(List<TestCase> testCases) {
        return ()
            .mapToDouble(tc -> 1.0 / (getFirstRelevantRank(tc)+1))
            .average().orElse(0);
    }
    
    // Manual evaluation of quality generation    public void humanEvaluation(List<RAGResponse> samples) {
        // Integrate with the labeling platform    }
}