Quickstart: install Infino and run your first search

Let’s get Infino running in a few minutes. We’ll build a small knowledge base (a handful of help-center notes) and search it four ways: by keyword, by meaning, by both at once (hybrid), and with SQL. Pick your language; each step builds on the one before it. How do you want to use Infino? This walkthrough uses the SDKs; the CLI and the MCP server do the same retrieval from the terminal or an AI agent.

SDK

Python, Node, or Rust — the walkthrough on this page.

CLI

Create, ingest, and search from the terminal or a coding agent — no code.

MCP server

Expose these searches as tools to an AI agent (Claude, Cursor, …).

Install

pip install infino
# Or with uv (https://docs.astral.sh/uv/):
uv pip install infino

npm install @infino-ai/infino

cargo add infino

Node: the examples are ESM

The Node examples below use import, so the file has to be a module. npm init -y writes "type": "commonjs", and running an import under that fails with Cannot use import statement outside a module. Either add "type": "module" to your package.json or save the file as .mjs.

Rust: Arrow types and allocator

Infino re-exports the Arrow crates it uses, so you don’t add them separately or match versions — reach them as infino::arrow_array and infino::arrow_schema (as the examples below do). update / delete take DataFusion predicates (col, lit); if you use them, add datafusion-expr matching Infino’s DataFusion version (cargo tree -p infino).Infino also installs the mimalloc global allocator by default. If you embed it in a process that already sets a global allocator, turn it off: infino = { default-features = false }.

Connect

First, open a connection. "memory://" keeps everything in memory for this walkthrough; point it at "./data" or an "s3://bucket/prefix" URI when you want your data to stick around. To run the same walkthrough against the hosted service, point it at "https://<host>/<database>" and pass an API key: see the Infino Cloud quickstart. Everything after the connect line is the same either way.

import infino
import pyarrow as pa

db = infino.connect("memory://")

import { connect, IndexSpec } from "@infino-ai/infino";

const db = connect("memory://");

use std::sync::Arc;
use infino::arrow_array::{FixedSizeListArray, Float32Array, LargeStringArray, RecordBatch};
use infino::arrow_schema::{DataType, Field, Schema};
use infino::{connect, Bm25SearchOptions, BoolMode, IndexSpec, Metric};

let db = connect("memory://")?;

Create a table

Now create a table. You give it a schema and say which columns to index: a full-text index on the text, and a vector index on the embedding.

schema = pa.schema([
    pa.field("source", pa.large_utf8(), nullable=False),
    pa.field("body", pa.large_utf8(), nullable=False),
    pa.field("embedding", pa.list_(pa.float32(), 16), nullable=False),
])
docs = db.create_table(
    "docs", schema,
    infino.IndexSpec().fts("body").vector("embedding", 16, "cosine"),
)

const docs = db.createTable(
  "docs",
  { source: "large_utf8", body: "large_utf8", embedding: { vector: 16 } },
  new IndexSpec().fts("body").vector("embedding", 16, "cosine"),
);

let item = Arc::new(Field::new("item", DataType::Float32, true));
let schema = Arc::new(Schema::new(vec![
    Field::new("source", DataType::LargeUtf8, false),
    Field::new("body", DataType::LargeUtf8, false),
    Field::new("embedding", DataType::FixedSizeList(item.clone(), 16), false),
]));
let docs = db.create_table(
    "docs",
    schema.clone(),
    IndexSpec::new().fts("body").vector("embedding", 16, Metric::Cosine),
)?;

Add data

Let’s add a few notes. The embed helper stands in for a real embedding model so the example runs on its own. It’s a 16-dim one-hot by topic (0 = billing, 1 = appearance). Your own embeddings will be dense and higher-dimensional; see Embeddings.

def embed(topic):
    v = [0.0] * 16
    v[topic] = 1.0
    return v

docs.append([
    {"source": "help-center", "body": "To cancel a subscription, open Settings then Billing.", "embedding": embed(0)},
    {"source": "help-center", "body": "Refunds return to the original payment method.",         "embedding": embed(0)},
    {"source": "blog",        "body": "Enable dark mode under Settings then Appearance.",        "embedding": embed(1)},
])

const embed = (topic) => { const v = Array(16).fill(0.0); v[topic] = 1.0; return v; };

docs.append([
  { source: "help-center", body: "To cancel a subscription, open Settings then Billing.", embedding: embed(0) },
  { source: "help-center", body: "Refunds return to the original payment method.",         embedding: embed(0) },
  { source: "blog",        body: "Enable dark mode under Settings then Appearance.",        embedding: embed(1) },
]);

fn embed(topic: usize) -> Vec<f32> {
    let mut v = vec![0.0_f32; 16];
    v[topic] = 1.0;
    v
}

let flat: Vec<f32> = [0usize, 0, 1].iter().flat_map(|&t| embed(t)).collect();
docs.append(&RecordBatch::try_new(
    schema,
    vec![
        Arc::new(LargeStringArray::from(vec!["help-center", "help-center", "blog"])),
        Arc::new(LargeStringArray::from(vec![
            "To cancel a subscription, open Settings then Billing.",
            "Refunds return to the original payment method.",
            "Enable dark mode under Settings then Appearance.",
        ])),
        Arc::new(FixedSizeListArray::new(item, 16, Arc::new(Float32Array::from(flat)), None)),
    ],
)?)?;

Search it

Now the part you came for. The same table answers every kind of query: keyword, meaning, hybrid, and SQL.

# Searches return `_id` + `score` by default; pass `projection` to name the
# columns you want back (here, `body`).
keyword  = docs.bm25_search("body", "cancel subscription", 5, projection=["body"])   # BM25
semantic = docs.vector_search("embedding", embed(0), 5, projection=["body"])         # vector kNN
# hybrid: BM25 + vector, fused with reciprocal-rank fusion:
hybrid   = docs.hybrid_search("body", "cancel subscription", "embedding", embed(0), 5, projection=["body"])
billing  = db.query_sql("SELECT body FROM docs WHERE source = 'help-center'")        # SQL

for name, hits in [("keyword", keyword), ("semantic", semantic), ("hybrid", hybrid), ("sql", billing)]:
    print(name, hits.column("body").to_pylist())

// Searches return `_id` + `score` by default; pass `projection` to name the
// columns you want back (here, `body`).
const keyword  = docs.bm25Search("body", "cancel subscription", 5, { projection: ["body"] });   // BM25
const semantic = docs.vectorSearch("embedding", embed(0), 5, { projection: ["body"] });         // vector kNN
// hybrid: BM25 + vector, fused with reciprocal-rank fusion:
const hybrid   = docs.hybridSearch("body", "cancel subscription", "embedding", embed(0), 5, { projection: ["body"] });
const billing  = db.querySql("SELECT body FROM docs WHERE source = 'help-center'");             // SQL

for (const [name, hits] of [["keyword", keyword], ["semantic", semantic], ["hybrid", hybrid], ["sql", billing]]) {
  console.log(name, hits.map((r) => r.body));
}

// Searches return `_id` + `score` by default; pass a projection to name the
// columns you want back (here, `body`).
let keyword = docs.bm25_search(
    "body", "cancel subscription", 5, Bm25SearchOptions::new(), Some(&["body"]),
)?; // BM25
let semantic = docs.vector_search(
    "embedding", &embed(0), 5, None, Some(&["body"]),
)?; // vector kNN
// hybrid: BM25 + vector, fused with reciprocal-rank fusion:
let hybrid = docs.hybrid_search(
    "body", "cancel subscription", BoolMode::Or,
    "embedding", &embed(0), 5, Some(&["body"]),
)?;
let billing = db.query_sql("SELECT body FROM docs WHERE source = 'help-center'")?; // SQL

Each search returns rows carrying the projected body. With this tiny corpus you get:

Expected output

keyword   "To cancel a subscription, open Settings then Billing."

semantic  "To cancel a subscription, open Settings then Billing."
          "Refunds return to the original payment method."
          "Enable dark mode under Settings then Appearance."

hybrid    "To cancel a subscription, open Settings then Billing."
          "Refunds return to the original payment method."
          "Enable dark mode under Settings then Appearance."

sql       "To cancel a subscription, open Settings then Billing."
          "Refunds return to the original payment method."

keyword matched the BM25 terms; semantic ranks the billing notes first; hybrid fuses the two rankings, so the exact keyword match leads while the semantically close note follows; sql returns the two help-center rows. From here, feed the retrieved passages to your model as grounding context.

Next steps

Core concepts

The mental model: one Parquet copy, indexed and queried four ways.

Guides

Tables, embeddings, indexing, search, and storage.

Infino Cloud

Run the same searches against a hosted database, no storage to manage.

SQL Reference

Query and compose search with SQL.

SDK

CLI