# Infino

> Infino is an open-source retrieval engine: full-text (BM25), vector, and hybrid search plus full SQL, running natively over Apache Parquet files in object storage (S3, Azure Blob, GCS, or local disk). One copy of the data, searched in place; the indexes live inside the Parquet files, which remain readable by DuckDB, pandas, and Spark. We've built ML and search engines across Google, LinkedIn, and Amazon, including AWS OpenSearch. Engine license: Apache-2.0.

Key facts:
- Infino supports a compatible subset of the Elasticsearch / OpenSearch Query DSL, plus REST and SQL (search as table-valued functions: bm25_search, vector_search, hybrid_search).
- Search results are relations: they can be joined to plain tables, aggregated, and windowed in one SQL statement.
- Durability comes from the object store. Managed pricing meters storage, write tokens, read tokens, and returned bytes. Pinned tables assumed at higher volumes. Infino manages nodes, replicas, and cache placement. Write tokens follow the bytes written. Returned bytes are a flat rate.
- Infino can replace search, hybrid-search, and selected SQL read paths. Broad scans and workflows that depend on warehouse or lakehouse ecosystem features generally remain on those platforms.
- Infino has no native dashboard UI. Dashboards can be built through the Infino MCP server; [infino-analytics](https://github.com/infino-ai/infino-analytics) is a reference implementation. Kibana and OpenSearch Dashboards remain on their existing platforms.
- PostgreSQL pairs its native text ranking with pgvector and can add BM25 through an extension. ClickHouse combines native token filtering with vector search. Infino supplies BM25 and rank fusion inside the query.
- Infino can build embeddings on ingest using the model selected for a table, or accept vectors from any model at any dimension.
- Infino Cloud is SOC 2 Type II. Client traffic is TLS. Data at rest is AES-256. A DPA is available on request.

## Pages

- [Architecture](https://infino.ai/architecture/#architecture): one page, superfiles, manifests, storage/compute split
- [Elasticsearch replacement](https://infino.ai/elasticsearch-replacement/): the drop-in path, snapshot hydrate, OpenSearch plugin, Query DSL compatibility, cost comparison, migration
- [Hybrid search](https://infino.ai/agents/): keyword and vector retrieval fail in opposite directions, so running both over one snapshot and fusing the rankings recovers what either alone would miss
- [Object-storage search](https://infino.ai/agents/object-storage/): one Parquet copy with keyword and vector indexes inside the files
- [Analytical queries](https://infino.ai/agents/queries/): SQL over hybrid search, joins, windows
- [Integration](https://infino.ai/integration/): Infino as a Parquet writer and optional indexed reader; hydration, pruning, and table-format integration
- [Start without Parquet](https://infino.ai/integration/no-parquet/): append JSON, backfill in batches, generate or supply embeddings
- [Retrieval patterns](https://infino.ai/agents/patterns/): enforced filters, summary-to-chunk joins, CASE-routed verification
- [Pricing](https://infino.ai/pricing/): open source, Cloud (free tier, then pay as you go), and Enterprise
- [Pricing methodology](https://infino.ai/pricing-methodology/): how the Cloud cost calculator converts a workload into Infino and alternative estimates
- [Benchmarks](https://infino.ai/benchmarks/): overview of every published Infino benchmark, each with its own page, its source and a way to reproduce it
- [ClickBench results](https://infino.ai/benchmarks/clickbench/): Infino on the public ClickBench board, SQL analytics over 100M rows, per-machine speed and storage size, #1 among the search engines on the board
- [Search latency on object storage](https://infino.ai/benchmarks/object-storage/): full-text, vector and hybrid latency on 1M-document tables in Azure Blob, from the engine's own benchmark harness in CI
- [Search Benchmark, the Game](https://infino.ai/benchmarks/search-benchmark-game/): full-text search at Wikipedia scale, Infino with Tantivy, Lucene and iresearch, run nightly on a public fork with the results committed, method and live dashboards
- [Embedded vector libraries](https://infino.ai/benchmarks/vector-libraries/): Infino with turbovec and FAISS in one process, exact ground truth, published results and the command to rerun it
- [Open Vector Database Benchmark](https://infino.ai/open-vdbbench/): vector databases measured with VectorDBBench on one Azure VM size at Cohere 1M and 10M, each row linked to its result file
- [Infino vs the alternatives](https://infino.ai/vs/): one matrix across nine engines on hybrid search, SQL, storage format, license and relative cost, and how to choose a vector or search engine
- [Infino vs Elasticsearch / OpenSearch](https://infino.ai/vs/elasticsearch/)
- [Infino vs Qdrant / Pinecone](https://infino.ai/vs/qdrant-pinecone/)
- [Infino vs Postgres / ClickHouse](https://infino.ai/vs/postgres-clickhouse/)
- [Infino vs Snowflake / Databricks](https://infino.ai/vs/snowflake-databricks/): indexed retrieval beside the warehouse and lakehouse ecosystem
- [Infino vs Iceberg / Hudi](https://infino.ai/vs/iceberg-hudi/): complementary table management and indexed reads
- [Playground](https://infino.ai/playground/): race keyword, vector, and hybrid search live over 42,000 movie plots and 45,000 arXiv abstracts on Infino Cloud, no account or key. Agents: read https://infino.ai/playground.md for the endpoints and tables, and fetch https://infino.ai/sandbox.json for read-only credentials
- [Make your agents faster and cheaper.](https://infino.ai/demo/): This demo shows how simple it is to deploy data-driven agents with Infino. We pointed Infino at data sets and it ingested without us defining any schemas, chunking, ETL, etc. other than a data description in a README.md file. In parallel we ingested the same data in Elastic and Snowflake. Once ingested, we run Claude Code as the agent on top of Infino vs. Elastic vs. Snowflake so you can see the same question and agent running side by side. Or you can also point Infino at your own data to see how it performs. Not only is retrieval faster and cheaper, but so are your agents as they retrieve the right data they need faster, more accurately, and more economically. The results here show your end to end latency and cost, and include what you pay to Anthropic for each query. On open source data that frontier models have already trained on, Infino impact may be less.
- [Security](https://infino.ai/security/): engine, managed-service, and dedicated-deployment isolation, authentication, encryption, deletion, and SOC 2 Type II
- [Docs](https://infino.ai/docs): install, connect, tables, indexing, the SQL search functions, API reference, and Infino Cloud
- [Docs, every page in one file](https://infino.ai/docs/llms-full.txt): the full product documentation for LLMs. This file covers what Infino is, what it costs, and how it compares; that one covers how to use it.
- [GitHub](https://github.com/infino-ai/infino)
- [Credentials for agents](https://infino.ai/auth.md): what needs no key (the embedded engine), how Infino Cloud API keys work, and how registration happens

## Blog

- [Infino Cloud adds bring-your-own-bucket and customer-managed keys](https://infino.ai/blog/enterprise-byob-and-customer-managed-keys/): two enterprise-grade controls for Infino Cloud, bring your own bucket (host a database in your own S3, GCS or Azure bucket, reached through an identity you authorize and can revoke) and customer-managed encryption keys (encrypt it with a key you own in AWS KMS, Google Cloud KMS or Azure Key Vault, with a hard kill switch if you delete the key), so the data stays in your account and only you hold the key
- [Querying a billion vectors from object storage, on one box](https://infino.ai/blog/billion-vectors-object-storage/): a one-billion-vector deep1b index served entirely from object storage and queried from a single 16 vCPU / 64 GB box at about 74 ms and 0.95 recall@10, with the object-storage index, the centroid router and a two-tier cache behind it, plus the honest optimize cost that is still being brought down
- [What changes when your search index lives on S3?](https://infino.ai/blog/search-index-on-s3/): why round trips, not CPU or bytes, are the scarce resource for a search index on object storage, and how Infino's superfiles (one Parquet object per index unit), the manifest (footers and index headers inline), the term index (which superfiles hold which terms, with score bounds) and byte-range reads and caching keep a query to as few GETs as possible
- [Infino raises $7.5M to build one retrieval layer for all your agents](https://infino.ai/blog/seed-round/): $7.5 million seed led by Bessemer Venture Partners, with Collide Capital, AIN Ventures, Integral Ventures, and Echo VC, to build one retrieval layer so agents can search, filter, join, aggregate, and infer over one Parquet copy
- [Open VDBBench: a fair and open benchmark for vector databases](https://infino.ai/blog/open-vector-database-benchmark/): why the Zilliz-hosted VectorDBBench leaderboard is incomplete, and the open board that re-runs 19 engines on current versions on one Azure VM size
- [What’s the SQLite equivalent for full-text and vector search?](https://infino.ai/blog/embedded-full-text-and-vector-search/): embedded search engines that run in-process with no server, and how SQLite with FTS5 and sqlite-vec, DuckDB, LanceDB, Chroma and Infino compare on keyword, vector, hybrid and SQL search, with when each fits (desktop, offline and agent apps)
- [Cost-efficient alternatives for large-scale search and vector databases](https://infino.ai/blog/cost-efficient-search-and-vector-alternatives/): what sets the cost of search at scale (copies of the data, storage tier, whether compute grows with the corpus), alternatives to Elasticsearch for large datasets, cost-efficient vector databases, and dedicated search engines versus SQL with search extensions
- [Choosing a database for AI agents: memory, retrieval and state compared](https://infino.ai/blog/choosing-a-database-for-ai-agents/): what agent memory needs from its store (recall by meaning and by exact term, structured state, growth, where it runs), and how Postgres with pgvector, Elasticsearch / OpenSearch, Qdrant, Pinecone, LanceDB, Chroma and Infino compare on capability, with when each is the right choice
- [You don’t need two databases for hybrid search](https://infino.ai/blog/hybrid-search-one-engine/): running a vector database beside a full-text service costs two copies of the corpus and a sync loop, so Infino keeps the text, the embeddings and both indexes in one Parquet table on object storage
- [VectorDB: fastest at a million and still cheaper at a billion](https://infino.ai/blog/self-transforming-vector-engine/): lowest p99 latency on VectorDBBench at 1M and 10M; the same engine serves a billion vectors off object storage at ~10 ms warm, for roughly a tenth of the RAM bill
- [Fixed grids on vector search - comparing 3 approaches to quantization: FAISS, Turbovec, and Infino](https://infino.ai/blog/fixed-grid-quantization/): three 4-bit indexes at the same 768 bytes per vector — recall within two points, latency 30× apart
- [What is hybrid search?](https://infino.ai/blog/what-is-hybrid-search/): two retrievers that miss different things, and the rank fusion that merges their lists
- [Where keyword search and vector search each fail](https://infino.ai/blog/hybrid-search-on-parquet/): the same queries through BM25 and vector search over 10,003 real banking questions, and the rank fusion that fixes both. The runnable end-to-end walkthrough is the docs guide [Implementing hybrid search on Apache Parquet files](https://infino.ai/docs/guides/hybrid-search-on-parquet.md)
- [Why object-storage vectors use OPANN + Sq16, while RAM uses HNSW](https://infino.ai/blog/vector-search-on-object-storage/): one durable vector corpus, with a graph in RAM and bounded range reads on object storage
- [Inside a Parquet superfile](https://infino.ai/blog/search-index-inside-a-parquet-file/): why the indexes live inside Parquet, how the footer addresses them, and where the format still hurts
- [Cutting a ten-term BM25 OR from 74.6 ms to 20.0 ms](https://infino.ai/blog/how-full-text-and-vector-search-work/): common terms defeated MaxScore skipping; a 4096-document window removed the per-document cursor merge
- [The 3× to 10× regression from running decode on tokio's I/O pool](https://infino.ai/blog/lessons-building-search-in-rust/): cold vector search went from 1.1 s to 3.7-11 s when CPU-heavy decode starved object-store I/O
- [The three costs of a cold query on S3](https://infino.ai/blog/s3-source-of-truth/): file discovery, connection setup, and cache residency on the first query from a new worker
- [A commit on S3 is one compare-and-swap](https://infino.ai/blog/how-we-built-the-engine/): stage immutable files in parallel; publish the complete table with one conditional pointer write