From Algolia to the Index Server

September 2026 · 8 min read

Algolia is a genuinely great hosted search product — fast edge latency, excellent typo tolerance, and the InstantSearch UI widgets that make a search box feel instant. This isn't a takedown. It's for the teams who've hit the reasons people leave: pricing that scales with every record and every search, data that has to leave your infrastructure, and the need for vector / hybrid retrieval that isn't a separate paid add-on. The Index Server is self-hosted, bills nothing per operation, does BM25 + vector + hybrid in one engine — and speaks an Algolia-compatible dialect so your existing client keeps working while you move.

The shape of the difference

	Algolia	Index Server
Hosting	managed SaaS (their cloud)	self-hosted — your VPC, on-prem, or air-gapped
Pricing model	per record + per search operation	flat: the instance you run, no per-op billing
Data residency	records + queries leave your network	nothing leaves the box
Faceted / filtered search	facets, filters, numeric filters	aggregations (terms/range/…), bool filters
Vector & hybrid	NeuralSearch (paid add-on)	built-in kNN + hybrid (BM25 + vector, RRF)
API	Algolia REST / InstantSearch	OpenSearch REST — and an Algolia-compatible dialect
Client migration	—	point your Algolia client at the dialect listener

Keep your Algolia client — the dialect is built in

You don't have to rewrite your search layer to evaluate it. The server exposes an Algolia-compatible dialect on its own listener (dialects.algolia-port), covering the data plane your app uses: saveObjects (batch), search, facets, filters and index settings. Point the client at the new host and existing code runs:

// your existing Algolia client — only the host changes
const client = algoliasearch('APP_ID', 'API_KEY', {
  hosts: [{ url: 'your-host:8055', protocol: 'http' }]   // the dialect listener
});
const index = client.initIndex('products');
await index.saveObjects([{ objectID: '1', name: 'Linen shirt', price: 49, category: 'women' }]);
const res = await index.search('linen', { facets: ['brand','category'] });

Query Rules and some control-plane calls aren't implemented — the dialect is a versioned data-plane subset and rejects the rest cleanly.

Side by side: the OpenSearch API

When you're ready to consolidate on one API, the same documents are reachable over the OpenSearch REST API — where you also get aggregations, vector and hybrid for free.

Indexing records

Algolia	SearchAI (OpenSearch API)
`index.saveObjects([ {objectID:"1", name:"Linen shirt", price:49} ])`	`POST /products/_bulk {"index":{"_id":"1"}} {"name":"Linen shirt","price":49}`

Search with filters + facets

Algolia:

index.search('linen', {
  filters: 'category:women AND price < 100',
  facets: ['brand', 'category']
});

Index Server — one _search body:

POST /products/_search
{ "query": { "multi_match": { "query": "linen", "fields": ["name^2","summary"] } },
  "post_filter": { "bool": { "filter": [
      { "term":  { "category": "women" } },
      { "range": { "price": { "lt": 100 } } } ] } },
  "aggs": { "brand":    { "terms": { "field": "brand" } },
            "category": { "terms": { "field": "category" } } } }

The aggs come back as facet counts, and post_filter narrows the hits without collapsing the facet counts — the same UX Algolia's facets give you.

Add semantic + hybrid (no add-on)

Where Algolia's semantic layer is a separate paid product, hybrid here is one clause over the same index — BM25 and vector fused with RRF, the query embedded server-side at ingest-time width:

POST /products/_search
{ "query": { "hybrid": { "queries": [
    { "multi_match": { "query": "comfortable summer top", "fields": ["name^2","summary"] } },
    { "neural": { "vec": { "query_text": "comfortable summer top", "k": 20 } } }
] } } }

Migrating the records

Console Migrate tab — bulk-load an export of your Algolia objects; objectID maps to _id, attributes become fields, and attributesForFaceting become keyword facets. Counts are recorded source-vs-target so completeness is part of the job.
Re-index from source (recommended) — if your records are derived from a system of record, index the source text with an embed mapping and get hybrid for free, with a clean mapping you control.

Honest scorecard — where Algolia still wins

Algolia remains the stronger choice if you need globally-distributed edge latency out of the box, its mature typo-tolerance and Rules engine, or the InstantSearch widget ecosystem — those are real, and replicating them is work. Choose the Index Server when the deciding factors are self-hosting and data residency, flat cost instead of per-record / per-search billing, and wanting keyword, vector and hybrid in one engine over an API the rest of your stack already speaks.

One line installs the server and inference engine:

curl -fsSL https://index-server.searchblox.com/install | sudo bash

Start with the Getting Started guide, the dialect details are in the docs, and the full engine comparison is on the benchmarks page.