Spring AI Vector Stores

Spring AI - Vector Stores & Similarity Search

Description

Comprehensive guide for Vector Store implementations and similarity search operations. Covers 14+ supported backends (PostgreSQL, Pinecone, Milvus, etc.), CRUD operations, advanced filtering, and deployment patterns.

When to Use

• Storing and retrieving vector embeddings
• Similarity-based semantic search
• Implementing search with filtering
• Building RAG data sources
• Hybrid search (vector + keyword)
• Document clustering
• Recommendation systems
• Multi-tenant vector storage

Topics Covered

1. Supported Vector Store Backends

• PostgreSQL with pgvector: Open-source, cost-effective
• Pinecone: Managed SaaS solution
• Milvus: Open-source vector database
• Weaviate: Semantic search platform
• Chroma: Embedding database
• Qdrant: Vector search engine
• Vespa: Scalable vector search
• Azure AI Search: Azure-native solution
• Azure Cosmos DB: Vector similarity
• Redis: In-memory with vector support
• Simple In-Memory: For testing/prototyping
• Neo4j: Graph + vector search
• MongoDB: Vector embeddings in documents
• Cassandra: Distributed vector storage

2. VectorStore API

• add(List<Document>) - Add documents with embeddings
• delete(List<String> ids) - Remove documents
• similaritySearch(SearchRequest) - Query similar documents
• similaritySearch(String query, int topK) - Simple search
• Batch operations for efficiency
• Atomic transactions where supported

3. Vector Search Operations

• Top-K retrieval: Most similar N documents
• Similarity threshold: Only results above threshold
• Distance metrics: Cosine, Euclidean, etc.
• Neighbor search variants: KNN, approximate nearest neighbor

4. Advanced Filtering

• SQL-like filter syntax: country == 'USA' && age > 25
• Filter expressions: AND, OR, NOT operations
• Field type support: String, number, date
• Nested filtering: Complex query logic
• Filter + vector search: Combined queries

5. Document Metadata

• Storing additional fields with embeddings
• Structured metadata (tags, source, timestamps)
• Metadata extraction during retrieval
• Filtering by metadata
• Nested document structures

6. Search Strategies

• Dense retrieval: Vector similarity only
• Hybrid search: Vector + keyword/BM25
• Multi-vector search: Multiple embedding fields
• Reranking strategies: Post-processing results
• Fusion techniques: Combining multiple searches

Code Patterns

Initialize Vector Store

@Configuration
public class VectorStoreConfig {
    @Bean
    public VectorStore vectorStore(
            EmbeddingModel embeddingModel,
            JdbcTemplate jdbc) {
        return new PgVectorStore(jdbc, embeddingModel);
    }
}

Add Documents

List<Document> documents = List.of(
    new Document("Spring Boot guide", Map.of(
        "source", "docs/spring-boot.md",
        "version", "3.0"
    )),
    new Document("Spring AI tutorial", Map.of(
        "source", "docs/spring-ai.md",
        "category", "ai"
    ))
);
vectorStore.add(documents);

Similarity Search

// Simple top-K search
List<Document> results = vectorStore.similaritySearch(
    "Spring Framework best practices",
    5
);

// With threshold
List<Document> results = vectorStore.similaritySearch(
    SearchRequest.query("AI development")
        .withTopK(10)
        .withSimilarityThreshold(0.75)
);

Advanced Filtering

SearchRequest request = SearchRequest.query("machine learning")
    .withTopK(5)
    .withFilterExpression("source == 'blog' && rating > 4")
    .withSimilarityThreshold(0.7);

List<Document> results = vectorStore.similaritySearch(request);

Hybrid Search

// PostgreSQL with BM25 + Vector
var results = vectorStore.similaritySearch(
    SearchRequest.query("Spring Cloud")
        .withTopK(10)
        .withHybridSearch(true)
        .withKeywordSearchWeight(0.3)
        .withSemanticSearchWeight(0.7)
);

Bulk Operations

// Batch add for performance
List<Document> batch = loadDocuments();
vectorStore.add(batch);

// Delete with filter
vectorStore.delete(
    List.of("doc-id-1", "doc-id-2", "doc-id-3")
);

Configuration Examples

PostgreSQL pgvector

spring.datasource.url=jdbc:postgresql://localhost/vectordb
spring.datasource.username=postgres
spring.ai.vectorstore.pgvector.create-table=true
spring.ai.vectorstore.pgvector.schema-name=public

Pinecone

spring.ai.vectorstore.pinecone.api-key=${PINECONE_API_KEY}
spring.ai.vectorstore.pinecone.index=my-index
spring.ai.vectorstore.pinecone.namespace=production

Qdrant

spring.ai.vectorstore.qdrant.host=localhost
spring.ai.vectorstore.qdrant.port=6333
spring.ai.vectorstore.qdrant.collection-name=documents

Design Patterns

1. Document Chunking + Embedding

Raw Document → Split into Chunks → Embed → Store with Metadata

2. Search + Reranking

User Query → Vector Search (Top 100) → Rerank → Return Top 10

3. Hybrid Search

Query → Parallel[Vector Search, Keyword Search] → Merge Results → Deduplicate

Performance Considerations

• Index optimization per backend
• Batch size tuning
• Dimensionality impact
• Query complexity
• Caching strategies
• Scaling horizontally vs vertically

Related Skills

• embeddings/SKILL.md - Creating embeddings
• rag-retrieval/SKILL.md - RAG with vector stores
• document-processing/SKILL.md - Chunking strategies
• advisors/SKILL.md - RAG advisor integration

References

• API: /pages/api/vectordbs.adoc
• Search: /pages/api/retrieval-augmented-generation.adoc
• Backend setup: Provider-specific documentation
• Filtering: /pages/api/vectordbs.adoc (filter expression section)