Scoring Model Examples

import dev.langchain4j.model.vertexai.VertexAiScoringModel;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.output.Response;

VertexAiScoringModel model = VertexAiScoringModel.builder()
    .projectId("your-project-id")
    .projectNumber("123456789012")
    .location("us-central1")
    .model("semantic-ranker-512@latest")
    .build();

String query = "What is machine learning?";

List<TextSegment> documents = List.of(
    TextSegment.from("Machine learning is a branch of artificial intelligence..."),
    TextSegment.from("Deep learning uses neural networks with multiple layers..."),
    TextSegment.from("Supervised learning requires labeled training data...")
);

Response<List<Double>> response = model.scoreAll(documents, query);
List<Double> scores = response.content();

for (int i = 0; i < scores.size(); i++) {
    System.out.println("Document " + i + " score: " + scores.get(i));
}

import java.util.stream.IntStream;
import java.util.stream.Collectors;

String query = "best practices for Java development";

List<TextSegment> documents = List.of(
    TextSegment.from("Java coding standards and conventions"),
    TextSegment.from("Introduction to Python programming"),
    TextSegment.from("Effective Java design patterns"),
    TextSegment.from("JavaScript frameworks comparison")
);

Response<List<Double>> response = model.scoreAll(documents, query);
List<Double> scores = response.content();

// Create ranked list (highest score first)
List<Integer> rankedIndices = IntStream.range(0, scores.size())
    .boxed()
    .sorted((i, j) -> Double.compare(scores.get(j), scores.get(i)))
    .collect(Collectors.toList());

System.out.println("Documents ranked by relevance:");
for (int rank = 0; rank < rankedIndices.size(); rank++) {
    int docIndex = rankedIndices.get(rank);
    System.out.println("Rank " + (rank + 1) + ": Document " + docIndex +
                       " (score: " + scores.get(docIndex) + ")");
}

import dev.langchain4j.data.document.Metadata;

List<TextSegment> documents = List.of(
    TextSegment.from(
        "Content about neural networks and deep learning architectures...",
        Metadata.from("title", "Deep Learning Guide")
    ),
    TextSegment.from(
        "Content about machine learning algorithms and techniques...",
        Metadata.from("title", "ML Fundamentals")
    ),
    TextSegment.from(
        "Content about data preprocessing and feature engineering...",
        Metadata.from("title", "Data Science Basics")
    )
);

String query = "neural network architectures";

Response<List<Double>> response = model.scoreAll(documents, query);
List<Double> scores = response.content();
// Model uses titles for better relevance scoring

VertexAiScoringModel model = VertexAiScoringModel.builder()
    .projectId("your-project-id")
    .projectNumber("123456789012")
    .location("us-central1")
    .model("semantic-ranker-512@latest")
    .titleMetadataKey("document_title")  // Custom key
    .build();

TextSegment doc = TextSegment.from(
    "Content...",
    Metadata.from("document_title", "My Document")  // Use same key
);

VertexAiScoringModel model = new VertexAiScoringModel(
    "your-project-id",              // projectId
    "123456789012",                 // projectNumber
    "us-central1",                  // location
    "semantic-ranker-512@latest",   // model
    "title"                         // titleMetadataKey
);

// 1. Initial search returns candidates
List<TextSegment> searchResults = performInitialSearch(userQuery);

// 2. Re-rank using scoring model
Response<List<Double>> scores = model.scoreAll(searchResults, userQuery);

// 3. Return top-N results
List<TextSegment> topResults = selectTopN(searchResults, scores.content(), 10);

String question = "How does photosynthesis work?";
List<TextSegment> knowledgeBase = loadDocuments();

// Score all documents against question
Response<List<Double>> response = model.scoreAll(knowledgeBase, question);
List<Double> scores = response.content();

// Select top-3 most relevant documents for context
List<TextSegment> context = selectTopN(knowledgeBase, scores, 3);

// Use context with language model
String contextText = context.stream()
    .map(TextSegment::text)
    .collect(Collectors.joining("\n\n"));
String prompt = "Context:\n" + contextText + "\n\nQuestion: " + question;

String userInterest = "renewable energy technologies";
List<TextSegment> articles = loadArticles();

Response<List<Double>> response = model.scoreAll(articles, userInterest);
List<Double> scores = response.content();

// Recommend articles with score above threshold
double threshold = 0.7;
List<TextSegment> recommendations = new ArrayList<>();
for (int i = 0; i < scores.size(); i++) {
    if (scores.get(i) >= threshold) {
        recommendations.add(articles.get(i));
    }
}

Response<List<Double>> response = model.scoreAll(documents, query);
List<Double> scores = response.content();

// Keep only high-scoring documents
List<TextSegment> relevantDocs = new ArrayList<>();
for (int i = 0; i < scores.size(); i++) {
    if (scores.get(i) > 0.5) {  // Threshold
        relevantDocs.add(documents.get(i));
    }
}

List<String> queries = List.of("AI", "ML", "DL");
List<TextSegment> corpus = loadCorpus();

for (String query : queries) {
    Response<List<Double>> response = model.scoreAll(corpus, query);
    System.out.println("Query: " + query);
    System.out.println("Scores: " + response.content());
    System.out.println();
}

try {
    Response<List<Double>> response = model.scoreAll(documents, query);
    List<Double> scores = response.content();
} catch (Exception e) {
    System.err.println("Scoring failed: " + e.getMessage());
}

// 1. Use embeddings for initial filtering (fast)
List<TextSegment> candidates = embeddingSearch(query, allDocuments, 100);

// 2. Use scoring model for precise re-ranking (slower but more accurate)
Response<List<Double>> response = model.scoreAll(candidates, query);
List<Double> scores = response.content();

// 3. Return top results
List<TextSegment> finalResults = selectTopN(candidates, scores, 10);

public static <T> List<T> selectTopN(
    List<T> items,
    List<Double> scores,
    int n
) {
    List<Integer> indices = IntStream.range(0, scores.size())
        .boxed()
        .sorted((i, j) -> Double.compare(scores.get(j), scores.get(i)))
        .limit(n)
        .collect(Collectors.toList());

    return indices.stream()
        .map(items::get)
        .collect(Collectors.toList());
}