Use Cases

VectorIndexConfiguration config = VectorIndexConfiguration.builder()
    .dimension(1536)
    .similarityFunction(VectorSimilarityFunction.COSINE)
    .build();

VectorIndexConfiguration config = VectorIndexConfiguration.builder()
    .dimension(768)
    .similarityFunction(VectorSimilarityFunction.DOT_PRODUCT)
    .build();

VectorIndexConfiguration config = VectorIndexConfiguration.builder()
    .dimension(128)
    .similarityFunction(VectorSimilarityFunction.EUCLIDEAN)
    .build();

public class Product
{
    private long id;
    private String name;
    private String description;
    private float[] embedding;  // Generated from name + description
    // ...
}

public class ProductVectorizer extends Vectorizer<Product>
{
    @Override
    public float[] vectorize(Product product)
    {
        return product.getEmbedding();
    }

    @Override
    public boolean isEmbedded()
    {
        return true;
    }
}

// Configure index for product catalog
VectorIndexConfiguration config = VectorIndexConfiguration.builder()
    .dimension(768)                       // Common for text embedding models
    .similarityFunction(VectorSimilarityFunction.COSINE)
    .maxDegree(32)
    .beamWidth(200)
    .onDisk(true)
    .indexDirectory(Path.of("/data/product-embeddings"))
    .persistenceIntervalMs(60_000)
    .build();

// Register and create index
GigaMap<Product> products = GigaMap.New();
VectorIndices<Product> vectorIndices = products.index().register(VectorIndices.Category());
VectorIndex<Product> similarityIndex = vectorIndices.add("similarity", config, new ProductVectorizer());

// Find similar products
Product currentProduct = products.get(productId);
List<Product> similar = similarityIndex.search(currentProduct.getEmbedding(), 10)
    .stream()
    .filter(e -> e.entityId() != productId)  // Exclude current product
    .map(VectorSearchResult.Entry::entity)
    .toList();

public class Customer
{
    private long id;
    private String name;
    private float[] behaviorEmbedding;  // Generated from purchase history, browsing, etc.
    // ...
}

public class CustomerVectorizer extends Vectorizer<Customer>
{
    @Override
    public float[] vectorize(Customer customer)
    {
        return customer.getBehaviorEmbedding();
    }

    @Override
    public boolean isEmbedded()
    {
        return true;
    }
}

// Configure index for customer embeddings
VectorIndexConfiguration config = VectorIndexConfiguration.builder()
    .dimension(128)                       // Behavioral embeddings are often compact
    .similarityFunction(VectorSimilarityFunction.DOT_PRODUCT)
    .maxDegree(24)
    .beamWidth(150)
    .onDisk(true)
    .indexDirectory(Path.of("/data/customer-embeddings"))
    .enablePqCompression(true)            // Large customer bases benefit from compression
    .pqSubspaces(32)
    .persistenceIntervalMs(30_000)
    .build();

// Find lookalike customers
GigaMap<Customer> customers = GigaMap.New();
VectorIndices<Customer> vectorIndices = customers.index().register(VectorIndices.Category());
VectorIndex<Customer> behaviorIndex = vectorIndices.add("behavior", config, new CustomerVectorizer());

// Find customers similar to high-value customer segment
Customer targetCustomer = customers.get(customerId);
List<Customer> lookalikes = behaviorIndex.search(targetCustomer.getBehaviorEmbedding(), 100)
    .stream()
    .map(VectorSearchResult.Entry::entity)
    .toList();

public class SupportTicket
{
    private long id;
    private String subject;
    private String description;
    private String resolution;
    private float[] embedding;  // Generated from subject + description
    // ...
}

public class TicketVectorizer extends Vectorizer<SupportTicket>
{
    @Override
    public float[] vectorize(SupportTicket ticket)
    {
        return ticket.getEmbedding();
    }

    @Override
    public boolean isEmbedded()
    {
        return true;
    }
}

// Configure index for support tickets
VectorIndexConfiguration config = VectorIndexConfiguration.builder()
    .dimension(1536)                      // OpenAI embeddings
    .similarityFunction(VectorSimilarityFunction.COSINE)
    .maxDegree(48)                        // Higher recall for accurate matching
    .beamWidth(300)
    .onDisk(true)
    .indexDirectory(Path.of("/data/ticket-embeddings"))
    .persistenceIntervalMs(10_000)
    .minChangesBetweenPersists(5)
    .build();

// Find similar resolved tickets
GigaMap<SupportTicket> tickets = GigaMap.New();
VectorIndices<SupportTicket> vectorIndices = tickets.index().register(VectorIndices.Category());
VectorIndex<SupportTicket> ticketIndex = vectorIndices.add("content", config, new TicketVectorizer());

// Match new ticket to existing solutions
float[] newTicketEmbedding = embeddingService.embed(newTicket.getSubject() + " " + newTicket.getDescription());
List<SupportTicket> matches = ticketIndex.search(newTicketEmbedding, 5)
    .stream()
    .filter(e -> e.score() > 0.85f)       // High confidence matches only
    .filter(e -> e.entity().getResolution() != null)
    .map(VectorSearchResult.Entry::entity)
    .toList();

public class Article
{
    private long id;
    private String title;
    private String content;
    private String[] tags;
    private float[] embedding;
    // ...
}

// Configure index for content
VectorIndexConfiguration config = VectorIndexConfiguration.builder()
    .dimension(768)
    .similarityFunction(VectorSimilarityFunction.COSINE)
    .maxDegree(32)
    .beamWidth(200)
    .onDisk(true)
    .indexDirectory(Path.of("/data/content-embeddings"))
    .optimizationIntervalMs(300_000)
    .build();

// Find related articles
GigaMap<Article> articles = GigaMap.New();
VectorIndices<Article> vectorIndices = articles.index().register(VectorIndices.Category());
VectorIndex<Article> contentIndex = vectorIndices.add("content", config, new ArticleVectorizer());

// Get recommendations based on current article
Article current = articles.get(articleId);
List<Article> related = contentIndex.search(current.getEmbedding(), 6)
    .stream()
    .filter(e -> e.entityId() != articleId)
    .limit(5)
    .map(VectorSearchResult.Entry::entity)
    .toList();