Null StudioNullStudio

Blog · November 16, 2026 · 9 min read

AI Search in Your Product: Semantic, Hybrid and Natural-Language Search for Buyers

By the Null Studio team

TL;DR: AI search lets people find things in your product by describing what they mean instead of guessing the exact words you used. For most products the right build is not "replace search with AI." It is hybrid search: keep keyword matching for names, codes and exact phrases, add semantic (vector) matching for meaning, and optionally let a language model turn a plain-English request into structured filters. The model is the easy part. Relevance depends on your data quality, on a test set of real queries, and on measuring what users actually do after they search. Start with the queries that fail today, prove the improvement on those, and only add generated answers on top once results are reliably right.

Search is one of the least glamorous features in most products and one of the most used. When it works, nobody mentions it. When it fails, users quietly conclude the thing they wanted is not there, and they leave, or they open a support ticket asking for something that was on the page all along.

That is why "can we add AI to our search?" is one of the most common requests we get from teams that already have a working product. It is a good instinct. It is also easy to over-build. This guide explains what AI search actually is, which version fits which product, what decides whether it works, and what to ask before you commission it.

What "AI search" actually means

Three different things get sold under the same label, and they solve different problems.

Semantic search matches meaning rather than words. Each item in your catalog or database is converted into an embedding, a list of numbers that represents what the text is about, and a user's query is converted the same way. Results are the items whose meaning sits closest to the query. A search for "something to keep coffee hot on my desk" can find a product titled "insulated mug warmer" even though none of the words overlap.

Natural-language filtering uses a language model to turn a request into the structured filters your product already has. "Invoices over 5,000 from last quarter that are still unpaid" becomes an amount filter, a date range and a status. The model does not search anything. It translates, and your existing, deterministic query does the work.

Answer generation retrieves the most relevant items and has a model write a direct answer with citations. This is the retrieval-augmented generation pattern we cover in depth in building an internal AI knowledge base. It is powerful for documentation and help content, and it carries the most risk, because a fluent answer can hide a wrong source.

Most products need the first two. Fewer need the third, and the ones that do should add it last.

Why pure semantic search usually disappoints

Teams that swap their keyword search for vector search alone often get a strange result: some queries get dramatically better and others get noticeably worse.

The ones that get worse are exact lookups. A customer searching an order number, a SKU, a person's surname, an error code or a legal clause reference wants that exact match at the top. Embeddings are built to capture meaning, so they are fuzzy by design. "Invoice INV-20418" and "Invoice INV-20481" look almost identical to a vector model and completely different to the user.

The fix is hybrid search. Run keyword matching and semantic matching in parallel, merge the two result lists, and rank the combined set. Keyword search handles precision, semantic search handles intent and vocabulary mismatch, and a ranking step decides the final order. Most modern search engines and databases now support this natively, so it rarely means running two separate systems.

A useful rule from our builds: if your users often know exactly what they are looking for, keyword quality still matters more than anything else, and semantic matching is a safety net. If your users often describe a need rather than name a thing, semantic matching carries more of the weight.

Your data decides relevance

No search model rescues a catalog with empty descriptions, inconsistent categories and three spellings of the same brand. This is the part of the project that is never in the demo and always in the timeline.

Decide what gets indexed, and how

For each type of record, decide which fields are searchable, which are filters and which are display-only. Titles and descriptions usually feed semantic matching. IDs, codes and names usually feed keyword matching. Prices, dates, status and location are filters, not text to be embedded.

Long records need to be split into sensible pieces before they are embedded, and the split matters. Keep headings attached to the text beneath them and carry the record's metadata with every piece, so a result can be filtered and linked back to its source.

Enrich thin records

Many catalogs have records with a title and nothing else. A language model can help here, offline and before indexing, by drafting descriptions, normalizing categories or extracting attributes from free text. Treat that output as a draft to review, not as truth, especially if it will be shown to customers. We walk through how to assess this groundwork in AI data readiness.

Keep the index in sync

A search index is a copy of your data, and copies go stale. Plan for changes to propagate quickly, for deleted or unpublished items to disappear from results, and for re-embedding when you change models. A result that links to something no longer for sale costs more trust than a slightly worse ranking.

Permissions and multi-tenancy

If your product has accounts, teams or customers whose data must stay separate, search is one of the easiest places to leak it. The access check has to happen inside the search query, so restricted records are never returned in the first place. Filtering results after retrieval, or asking a model not to mention something, is not a security control.

This is straightforward to design in from the start and painful to retrofit, which is why we raise it on day one of any search work in a SaaS product. The wider patterns are in multi-tenant SaaS architecture and AI feature security.

Measure relevance before and after

The most common failure we see is a team that ships AI search, tries a handful of queries, finds them impressive and calls it done. Then a month later support tickets reveal a whole class of queries that got worse.

Build a query test set first

Pull real queries from your search logs. Include the most frequent ones, the ones that currently return nothing, the exact lookups, the misspellings and the vague ones. For each, record what a good result looks like. A few hundred real queries with judged results is enough to compare approaches honestly, and it becomes the regression test you rerun after every change to fields, ranking or models. The general discipline is covered in evaluating AI features.

Watch behavior, not just clicks

In production, the useful signals are the zero-result rate, how often a search is immediately followed by a rephrased search, how often a search leads to the action that matters (a purchase, an opened record, a booked appointment) and how often a search is followed by a support contact. Instrument these before launch so you have a baseline to compare against. Our guide to product analytics for an MVP covers setting up events that answer real questions.

The zero-result log deserves special attention. It tells you exactly which words your users use that your catalog does not, and often which products or content you are missing entirely.

Speed and cost

Users expect search to feel instant, and it is typed constantly, so both latency and cost scale with every keystroke.

Embedding a query and running a hybrid search is fast and cheap, typically fine for search-as-you-type. Calling a large language model on every query is not. If you add natural-language filtering, trigger it only when a query looks like a request rather than a keyword, use a small model for the translation step, and cache common patterns. Generated answers should be an explicit step the user chooses, not something that fires on every search. We break down these trade-offs in AI cost control and choosing an AI model.

Where generated answers fit, and where they do not

Answer generation earns its place where users are asking questions rather than looking for an item: help centers, policy documents, product documentation, course material. It fits badly where the user wants to browse and compare, such as a product catalog, where a written paragraph gets in the way of the list.

If you add it, keep the answer tied to its sources, let users click through to the original, and make the system say so when the retrieved material does not contain an answer. The failure modes and guardrails are covered in AI hallucinations in production.

Multilingual search

If your users search in more than one language, a multilingual embedding model can match a query in one language to content written in another, which is often a bigger win than any ranking tweak. Test it with real queries in each language you serve, because quality varies by language and domain. Our work on Fortell AI, which handles intake for Community Action Agencies in over 100 languages, is a reminder that "supports the language" and "works well in that language for this domain" are different claims. We go deeper in multilingual voice AI.

Build, buy or configure

There are three realistic routes.

Whichever route you take, own your query test set and your index configuration, so you can move providers later without starting again.

Where we fit

We add AI features to existing products as often as we build new ones, and search is one of the most common. The pattern is the one we describe in adding AI to an existing product: start from a job users are failing at, prove the improvement on real data, ship it behind a flag and measure.

Our own products face the same problem in different shapes. Fyuel brings customers, suppliers, tankers, ledgers, banks and reports into one real-time system, and in a product like that finding the right record fast is half the value. LectureNotes AI turns recorded lectures into summaries and outlines, the kind of material that becomes far more useful once it can be found by meaning. Our voice work for CallGuard AI, CallSetter AI and Fortell AI depends on agents retrieving the right business facts in the middle of a live conversation, which is search under a much tighter deadline.

Questions to ask before you commission AI search


Users searching your product and not finding what is there? Book a demo and we will look at your real search logs, the failing queries and a first scope that proves the improvement in weeks. See our work: Fyuel, LectureNotes AI, Fortell AI and more, shipped in days, not months.

FAQ

What is the difference between semantic search and keyword search?

Keyword search matches the words in a query to the words in your content, which is precise for names, codes and exact phrases. Semantic search matches meaning using embeddings, so it finds relevant items even when the words differ, but it is fuzzy on exact lookups like order numbers or SKUs.

Should we replace our search with AI search?

Usually not. For most products the best result is hybrid search: keep keyword matching for exact lookups, add semantic matching for intent and vocabulary mismatch, and rank the merged results. Replacing keyword search entirely often makes exact lookups worse.

How do you know if AI search is actually better?

Build a test set of real queries from your search logs, including frequent, failing, exact and vague queries, with judged good results. Compare approaches against it before launch, then track zero-result rate, rephrased searches and searches that lead to the action that matters after launch.

Is AI search expensive to run?

Embedding queries and running hybrid search is fast and cheap enough for search-as-you-type. Cost and latency rise when a large language model is called on every query, so natural-language filtering and generated answers should be triggered selectively, use smaller models where possible and cache common patterns.

Want it built, not just explained?

We design, build and run these systems end-to-end — shipped in days, not months.

Book a demo →

Keep reading