feat(summarization): add extractive summarization for SubEM evaluation

Implement BERT-based extractive summarization that preserves exact entity
names, addressing the Long-Range Understanding (LRU) benchmark failure
caused by abstractive summarization paraphrasing entity names.

New classes in com.redis.vl.extensions.summarization:
- ExtractiveSelector: K-means sentence selection using BERT embeddings
- SentenceSplitter: OpenNLP-based sentence detection
- EmbeddedSentence: Clusterable wrapper for k-means algorithm

Algorithm:
1. Split document into sentences using OpenNLP
2. Embed sentences with SentenceTransformers/BERT
3. Cluster using k-means++ (Apache Commons Math3)
4. Select sentence closest to each cluster centroid
5. Return sentences in original order (preserves exact text)

Key benefit: Unlike abstractive summarization which paraphrases
("Jennifer" -> "the protagonist"), extractive summarization preserves
verbatim text, enabling SubEM matching to succeed.

Dependencies added:
- org.apache.opennlp:opennlp-tools:2.3.0
- org.apache.commons:commons-math3:3.6.1

Author: bsbodden

core/build.gradle.kts

@@ -25,6 +25,12 @@ dependencies {
     implementation("com.google.guava:guava:33.4.0-jre")
     implementation("com.github.f4b6a3:ulid-creator:5.2.3")
 
+    // For extractive summarization - sentence splitting
+    implementation("org.apache.opennlp:opennlp-tools:2.3.0")
+
+    // For k-means clustering in extractive summarization
+    implementation("org.apache.commons:commons-math3:3.6.1")
+
     // Lombok for reducing boilerplate
     compileOnly("org.projectlombok:lombok:1.18.36")
     annotationProcessor("org.projectlombok:lombok:1.18.36")

core/src/main/java/com/redis/vl/extensions/summarization/EmbeddedSentence.java

@@ -0,0 +1,60 @@
+package com.redis.vl.extensions.summarization;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import org.apache.commons.math3.ml.clustering.Clusterable;
+
+/** A sentence with its embedding, implementing Clusterable for k-means. */
+public class EmbeddedSentence implements Clusterable {
+
+  private final int index;
+  private final double[] embedding;
+
+  /**
+   * Create an embedded sentence.
+   *
+   * @param index Original index in the sentence list (for preserving order)
+   * @param embedding The BERT embedding as float array
+   */
+  public EmbeddedSentence(int index, float[] embedding) {
+    this.index = index;
+    this.embedding = toDoubleArray(embedding);
+  }
+
+  private static double[] toDoubleArray(float[] floats) {
+    double[] doubles = new double[floats.length];
+    for (int i = 0; i < floats.length; i++) {
+      doubles[i] = floats[i];
+    }
+    return doubles;
+  }
+
+  /** Get the original index of this sentence. */
+  public int index() {
+    return index;
+  }
+
+  /** Get the embedding as double array (required by Clusterable). */
+  @Override
+  @SuppressFBWarnings(
+      value = "EI_EXPOSE_REP",
+      justification = "Clusterable interface requires direct array access for k-means performance")
+  public double[] getPoint() {
+    return embedding;
+  }
+
+  /** Calculate cosine similarity with another embedded sentence. */
+  public double cosineSimilarity(EmbeddedSentence other) {
+    double dotProduct = 0.0;
+    double normA = 0.0;
+    double normB = 0.0;
+
+    for (int i = 0; i < embedding.length; i++) {
+      dotProduct += embedding[i] * other.embedding[i];
+      normA += embedding[i] * embedding[i];
+      normB += other.embedding[i] * other.embedding[i];
+    }
+
+    if (normA == 0 || normB == 0) return 0.0;
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+}

core/src/main/java/com/redis/vl/extensions/summarization/ExtractiveSelector.java

@@ -0,0 +1,209 @@
+package com.redis.vl.extensions.summarization;
+
+import com.redis.vl.utils.vectorize.SentenceTransformersVectorizer;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.IntStream;
+import org.apache.commons.math3.ml.clustering.CentroidCluster;
+import org.apache.commons.math3.ml.clustering.KMeansPlusPlusClusterer;
+
+/**
+ * BERT-based extractive summarization using sentence clustering.
+ *
+ * <p>This class selects the most representative sentences from a document by embedding sentences
+ * with BERT, clustering them with k-means, and selecting the sentence closest to each cluster
+ * centroid.
+ *
+ * <p><b>Key Feature:</b> Preserves original text exactly, which is critical for SubEM (Substring
+ * Exact Match) evaluation where paraphrasing fails.
+ *
+ * <h2>Example Usage:</h2>
+ *
+ * <pre>{@code
+ * SentenceTransformersVectorizer vectorizer = SentenceTransformersVectorizer.builder()
+ *     .modelName("all-MiniLM-L6-v2")
+ *     .build();
+ *
+ * ExtractiveSelector selector = new ExtractiveSelector(vectorizer);
+ * SentenceSplitter splitter = new SentenceSplitter();
+ *
+ * String document = "Long document text...";
+ * List<String> sentences = splitter.split(document);
+ * List<String> keySentences = selector.selectKeySentences(sentences, 10);
+ *
+ * // keySentences contains the 10 most representative sentences
+ * // in their original order, with exact original text preserved
+ * }</pre>
+ */
+public class ExtractiveSelector {
+
+  private final SentenceTransformersVectorizer embedder;
+  private final int defaultNumSentences;
+  private final int maxIterations;
+
+  /**
+   * Create an extractive selector with default settings.
+   *
+   * @param embedder The sentence transformer vectorizer for embeddings
+   */
+  public ExtractiveSelector(SentenceTransformersVectorizer embedder) {
+    this(embedder, 10, 100);
+  }
+
+  /**
+   * Create an extractive selector with custom number of sentences.
+   *
+   * @param embedder The sentence transformer vectorizer for embeddings
+   * @param defaultNumSentences Default number of sentences to select
+   */
+  public ExtractiveSelector(SentenceTransformersVectorizer embedder, int defaultNumSentences) {
+    this(embedder, defaultNumSentences, 100);
+  }
+
+  /**
+   * Create an extractive selector with full configuration.
+   *
+   * @param embedder The sentence transformer vectorizer for embeddings
+   * @param defaultNumSentences Default number of sentences to select
+   * @param maxIterations Maximum k-means iterations
+   */
+  @SuppressFBWarnings(
+      value = "EI_EXPOSE_REP2",
+      justification = "Embedder is intentionally shared; it's a heavyweight resource")
+  public ExtractiveSelector(
+      SentenceTransformersVectorizer embedder, int defaultNumSentences, int maxIterations) {
+    this.embedder = embedder;
+    this.defaultNumSentences = defaultNumSentences;
+    this.maxIterations = maxIterations;
+  }
+
+  /**
+   * Select the most representative sentences using the default count.
+   *
+   * @param sentences List of sentences to select from
+   * @return Selected sentences in original order
+   */
+  public List<String> selectKeySentences(List<String> sentences) {
+    return selectKeySentences(sentences, defaultNumSentences);
+  }
+
+  /**
+   * Select the k most representative sentences from the input.
+   *
+   * <p>Algorithm:
+   *
+   * <ol>
+   *   <li>Embed all sentences using BERT
+   *   <li>Cluster embeddings using k-means++
+   *   <li>For each cluster, select the sentence closest to the centroid
+   *   <li>Return sentences in their original order
+   * </ol>
+   *
+   * @param sentences List of sentences to select from
+   * @param k Number of sentences to select
+   * @return Selected sentences in original order (preserves exact text)
+   */
+  public List<String> selectKeySentences(List<String> sentences, int k) {
+    if (sentences == null || sentences.isEmpty()) {
+      return List.of();
+    }
+
+    // If we have fewer sentences than k, return all
+    if (sentences.size() <= k) {
+      return new ArrayList<>(sentences);
+    }
+
+    // Filter out empty/whitespace sentences
+    List<IndexedSentence> validSentences =
+        IntStream.range(0, sentences.size())
+            .filter(i -> sentences.get(i) != null && !sentences.get(i).isBlank())
+            .mapToObj(i -> new IndexedSentence(i, sentences.get(i)))
+            .toList();
+
+    if (validSentences.size() <= k) {
+      return validSentences.stream().map(IndexedSentence::text).toList();
+    }
+
+    // 1. Embed all sentences
+    List<String> textsToEmbed = validSentences.stream().map(IndexedSentence::text).toList();
+    List<float[]> embeddings = embedder.embedSentences(textsToEmbed);
+
+    // 2. Create clusterable points
+    List<EmbeddedSentence> points =
+        IntStream.range(0, validSentences.size())
+            .mapToObj(i -> new EmbeddedSentence(validSentences.get(i).index(), embeddings.get(i)))
+            .toList();
+
+    // 3. K-means++ clustering
+    KMeansPlusPlusClusterer<EmbeddedSentence> clusterer =
+        new KMeansPlusPlusClusterer<>(k, maxIterations);
+    List<CentroidCluster<EmbeddedSentence>> clusters = clusterer.cluster(points);
+
+    // 4. Select sentence closest to each cluster centroid
+    List<Integer> selectedIndices =
+        clusters.stream()
+            .map(this::findClosestToCentroid)
+            .map(EmbeddedSentence::index)
+            .sorted() // Preserve original order
+            .toList();
+
+    // 5. Return original sentences
+    return selectedIndices.stream().map(sentences::get).toList();
+  }
+
+  /** Find the sentence closest to the cluster centroid. */
+  private EmbeddedSentence findClosestToCentroid(CentroidCluster<EmbeddedSentence> cluster) {
+    double[] centroid = cluster.getCenter().getPoint();
+
+    return cluster.getPoints().stream()
+        .min(Comparator.comparingDouble(point -> euclideanDistance(point.getPoint(), centroid)))
+        .orElseThrow(() -> new IllegalStateException("Empty cluster"));
+  }
+
+  /** Calculate Euclidean distance between two points. */
+  private double euclideanDistance(double[] a, double[] b) {
+    double sum = 0.0;
+    for (int i = 0; i < a.length; i++) {
+      double diff = a[i] - b[i];
+      sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+  }
+
+  /** Helper record to track original indices. */
+  private record IndexedSentence(int index, String text) {}
+
+  /** Builder for ExtractiveSelector. */
+  public static Builder builder(SentenceTransformersVectorizer embedder) {
+    return new Builder(embedder);
+  }
+
+  public static class Builder {
+    private final SentenceTransformersVectorizer embedder;
+    private int defaultNumSentences = 10;
+    private int maxIterations = 100;
+
+    @SuppressFBWarnings(
+        value = "EI_EXPOSE_REP2",
+        justification = "Embedder is intentionally shared; it's a heavyweight resource")
+    public Builder(SentenceTransformersVectorizer embedder) {
+      this.embedder = embedder;
+    }
+
+    public Builder defaultNumSentences(int n) {
+      this.defaultNumSentences = n;
+      return this;
+    }
+
+    public Builder maxIterations(int n) {
+      this.maxIterations = n;
+      return this;
+    }
+
+    public ExtractiveSelector build() {
+      return new ExtractiveSelector(embedder, defaultNumSentences, maxIterations);
+    }
+  }
+}

core/src/main/java/com/redis/vl/extensions/summarization/SentenceSplitter.java

@@ -0,0 +1,75 @@
+package com.redis.vl.extensions.summarization;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import opennlp.tools.sentdetect.SentenceDetectorME;
+import opennlp.tools.sentdetect.SentenceModel;
+
+/** OpenNLP-based sentence splitting utility. Thread-safe after initialization. */
+public class SentenceSplitter {
+
+  private final SentenceDetectorME detector;
+
+  /**
+   * Create a sentence splitter using the default English model. The model is loaded from the
+   * classpath.
+   */
+  public SentenceSplitter() {
+    this(loadDefaultModel());
+  }
+
+  /**
+   * Create a sentence splitter with a custom model.
+   *
+   * @param model The OpenNLP sentence model to use
+   */
+  public SentenceSplitter(SentenceModel model) {
+    this.detector = new SentenceDetectorME(model);
+  }
+
+  private static SentenceModel loadDefaultModel() {
+    try (InputStream modelIn =
+        SentenceSplitter.class.getResourceAsStream("/models/opennlp/en-sent.bin")) {
+      if (modelIn == null) {
+        throw new IllegalStateException(
+            "OpenNLP English sentence model not found. "
+                + "Ensure 'en-sent.bin' is in resources/models/opennlp/");
+      }
+      return new SentenceModel(modelIn);
+    } catch (IOException e) {
+      throw new IllegalStateException("Failed to load OpenNLP sentence model", e);
+    }
+  }
+
+  /**
+   * Split text into sentences.
+   *
+   * @param text The text to split
+   * @return List of sentences
+   */
+  public List<String> split(String text) {
+    if (text == null || text.isBlank()) {
+      return List.of();
+    }
+    synchronized (detector) {
+      return Arrays.asList(detector.sentDetect(text));
+    }
+  }
+
+  /**
+   * Split text into sentences with position spans.
+   *
+   * @param text The text to split
+   * @return Array of Span objects with start/end positions
+   */
+  public opennlp.tools.util.Span[] splitWithSpans(String text) {
+    if (text == null || text.isBlank()) {
+      return new opennlp.tools.util.Span[0];
+    }
+    synchronized (detector) {
+      return detector.sentPosDetect(text);
+    }
+  }
+}

core/src/main/java/com/redis/vl/utils/vectorize/SentenceTransformersVectorizer.java

@@ -172,6 +172,20 @@ public List<List<Float>> embedBatchAsLists(List<String> texts) {
     return result;
   }
 
+  /**
+   * Embed multiple sentences for clustering/selection. Useful for extractive summarization where we
+   * need to compare sentence similarities.
+   *
+   * @param sentences List of sentences to embed
+   * @return List of embedding vectors (float arrays)
+   */
+  public List<float[]> embedSentences(List<String> sentences) {
+    if (sentences == null || sentences.isEmpty()) {
+      return List.of();
+    }
+    return generateEmbeddingsBatch(sentences, 32);
+  }
+
   private List<Float> floatArrayToList(float[] array) {
     List<Float> list = new ArrayList<>(array.length);
     for (float value : array) {