---
title: "The hidden index: why search can’t just be exact match anymore"
description: "Why agents need search that matches on meaning, not spelling: what an embedding is, why nearest-neighbour search trades a little recall for speed, and why Infino builds its vector index into the same Parquet files as the text."
canonical: https://infino.ai/blog/hidden-index/
published: 2026-11-03
---

# The hidden index: why search can’t just be exact match anymore

By [Savan Nahar](https://www.linkedin.com/in/savannahar/) · Nov 3, 2026 · engineering

Picture this. You hook Claude up to Uber Eats through an MCP server and tell it: “order me something spicy and noodle based for dinner.” Then you sit back and watch what it does. It reads the tool list, finds a search tool, and has to turn your craving into a query. It types “spicy noodles.”

Here’s the thing. Two miles away there’s a Korean place with a bowl on the menu called Korean Ramyun that is, in every way, exactly what you asked for. Whether it comes up depends entirely on what sits under that search tool. If it’s doing what the search box in every app did until a couple of years ago, checking whether the letters you typed show up somewhere in the letters of the dish name, that bowl never makes the list. “Spicy noodles” and “Korean Ramyun (Tofu)” don’t share a single word. Ramyun isn’t ramen isn’t noodles to a string matcher. That’s it. That’s the entire operation underneath.

Until a couple of years ago this was fine, because the thing typing into the search box was always a person, and a person already carries a rough sense of which word they’re looking for even when they don’t know the exact name of the dish. I’d have scrolled the menu myself, seen “Korean Ramyun,” and figured it out. Nobody really needed the search box to be smarter than that.

An agent can’t scroll and figure it out. It isn’t recalling a word it half remembers, it’s trying to satisfy a craving, and the craving and the menu item are frequently the same thing wearing two unrelated names. “Spicy noodles” and “Korean Ramyun” point at the same bowl. Zero overlapping vocabulary. So you need a search that matches on meaning instead of spelling, and that’s basically the entire reason vectors showed up in search engines in the first place.

## What a vector is

Concretely, a vector is just a list of numbers a model spits out for a chunk of text, image or audio. The trick is the model gets trained so that two pieces of text meaning close to the same thing end up as two lists of numbers sitting close together in space. “spicy noodles” and “Korean Ramyun” land near each other even with zero words in common. Here’s roughly what that looks like:

```
"spicy noodles"     → [ 0.81, -0.12,  0.44,  0.07, ... ]
"korean ramyun"     → [ 0.79, -0.09,  0.47,  0.05, ... ]
"vanilla ice cream" → [-0.33,  0.62, -0.08,  0.51, ... ]
```

The first two lists almost match position by position. The third one doesn’t. Squint and you can already see which two are about the same thing without reading a single word.

![Close in meaning is close in space: a 2-D projection where spicy noodles, korean ramyun and mapo tofu sit together in one cluster, green salad and vanilla ice cream sit far away, and a search is drawn as finding the nearest points to the query.](https://infino.ai/blog/hidden-index/close-in-meaning.png)

768 dimensions squashed to 2 so it fits on a page. Numbers are illustrative.

People call this an embedding, and once your data is a pile of these, search stops being a string-matching problem and turns into “find me the nearest points to this point,” which is a geometry problem. I know that sounds suspiciously simple for something people call AI search like it’s magic. It mostly is just that though. The hard part isn’t the idea, it’s doing “find nearest points” fast across a few hundred million of them while someone’s waiting on an answer in under twenty milliseconds. Most of this series is really about that part.

## Why nobody searches every vector

If you have a billion vectors and want the ten closest to your query, the only way to be certain is to compute the distance to all billion of them. Nobody does that in production, because at that size one query takes long enough that the user has already given up and ordered something else. What every vector engine does instead, ours included, is look at a small slice of the data that’s likely to hold the answer and accept that it will sometimes miss. You then measure how often it misses, and that number is what people mean by recall.

Almost everything in this series is about keeping recall high while keeping the search cheap. IVF does it by grouping nearby vectors into buckets ahead of time, so at query time you only look inside the few buckets closest to your query. HNSW does it by building a graph where each vector links to its neighbours, so you can walk from a starting point toward the answer without touching most of the data. Quantization helps in a different way, by storing each vector in fewer bytes so comparisons are faster and more of the index fits in memory, at the price of a little precision.

## Why the index is hidden

Infino started as a log and text search engine. Over the last couple of years our users started asking it questions that needed meaning rather than keywords, and at the same time most databases we looked at were adding vector search by building a separate index over a separate copy of the data. That means two indexes to keep in sync and twice the storage to pay for, which never sat right with us. So we built vector search into the same Parquet files that already hold the text and the rest of the row. That’s the decision this whole series is about.

Doing it that way forces a lot of other decisions. Our Parquet files live on object storage, and object storage doesn’t let you edit a file in place, so the vector index can’t be something we edit in place either. What we do instead is build it as a separate table next to the one you write to, one you never see or configure, and whenever the data changes we rebuild the affected parts as new files and swap them in at commit time. Because nobody is around to tune that table by hand, the engine has to measure its own recall and tune itself. That hidden table is where the series gets its name, and most of what I’ll walk through in the next posts comes down to how you make it fast given those constraints.

One note before I keep going: I work at Infino. Every number in this series ties back to a real commit or a benchmark run I’ll link, and anywhere I’m not sure, I’ll say I’m not sure instead of rounding it up.

The engine itself is open source. You can go read the code, or clone it and watch it do the things I’m describing. Over the next couple of posts I want to dive deep into the engine itself, how it’s actually built.

If you have reached this far, please consider giving [our open source repo (infino-ai/infino)](https://github.com/infino-ai/infino) a star on GitHub.
