# Spring AI Vector Stores

> A comprehensive guide for Vector Store implementations and similarity search, covering 14+ backends, CRUD operations, and advanced filtering.

- Skill: `mat-garcia/spring-ai-vector-stores` (Agent Skill)
- Install (CLI): `npx skillmds@latest add mat-garcia/spring-ai-vector-stores`
- Raw SKILL.md: https://api.skillmd.com/api/skills/mat-garcia/spring-ai-vector-stores/raw
- Safety review: pending (external: skill-scanner PASS, skillspector PASS)
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: Complete terms in LICENSE.txt
- Author: mat-garcia (https://skillmd.com/u/mat-garcia)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/mat-garcia/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

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

### Add Documents

```java
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

```java
// 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

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

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

### Hybrid Search

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

### Bulk Operations

```java
// 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

```properties
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

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

### Qdrant

```properties
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)