AWS Builder Center

Semantic Search, Minus the Ops

How a single field-mapping setting brings intent-aware search to managed Amazon OpenSearch domains, using a service-managed sparse model that does its work at index time so queries stay as fast as keyword search.

A customer types "shoes for the beach" into your store's search bar. Your catalog has exactly what they want — a pair of water-resistant sandals, a listing for surf footwear. They see none of it. The search returns nothing useful, the customer bounces, and you never even know it happened.
This is the quiet failure mode of lexical search. It matches words, not meaning. "Shoes," "beach," "for," "the" — it dutifully hunts for those exact tokens and skips the "sandals", because nobody wrote the word "shoes" in that listing. For product codes and model numbers, word-matching is perfect. For the way people talk, it can miss.
Traditionally, closing this gap meant building a pipeline. You'd pick an embedding model, stand up an inference endpoint, wire ingest pipelines to vectorize every document, rewrite your queries into k-NN (k-nearest neighbors) requests, and tune the hybrid scoring until it felt right. Semantic search worked — but it was a project, not a feature.

One Line Instead of a Pipeline

 Amazon OpenSearch Service 's Automatic Semantic Enrichment (ASE) collapses that whole pipeline into a single setting. On a managed domain running OpenSearch 2.19 or later, you mark a text field as semantically enriched — and that's the entire integration.
"title": {
"type": "text",
"semantic_enrichment": {
"status": "ENABLED",
"language_options": "english"
}
}

Behind that one block, the service quietly provisions a managed sparse model, builds the ingest pipeline that enriches your documents, and creates a search pipeline that rewrites your queries. You don't host a model. You don't manage an endpoint. You don't touch your query code.

The Clever Part: Do the Work Once

Here's the design decision that makes ASE fast as well as simple. The sparse model runs only when you index a document. It reads your text and expands it into a set of weighted terms — the original words plus the related ones it learned in training, so "beach shoes" quietly gains "sandals," "footwear," "waterproof." Those enriched terms live in OpenSearch's native Lucene index, right alongside the original text.
This is worth pausing on, because it's different from the embedding approach most people picture. A dense embedding model turns each document into one fixed-length vector of floating-point numbers — a point in high-dimensional space — and search means finding nearby points, usually with an approximate nearest-neighbor index like HNSW. ASE's model is sparse instead: rather than a dense coordinate, it emits a list of actual terms, each with a learned weight. Because those terms are just weighted tokens, they slot into the same inverted index Lucene already uses for keyword search. There's no separate vector index to provision, size, or keep warm in memory — the semantic signal rides along with the lexical one.
At search time, the model doesn't run at all. The incoming query is simply tokenized and matched against that already-enriched index. All the expensive thinking happened earlier, during ingestion, so queries stay lean.
This is called  document-only mode , and it's the key concept of the design. In a full neural-sparse setup, the model would also expand the query at search time — enriching "sandals for water" with its own related terms before matching. ASE deliberately skips that step. The query is tokenized, nothing more. That's what keeps a semantic query as cheap as a lexical one, and it's why there's no inference endpoint sitting in your search path waiting to add latency or fail under load. Below is a flow diagram for index and query paths:


The payoff shows up in the benchmarks. For English content, ASE improved relevance by about 20% over classic BM25 — and slightly lowered p90 latency (24 ms vs. 26 ms), because there's no model inference on the query path. For multilingual content, the relevance jump was around 105%, at a small latency cost. The query side isn't expanded, yet the results still land, because the document side was enriched generously enough to meet plain query words where they are.
Here's how that nets out, measured on the  BEIR  benchmark for English and MIRACL for multilingual content (p90 latency, lower is better):

BM25 (baseline)
ASE — English
ASE — Multilingual
Relevance (NDCG@10)
baseline
+20%
+105%
P90 search latency
26 ms
24 ms (-7.7%)
36 ms (+38.4%)

Your Application Doesn't Change

Your search code stays exactly as it is. ASE intercepts your existing match queries — standalone or buried inside bool, dis_max, function_score, and other compound queries — and transparently rewrites them into semantic neural_sparse queries. No new query DSL to learn. The one exception today is multi_match, which isn't supported — restructure those as match clauses.
Adding ASE to an existing index is just as light, with one thing to remember: existing documents aren't backfilled. Enable enrichment on a field and only new documents get it — you must re-ingest the old ones to bring them along.

From Zero to Semantic in Two Commands

Two prerequisites, both managed-domain specifics: the domain must run OpenSearch 2.19 or later and be on the latest service software update. ASE works on both public-access and VPC-access domains (VPC domains need one extra authorization, noted below). With that in place, you create the index with the enriched field declared up front:
aws opensearch create-index \
--domain-name my-domain \
--index-name product-catalog \
--index-schema '{
"mappings": {
"properties": {
"product_id": { "type": "keyword" },
"title": {
"type": "text",
"semantic_enrichment": {
"status": "ENABLED",
"language_options": "english"
}
}
}
}
}


Already have an index in production? This is where managed domains give you room that Serverless collections don't. On Serverless, enrichment must be declared when the index is created and can't be switched on afterward — you decide up front or recreate. On a managed domain you can add a new enriched field to a live index with update-index — no tear-down, no recreate:
aws opensearch update-index \
--domain-name my-domain \
--index-name product-catalog \
--index-schema '{
"mappings": {
"properties": {
"description": {
"type": "text",
"semantic_enrichment": {
"status": "ENABLED",
"language_options": "english"
}
}
}
}
}


A few things worth knowing before you implement ASE:
  • Enrichment only applies to top-level text fields — nested fields aren't supported.
  • You can't change a field's language_options in place; you disable enrichment, then re-enable it with the new language.
  • Index settings are immutable on an enriched index, so changing those still means recreate-and-re-index.
  • If the index already carries a custom ingest or search pipeline you built yourself, ASE won't layer on top of it — you remove the custom pipeline first.
  • On VPC-access domains there's also a one-time step: authorize the Amazon OpenSearch Service features principal before you create or manage a semantic index.

Where It Fits and Where It Doesn't

ASE shines on short-to-medium natural-language fields: product titles, descriptions, reviews, summaries. It's especially compelling for multilingual catalogs, where lexical search struggles most and the relevance gains are largest.
ASE may not be optimal for everything. Very long documents get truncated — the model reads the first 8,192 tokens for English, 512 for multilingual — so lengthy articles need chunking. Log-analytics workloads, where exact matching already works and index size matters, rarely justify the extra storage. And indexing inference is soft-capped at 200 TPS (AWS Support can raise it).

Conclusion

Semantic search used to be a decision about infrastructure. With Automatic Semantic Enrichment, it's a decision about a single field mapping. For teams already running Amazon OpenSearch Service, the sandals can finally show up in the search results — and it takes one line to get them there. Automatic semantic enrichment supports English, Arabic, Bengali, Chinese, Finnish, French, Hindi, Indonesian, Japanese, Korean, Persian, Russian, Spanish, Swahili, and Telugu.

Next Steps

Ready to try it? If you're already running an Amazon OpenSearch Service domain on 2.19 or later, you're one field mapping away from semantic search. Spin up a test index, enable  semantic_enrichment  on a title or description field, re-ingest a sample of your data, and run your existing  match  queries against it — then compare the results to your current lexical search. Measure the relevance lift on your own data before you commit to anything, and let the numbers make the case.
To learn more and get started with ASE, please visit the  AWS documentation .
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article