Infino AI: One Parquet File for Both Vector and SQL Retrieval

AI Agents' retrieval needs are becoming increasingly complex: they need keyword matching, semantic vector search, and SQL for aggregation and analysis. The traditional approach is to deploy Elasticsearch, a vector database, and an OLAP engine separately, which means data gets copied multiple times, and synchronization latency and operational overhead rise accordingly. Infino AI, ranked #15 on Product Hunt, proposes a different path—keep just one copy of Parquet data and write BM25 and vector indexes directly into the file.

One Dataset, Three Types of Retrieval

Infino positions itself as an open-source retrieval engine for AI Agents. Its core design decision is: data is stored in Parquet format on S3 or local disk, and indexes are no longer separate from the data—they are embedded inside the Parquet files. Agents can issue keyword search (BM25), vector search, hybrid search, and SQL queries against the same dataset.

This means there is no longer a need to copy data from the lakehouse to a search engine and then to a vector store. For Agent applications that frequently invoke retrieval capabilities, the data path is shortened, and the complexity of maintaining consistency drops accordingly. The project is open source under Apache-2.0, with a generally available Infino Cloud offering that includes a free tier.

Parquet is a columnar storage format originally developed through a collaboration between Twitter and Cloudera, and now an Apache top-level project. It uses columnar compression, supports nested data structures, and embeds rich metadata (such as schema and statistics), making it well suited for big data analytics. Parquet files are typically stored on distributed storage such as HDFS and S3, and are widely supported by query engines including Spark, Presto, and Hive. Because columnar storage inherently offers high compression ratios and column-wise reads, it performs excellently in OLAP scenarios. Infino's choice of Parquet as its data foundation means it can directly reuse the existing data lake ecosystem and avoid data migration.

BM25 is a classic sparse retrieval algorithm that computes the relevance between a query and a document based on term frequency (TF) and inverse document frequency (IDF), with document length normalization. It is the default scoring algorithm in Elasticsearch and Lucene and performs reliably in keyword-matching scenarios. BM25 and vector retrieval are complementary: the former excels at exact matching and term queries, while the latter excels at semantic similarity. Infino embeds the BM25 index into Parquet, enabling keyword retrieval to be executed directly at the file level without relying on an external search engine.

Vector indexes (such as HNSW and IVF) are used to accelerate approximate nearest neighbor search over high-dimensional vectors. Traditional vector databases need to store raw vectors and index structures separately, whereas Infino also embeds vector indexes into Parquet files, achieving physical unification of index and data. This eliminates one data copy, but at the same time introduces new engineering challenges for index updates and query performance.

Why "Indexes in Files" Is Worth Attention

Putting BM25 and vector indexes inside Parquet files is effectively challenging a long-standing architectural convention: the separation of indexing and storage. The benefit of a separated architecture is independent scaling; the cost is data movement and dual-write consistency.

Infino's choice is better suited to scenarios where "data already lives on object storage and retrieval is a downstream consumer." Agent workloads are often bursty and diverse—the same Agent might first do keyword filtering, then vector reranking on the candidate set, and finally use SQL to compute distributions. If each type of query has to access a different system, orchestration logic quickly balloons. A single Parquet copy plus multi-modal indexes allows these combined queries to be completed within one engine.

Of course, this architecture has its boundaries. The latency characteristics of object storage, the granularity of index updates, and caching strategies under high concurrency are all engineering issues that need to be validated under real workloads. The source material does not disclose specific performance metrics, and genuine community feedback will take time to accumulate.

A Dual-Track Strategy of Open Source + Cloud Service

Infino adopts a model of Apache-2.0 open source plus a managed cloud service. For developers, full functionality can run locally or on their own S3; for teams looking to reduce operational effort, Infino Cloud offers an out-of-the-box option with a free tier for trials.

This dual-track strategy is already quite common in the database and retrieval space. The key question is whether the open-source version retains enough core capability. Judging from the project description, all four retrieval types—keyword, vector, hybrid, and SQL—are within the open-source scope, and the cloud service differs mainly in managed convenience rather than feature crippling.

Who It's For, and Who It's Not For

Infino's target users are developers building Agent applications, especially teams whose data already resides in Parquet/object storage and who do not want to maintain multiple retrieval systems. For scenarios where the query pattern is primarily single-mode vector retrieval and the data volume is small, the benefits of introducing a new engine may be limited; for medium-to-large Agent projects that need cross-modal combined queries and are sensitive to the number of data copies, this approach is worth evaluating.

The project received 89 upvotes and 9 comments on Product Hunt and is still in an early exposure phase. As a developer tool, its real value ultimately depends on query latency, index build efficiency, and ecosystem integration—all of which need to be tested in real projects.

FAQ

What query types does Infino support? Keyword (BM25), vector, hybrid, and SQL queries, all against the same Parquet data.

Where can data be stored? It supports S3 or local disk, with indexes embedded in Parquet files.

Is it open source? Yes, under the Apache-2.0 license. A managed Infino Cloud service is also available, including a free tier.

How is it different from existing vector databases? The main difference is that it does not copy data and keeps indexes and data in the same file, reducing data synchronization across multiple systems.

Additional Background

In traditional architectures, separation of indexing and storage means raw data is stored in a data lake (such as S3), while indexes (such as inverted indexes and vector indexes) are stored in dedicated search engines or vector databases. This separation brings the flexibility of horizontal scaling, but also introduces the complexity of data synchronization: when raw data is updated, the index needs to be rebuilt asynchronously, which may cause temporary inconsistency, and dual-write logic increases the burden on the application layer. In addition, multiple data copies also drive up storage costs and operational overhead.

Object storage (such as Amazon S3) offers high durability, low cost, and high scalability, but its latency is usually higher than local disk, and it is not friendly to frequent small-file reads and writes. After embedding indexes into Parquet files, queries may need to pull an entire file or selected columns from object storage, which places higher demands on index locality. Common optimizations include using Parquet's column pruning and predicate pushdown to reduce the amount of data read, and deploying a cache layer on compute nodes to lower latency. These engineering details directly affect the practical feasibility of the "indexes in files" architecture.

One-line Summary

Infino embeds BM25 and vector indexes into Parquet files, providing AI Agents with multi-modal retrieval over a single data copy.

Paragraph Summary

Infino AI is an open-source retrieval engine for AI Agents whose core innovation is embedding BM25 keyword indexes and vector indexes directly into Parquet files, thereby keeping only one copy of the data. The engine supports keyword search, vector search, hybrid search, and SQL queries over the same data, avoiding the synchronization latency and operational overhead caused by copying data among Elasticsearch, vector databases, and OLAP engines in traditional solutions. The project is open source under Apache-2.0 and also offers a managed Infino Cloud service with a free tier. Its target users are Agent developers whose data already resides in Parquet/object storage, who need cross-modal combined queries, and who are sensitive to the number of data copies. However, the product is still early-stage, and its actual performance and ecosystem integration remain to be validated.