Skip to main content
langchain4j-vector-stores-configuration Provides configuration patterns for LangChain4J vector stores in RAG applications. Use when building semantic search, integrating vector databases (PostgreSQL/pgvector, Pinecone, MongoDB, Milvus, Neo4j), implementing embedding storage/retrieval, setting up hybrid search, or optimizing vector database performance for production AI applications.
설치로 이동 Skills Marketplace 커뮤니티가 만든 AI 스킬을 발견하고 탐색하세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill langchain4j-vector-stores-configuration명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
Zip 다운로드 다운로드 중... 이 저장소의 다른 Skills Posts review findings from a JSON file as inline comments on a GitHub Pull Request, attaching each comment to its file and line. Use when you have a list/JSON of review findings (each with a file path, line number, and a message such as summary/failure_scenario) and want them published on a PR as inline review comments. Triggers include "post these review comments on the PR", "associate comments to files in the PR", "publish review findings to PR
typescript-security-review Provides security review capability for TypeScript/Node.js applications, validates code against XSS, injection, CSRF, JWT/OAuth2 flaws, dependency CVEs, and secrets exposure. Use when performing security audits, before deployment, reviewing authentication/authorization implementations, or ensuring OWASP compliance for Express, NestJS, and Next.js. Triggers on "security review", "check for security issues", "TypeScript security audit".
Initialize Spec-Driven Development context — detects tech stack, conventions, architecture patterns, and bootstraps persistence backends. Triggers on 'sdd-init', 'init sdd', 'setup sdd', 'initialize sdd', 'setup project', 'initialize project context'. Creates/updates docs/specs/architecture.md & ontology.md (Constitution), and populates knowledge-graph.json.
giuseppe-trisciuoglio
giuseppe-trisciuoglio/developer-kit
GitHub 저장소 열기 name langchain4j-vector-stores-configuration description Provides configuration patterns for LangChain4J vector stores in RAG applications. Use when building semantic search, integrating vector databases (PostgreSQL/pgvector, Pinecone, MongoDB, Milvus, Neo4j), implementing embedding storage/retrieval, setting up hybrid search, or optimizing vector database performance for production AI applications. allowed-tools Read, Write, Edit, Bash, Glob, Grep
LangChain4J Vector Stores Configuration
Configure vector stores for Retrieval-Augmented Generation applications with LangChain4J.
Overview
LangChain4J provides a unified abstraction for vector stores (PostgreSQL/pgvector, Pinecone, MongoDB Atlas, Milvus, Neo4j) with builder-based configuration, metadata filtering, and hybrid search support.
When to Use
Configuring vector stores for semantic search and RAG applications
Setting up embedding storage with metadata filtering and hybrid search
Optimizing vector database performance for production AI workloads
Instructions
Set Up Basic Vector Store
Configure an embedding store for vector operations:
@Bean
public EmbeddingStore<TextSegment> embeddingStore () {
return PgVectorEmbeddingStore.builder()
.host("localhost" )
.port(5432 )
.database("vectordb" )
.user("username" )
.password("password"
"embeddings"
1536
true
true
Validation Workflow Follow this workflow to ensure correct vector store setup:
Configure : Build the embedding store with required dimensions and connection parametersTest connection : Verify store connectivity with a health check before ingesting dataValidate dimensions : Confirm embedding model dimensions match store configurationIngest test data : Add a small batch of test documents to verify ingestion worksRun test query : Execute a sample semantic search to confirm retrieval accuracyProceed to production : Only after all steps pass, proceed with full data ingestion
Configure Multiple Vector Stores Use different stores for different use cases:
@Configuration
public class MultiVectorStoreConfiguration {
@Bean
@Qualifier("documentsStore")
public EmbeddingStore<TextSegment> documentsEmbeddingStore () {
return PgVectorEmbeddingStore.builder()
.table("document_embeddings" )
.dimension(1536 )
.build();
}
@Bean
@Qualifier("chatHistoryStore")
public EmbeddingStore<TextSegment> chatHistoryEmbeddingStore () {
return MongoDbEmbeddingStore.builder()
.collectionName("chat_embeddings" )
.build();
}
}
Implement Document Ingestion Use EmbeddingStoreIngestor for automated document processing:
@Bean
public EmbeddingStoreIngestor embeddingStoreIngestor (
EmbeddingStore<TextSegment> embeddingStore,
EmbeddingModel embeddingModel) {
return EmbeddingStoreIngestor.builder()
.documentSplitter(DocumentSplitters.recursive(
300 ,
20 ,
new OpenAiTokenizer (GPT_3_5_TURBO)
))
.embeddingModel(embeddingModel)
.embeddingStore(embeddingStore)
.build();
}
Set Up Metadata Filtering Configure metadata-based filtering capabilities:
IndexMapping indexMapping = IndexMapping.builder()
.dimension(1536 )
.metadataFieldNames(Set.of("category" , "source" , "created_date" , "author" ))
.build();
EmbeddingSearchRequest request = EmbeddingSearchRequest.builder()
.queryEmbedding(queryEmbedding)
.maxResults(10 )
.filter(and(
metadataKey("category" ).isEqualTo("technical_docs" ),
metadataKey("created_date" ).isGreaterThan(LocalDate.now().minusMonths(6 ))
))
.build();
Configure Production Settings Implement connection pooling and monitoring:
@Bean
public EmbeddingStore<TextSegment> optimizedPgVectorStore () {
HikariConfig hikariConfig = new HikariConfig ();
hikariConfig.setJdbcUrl("jdbc:postgresql://localhost:5432/vectordb" );
hikariConfig.setUsername("username" );
hikariConfig.setPassword("password" );
hikariConfig.setMaximumPoolSize(20 );
hikariConfig.setMinimumIdle(5 );
hikariConfig.setConnectionTimeout(30000 );
DataSource dataSource = new HikariDataSource (hikariConfig);
return PgVectorEmbeddingStore.builder()
.dataSource(dataSource)
.table("embeddings" )
.dimension(1536 )
.useIndex(true )
.build();
}
Implement Health Checks Monitor vector store connectivity:
@Component
public class VectorStoreHealthIndicator implements HealthIndicator {
private final EmbeddingStore<TextSegment> embeddingStore;
@Override
public Health health () {
try {
embeddingStore.search(EmbeddingSearchRequest.builder()
.queryEmbedding(new Embedding (Collections.nCopies(1536 , 0.0f )))
.maxResults(1 )
.build());
return Health.up()
.withDetail("store" , embeddingStore.getClass().getSimpleName())
.build();
} catch (Exception e) {
return Health.down()
.withDetail("error" , e.getMessage())
.build();
}
}
}
Examples
Basic RAG Application Setup @Configuration
public class SimpleRagConfig {
@Bean
public EmbeddingStore<TextSegment> embeddingStore () {
return PgVectorEmbeddingStore.builder()
.host("localhost" )
.database("rag_db" )
.table("documents" )
.dimension(1536 )
.build();
}
@Bean
public ChatLanguageModel chatModel () {
return OpenAiChatModel.withApiKey(System.getenv("OPENAI_API_KEY" ));
}
}
Semantic Search Service @Service
public class SemanticSearchService {
private final EmbeddingStore<TextSegment> store;
private final EmbeddingModel embeddingModel;
public List<String> search (String query, int maxResults) {
Embedding queryEmbedding = embeddingModel.embed(query).content();
EmbeddingSearchRequest request = EmbeddingSearchRequest.builder()
.queryEmbedding(queryEmbedding)
.maxResults(maxResults)
.minScore(0.75 )
.build();
return store.search(request).matches().stream()
.map(match -> match.embedded().text())
.toList();
}
}
Production Setup with Monitoring @Configuration
public class ProductionVectorStoreConfig {
@Bean
public EmbeddingStore<TextSegment> vectorStore (
@Value("${vector.store.host}") String host,
MeterRegistry meterRegistry) {
EmbeddingStore<TextSegment> store = PgVectorEmbeddingStore.builder()
.host(host)
.database("production_vectors" )
.useIndex(true )
.indexListSize(200 )
.build();
return new MonitoredEmbeddingStore <>(store, meterRegistry);
}
}
Best Practices
Choose the Right Vector Store
Use InMemoryEmbeddingStore for local development and testing
Fast setup, no external dependencies
Data lost on application restart
PostgreSQL + pgvector : Excellent for existing PostgreSQL environmentsPinecone : Managed service, good for rapid prototypingMongoDB Atlas : Good integration with existing MongoDB applicationsMilvus/Zilliz : High performance for large-scale deployments
Configure Appropriate Index Types Choose index types based on performance requirements:
.indexType(IndexType.FLAT)
.indexType(IndexType.IVF_FLAT)
.indexType(IndexType.HNSW)
Optimize Vector Dimensions Match embedding dimensions to your model:
.dimension(1536 )
.dimension(3072 )
.dimension(384 )
.dimension(768 )
Implement Batch Operations Use batch operations for better performance:
@Service
public class BatchEmbeddingService {
private static final int BATCH_SIZE = 100 ;
public void addDocumentsBatch (List<Document> documents) {
for (List<Document> batch : Lists.partition(documents, BATCH_SIZE)) {
List<TextSegment> segments = batch.stream()
.map(doc -> TextSegment.from(doc.text(), doc.metadata()))
.collect(Collectors.toList());
List<Embedding> embeddings = embeddingModel.embedAll(segments)
.content();
embeddingStore.addAll(embeddings, segments);
}
}
}
Secure Configuration Protect sensitive configuration:
@Value("${vector.store.api.key:#{null}}")
private String apiKey;
@PostConstruct
public void validateConfiguration () {
if (StringUtils.isBlank(apiKey)) {
throw new IllegalStateException ("Vector store API key must be configured" );
}
}
References For comprehensive documentation and advanced configurations, see:
Constraints and Warnings
Vector dimensions must match the embedding model; mismatched dimensions will cause errors.
Large vector collections require proper indexing configuration for acceptable search performance.
Embedding generation can be expensive; implement batching and caching strategies.
Different vector stores have different distance metric support; verify compatibility.
Connection pooling is critical for production deployments to prevent connection exhaustion.
Metadata filtering capabilities vary between vector store implementations.
Vector stores consume significant memory; monitor resource usage in production.
Migration between vector store providers may require re-embedding all documents.
Batch operations are more efficient than single-document operations.
Always validate configuration during application startup to fail fast.
