Drop-in replacement for Elasticsearch or OpenSearch,
simpler and more scalable.

Hydrate from the snapshots you already take. Or keep OpenSearch and replace Lucene with Infino. Compatible Query DSL keeps its shape.

your application same Query DSL elasticsearch retires OBJECT STORAGE docs.sf.parquet
infino hydrate --from snapshot

Hydrate from your snapshots

Point Infino at an Elasticsearch or OpenSearch snapshot repository. Infino reads the snapshot, not the live cluster, and writes each live document into an Infino table as open Parquet.

  • The snapshot repository you already keep is the source. Name the index. Infino loads the snapshot you name, or the newest successful one that holds it.
  • Each live document becomes a row. Source fields become columns. The id the index knew the document by is kept.
  • Only the documents the snapshot still holds are loaded. Nested documents stay inside their parent.
  • Vector fields can come along as columns. Infino can also embed the text on the way in.
infino plugin --opensearch

Keep OpenSearch. Replace Lucene.

An OpenSearch plugin puts Infino under the APIs you already run. The cluster, the REST surface, and OpenSearch Dashboards stay. Nothing is written to Lucene.

  • Index names, mappings, and settings stay in cluster state.
  • Every document lives in an Infino table, on Infino Cloud or in your own bucket.
  • Bulk, search, and get keep the OpenSearch actions you already call.
  • Nodes no longer hold the durable copy. Dashboards aggregations keep working on this path.

talk to an engineer →

cat request.json

Your queries keep working

Point existing clients at Infino, or keep them on OpenSearch with the plugin. Compatible Query DSL requests keep the same shape. Unsupported Lucene features are listed below.

request.json
// POST /tickets/_search · compatible request
{
  "query": {
    "bool": {
      "must":   { "match": { "body": "disk full" } },
      "filter": { "term":  { "level": "error" } }
    }
  },
  "size": 10
}

// → same request shape and client · answered from Parquet in your bucket

vs elasticsearch / opensearch →

cat upgrade.sql

SQL joins on search results

In Infino a ranked search is a relation, so it joins against the rest of your data in the same statement.

upgrade.sql
SELECT   p.name AS plan, count(*) AS tickets
FROM     hybrid_search('tickets', 'body', 'disk full',
                       'embedding', :q, 5000) h    -- keyword + vector, fused
JOIN     accounts a ON a.id = h.account_id          -- a plain table
JOIN     plans    p ON p.id = a.plan_id
GROUP BY p.name
ORDER BY tickets DESC;

-- → search joined to your business tables

hybrid search →

cat RUNBOOK.diff

A file-and-compute operating model

Elasticsearch and OpenSearch organize data as shards on cluster nodes. Infino separates durable Parquet in object storage from the compute that reads it.

  • Table schemas replace index mappings. A new field becomes a column.
  • Object storage provides durability, while local RAM and NVMe hold disposable cached data.
  • Retained data grows in the bucket and query compute scales independently.
infino bench --latency

Measured search latency

Internal External
Workload Cohere, 768 dimensions, 10M docs, top-10
p50
5ms 314ms
p99
12ms 850ms
  • Warm
  • Cold

Internal 10M-document run. Its full results are not published yet. The published engine benchmarks, with a way to reproduce each one, are on the benchmarks page.

Published runs: infino.ai/benchmarks ↗
infino migrate --from elasticsearch

How migration works

  • Hydrate from an Elasticsearch or OpenSearch snapshot repository into Infino tables.
  • Or keep OpenSearch and replace Lucene, so new writes land in Infino tables.
  • If you have no snapshot, export with the pipeline you already run and append into Infino tables.
  • Dual-run both systems against real traffic and compare results and cost. Then cut reads over.
cat TRADEOFFS.md

Compatibility and tradeoffs

  • Compatible Query DSL requests, bulk and index clients, BM25, vector, and hybrid search retain familiar interfaces.
  • Data lands as open Parquet and gains DataFusion SQL over the same rows, with object-storage retention and independently scaled compute.
  • Infino dashboards can be built through the MCP server. infino-analytics is a reference implementation. OpenSearch Dashboards stays on the plugin path.

vs elasticsearch / opensearch →

cat FAQ.md

Migration questions

Will existing Elasticsearch queries and clients work with Infino?

Infino implements a supported Query DSL subset, so compatible clients and requests keep their shape. Lucene-specific analyzers, span queries, stop words, distance, and proximity require different queries. Bulk and index clients can be repointed after validating pipeline-specific behavior. On the OpenSearch plugin path, existing clients stay pointed at OpenSearch. Infino has no native dashboard UI. Dashboards can be built through its MCP server. Kibana stays on Elasticsearch. OpenSearch Dashboards keeps working when the plugin replaces Lucene.

How does the operating model change?

Durable data grows as Parquet files in object storage, while compute reads and caches the working set. Table schemas replace mappings, and capacity scales independently from retained data.

Is Infino cheaper than Elasticsearch or OpenSearch?

Infino keeps one searchable copy in object storage, reducing the hot storage and replica capacity carried by a traditional search cluster. Cloud meters storage, write tokens, read tokens, and returned bytes. Plans are on the pricing page.

What does SQL add?

Search results become relations. A ranked hybrid search can join an accounts table, group by plan, or window by week inside one DataFusion query. Elasticsearch offers ES|QL and a SQL plugin. Infino exposes search as table-valued functions inside SQL.

How does migration work?

Hydrate from an Elasticsearch or OpenSearch snapshot repository into Infino tables. Or keep OpenSearch and replace Lucene so new writes land in Infino. If you have no snapshot, export with the pipeline you already run. Dual-run representative traffic before cutover. Requests inside the supported Query DSL subset retain their shape. Lucene-specific features require an alternate query.

Do I have to export from the live cluster?

No. Infino reads the snapshot repository. The live cluster is never read. A pipeline export is only the fallback when you have no snapshot.

Does this apply to OpenSearch too?

Yes. Snapshot hydrate and the supported Query DSL subset apply to OpenSearch. The plugin path is OpenSearch only. It keeps the OpenSearch REST API and Dashboards while documents live in Infino tables. Ranked results may differ. Lucene-specific analyzers, span queries, stop words, distance, and proximity require alternate queries.

Run the swap on your own bucket.

Free tier · No credit card to start

or run it yourself: pip install infino · Apache-2.0 · quickstart →

Go deeper: vs elasticsearch / opensearch · architecture · docs ↗