List the tables in the connected catalog. Call this first to discover what is available to search or query.

Return a table's column names and types — call before searching so you know which column to target and what fields each result row carries.

Provision the database named in the connection. On Infino Cloud this registers the database; on a local path or bucket the catalog root is the database, so this is a no-op success. Idempotent: an existing database is reported as created: false. Call it when a hosted connection answers 404.

Create a table from a {column: type} descriptor. Full-text (BM25) indexes go on the columns named in 'fts' (default: every large_utf8 column; the index requires that type). With vector: true the server adds an 'embedding' column sized to its embedder and a cosine vector index on it, so semantic and hybrid search work and rows added without a vector are embedded from their text. Every column is required in every row you add, so declare only columns you will always fill. Give every table a stable key column of type utf8 so rows can be replaced or removed later by predicate (e.g. key = 'doc-1'); keep utf8 for ids and short labels and large_utf8 for the text to search, so the searches infer the right column.

Drop a table from the catalog and, by default, delete its storage objects too. Pass purge: false to only unregister the table and leave the bytes in place. Irreversible.

Use when searching for a concept by meaning and the exact wording is unknown — this retrieves paraphrases and synonyms, not just literal matches. Embeds the query with a local model (no API key) and ranks a table's embedding column by vector similarity. Each hit carries a score that is a DISTANCE (lower is closer) plus the columns you project ('columns'; the full text column by default). Optional 'filter' restricts the ranking to rows whose keyword column matches a predicate first (a pushdown pre-filter, e.g. semantic search only within rows tagged 'billing'). For exact terms use infino_keyword_search; when the query has both literal terms and an intent use infino_hybrid_search.

Use when the query is literal terms — identifiers, error codes, product names, exact phrases — and you want results ranked by relevance. BM25 full-text search over a text column: ranks rows by how well the query's tokens (and their stems) match, each with a relevance score (higher is better) plus the columns you project ('columns'; the full text column by default). Matches exact tokens, not synonyms or paraphrases. Prefer this over SQL LIKE for known literal terms. For meaning-based search use infino_semantic_search; for both at once use infino_hybrid_search.

Use when a query carries both specific terms and an intent — you want exact-term precision without giving up paraphrase recall. Fuses BM25 over a text column with vector similarity over the embedding column in a single ranking pass, so rows matching the literal terms AND the meaning rank highest; the score is the fused rank (higher is better) plus the columns you project ('columns'; the full text column by default). Embeds the query with a local model (no API key). Sits between infino_keyword_search (literal only) and infino_semantic_search (meaning only).

Use when you need the SET of rows containing a keyword, not a ranked order — a fast unranked keyword filter. Returns rows whose text column contains the token(s), matching indexed tokens and their stems. For ranked results use infino_keyword_search; for analytical filtering across columns use infino_sql.

Use to fetch rows whose column exactly equals a value — a tag, status, or id string. Unranked exact-equality filter over an indexed column. For ranked text relevance use infino_keyword_search; for multi-column analytical filtering use infino_sql.

Use when you only need HOW MANY rows match a keyword query, not the rows themselves — a fast tally over a text column, without fetching or ranking. Cheaper than infino_keyword_search when a number is all you need (e.g. 'how many docs mention X'). For the matching rows use infino_keyword_search or infino_token_match.

Use for structural or analytical questions — counts, GROUP BY, joins, aggregates, filtering by column value — returning result rows. The engine's search functions are callable as table-valued relations, so a single query can rank AND aggregate: bm25_search('table','text_col','terms', k) — also bm25_search_prefix / token_match / exact_match — need no embedding. vector_search('table','vec_col', {{q}}, k) and hybrid_search('table','text_col','terms','vec_col', {{q}}, k) need a query vector: put a {{name}} placeholder where the vector goes and pass embed:{"name":"query text"} — the server embeds the text and substitutes the vector in. Example: SELECT path, SUM(end_line - start_line + 1) AS lines FROM bm25_search('docs','body','error timeout', 300) GROUP BY path ORDER BY lines DESC. Any single statement is allowed, DDL/DML included.

Append documents (rows, as JSON objects keyed by column name) to a table; one call is one commit. If the table has a vector index and a document omits the vector, the server embeds its text column (a local model, no API key). Send tens of rows per call; for a whole corpus use the infino CLI or an SDK.

Replace the rows matching a SQL predicate with new documents, 1:1; the number of matched rows must equal the number of replacement documents. As with add, a row that omits its vector has it embedded from the text column (local model, no API key). Requires durable storage (not memory://).

Delete the rows matching a SQL predicate, e.g. "status = 'spam'". Returns how many rows matched and were removed. Check the predicate first with infino_count or infino_sql. Requires durable storage (not memory://).