To build semantic search in Java, turn document passages and user queries into embeddings, store the passages and vectors in a vector store, then retrieve passages whose vectors are close to the query vector. Frameworks such as Spring AI and LangChain4j provide Java-facing abstractions; PostgreSQL with PGVector, OpenSearch, and Elasticsearch are among the backend options. The right setup depends on your existing stack and whether you need exact keyword matches alongside semantic relevance.
How Java semantic search works
An embedding model converts text into a numeric vector, often represented in Java as a float[]. Texts with related meaning tend to have vectors that are close under a chosen distance or similarity measure. A vector store persists the vectors along with document text and, commonly, metadata, then finds records near a supplied query vector. These are separate responsibilities: the embedding model creates representations, while the store indexes and retrieves them. Spring AI’s vector database reference describes this division.
As an Amazon Associate I earn from qualifying purchases.
A typical application has two flows. During ingestion, it prepares and splits source material, embeds passages, and stores them. At query time, it embeds the user’s query, searches for similar passages, and passes useful results to the application—or to a retrieval-augmented generation (RAG) pipeline. Semantic retrieval can find relevant wording that does not exactly match the query, but it does not guarantee that every returned passage is useful or that exact names and identifiers will rank well.
Choose the Java abstraction and backend
Start with the framework that fits the rest of the application, then check whether its store integration exposes the operations you need. An abstraction can make application code less dependent on a particular backend, but backend-specific features may still require that backend’s native client.
| Option | Consider it when | Check before choosing |
|---|---|---|
| Spring AI with PostgreSQL and PGVector | Your application already uses PostgreSQL and you want vector retrieval alongside relational data. | Extension and schema setup, embedding dimensions, metadata behavior, index choice, and performance on your workload. Spring AI documents exact and approximate search options. PGVector reference |
| OpenSearch | Your team already operates OpenSearch or wants its semantic-search and ingest workflows. | Model setup, index mapping and dimensions, and whether automated or manual setup better fits your need for speed or control. Semantic search documentation |
| Elasticsearch | You want vector retrieval integrated with full-text search, filters, and other search operations. | Whether a managed semantic-text workflow or a more customized route suits the application, and how hybrid retrieval performs for your queries. Vector search documentation |
| Spring AI or LangChain4j | You are choosing the Java framework integration rather than the search backend itself. | Fit with the surrounding application, current release compatibility, available store integrations, and whether required operations need a native client. Spring AI integrations; LangChain4j embedding stores |
Spring AI provides a VectorStore abstraction and describes documents as text plus key-value metadata. LangChain4j documents a PgVectorEmbeddingStore integration and examples for multiple stores. For the exact dependency coordinates and configuration, use the current framework documentation rather than copying a version from an older example. The LangChain4j PGVector page currently displays dev.langchain4j:langchain4j-pgvector:1.21.0-beta31; that is a page-specific beta version, not a general stable-version recommendation. LangChain4j PGVector integration
Build the ingestion flow
- Collect source content and useful metadata. Create records that preserve the text to retrieve and identifiers such as source ID, title, section, date, or access-control attributes. Metadata can support filtering and help the application identify where a result came from.
- Split long material into passages. Embed retrieval-sized chunks rather than assuming a whole book, manual, or large page should be one record. OpenSearch’s documented workflow applies text chunking before its text-embedding processor. Chunk size and overlap depend on the corpus and the questions users ask; the cited documentation does not establish universal values. OpenSearch semantic search
- Embed and write the records. With Spring AI, the general pattern is to load source material into
Documentobjects and add them to aVectorStore; the store integration handles embedding and persistence according to its configuration. Keep the embedding model and its configuration consistent with the query path. Spring AI vector databases - Verify the schema and dimensions. The vector field’s configured dimension must equal the embedding model’s output dimension. A mismatch prevents compatible storage or comparison. In Spring AI’s PGVector configuration, changing the vector dimension can require recreating the vector table. Spring AI PGVector
Configure PGVector with Spring AI
The Spring AI PGVector reference lists the spring-ai-starter-vector-store-pgvector starter, a PostgreSQL data source, and an EmbeddingModel among the setup components. It documents configuration for dimensions, distance type, and index type. Its sample uses HNSW and cosine distance; those are example choices, not universal recommendations. Check the current Spring AI release train for compatible dependency management and exact configuration properties. Spring AI PGVector setup
Rank #2
Do not assume the starter creates the database schema automatically. Schema initialization is opt-in in the current Spring AI reference, so configure it explicitly if you want Spring AI to initialize the schema; otherwise, provision the required schema through your database-management process. Review the generated schema and permissions as part of deployment.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Once the store is configured, the documented application pattern is to add documents and call similaritySearch with a query and a top-K setting. Spring AI also exposes similarity-threshold and metadata-filter controls. Treat these as tuning controls, not self-validating relevance guarantees: a threshold that works for one model or corpus may be unsuitable for another. Spring AI search controls
Choose exact or approximate vector indexing
Spring AI’s PGVector configuration documents three index choices: NONE for exact nearest-neighbor search, IVFFlat, and HNSW. Approximate indexes can reduce query work on larger collections, but their setup and resource trade-offs matter.
- Exact search (
NONE): compares vectors without an approximate index. It is a useful baseline for smaller collections or for measuring the effect of approximation, though its query cost may not suit every scale. - IVFFlat: Spring AI describes it as faster to build and lower-memory than HNSW. Evaluate its retrieval quality and query latency on representative data before choosing it.
- HNSW: Spring AI describes it as using more memory and taking longer to build than IVFFlat, with a better speed-recall trade-off and no training step. The actual trade-off depends on the workload and configuration.
These are qualitative comparisons from the framework documentation, not performance measurements for your deployment. Benchmark with the intended corpus and representative queries, measuring latency and whether expected relevant passages appear. PGVector index options
Rank #4
Query for meaning and exact terms
At query time, produce a query vector compatible with the vectors used during ingestion, retrieve a manageable candidate set, and apply metadata filters when the user or application requires a constrained search. Keep the model and vector dimension aligned: OpenSearch calls out setting output_dimension when the model’s output differs from the workflow template default, and Elasticsearch likewise requires query and stored vectors to have compatible dimensions. OpenSearch dimensions; Elasticsearch vector search
Pure vector similarity is not always the best retrieval method. If a query contains a product code, person’s name, error identifier, or rare phrase, exact lexical matching may be important. Compare vector-only retrieval with hybrid lexical-plus-vector retrieval on those cases. Elastic documents combining meaning-based vector search with keyword full-text matching, filters, and other search operations in one engine. LangChain4j’s PGVector guide also documents hybrid search that uses both an embedding and query text. Elastic vector search; LangChain4j PGVector
Best Value
Evaluate relevance before tuning production settings
Build a small evaluation set from real user questions and the passages your application should retrieve. For each query, record the expected relevant passages, then compare retrieval configurations rather than relying on a plausible-looking result from a single test.
- Check whether relevant passages appear near the top of results, including for queries phrased differently from the source text.
- Include exact-name, identifier, and rare-term queries to expose cases where lexical matching or hybrid retrieval may help.
- Test metadata filters and access restrictions alongside semantic relevance; a relevant result that should not be visible is still a failure.
- Compare top-K and threshold settings on the same queries, then measure latency and resource use under expected load.
- Re-run the evaluation after changing the embedding model, chunking strategy, dimensions, index, or retrieval settings.
Neither the framework references nor the backend documentation establish a universally correct chunk size, overlap, top-K, threshold, index, or benchmark result for Java applications. Select them against your own corpus, relevance expectations, and operating constraints.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →
