◆ VECTOR DB RAG

LanceDB

v0.38.0 open-source

Developer-friendly OSS embedded retrieval library for multimodal AI. Search More; Manage Less.

source ↗ website ↗ rss ↗ last repo push Aug 31, 2026

import lancedb

db = lancedb.connect(
    "az://my-container/my-database",
    azure_storage_options={
        "account_name": "my-account",
        "account_key": "my-key",
    },
)
from lancedb.query import DocumentGranularity

# Create index at list-element granularity
table.create_fts_index("chunks", document_granularity=DocumentGranularity.LIST_ELEMENT)

# Query at the same granularity
results = (
    table.search("neural scaling laws", query_type="fts")
    .document_granularity(DocumentGranularity.LIST_ELEMENT)
    .limit(5)
    .to_pandas()
)
from lancedb.streaming import StreamingDataset, StreamingDataLoader

dataset = StreamingDataset(
    table,
    num_splits=8,
    pack_sequences=2048,   # block length in tokens
    eos_id=2,
    pad_id=1,
    blocks_per_epoch="auto",
)
loader = StreamingDataLoader(dataset, batch_size=4, num_workers=4)

for batch in loader:
    # batch contains 'input_ids' and 'doc_ids' LongTensors
    train_step(batch)
    checkpoint = dataset.state_dict()  # consumer-committed checkpoint
job = await table.refresh_column_async("summary_embedding")
result = await job.wait()
for await (const name of db.listTables()) {
  console.log(name);
}
const names = [];
let pageToken = undefined;
do {
  const page = await conn.listTables({ limit: 100, pageToken });
  names.push(...page.tables);
  pageToken = page.pageToken;
} while (pageToken);
const page = await conn.listTables('my/namespace', { limit: 50 });
console.log(page.tables);
import * as lancedb from "@lancedb/lancedb";
const db = await lancedb.connect("./.lancedb");
const table = await db.openTable("my_table");

const plan = await table.query()
  .nearestTo([0.5, 0.2])
  .limit(10)
  .analyzePlan();

console.log(plan);
import * as lancedb from "@lancedb/lancedb";
const db = await lancedb.connect("./.lancedb");
const table = await db.openTable("my_table");

const schema = await table.query()
  .select(["id", "vector"])
  .where("id > 0")
  .outputSchema();

console.log(schema.fields.map(f => `${f.name}: ${f.type}`));
import lancedb

db = lancedb.connect(
    "az://my-container/my-database",
    azure_storage_options={
        "account_name": "some-account",
        "account_key": "some-key",
    },
)
from lancedb.query import DocumentGranularity

# Create the index at list-element granularity
table.create_fts_index("chunks", document_granularity=DocumentGranularity.LIST_ELEMENT)

# Query at the same granularity
results = (
    table.search("adversarial prompt", query_type="fts")
    .document_granularity(DocumentGranularity.LIST_ELEMENT)
    .limit(10)
    .to_pandas()
)
from lancedb.streaming import StreamingDataset, StreamingDataLoader

dataset = StreamingDataset(table, num_splits=2)
loader = StreamingDataLoader(dataset, batch_size=8, num_workers=2)

for batch in loader:
    # train step ...
    checkpoint = dataset.state_dict()  # safe: committed on batch delivery
await table.create_fts_index("body", stop_words=["foo", "bar", "baz"])
await table.flush_lsm()
await table.compact_lsm()
stats = await table.get_lsm_stats()
print(stats)
import lancedb
from lancedb.rerankers import WatsonxReranker

db = lancedb.connect('~/.lancedb')
tbl = db.open_table('my_table')
reranker = WatsonxReranker()
results = tbl.search('network intrusion detection', query_type='hybrid').rerank(reranker=reranker).limit(5).to_pandas()
from lancedb.rerankers import WatsonxReranker
import lancedb

db = lancedb.connect("./my_db")
table = db.open_table("my_table")
reranker = WatsonxReranker()
results = (
    table.search("neural network", query_type="hybrid")
    .rerank(reranker=reranker)
    .limit(5)
    .to_list()
)
results = (
    table.search(query_vector)
    .where(Expr.field("category").isin(["malware", "phishing", "ransomware"]))
    .limit(10)
    .to_pandas()
)
results = table.search(query_vector).approx(True).limit(50).to_pandas()
from lancedb.query import Expr
tbl.delete(Expr.field("status").isin(["stale", "archived"]))
from lancedb.query import Expr
results = table.search().where(Expr.col("status").isin(["active", "pending"])).to_list()
await table.add(data, { progress: (count) => console.log(`Inserted ${count} rows`) });
import lancedb
table.search().where(lancedb.lit(b'\x00\x01\x02') == table['payload']).to_list()
const results = await table
  .query()
  .order_by([{ column: 'score', ascending: false }])
  .toArray();
import lancedb
from lancedb import ClientConfig

db = lancedb.connect(
    "db://my-project",
    api_key="<api_key>",
    client_config=ClientConfig(user_id="[email protected]"),
)
await table.prewarmData();
from lancedb import ClientConfig

config = ClientConfig(user_id="[email protected]")
db = lancedb.connect("db://my-lancedb", client_config=config)
let result = table.delete("status = 'inactive'").await?;
println!("Deleted {} rows", result.num_deleted_rows);
plan = (
    table.search('security breach', query_type='hybrid')
    .explain_plan(verbose=True)
)
print(plan)
result = table.delete("category = 'obsolete'")
print(result.num_deleted_rows)
table.update(where="id = 42", values={"metadata": {"source": "ingest", "version": 3}})
table.update(where="id = 42", values={"metadata": {"source": "upload", "version": 2}})
results = table.search(query_vector).fast_search().limit(10).to_list()
results = table.search(query_vector).fast_search().to_list()
uri = table.uri
print(uri)  # e.g. s3://my-bucket/my-db/my-table.lance
table = db.create_table('my_table', data=df, storage_options={'stable_row_ids': 'true'})
import lancedb

db = lancedb.connect("<uri>")
tbl = db.create_table(
    "my_table",
    data=my_data,
    storage_options={"stable_row_ids": "true"}
)
import lancedb
from pydantic import BaseModel

class Item(BaseModel):
    id: int
    text: str
    vector: list[float]

async def query():
    db = await lancedb.connect_async("<uri>")
    tbl = await db.open_table("my_table")
    results = await tbl.query().limit(10).to_pydantic(Item)
    return results
import lancedb

db = lancedb.connect("<uri>")
tbl = db.open_table("my_table")
tbl.create_index(metric="cosine", index_type="IVF_SQ", vector_column_name="vector")
results = await table.search(query_vector).to_pydantic(MyModel)
schema = table.search(query_vector).limit(10).output_schema()
print(schema)
table.create_index("embedding", index_type="IVF_RQ")
schema = table.search(query_vector).limit(10).output_schema()
print(schema)
table.create_index(metric='cosine', name='my_vector_index', train=False)
table.create_index("vector", index_type="IVF_PQ", name="my_vector_index", train=False)
table.create_index("embedding", name="my_vector_index")
table.create_index("embedding", name="my_embedding_idx")
import lancedb

db = lancedb.connect(
    "db://my-project",
    api_key="<api_key>",
    region="us-east-1",
    timeout=30,  # seconds
)
table.merge_insert("id").when_matched_update_all().when_not_matched_insert_all().execute(new_data, timeout=30)
table.create_tag("v1-baseline", version=5)
# ... later ...
table.checkout_tag("v1-baseline")
stats = table.stats()
print(stats)
table.merge_insert("id").when_matched_update_all().when_not_matched_insert_all().execute(new_data, timeout=30)
import lancedb
import pyarrow as pa

def batch_generator():
    for i in range(10):
        yield pa.record_batch({"vec": [[float(i)] * 128], "id": [i]},
                              schema=pa.schema([pa.field("vec", pa.list_(pa.float32(), 128)),
                                                pa.field("id", pa.int64())]))

db = lancedb.connect("./mydb")
table = db.create_table("embeddings", data=batch_generator())
import lancedb

db = lancedb.connect("./mydb")
tbl = db.open_table("my_table")

tbl.alter_columns({"path": "embedding", "metadata": {"model": "text-embedding-3-small", "dim": "1536"}})
import asyncio
import lancedb

async def main():
    db = await lancedb.connect_async("~/.lancedb")
    table = await db.open_table("my_vectors")
    results = await table.search([0.1, 0.2, 0.3]).limit(10).to_pandas()
    print(results)

asyncio.run(main())
results = table.search(query_vector).distance_type("cosine").limit(10).to_list()
table.drop_index("my_vector_index")
results = table.search(query_vector).distance_type("cosine").limit(10).to_list()
results = table.search(query_vector).distance_type('cosine').limit(10).to_list()
table.drop_index("index_name")
table.drop_index("vector_idx")
result = await table.query().nearest_to(vector).to_polars()
results = await table.search(query_vector).to_polars()
print(results)
results = await table.search([0.1, 0.2, 0.3]).limit(10).to_polars()
results = table.search(query_vector).bypass_vector_index(True).limit(10).to_list()
await db.drop_table("my_table", ignore_missing=True)
table.create_index(metric="hamming", index_type="IVF_FLAT", vector_column_name="binary_vec")
results = table.search(query_vector).bypass_vector_index(True).limit(10).to_list()
await db.drop_table("my_table", ignore_missing=True)
import lancedb

db = lancedb.connect(
    "az://my-container/my-db",
    storage_options={"account_name": "mystorageaccount"}
)
import lancedb

db = lancedb.connect(
    "az://my-container/my-db",
    storage_options={"account_name": "mystorageaccount"}
)
import lancedb
import pyarrow.dataset as ds

db = lancedb.connect("./mydb")
table = db.open_table("embeddings")
dataset = table.to_arrow_dataset()
batches = dataset.to_batches()
results = await table.search([0.1, 0.2, 0.3]).fast_search().limit(10).to_list()
results = await table.search([[0.1, 0.2], [0.3, 0.4]]).limit(5).to_list()
results = await table.search('malware signature').with_row_id(True).limit(20).to_list()
results = table.search(query_vector).fast_search().to_list()
results = table.search([vec1, vec2, vec3]).to_list()
results = table.search('threat actor', query_type='fts').where("severity = 'high'").to_list()
results = table.search(query_vector).fast_search().limit(10).to_list()
embeddings = get_registry().get("huggingface").create(name="trust-remote/model", trust_remote_code=True)
embeddings = get_registry().get('huggingface').create(name='org/custom-model', trust_remote_code=True)
table = db.create_table("my_table", schema=schema, data_storage_version="legacy")
results = table.search('attack vector', query_type='hybrid').phrase_query(True).to_list()
results = table.search('exact phrase here').phrase_query(True).limit(10).to_list()
await table.create_scalar_index('category', index_type='BITMAP')
results = await table.query().where("category = 'news'").to_list()
await table.create_scalar_index("category", index_type="BITMAP")
from lancedb.embeddings import get_registry
from lancedb.rerankers import JinaReranker

jina_embed = get_registry().get('jina').create()
reranker = JinaReranker()

results = table.search('cybersecurity threat intelligence') \
    .rerank(reranker=reranker) \
    .to_pandas()
await tbl.update({ valuesSql: { price: 'price * 1.1' } })
await table.optimize()
table = db.open_table("my_vectors", index_cache_size=512)
db.rename_table("old_name", "new_name")
from datasets import load_dataset
ds = load_dataset("squad", split="train")
table = db.create_table("squad", ds)
from datasets import load_dataset
ds = load_dataset("squad")
table = db.create_table("squad", data=ds)
from lancedb.embeddings import get_registry

openai = get_registry().get('openai').create()
print(openai.model_names())
table.drop_columns(["embedding"])
import lancedb

db = lancedb.connect(
    "s3://my-bucket/lancedb",
    read_consistency_interval=5  # seconds
)
table = db.open_table("my_table")
import lancedb

db = lancedb.connect("~/.lancedb")
table = db.open_table("my_table")
count = table.count_rows(filter="category = 'critical'")
print(count)
results = (
    table.search("your query", query_type="hybrid")
    .rerank(reranker=reranker)
    .limit(10)
    .to_pandas()
)
from lancedb.embeddings import get_registry

bedrock = get_registry().get("bedrock").create()

class MyTable(LanceModel):
    text: str = bedrock.SourceField()
    vector: Vector(bedrock.ndims()) = bedrock.VectorField()
table = db.create_table('my_table', data=df, exist_ok=True)
df = table.to_polars()
import lancedb

db = lancedb.connect("./my_db")
table = db.create_table("my_table", data=my_data, exist_ok=True)
import lancedb

db = lancedb.connect("./my_db")
table = db.open_table("my_table")
df = table.to_polars()
import lancedb

db = lancedb.connect("./my_db")
table = db.create_table("items", data=[{"vector": [1.0, 2.0], "label": "a"}], exist_ok=True)
df = table.search(query_vector).to_pandas(flatten=True)
table.create_scalar_index("price")
results = (
    table.search([0.1, 0.2, 0.3])
        .where("category = 'public'")
        .prefilter(True)
        .limit(10)
        .to_list()
)
table.update(where="status = 'pending'", values={"status": "reviewed"})
table.update(where="status = 'pending'", values={"status": "processed"})
results = table.search().where("score > 0.9").to_list()
await tbl.update({
  filter: "id = 2",
  updates: { vector: [2, 2], name: "Michael" },
})
df = table.search(query_vector).limit(10).to_pandas()
results = table.search(query_vector).limit(10).to_pandas()
table.search(query_vector).where("category = 'malware'", prefilter=True).limit(10).to_df()
pip install lancedb[clip]
import lancedb
print(lancedb.__version__)
import lancedb

def record_generator():
    for i in range(100_000):
        yield {"id": i, "vector": [float(i), float(i)], "text": f"item {i}"}

db = lancedb.connect("./mydb")
table = db.open_table("items")
table.add(record_generator())
results = table.search([0.1, 0.2]).limit(10).to_pandas()
print(results[["id", "text", "_distance"]].sort_values("_distance"))
import lancedb
from lancedb.pydantic import LanceModel, vector

class Document(LanceModel):
    text: str
    vector: vector(384)

db = lancedb.connect("/tmp/mydb")
table = db.create_table("docs", schema=Document.to_arrow_schema())
table.add([Document(text="hello world", vector=[0.1] * 384)])

results = table.search([0.0] * 384).limit(5).to_pydantic(Document)
print(results)
await table.createIndex({ replace: true });
const table = await db.createTable('embeddings', data, { writeMode: WriteMode.Overwrite });
const count = await table.countRows();
console.log(`Row count: ${count}`);
const lancedb = require('vectordb');
const db = await lancedb.connect('/tmp/mydb');
const table = await db.createTable('embeddings', [
  { vector: [0.1, 0.2, 0.3], text: 'hello world' }
]);
const results = await table.search([0.1, 0.2, 0.3]).limit(5).execute();

Summary

LanceDB is an open-source multimodal data platform for AI/ML applications, and its use is governed by the MIT license. It is exposed as a central location for developers to build, train, and analyze AI workloads, allowing storage, indexing, and searching across petabytes of multimodal data and vectors. It is for developers building AI/ML applications and its architecture is built on the Lance columnar format, while its README describes it as the ultimate multimodal data platform. The project shows ongoing development activity based on the provided documentation links and general availability.

Developer-friendly OSS embedded retrieval library for multimodal AI. Search More; Manage Less.

What LanceDB answers

What query types can I execute against the data?

The system performs search by keyword, vector, or using SQL.

How large is the dataset I can manage?

It supports storage, indexing, and search over petabytes of multimodal data and vectors.

What format is the underlying storage built upon?

The platform is built on the Lance columnar format.

Where can I find examples of how to use the system?

Recipes are available in the main repository.

Can I build, train, and analyze different kinds of AI workloads?

LanceDB acts as a central location for developers to build, train, and analyze their AI workloads.

Does the system support searching across different data types?

It handles multimodal data, allowing searching across vectors and other types.

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

docs update Aug 31, 2026 · issue 012

LanceDB adds sequence-packing for LLM training, list-element FTS granularity, GPU remote functions, and Azure direct-credential support.
└──▷ USE IT
Connect to an Azure-hosted LanceDB database by passing credentials inline instead of relying on environment variables.
python
```
import lancedb

db = lancedb.connect(
    "az://my-container/my-database",
    azure_storage_options={
        "account_name": "my-account",
        "account_key": "my-key",
    },
)
```
Build a full-text-search index that treats each element of a nested list field as its own document, then query it at list-element granularity to get physical coordinates.
python
```
from lancedb.query import DocumentGranularity

# Create index at list-element granularity
table.create_fts_index("chunks", document_granularity=DocumentGranularity.LIST_ELEMENT)

# Query at the same granularity
results = (
    table.search("neural scaling laws", query_type="fts")
    .document_granularity(DocumentGranularity.LIST_ELEMENT)
    .limit(5)
    .to_pandas()
)
```
Enable sequence-packing for LLM pre-training so the streaming dataset joins consecutive token lists into fixed-length blocks with document-index tensors for masking.
python
```
from lancedb.streaming import StreamingDataset, StreamingDataLoader

dataset = StreamingDataset(
    table,
    num_splits=8,
    pack_sequences=2048,   # block length in tokens
    eos_id=2,
    pad_id=1,
    blocks_per_epoch="auto",
)
loader = StreamingDataLoader(dataset, batch_size=4, num_workers=4)

for batch in loader:
    # batch contains 'input_ids' and 'doc_ids' LongTensors
    train_step(batch)
    checkpoint = dataset.state_dict()  # consumer-committed checkpoint
```
- ›Adds azure_storage_options parameter to pass Azure Blob Storage credentials (e.g. account_name, account_key) directly when connecting to an az:// URI, without setting environment variables.
- ›Adds document_granularity parameter (accepts DocumentGranularity.ROW or DocumentGranularity.LIST_ELEMENT) to full-text-search index creation and queries, enabling per-list-element document indexing with physical coordinates returned in _doc_index.
- ›Adds pack_sequences mode to the streaming dataset: consecutive token lists are joined with eos_id, sliced into fixed-length blocks, and each item yields a dict of input_ids and doc_ids LongTensors for block-diagonal masking or position-id resets.
- ›Adds eos_id (separator token between packed documents), pad_id (padding token to complete short blocks), and blocks_per_epoch (total packed blocks per epoch, or 'auto' for corpus-level estimation) — all required companions to pack_sequences.
- ›Introduces StreamingDataLoader, a PyTorch DataLoader subclass that carries consumer-committed StreamingDataset checkpoints alongside every internal batch, enabling safe mid-epoch resumption with multiple workers.
+3 moreshow less
- ›Adds gpu flag to remote Function definitions, requiring a GPU for every execution; the requirement is baked into the immutable Function version.
- ›Adds conda_channels and channels options to remote environment definitions, allowing Conda packages and priority-ordered channels alongside gpu and environment-variable settings.
- ›Adds field metadata convention keys lancedb:description, lancedb:tag:<name>, lancedb:logical-column, and lancedb:status (values: production, candidate, deprecated, archived) for annotating table columns via the metadata API.
v0.38.0 Aug 31, 2026 · issue 012

LanceDB v0.38.0 adds computed columns, materialized views, GPU-backed functions, blob URI writes, and async table ops across Python and Node.js SDKs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.38.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.38.0
```
└──▷ USE IT
Kick off an async computed-column refresh and hold a job handle to poll or await the result.
python
```
job = await table.refresh_column_async("summary_embedding")
result = await job.wait()
```
List tables with the new Node.js listTables API instead of the deprecated tableNames.
javascript
```
for await (const name of db.listTables()) {
  console.log(name);
}
```
- ›Adds listTables to the Node.js SDK, deprecating tableNames, for paginated table listing driven by the store's own cursor.
- ›Adds on_transform_error fault-tolerance parameter to StreamingDataset in Python, letting callers control error handling during data transforms.
- ›Adds backpressure to the StreamingDataset post-transform queue in Python to prevent unbounded memory growth during streaming ingestion.
- ›Supports sequence packing in StreamingDataset for Python, enabling efficient packing of variable-length sequences for training workloads.
- ›Adds an asynchronous drop-table API so table deletion no longer blocks the caller.
+24 moreshow less
- ›Supports declaring computed columns by SQL expression on both local and remote tables.
- ›Adds refresh_column_async, which returns a job handle for tracking computed-column refresh progress.
- ›Enables computed columns to read earlier declarations within the same batch, allowing multi-step column derivation.
- ›Supports blob computed column refresh, extending computed-column refresh to blob-typed columns.
- ›Supports Blob v2 UDF signatures for user-defined functions operating on blob data.
- ›Adds materialized view declarations on local tables, plus a refresh API to update them; Python and Node.js bindings included.
- ›Binds materialized view refresh to the view incarnation so stale refreshes against a replaced view are rejected.
- ›Adds first-class function wire contracts, scalar function authoring, and a catalog client for managing remote functions.
- ›Adds grouped function column bindings, allowing a function to be bound to a group of columns.
- ›Supports binding function versions to specific columns in Python.
- ›Supports GPU resource requirements on Functions, enabling GPU-accelerated remote function execution.
- ›Supports large_utf8 function signatures in Python for Functions returning large string types.
- ›Supports nested Arrow types in Python Function definitions.
- ›Supports conda environment declarations on Functions, letting authors pin the runtime environment.
- ›Adds blob URI write acceptance so blob data can be written via URI reference.
- ›Exposes list-element FTS document granularity, giving full-text search finer control over how list fields are indexed.
- ›Accepts Python expressions (not just strings) in update filters in Python.
- ›Exposes LSM checkpoint and stats on the synchronous Python RemoteTable.
- ›Brings the MemWAL LSM surface to parity across all SDKs.
- ›Renames branch merge to cherry_pick for branch operations.
- ›Supports remote tables in the data loader.
- ›Pins the base table version for data loader reads, ensuring consistent snapshots during load.
- ›Returns typed refresh job results from refresh operations.
- ›Requires Node.js >= 22; npm lockfiles are dropped from the Node.js package.
└──▷ BREAKING ON UPGRADE
- !Table existence is now manifest-authoritative: tables that lack a manifest entry are no longer considered to exist, even if other store artifacts are present.
- !The Python SDK now requires Pydantic v2; Pydantic v1 is no longer supported.
- !The Node.js SDK now keys parsed embedding configs by vector column name; projects relying on the previous keying scheme will need to update their embedding config references.
- !The branch merge operation is renamed to cherry_pick; any code calling merge on a branch must be updated to cherry_pick.
- !Table listings are now paged from the store's own cursor; external code that constructed or passed page tokens for table listings must be updated.
- !The Node.js SDK now requires Node >= 22; projects running on Node 18 or 20 must upgrade.
docs update Aug 29, 2026 · issue 010

LanceDB JS Connection.listTables() gains paginated listing with optional namespace path support
└──▷ USE IT
Walk all pages of tables in a LanceDB database without missing any, even when a page is shorter than the requested limit.
javascript
```
const names = [];
let pageToken = undefined;
do {
  const page = await conn.listTables({ limit: 100, pageToken });
  names.push(...page.tables);
  pageToken = page.pageToken;
} while (pageToken);
```
List tables scoped to a specific namespace path rather than the root namespace.
javascript
```
const page = await conn.listTables('my/namespace', { limit: 50 });
console.log(page.tables);
```
- ›Adds paginated listTables(options) overload to Connection, returning a ListTablesResponse with a tables array and an optional continuation token for walking large table lists page by page.
- ›Adds listTables(namespacePath, options) overload to Connection to list tables scoped to a specific namespace path, defaulting to the root namespace when omitted.
- ›Introduces ListTablesOptions and ListTablesResponse types to support page-size control and token-based pagination in listTables calls.
docs update Aug 29, 2026 · issue 010

LanceDB JS adds AutoQuery class for automatic full-text/vector search routing and LSM MemWAL read control via useLsm()
└──▷ USE IT
Profile a vector search query by inspecting its physical execution plan with runtime metrics to identify bottlenecks.
typescript
```
import * as lancedb from "@lancedb/lancedb";
const db = await lancedb.connect("./.lancedb");
const table = await db.openTable("my_table");

const plan = await table.query()
  .nearestTo([0.5, 0.2])
  .limit(10)
  .analyzePlan();

console.log(plan);
```
Inspect the output schema of a query before execution to validate column names and types in a pipeline.
typescript
```
import * as lancedb from "@lancedb/lancedb";
const db = await lancedb.connect("./.lancedb");
const table = await db.openTable("my_table");

const schema = await table.query()
  .select(["id", "vector"])
  .where("id > 0")
  .outputSchema();

console.log(schema.fields.map(f => `${f.name}: ${f.type}`));
```
- ›Adds useLsm(enable: boolean) method to control MemWAL read routing per query: true forces the LSM scanner (errors if no MemWAL write spec), false bypasses MemWAL and reads the base table only even when a spec is present.
- ›Adds analyzePlan(distributedMetrics?) method that executes a query and returns the physical query plan annotated with runtime metrics (elapsed time, rows processed, I/O statistics, IOPS); accepts AnalyzePlanDistributedMetrics to control how distributed worker metrics are aggregated.
- ›Introduces the AutoQuery class — a query builder that automatically selects full-text or vector search based on the table revision at execution time, exposing fullTextSearch(), where(), orderBy(), limit(), offset(), select(), fastSearch(), withRowId(), toArray(), and toArrow().
- ›Adds orderBy(ordering: ColumnOrdering | ColumnOrdering[]) to sort query results by one or more columns.
- ›Adds offset(offset: number) for pagination support in query results.
+1 moreshow less
- ›Adds outputSchema() returning a Promise<Schema> so callers can inspect output column types and names before executing a query.
docs update Aug 29, 2026 · issue 010

LanceDB adds Azure direct-credential auth, LIST_ELEMENT FTS granularity, sequence packing for streaming, and StreamingDataLoader for PyTorch.
└──▷ USE IT
Open an Azure-hosted LanceDB database by passing credentials directly instead of relying on environment variables.
python
```
import lancedb

db = lancedb.connect(
    "az://my-container/my-database",
    azure_storage_options={
        "account_name": "some-account",
        "account_key": "some-key",
    },
)
```
Index a list-typed text column so each list element is its own FTS document, then query at list-element granularity to get per-element coordinates in _doc_index.
python
```
from lancedb.query import DocumentGranularity

# Create the index at list-element granularity
table.create_fts_index("chunks", document_granularity=DocumentGranularity.LIST_ELEMENT)

# Query at the same granularity
results = (
    table.search("adversarial prompt", query_type="fts")
    .document_granularity(DocumentGranularity.LIST_ELEMENT)
    .limit(10)
    .to_pandas()
)
```
Use StreamingDataLoader for safe mid-epoch checkpointing during GPU training — checkpoint state is committed only when the trainer consumes the batch.
python
```
from lancedb.streaming import StreamingDataset, StreamingDataLoader

dataset = StreamingDataset(table, num_splits=2)
loader = StreamingDataLoader(dataset, batch_size=8, num_workers=2)

for batch in loader:
    # train step ...
    checkpoint = dataset.state_dict()  # safe: committed on batch delivery
```
- ›Adds azure_storage_options parameter (with account_name and account_key keys) to pass Azure Blob Storage credentials directly when opening a database, without setting environment variables.
- ›Adds allow_external_blob_outside_bases flag to allow blob URIs that sit outside registered blob bases on local tables, storing a reference so the object must remain readable.
- ›Adds document_granularity parameter (accepting DocumentGranularity.ROW or DocumentGranularity.LIST_ELEMENT) to full-text-search index creation and query methods, letting callers explicitly choose whether a row or each deepest-list element is treated as one FTS document.
- ›Introduces DocumentGranularity enum (ROW / 'row', LIST_ELEMENT / 'list_element') in lancedb.query to control full-text-search document scope, enabling per-list-element indexing and returning physical coordinates in _doc_index for matching queries.
- ›Adds sequence-packing mode to StreamingDataset via pack_sequences, eos_id, pad_id, and blocks_per_epoch parameters; packs consecutive token lists into fixed-length blocks with doc_ids for block-diagonal masking, with blocks_per_epoch supporting an 'auto' estimate.
+3 moreshow less
- ›Adds transform_queue_depth parameter to StreamingDataset to cap peak memory by limiting buffered post-transform batches per split before backpressure is applied to the transform stage.
- ›Introduces StreamingDataLoader (in lancedb.streaming) — a PyTorch DataLoader subclass that commits consumer-side dataset checkpoints only when a prefetched batch is returned by next(), enabling safe mid-epoch resumption across topology changes.
- ›Adds field metadata conventions under lancedb:description, lancedb:tag:<name>, lancedb:logical-column, and lancedb:status keys for human-readable descriptions, tagging, column grouping, and lifecycle state (production, candidate, deprecated, archived).
v0.37.1 Aug 10, 2026 · issue -009

LanceDB v0.37.1 adds LSM table operations, custom FTS stop-words, blob range reads, job handles for index creation, and namespace/table existence checks.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.37.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.37.1
```
└──▷ USE IT
Apply custom stop-words to an FTS index so domain-specific noise terms are excluded from search.
python
```
await table.create_fts_index("body", stop_words=["foo", "bar", "baz"])
```
Flush and compact the LSM layer after a bulk ingest to reclaim space and improve read performance.
python
```
await table.flush_lsm()
await table.compact_lsm()
stats = await table.get_lsm_stats()
print(stats)
```
- ›Adds checkpoint_lsm, flush_lsm, compact_lsm, and get_lsm_stats methods to the table API for direct LSM lifecycle management.
- ›Adds use_lsm option to queries to read MemWAL LSM data.
- ›Makes create_index return a Job handle, enabling callers to track and await async index-build progress.
- ›Adds connection-level job operations for managing background jobs at the connection scope.
- ›Supports batched blob range reads, enabling efficient partial retrieval of large binary objects.
+9 moreshow less
- ›Adds seekable blob range reads for remote tables via RemoteTable.
- ›Adds RemoteTable fetch_blobs HTTP client for fetching binary objects over the remote protocol.
- ›Adds block_size configuration for full-text search indexes.
- ›Supports custom stop-word lists for full-text search indexes.
- ›Exposes AsyncTable.to_lance in Python for converting async table references to Lance datasets.
- ›Adds configurable streaming transform parallelism in Python.
- ›Adds namespace and table existence checks in Python (namespace_exists / table_exists).
- ›Makes add_columns a builder pattern in the Rust API, enabling chained column-addition configuration.
- ›Infers maintained indexes automatically when an LsmWriteSpec omits them.
└──▷ BREAKING ON UPGRADE
- !add_columns in the Rust API is now a builder — call sites that used the previous direct invocation signature must be updated to the builder pattern.
- !LsmWriteSpec now infers maintained indexes when they are omitted; any code that relied on omitted indexes being ignored may see changed behavior.
v0.37.1 Aug 10, 2026 · issue 002

LanceDB v0.37.1 adds LSM table controls, async Lance access, custom FTS stop-words, blob range reads, and job-handle APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.37.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.37.1
```
- ›Adds checkpoint_lsm, flush_lsm, compact_lsm, and get_lsm_stats methods to the table API for explicit LSM lifecycle management.
- ›Adds use_lsm to query options to read MemWAL LSM data directly.
- ›Adds block size configuration for full-text search (FTS) indexes.
- ›Adds support for custom stop-word lists in FTS indexes.
- ›Exposes AsyncTable.to_lance in the Python SDK for async access to the underlying Lance dataset.
+8 moreshow less
- ›Adds streaming transform parallelism configuration in the Python SDK.
- ›Makes create_index return a Job handle, enabling callers to track or await index-build progress.
- ›Adds connection-level job operations for managing background jobs across a connection.
- ›Adds RemoteTable fetch_blobs HTTP client for fetching binary large objects via remote tables.
- ›Adds seekable blob range reads for remote tables.
- ›Supports batched blob range reads.
- ›Makes add_columns a builder in the Rust SDK (also a breaking change — see below).
- ›Adds inference of maintained indexes when an LsmWriteSpec omits them.
└──▷ BREAKING ON UPGRADE
- !add_columns in the Rust SDK is now a builder — call sites that used the previous non-builder API will not compile.
- !Index inference behaviour changes: when an LsmWriteSpec omits maintained indexes, LanceDB now infers them automatically rather than treating them as absent.
python-v0.36.0 Jul 28, 2026 · issue -022

LanceDB python-v0.36.0 adds elastic dataloaders, OpenTelemetry metrics, WatsonxReranker, FTS tokenization, Tencent COS/GooseFS support, and remote branch diff/merge APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.36.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.36.0
```
└──▷ USE IT
Rerank hybrid search results using IBM Watsonx when your retrieval pipeline is backed by a Watsonx model.
python
```
import lancedb
from lancedb.rerankers import WatsonxReranker

db = lancedb.connect('~/.lancedb')
tbl = db.open_table('my_table')
reranker = WatsonxReranker()
results = tbl.search('network intrusion detection', query_type='hybrid').rerank(reranker=reranker).limit(5).to_pandas()
```
- ›Adds get_lsm_write_spec method to read the installed LSM write spec from a table.
- ›Exposes Lance metrics via OpenTelemetry in Python and Node for observability into query and ingestion performance.
- ›Adds remote branch diff and merge client APIs for version-controlled table workflows.
- ›Adds WatsonxReranker reranker component for IBM Watsonx-backed reranking in retrieval pipelines.
- ›Adds Tencent COS and GooseFS object store support via new feature flags.
+6 moreshow less
- ›Publishes lancedb-compat wheels for pre-Haswell x86_64 hosts.
- ›Adds blob v2 fetch API in Python for retrieving binary large objects.
- ›Adds an elastic dataloader as an iterable dataset for flexible batch loading.
- ›Adds table FTS (full-text search) query tokenization support.
- ›Supports date, datetime, bytes, and Decimal literals in the expression builder.
- ›Supports distributed analyze plan metrics in clients.
└──▷ BREAKING ON UPGRADE
- !Permutation.with_format('torch') behavior is changed to align with HuggingFace's set_format('torch') — existing code relying on the previous output format will need to be updated.
python-v0.36.0 Jul 28, 2026 · issue 002

LanceDB python-v0.36.0 adds elastic dataloaders, OpenTelemetry metrics, WatsonxReranker, FTS tokenization, blob v2 API, and Tencent COS/GooseFS support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.36.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.36.0
```
- ›Adds get_lsm_write_spec to read the installed LSM write spec from a table.
- ›Exposes Lance metrics via OpenTelemetry in both Python and Node clients.
- ›Adds WatsonxReranker component for reranking search results in Python.
- ›Adds table full-text-search (FTS) query tokenization support.
- ›Adds Tencent COS and GooseFS object store support via new feature flags.
+7 moreshow less
- ›Publishes lancedb-compat wheels for pre-Haswell x86_64 hosts.
- ›Adds remote branch diff and merge client APIs.
- ›Adds blob v2 fetch API in Python.
- ›Adds an elastic dataloader as an iterable dataset.
- ›Supports date, datetime, bytes, and Decimal literals in the expression builder.
- ›Supports distributed analyze plan metrics in clients.
- ›Aligns Permutation.with_format('torch') with HuggingFace set_format('torch') behavior.
└──▷ BREAKING ON UPGRADE
- !Permutation.with_format('torch') now aligns with HuggingFace set_format('torch') semantics, which may change the output format of existing code relying on the previous behavior.
v0.33.0 Jul 28, 2026 · issue -022

LanceDB v0.33.0 adds OpenTelemetry metrics, FTS tokenization, WatsonxReranker, Tencent COS/GooseFS storage, and remote branch diff/merge APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.33.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.33.0
```
└──▷ USE IT
Rerank search results using the new WatsonxReranker in a hybrid search pipeline.
python
```
from lancedb.rerankers import WatsonxReranker
import lancedb

db = lancedb.connect("./my_db")
table = db.open_table("my_table")
reranker = WatsonxReranker()
results = (
    table.search("neural network", query_type="hybrid")
    .rerank(reranker=reranker)
    .limit(5)
    .to_list()
)
```
- ›Adds get_lsm_write_spec API to read the installed LSM write spec from a table.
- ›Exposes Lance metrics via OpenTelemetry in both Python and Node clients.
- ›Adds table full-text-search (FTS) query tokenization support.
- ›Adds remote branch diff and merge client APIs.
- ›Adds Tencent COS and GooseFS object store support via new feature flags.
+7 moreshow less
- ›Adds WatsonxReranker component for Python reranking pipelines.
- ›Adds a blob v2 fetch API for Python.
- ›Adds an elastic dataloader as an iterable dataset.
- ›Supports date, datetime, bytes, and Decimal literals in the expression builder.
- ›Supports distributed analyze plan metrics in clients.
- ›Publishes lancedb-compat wheels for pre-Haswell x86_64 hosts.
- ›Aligns Permutation.with_format('torch') behavior with HuggingFace set_format('torch').
└──▷ BREAKING ON UPGRADE
- !Permutation.with_format('torch') now behaves like HuggingFace's set_format('torch'), which may change output format for existing callers.
v0.33.0 Jul 28, 2026 · issue 002

LanceDB v0.33.0 adds OpenTelemetry metrics, WatsonxReranker, FTS tokenization, Tencent COS/GooseFS support, and remote branch diff/merge APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.33.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.33.0
```
- ›Adds get_lsm_write_spec to read the installed LSM write spec from a table.
- ›Exposes Lance metrics via OpenTelemetry in Python and Node clients.
- ›Adds blob v2 fetch API in Python.
- ›Adds remote branch diff and merge client APIs.
- ›Adds an elastic dataloader as an iterable dataset.
+7 moreshow less
- ›Adds WatsonxReranker component for Python reranking pipelines.
- ›Adds table FTS query tokenization.
- ›Supports date, datetime, bytes, and Decimal literals in the expression builder.
- ›Adds Tencent COS and GooseFS object store support via new feature flags.
- ›Publishes lancedb-compat wheels for pre-Haswell x86_64 hosts.
- ›Supports distributed analyze plan metrics in clients.
- ›Aligns Permutation.with_format('torch') behavior with HuggingFace set_format('torch').
└──▷ BREAKING ON UPGRADE
- !Permutation.with_format('torch') now aligns with HuggingFace set_format('torch') semantics, which may change behavior for existing Python code relying on the previous format output.
v0.32.0-beta.3 Jul 24, 2026 · issue -026

LanceDB v0.32.0-beta.3 adds block size configuration for full-text search indexing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.32.0-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.32.0-beta.3
```
- ›Adds block size configuration for full-text search (fts) index building.
v0.32.0-beta.3 Jul 24, 2026 · issue 002

LanceDB v0.32.0-beta.3 adds block size configuration for full-text search indexes.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.32.0-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.32.0-beta.3
```
- ›Adds block size configuration for full-text search (FTS) index creation, enabling tuning of on-disk index layout.
python-v0.35.0-beta.3 Jul 24, 2026 · issue -026

LanceDB adds block size configuration for full-text search indexes.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.35.0-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.35.0-beta.3
```
- ›Adds block size configuration for full-text search (FTS) indexes, enabling tuning of index storage granularity.
python-v0.35.0-beta.3 Jul 24, 2026 · issue 002

LanceDB python-v0.35.0-beta.3 adds block size configuration for full-text search indexes.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.35.0-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.35.0-beta.3
```
- ›Adds block size configuration for full-text search (FTS) index creation, enabling tuning of index storage layout.
python-v0.36.0-beta.0 Jul 24, 2026 · issue -026

LanceDB python-v0.36.0-beta.0 adds remote branch diff/merge APIs, distributed plan metrics, and pre-Haswell wheel support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.36.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.36.0-beta.0
```
- ›Adds remote branch diff and merge client APIs for managing data branches programmatically.
- ›Publishes lancedb-compat wheels targeting pre-Haswell x86_64 hosts, enabling deployment on older CPU architectures that lack AVX2 support.
- ›Supports distributed analyze plan metrics in clients for observability into query execution across distributed setups.
- ›Extends skill references to work with jobs, including server connection contexts.
python-v0.36.0-beta.0 Jul 24, 2026 · issue 002

LanceDB python-v0.36.0-beta.0 adds remote branch diff/merge client APIs, distributed analyze plan metrics, and a pre-Haswell x86_64 compatibility wheel.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.36.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.36.0-beta.0
```
- ›Adds remote branch diff and merge client APIs for managing dataset branches programmatically.
- ›Supports distributed analyze plan metrics surfaced in clients for observability into query execution.
- ›Extends skill references to work with jobs, including server connection scenarios.
v0.33.0-beta.0 Jul 24, 2026 · issue -026

LanceDB v0.33.0-beta.0 adds distributed query plan metrics, pre-Haswell wheel support, and remote branch diff/merge client APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.33.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.33.0-beta.0
```
- ›Adds remote branch diff and merge client APIs for programmatic branch management.
- ›Publishes lancedb-compat wheels for pre-Haswell x86_64 hosts that lack AVX2 support.
- ›Supports distributed analyze plan metrics surfaced to clients for query performance observability.
v0.33.0-beta.0 Jul 24, 2026 · issue 002

LanceDB v0.33.0-beta.0 adds remote branch diff/merge client APIs, distributed query plan metrics, and pre-Haswell x86_64 wheel support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.33.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.33.0-beta.0
```
- ›Adds remote branch diff and merge client APIs for managing divergent dataset versions across distributed deployments.
- ›Supports distributed analyze plan metrics surfaced to clients, enabling visibility into query execution across distributed nodes.
python-v0.35.0-beta.2 Jul 14, 2026 · issue -036

LanceDB python-v0.35.0-beta.2 adds a blob v2 fetch API, WatsonxReranker support, and FTS query tokenization.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.35.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.35.0-beta.2
```
- ›Adds WatsonxReranker component for reranking search results using IBM Watsonx.
- ›Adds FTS query tokenization support for table full-text-search queries.
- ›Introduces a blob v2 fetch API for retrieving binary large object data.
v0.32.0-beta.2 Jul 14, 2026 · issue -036

LanceDB v0.32.0-beta.2 adds a blob v2 fetch API, WatsonxReranker support, and FTS query tokenization.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.32.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.32.0-beta.2
```
- ›Adds FTS query tokenization support via table FTS query tokenization, enabling richer full-text search configuration.
- ›Adds WatsonxReranker component to the Python reranker integrations for IBM Watsonx-backed result reranking.
- ›Adds a blob v2 fetch API to the Python client for retrieving binary large object data.
python-v0.35.0-beta.0 Jul 10, 2026 · issue -040

LanceDB python-v0.35.0-beta.0 adds an elastic dataloader, OpenTelemetry metrics, Tencent COS/GooseFS support, and expanded expression literal types.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.35.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.35.0-beta.0
```
- ›Adds get_lsm_write_spec function to read the installed LSM write spec from a dataset.
- ›Aligns Permutation.with_format('torch') behavior with HuggingFace's set_format('torch') convention.
- ›Adds an elastic dataloader as an iterable dataset for flexible, streaming data loading.
- ›Supports date, datetime, bytes, and Decimal literals in the expression builder.
- ›Exposes Lance metrics via OpenTelemetry in both Python and Node.
+1 moreshow less
- ›Adds Tencent COS and GooseFS object store support via new feature flags.
└──▷ BREAKING ON UPGRADE
- !Permutation.with_format('torch') behavior has changed to align with HuggingFace's set_format('torch') — existing code relying on the previous behavior will need to be updated.
v0.32.0-beta.0 Jul 10, 2026 · issue -040

LanceDB v0.32.0-beta.0 adds an elastic dataloader, OpenTelemetry metrics, Tencent COS/GooseFS support, and richer expression literals.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.32.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.32.0-beta.0
```
- ›Adds get_lsm_write_spec function to read the currently installed LSM write spec from a table.
- ›Exposes Lance metrics via OpenTelemetry in Python and Node, enabling observability integration.
- ›Adds Tencent COS and GooseFS object store support via new feature flags.
- ›Adds an elastic dataloader as an iterable dataset for flexible data loading pipelines.
- ›Supports date, datetime, bytes, and Decimal literals in the expression builder.
+1 moreshow less
- ›Aligns Permutation.with_format('torch') behavior with HuggingFace set_format('torch').
└──▷ BREAKING ON UPGRADE
- !Permutation.with_format('torch') now behaves like HuggingFace's set_format('torch'), which may change output format semantics for existing callers.
python-v0.34.0 Jul 2, 2026 · issue -048

LanceDB v0.34.0 adds FM-Index substring search, table branches, OAuth support, Polars integration, and approx vector query mode.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.34.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.34.0
```
└──▷ USE IT
Use isin on the Expr builder to filter rows to a known set of values before a vector search.
python
```
results = (
    table.search(query_vector)
    .where(Expr.field("category").isin(["malware", "phishing", "ransomware"]))
    .limit(10)
    .to_pandas()
)
```
Request approximate nearest-neighbor search explicitly to trade recall for speed on large indexes.
python
```
results = table.search(query_vector).approx(True).limit(50).to_pandas()
```
- ›Adds update_field_metadata method to edit per-field Arrow metadata on table columns.
- ›Adds isin support to the Expr builder for filter expressions.
- ›Adds approx mode to vector queries, letting callers explicitly request approximate nearest-neighbor search.
- ›Adds FM-Index scalar index type for substring search via create_index.
- ›Adds table branch support to local and remote tables and Python/TypeScript bindings, including checking out a specific version on a branch.
+13 moreshow less
- ›Adds rename_table on LanceNamespaceDatabase to rename tables within a namespace.
- ›Adds OAuth connection config (header provider) exposed in Python and Node.js bindings.
- ›Adds Polars DataFrame integration for reading and writing data.
- ›Adds rich per-index metadata fields to IndexConfig, exposed in Python and Node.js bindings.
- ›Adds x-lancedb-min-read-version watermark header on remote reads for monotonic read guarantees.
- ›Supports Expr objects in Table.delete and merge_insert when_not_matched_by_source_delete.
- ›Supports remote tables in PyTorch dataloaders.
- ›Supports blob modes in query .to_pandas() output.
- ›Routes merge_insert through the MemWAL LSM write path for improved write consistency.
- ›Implements set/unset_lsm_write_spec REST variant for remote tables.
- ›Re-exports arrow and datafusion crates from the lancedb Rust crate.
- ›Unifies sync create_index API to match the async API signature.
- ›Sends read-freshness signal on the lance-namespace path to support consistent reads.
└──▷ BREAKING ON UPGRADE
- !The loss field is dropped from IndexStatistics; any code reading that field will break.
- !Multiple repeated where filters are now combined with AND instead of the later filter replacing the earlier one; queries relying on the replacement behavior will now behave differently.
v0.31.0 Jul 2, 2026 · issue -048

LanceDB v0.31.0 adds FM-Index substring search, table branching, OAuth auth, approx vector query mode, and Polars integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.31.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.31.0
```
└──▷ USE IT
Use isin on an Expr to filter rows in a delete operation without writing raw SQL strings.
python
```
from lancedb.query import Expr
tbl.delete(Expr.field("status").isin(["stale", "archived"]))
```
- ›Adds update_field_metadata API to edit per-field metadata on a table (supersedes the now-deprecated replace_field_metadata).
- ›Adds isin support to the Expr builder for filter expressions.
- ›Accepts Expr objects in Table.delete and merge_insert when_not_matched_by_source_delete for richer predicate building.
- ›Supports FM-Index scalar index type for substring search via create_index.
- ›Adds approx mode to vector queries in the query builder.
+16 moreshow less
- ›Adds table branch support — create and check out versioned branches — across remote tables and Python/TypeScript bindings.
- ›Supports rename_table on LanceNamespaceDatabase.
- ›Adds Polars DataFrame integration for reading and writing LanceDB tables.
- ›Adds OAuth header provider for Rust, with OAuth connection config exposed in Python and Node.js bindings.
- ›Implements set/unset_lsm_write_spec REST variant for remote tables.
- ›Routes merge_insert through the MemWAL LSM write path.
- ›Supports DataFusion expressions for merge insert predicates in Rust.
- ›Expands IndexConfig with rich per-index metadata, exposed in Python and Node.js bindings.
- ›Supports remote tables in PyTorch dataloaders.
- ›Supports blob modes in query to_pandas output.
- ›Adds blob v2 schema declaration, write path, and blob read/materialization APIs in Rust.
- ›Enables monotonic reads via x-lancedb-min-read-version watermark header on the remote path.
- ›Sends read-freshness signal on the lance-namespace path.
- ›Re-exports arrow and datafusion crates from the lancedb Rust crate.
- ›Unifies sync create_index API in Python to match the async API.
- ›Drops N+1 queries in RemoteTable::list_indices by migrating list_indices to use Lance's describe_indices.
└──▷ BREAKING ON UPGRADE
- !The loss field is removed from IndexStatistics; any code reading index_statistics.loss will break.
- !Multiple repeated where filters are now combined with AND instead of the later filter silently replacing the earlier one; queries that relied on replacement behavior will now produce different (AND-combined) results.
python-v0.34.0-beta.6 Jul 2, 2026 · issue -048

LanceDB python-v0.34.0-beta.6 re-exports arrow and datafusion crates from the lancedb Rust crate.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.34.0-beta.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.34.0-beta.6
```
- ›Re-exports arrow and datafusion crates directly from the lancedb Rust crate, removing the need for separate dependency declarations.
└──▷ BREAKING ON UPGRADE
- !Repeated .where() filter calls are now combined with AND instead of the later call replacing the earlier one — queries that relied on the previous replacement behavior will now produce different results.
v0.31.0-beta.6 Jul 2, 2026 · issue -048

LanceDB v0.31.0-beta.6 re-exports arrow and datafusion crates from the lancedb Rust crate.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.31.0-beta.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.31.0-beta.6
```
- ›Re-exports arrow and datafusion crates directly from the lancedb Rust crate, removing the need for separate dependency declarations.
└──▷ BREAKING ON UPGRADE
- !Multiple where filter calls on the same query are now combined with AND instead of the later call replacing the earlier one.
python-v0.34.0-beta.5 Jun 30, 2026 · issue -050

LanceDB python-v0.34.0-beta.5 adds OAuth connection config, Polars DataFrame integration, and monotonic reads via watermark header.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.34.0-beta.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.34.0-beta.5
```
- ›Adds monotonic reads for remote tables via the x-lancedb-min-read-version watermark header, ensuring read-your-writes consistency in distributed scenarios.
- ›Exposes OAuth connection configuration for remote connections in both the Python and Node clients.
- ›Adds Polars DataFrame integration, enabling direct use of Polars DataFrames with LanceDB tables.
- ›Adds improved branch-handling capabilities to the LanceDB skill set for working with table branches.
v0.31.0-beta.5 Jun 30, 2026 · issue -050

LanceDB v0.31.0-beta.5 adds OAuth connection config, Polars DataFrame integration, monotonic reads, and branch-aware skills.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.31.0-beta.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.31.0-beta.5
```
- ›Adds monotonic reads for remote tables via the x-lancedb-min-read-version watermark header, ensuring consistent read ordering across distributed access.
- ›Exposes OAuth connection configuration for remote connections in both the Python and Node clients.
- ›Adds Polars DataFrame integration, enabling direct use of Polars DataFrames as an input/output format.
- ›Adds a skill to work with branches more effectively in LanceDB's agent/skill system.
v0.31.0-beta.4 Jun 29, 2026 · issue -051

LanceDB v0.31.0-beta.4 adds an OAuth header provider for Rust clients.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.31.0-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.31.0-beta.4
```
- ›Adds an OAuth header provider to the Rust client, enabling authenticated requests to LanceDB services via OAuth.
python-v0.34.0-beta.4 Jun 29, 2026 · issue -051

LanceDB python-v0.34.0-beta.4 adds an OAuth header provider for authenticated connections.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.34.0-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.34.0-beta.4
```
- ›Adds an OAuth header provider for authenticating requests, enabling token-based auth flows when connecting to LanceDB services.
python-v0.34.0-beta.2 Jun 23, 2026 · issue -057

LanceDB python-v0.34.0-beta.2 adds blob v2 schema declaration, write path, and blob read/materialization APIs in Rust.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.34.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.34.0-beta.2
```
- ›Adds blob v2 schema declaration and write path in the Rust backend.
- ›Adds blob read and materialization APIs in the Rust backend.
v0.31.0-beta.2 Jun 23, 2026 · issue -057

LanceDB v0.31.0-beta.2 adds blob v2 schema declaration, write path, and blob read/materialization APIs in Rust.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.31.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.31.0-beta.2
```
- ›Adds blob v2 schema declaration and write path in the Rust API.
- ›Adds blob read and materialization APIs in the Rust API.
v0.31.0-beta.0 Jun 18, 2026 · issue -062

LanceDB v0.31.0-beta.0 adds table branches, FM-Index substring search, approx vector query mode, and richer IndexConfig metadata.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.31.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.31.0-beta.0
```
- ›Adds FM-Index scalar index type for substring search via feat: support FM-Index scalar index for substring search.
- ›Adds approx mode to vector queries, enabling approximate nearest-neighbor search control.
- ›Adds isin support to the Expr builder for set-membership filter expressions.
- ›Accepts Expr in Table.delete and in merge when_not_matched_by_source_delete (Python).
- ›Expands IndexConfig with rich per-index metadata, now exposed in Python and Node.js bindings.
+5 moreshow less
- ›Adds table branch support, including checkout of a specific version on a branch, for remote tables and Python/TypeScript bindings.
- ›Implements set/unset_lsm_write_spec as a REST variant for remote tables.
- ›Supports rename_table on LanceNamespaceDatabase.
- ›Adds connect and update column metadata capabilities.
- ›Sends a read-freshness signal on the lance-namespace path.
└──▷ BREAKING ON UPGRADE
- !The loss field is removed from IndexStatistics (dropped as unused).
python-v0.34.0-beta.0 Jun 18, 2026 · issue -062

LanceDB python-v0.34.0-beta.0 adds FM-Index substring search, table branching, approx vector query mode, and richer IndexConfig metadata.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.34.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.34.0-beta.0
```
└──▷ USE IT
Filter rows using set-membership in a query expression instead of hand-crafting a SQL IN clause.
python
```
from lancedb.query import Expr
results = table.search().where(Expr.col("status").isin(["active", "pending"])).to_list()
```
- ›Adds FM-Index scalar index type for substring search, enabling efficient sub-string queries on text columns.
- ›Adds isin support to the Expr builder for set-membership filtering.
- ›Accepts Expr objects in Table.delete and in merge when_not_matched_by_source_delete, replacing raw SQL strings.
- ›Adds approx mode to vector queries, letting callers trade recall for speed at query time.
- ›Adds table branch support to local tables, remote tables, and Python/TypeScript bindings, including the ability to check out a specific version on a branch.
+5 moreshow less
- ›Expands IndexConfig with rich per-index metadata fields, exposed in both Python and Node.js bindings.
- ›Implements set/unset LSM write spec via the REST remote variant.
- ›Adds rename_table support on LanceNamespaceDatabase.
- ›Adds column metadata connect and update capabilities.
- ›Sends a read-freshness signal on the lance-namespace path.
└──▷ BREAKING ON UPGRADE
- !The loss field is removed from IndexStatistics (dropped as unused).
python-v0.33.1-beta.2 Jun 4, 2026 · issue -076

LanceDB python-v0.33.1-beta.2 adds DataFusion expression support for merge insert predicates.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.33.1-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.33.1-beta.2
```
- ›Supports DataFusion expressions as predicates in merge insert operations, enabling richer conditional logic when upserting records.
v0.30.1-beta.2 Jun 4, 2026 · issue -076

LanceDB v0.30.1-beta.2 adds DataFusion expression support for merge insert predicates in Rust.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.30.1-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.30.1-beta.2
```
- ›Supports DataFusion expressions as predicates in merge insert operations via the Rust API.
v0.30.1-beta.1 Jun 3, 2026 · issue -077

LanceDB v0.30.1-beta.1 adds remote table support in PyTorch dataloaders, per-field metadata editing, and blob mode queries.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.30.1-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.30.1-beta.1
```
- ›Adds update_field_metadata method to edit per-field metadata on tables.
- ›Supports blob modes in query to_pandas conversions.
- ›Supports remote tables in PyTorch dataloaders for distributed training workflows.
python-v0.33.1-beta.1 Jun 3, 2026 · issue -077

LanceDB v0.33.1-beta.1 adds remote table PyTorch dataloader support, per-field metadata editing, and blob mode queries.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.33.1-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.33.1-beta.1
```
- ›Adds update_field_metadata method to edit per-field metadata on a table.
- ›Supports blob modes in query to_pandas conversions.
- ›Supports remote tables in PyTorch dataloaders.
python-v0.33.1-beta.0 Jun 1, 2026 · issue -079

LanceDB python-v0.33.1-beta.0 unifies the sync create_index API with the async API and routes merge_insert through the MemWAL LSM write path.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.33.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.33.1-beta.0
```
- ›Unifies the sync create_index API signature to match the async create_index API, enabling consistent index-creation code across sync and async usage.
- ›Routes merge_insert through the MemWAL LSM write path, enabling merge-insert operations to benefit from the LSM-based write pipeline.
v0.30.1-beta.0 Jun 1, 2026 · issue -079

LanceDB v0.30.1-beta.0 unifies the sync create_index API with the async API and routes merge_insert through the MemWAL LSM write path.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.30.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.30.1-beta.0
```
- ›Unifies the synchronous create_index API signature to match the async create_index API in Python, enabling consistent usage across both execution models.
- ›Routes merge_insert through the MemWAL LSM write path, unlocking improved write consistency and performance for upsert workloads.
python-v0.33.0 May 28, 2026 · issue -083

LanceDB python-v0.33.0 adds namespace management, LSM write spec, unenforced primary keys, and streaming ingestion primitives.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.33.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.33.0
```
- ›Adds order_by method to the Node.js Query class for sorting query results.
- ›Adds progress callback to Table.add in Node.js to track ingestion progress.
- ›Adds renameTable method on Node.js Connection for in-place table renaming.
- ›Adds namespace management methods on Node.js Connection for creating, listing, and deleting namespaces.
- ›Exposes connectNamespace on Node.js Connection for namespace-backed connections.
+8 moreshow less
- ›Adds Scannable primitive in Node.js for streaming data ingestion into tables.
- ›Adds public take_offsets method on Permutation in the Python API.
- ›Supports bytes values in Python lit() expressions.
- ›Aligns to_pandas to accept standard pandas keyword arguments in Python.
- ›Supports setting an unenforced primary key on a table.
- ›Supports setting LSM write spec per table for write performance tuning.
- ›Supports DataFusion Expr for row deletions in the Rust API.
- ›Sends read-freshness headers for remote table consistency in remote connections.
└──▷ BREAKING ON UPGRADE
- !Nested field paths in native index creation now behave differently — existing code relying on the previous (broken) path handling may need to be updated.
v0.30.0 May 28, 2026 · issue -083

LanceDB v0.30.0 adds namespace management, streaming ingestion, unenforced primary keys, LSM write spec, and DataFusion Expr deletions.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.30.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.30.0
```
└──▷ USE IT
Track progress during bulk data ingestion into a LanceDB table in Node.js.
javascript
```
await table.add(data, { progress: (count) => console.log(`Inserted ${count} rows`) });
```
- ›Adds namespace management methods (connectNamespace) on the Node.js Connection object, enabling namespace-backed connections.
- ›Adds renameTable method on the Node.js Connection for in-place table renaming.
- ›Adds order_by method to the Node.js Query for deterministic result ordering.
- ›Adds progress callback to Table.add in the Node.js API for monitoring ingestion progress.
- ›Adds Scannable primitive to the Node.js client for streaming data ingestion.
+7 moreshow less
- ›Adds support for bytes values in Python lit() filter expressions.
- ›Adds public take_offsets method on Python Permutation class.
- ›Aligns Python to_pandas() to accept pandas kwargs directly.
- ›Adds support for setting an unenforced primary key on a table.
- ›Adds support for setting the LSM write spec for a table.
- ›Adds support for DataFusion Expr in Rust table row deletions.
- ›Sends read-freshness headers for remote table consistency in remote connections.
python-v0.33.0-beta.0 May 21, 2026 · issue -090

LanceDB python-v0.33.0-beta.0 aligns to_pandas kwargs and adds Node.js table rename and add-progress features.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.33.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.33.0-beta.0
```
- ›Aligns to_pandas to accept pandas keyword arguments directly in the Python client.
- ›Adds renameTable method on Connection in the Node.js client to rename tables.
- ›Adds a progress callback to Table.add in the Node.js client for tracking ingestion progress.
└──▷ BREAKING ON UPGRADE
- !Nested field paths in native index creation are now handled differently; existing setups relying on the prior path format for nested fields may break on upgrade.
v0.30.0-beta.0 May 21, 2026 · issue -090

LanceDB v0.30.0-beta.0 adds progress reporting to Table.add and renameTable on Connection in Node.js, plus pandas kwarg alignment in Python.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.30.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.30.0-beta.0
```
- ›Adds renameTable method on Connection in the Node.js SDK to rename tables in place.
- ›Adds progress callback support to Table.add in the Node.js SDK to track insertion progress.
- ›Aligns to_pandas pandas kwargs in the Python SDK so all upstream pandas keyword arguments are passed through.
└──▷ BREAKING ON UPGRADE
- !Nested field paths in native index creation now use canonical nested index path format, which may change how existing nested-field indexes are addressed or referenced.
v0.29.1-beta.0 May 18, 2026 · issue -093

LanceDB v0.29.1-beta.0 adds namespace management, streaming ingestion, LSM write spec, and unenforced primary keys for Node.js and Python.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.29.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.29.1-beta.0
```
└──▷ USE IT
Use bytes literals in filter expressions when querying tables that store binary fields.
python
```
import lancedb
table.search().where(lancedb.lit(b'\x00\x01\x02') == table['payload']).to_list()
```
- ›Adds Connection.renameTable in the Node.js SDK with namespace support.
- ›Adds order_by method to Query in the Node.js SDK for sorted query results.
- ›Exposes connectNamespace for namespace-backed connections in the Node.js SDK.
- ›Adds namespace management methods on Connection in the Node.js SDK.
- ›Adds Scannable primitive to the Node.js SDK for streaming data ingestion.
+4 moreshow less
- ›Supports bytes values in lit() expressions in the Python SDK.
- ›Adds public take_offsets method on Permutation in the Python SDK.
- ›Supports setting an unenforced primary key on a table.
- ›Supports setting the LSM write spec for a table.
python-v0.32.1-beta.0 May 18, 2026 · issue -093

LanceDB python-v0.32.1-beta.0 adds namespace management, streaming ingestion, bytes in lit(), unenforced primary keys, and LSM write spec support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.32.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.32.1-beta.0
```
└──▷ USE IT
Return query results in a defined order using the new order_by method in the Node.js client.
javascript
```
const results = await table
  .query()
  .order_by([{ column: 'score', ascending: false }])
  .toArray();
```
- ›Adds bytes support in lit() expressions for Python, enabling byte-literal predicates in filter expressions.
- ›Adds take_offsets as a public method on Permutation in the Python API for direct offset-based row retrieval.
- ›Adds namespace management methods on Connection in the Node.js API, plus connectNamespace for namespace-backed connections.
- ›Adds Connection.renameTable with namespace support in the Node.js API.
- ›Adds order_by method to Query in the Node.js API for sorted result sets.
+3 moreshow less
- ›Adds Scannable primitive in the Node.js API for streaming ingestion workflows.
- ›Supports setting an unenforced primary key on a table.
- ›Supports setting the LSM write spec for a table.
python-v0.32.0 May 13, 2026 · issue -098

LanceDB python-v0.32.0 adds IVF_HNSW_FLAT index, model-backed FTS tokenizers, Enum/Pydantic support, and namespace operations.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.32.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.32.0
```
└──▷ USE IT
Tag client requests with a user identity when connecting to LanceDB Cloud for audit and multi-tenant tracking.
python
```
import lancedb
from lancedb import ClientConfig

db = lancedb.connect(
    "db://my-project",
    api_key="<api_key>",
    client_config=ClientConfig(user_id="[email protected]"),
)
```
- ›Adds IVF_HNSW_FLAT vector index type, combining IVF partitioning with HNSW graph search over flat (uncompressed) vectors.
- ›Adds user_id field to ClientConfig for per-user identification in enterprise/cloud connections.
- ›Supports model-backed native FTS tokenizers, enabling language-model-driven tokenization for full-text search indexes.
- ›Supports Enum types in Pydantic-to-Arrow schema conversion, so Python enum fields map correctly to Arrow schemas.
- ›Supports child namespace operations and JSON serialization for LanceDBConnection, enabling nested namespace hierarchies.
+3 moreshow less
- ›Adds manifest-enabled directory namespace mode for organizing tables within namespaces.
- ›Supports nested namespace operations in database listing.
- ›Makes Permutation fork-safe for PyTorch DataLoader workers, enabling safe use in multi-process data loading.
└──▷ BREAKING ON UPGRADE
- !Namespace-related naming and enterprise integration have been consolidated — existing code referencing the old namespace identifiers or enterprise connection fields may break after upgrade.
v0.29.0 May 13, 2026 · issue -098

LanceDB v0.29.0 adds IVF_HNSW_FLAT index, model-backed FTS tokenizers, nested namespace ops, and a Node.js prewarmData method.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.29.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.29.0
```
└──▷ USE IT
Pre-warm a Node.js table's data into memory before running latency-sensitive queries.
javascript
```
await table.prewarmData();
```
- ›Adds IVF_HNSW_FLAT vector index support in Python, combining IVF partitioning with HNSW and flat re-ranking for improved ANN search.
- ›Adds prewarmData method on the Node.js Table object to pre-load table data into memory before queries.
- ›Adds user_id field to ClientConfig for user identification in enterprise integrations.
- ›Supports model-backed native FTS tokenizers in Python, enabling neural/model-driven full-text search tokenization.
- ›Adds manifest-enabled directory namespace mode for managing database namespaces.
+3 moreshow less
- ›Supports child namespace operations and JSON serialization for LanceDBConnection in Python.
- ›Supports nested namespace operations in listing databases from Rust.
- ›Supports Enum types in Pydantic-to-Arrow schema conversion in Python.
└──▷ BREAKING ON UPGRADE
- !Namespace-related naming and enterprise integration identifiers have been consolidated — existing code referencing the old namespace naming conventions or enterprise integration entry points may break and require updates.
python-v0.31.0-beta.6 Apr 16, 2026 · issue -125

LanceDB python-v0.31.0-beta.6 adds nested namespace support for listing databases.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.31.0-beta.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.31.0-beta.6
```
- ›Supports nested namespace operations when listing databases.
v0.28.0-beta.6 Apr 16, 2026 · issue -125

LanceDB v0.28.0-beta.6 adds nested namespace support for listing databases in Rust.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.28.0-beta.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.28.0-beta.6
```
- ›Supports nested namespace operations when listing databases via the Rust client.
v0.28.0-beta.2 Apr 11, 2026 · issue -130

LanceDB v0.28.0-beta.2 adds user_id field to ClientConfig for user identification.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.28.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.28.0-beta.2
```
- ›Adds user_id field to ClientConfig for associating requests with a specific user identity.
python-v0.31.0-beta.2 Apr 11, 2026 · issue -130

LanceDB python-v0.31.0-beta.2 adds user_id field to ClientConfig for user identification.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.31.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.31.0-beta.2
```
└──▷ USE IT
Tag client connections with a user identifier to track or audit requests per user.
python
```
from lancedb import ClientConfig

config = ClientConfig(user_id="[email protected]")
db = lancedb.connect("db://my-lancedb", client_config=config)
```
- ›Adds user_id field to ClientConfig for attaching a user identifier to client connections.
python-v0.30.2 Mar 31, 2026 · issue -141

LanceDB python-v0.30.2 adds a type-safe expression builder API, progress bars for add(), parallel remote inserts, and Float16/Float64/Uint8 vector query support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.30.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.30.2
```
- ›Adds a type-safe expression builder API for Python (feat(python): add type-safe expression builder API).
- ›Adds a progress bar for the add() method when ingesting data.
- ›Enables parallel inserts for remote tables via multipart write (Rust backend).
- ›Supports Float16, Float64, and Uint8 vector queries in the Node.js client.
v0.27.2 Mar 31, 2026 · issue -141

LanceDB v0.27.2 adds parallel remote inserts, Float16/Float64/Uint8 vector queries, a type-safe Python expression builder, and a progress bar for add().
└──▷ GET THIS VERSION
```
$ git clone --branch v0.27.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.27.2
```
- ›Adds type-safe expression builder API in Python for constructing queries with compile-time safety.
- ›Supports Float16, Float64, and Uint8 vector queries in the Node.js client.
- ›Adds progress bar for add() operations to surface ingestion status.
- ›Enables parallel inserts for remote tables via multipart write in the Rust client, improving throughput for large uploads.
python-v0.30.2-beta.0 Mar 25, 2026 · issue -147

LanceDB python-v0.30.2-beta.0 adds parallel remote inserts via multipart write and a progress bar for add().
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.30.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.30.2-beta.0
```
- ›Adds a progress bar to the add() method to track data ingestion in real time.
- ›Enables parallel inserts for remote tables via multipart write, improving throughput for large uploads.
- ›Updates the lance dependency to v3.0.1.
v0.27.2-beta.0 Mar 25, 2026 · issue -147

LanceDB v0.27.2-beta.0 adds parallel multipart inserts for remote tables and a progress bar for add().
└──▷ GET THIS VERSION
```
$ git clone --branch v0.27.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.27.2-beta.0
```
- ›Adds progress bar for the add() method to track data ingestion.
- ›Enables parallel inserts for remote tables via multipart write in the Rust client.
v0.27.0 Mar 16, 2026 · issue -156

LanceDB v0.27.0 adds a Rust expression builder API, fast_search parity, parallel inserts, and num_deleted_rows reporting.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.27.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.27.0
```
└──▷ USE IT
Check how many rows were removed after a delete operation using the new num_deleted_rows field.
rust
```
let result = table.delete("status = 'inactive'").await?;
println!("Deleted {} rows", result.num_deleted_rows);
```
- ›Adds expression builder API in Rust (feat(rust): add expression builder API) for type-safe query filters via Expr in query construction.
- ›Supports Expr in projection queries in Rust, enabling type-safe column selection.
- ›Accepts RecordBatch and Vec<RecordBatch> directly in create_table() and Table.add() in Rust, removing the need to wrap in a record-batch reader.
- ›Adds num_deleted_rows field to the delete operation result, making it possible to inspect how many rows were removed.
- ›Adds fast_search keyword argument parity between vector search and FTS search.
+10 moreshow less
- ›Supports prewarm_index and prewarm_data on remote tables.
- ›Adds support for remote index params via the remote SDK.
- ›Allows passing Azure client/tenant ID through the remote SDK.
- ›Supports dict-to-SQL struct conversion in Python table.update(), enabling structured updates without manual SQL string construction.
- ›Supports field and data-type input in the Node.js add_columns() method.
- ›Enables parallel inserts for local tables, improving write throughput.
- ›Checks for dataset updates in the background, reducing latency for consistency-sensitive reads.
- ›Shows reranker info in the hybrid search explain plan, making it easier to debug ranking pipelines.
- ›Infers JS native arrays automatically in the Node.js binding.
- ›Upgrades lance dependency to v3.0.0-rc.3, including bindings for fast_search.
└──▷ BREAKING ON UPGRADE
- !create_table() and Table.add() in Rust now accept RecordBatch and Vec<RecordBatch> directly; callers previously relying on the old input types will need to update their call sites.
python-v0.30.0 Mar 16, 2026 · issue -156

LanceDB python-v0.30.0 adds fast_search parity, parallel inserts, expression-builder filters, and more new query and storage capabilities.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.30.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.30.0
```
└──▷ USE IT
Run a hybrid search and confirm which reranker is active by inspecting the explain plan.
python
```
plan = (
    table.search('security breach', query_type='hybrid')
    .explain_plan(verbose=True)
)
print(plan)
```
- ›Adds num_deleted_rows field to delete operation results, letting callers confirm how many rows were removed.
- ›Adds fast_search keyword argument parity between vector and FTS searches so both query types share the same interface.
- ›Adds expression builder API in Rust for type-safe query filters, replacing raw SQL strings in filter clauses.
- ›Adds Expr support in projection queries (Rust), enabling type-safe column selection.
- ›Adds add_columns() support for field/data type input in the Node.js SDK.
+11 moreshow less
- ›Supports dict-to-SQL struct conversion in table.update() for Python, letting callers pass plain dicts for struct fields.
- ›Adds bindings for fast_search via Lance 3.0.0-rc upgrade, enabling accelerated ANN lookups.
- ›Supports prewarm_index and prewarm_data on remote tables to reduce cold-query latency.
- ›Adds support for remote index params, extending index configuration to LanceDB Cloud tables.
- ›Enables passing Azure client/tenant ID through the remote SDK for Azure-backed deployments.
- ›Enables parallel inserts for local tables, improving bulk-write throughput.
- ›Adds background dataset-update checks so stale reads are detected without blocking query threads.
- ›Shows reranker info in hybrid search explain plans for easier pipeline debugging.
- ›Caches schema of remote tables to reduce round-trips on repeated queries.
- ›Infers JS native arrays automatically in the Node.js SDK, removing manual type hints.
- ›Upgrades napi-rs from v2 to v3 in the Node.js binding layer.
└──▷ BREAKING ON UPGRADE
- !create_table() and Table.add() in the Rust SDK now accept RecordBatch and Vec<RecordBatch> directly; callers passing other input types must update to these forms.
v0.27.0-beta.5 Mar 9, 2026 · issue -162

LanceDB v0.27.0-beta.5 adds JS native array inference and upgrades Lance to 3.0.0-rc.3.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.27.0-beta.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.27.0-beta.5
```
- ›Adds automatic inference of JavaScript native arrays, removing the need to manually specify array schema when ingesting JS data.
- ›Upgrades the underlying Lance storage engine to 3.0.0-rc.3.
python-v0.30.0-beta.5 Mar 9, 2026 · issue -162

LanceDB python-v0.30.0-beta.5 adds JS native array inference and upgrades Lance to 3.0.0-rc.3.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.30.0-beta.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.30.0-beta.5
```
- ›Adds automatic inference of JavaScript native arrays, reducing manual schema specification when ingesting JS-native data.
- ›Upgrades the Lance backend to version 3.0.0-rc.3.
v0.27.0-beta.4 Mar 9, 2026 · issue -162

LanceDB v0.27.0-beta.4 adds num_deleted_rows to delete results, remote index params, and dict-to-SQL struct conversion in table.update()
└──▷ GET THIS VERSION
```
$ git clone --branch v0.27.0-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.27.0-beta.4
```
└──▷ USE IT
Confirm how many rows were removed after a delete operation using the new num_deleted_rows field.
python
```
result = table.delete("category = 'obsolete'")
print(result.num_deleted_rows)
```
Update a row with a nested struct column by passing a plain Python dict instead of manually constructing SQL.
python
```
table.update(where="id = 42", values={"metadata": {"source": "ingest", "version": 3}})
```
- ›Adds num_deleted_rows field to the delete operation result, letting callers confirm how many rows were removed.
- ›Adds support for remote index params, enabling index configuration through the remote SDK.
- ›Adds parity for the fast_search keyword argument between vector and FTS searches.
- ›Supports dict-to-SQL struct conversion in table.update() (Python), simplifying structured updates without manual SQL construction.
- ›Allows passing Azure client ID and tenant ID through the remote SDK for Azure-backed connections.
python-v0.30.0-beta.4 Mar 9, 2026 · issue -162

LanceDB python-v0.30.0-beta.4 adds delete result row counts, remote index params, fast_search parity for FTS, dict-to-struct in update(), and Azure client/tenant ID passthrough.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.30.0-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.30.0-beta.4
```
└──▷ USE IT
Update a struct-typed column by passing a plain Python dict instead of manually constructing an Arrow struct.
python
```
table.update(where="id = 42", values={"metadata": {"source": "upload", "version": 2}})
```
- ›Adds num_deleted_rows field to the result returned by table.delete(), letting callers inspect how many rows were removed.
- ›Adds support for fast_search keyword argument in full-text search (FTS) queries, bringing parity with vector search.
- ›Supports dict-to-SQL-struct conversion in table.update(), allowing Python dicts to be passed directly as struct values.
- ›Allows passing Azure client ID and tenant ID through the remote SDK when connecting to Azure-backed LanceDB deployments.
- ›Adds support for remote index params, enabling index configuration to be specified via the remote SDK.
python-v0.30.0-beta.3 Feb 28, 2026 · issue -170

LanceDB python-v0.30.0-beta.3 adds bindings for fast_search via lance 3.0.0-rc.2 upgrade
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.30.0-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.30.0-beta.3
```
- ›Adds Python bindings for fast_search backed by an upgrade to lance 3.0.0-rc.2.
v0.27.0-beta.3 Feb 28, 2026 · issue -170

LanceDB v0.27.0-beta.3 adds bindings for fast_search via Lance 3.0.0-rc.2 upgrade
└──▷ GET THIS VERSION
```
$ git clone --branch v0.27.0-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.27.0-beta.3
```
- ›Adds bindings for fast_search backed by an upgrade to Lance 3.0.0-rc.2.
python-v0.30.0-beta.2 Feb 25, 2026 · issue -173

LanceDB python-v0.30.0-beta.2 adds parallel local inserts and a type-safe Rust expression builder API for query filters.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.30.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.30.0-beta.2
```
- ›Adds an expression builder API in the Rust client for constructing type-safe query filters programmatically.
- ›Enables parallel inserts for local tables, improving write throughput for local LanceDB deployments.
- ›Upgrades the Node.js bindings from napi-rs v2 to v3.
- ›Hooks up a new writer backend for insert operations.
v0.27.0-beta.2 Feb 25, 2026 · issue -173

LanceDB v0.27.0-beta.2 adds a Rust expression builder API for type-safe query filters and parallel inserts for local tables.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.27.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.27.0-beta.2
```
- ›Adds expression builder API in the Rust SDK for constructing type-safe query filters programmatically.
- ›Enables parallel inserts for local tables, improving write throughput.
- ›Upgrades napi-rs from v2 to v3 in the Node.js bindings, bringing the latest NAPI runtime support.
python-v0.30.0-beta.1 Feb 23, 2026 · issue -175

LanceDB python-v0.30.0-beta.1 adds background dataset update checks.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.30.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.30.0-beta.1
```
- ›Adds background checking for dataset updates, enabling tables to stay consistent without blocking the main thread.
v0.27.0-beta.1 Feb 23, 2026 · issue -175

LanceDB v0.27.0-beta.1 adds background dataset update checks for improved consistency.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.27.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.27.0-beta.1
```
- ›Checks for dataset updates in the background, enabling tables to stay consistent without blocking query operations.
v0.27.0-beta.0 Feb 17, 2026 · issue -181

LanceDB v0.27.0-beta.0 adds RecordBatch support in Rust, reranker info in hybrid search explain plans, and improved PyTorch Permutation integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.27.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.27.0-beta.0
```
- ›Accepts RecordBatch and Vec<RecordBatch> directly in create_table() and Table.add() in the Rust API, removing the need to wrap batches before ingestion.
- ›Shows reranker info in hybrid search explain plans, making it easier to inspect and debug reranking behavior.
- ›Improves Permutation PyTorch integration and adds a getitems implementation for the permutation type.
└──▷ BREAKING ON UPGRADE
- !The Rust create_table() and Table.add() APIs now accept RecordBatch and Vec<RecordBatch> directly; callers using the previous input types may need to update their call sites.
python-v0.30.0-beta.0 Feb 17, 2026 · issue -181

LanceDB python-v0.30.0-beta.0 adds reranker info in hybrid search explain plans and improves PyTorch Permutation integration.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.30.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.30.0-beta.0
```
- ›Shows reranker info in hybrid search explain plans for better query introspection.
- ›Improves PyTorch integration for the Permutation type, including a new getitems implementation.
- ›Updates the lance dependency to v2.0.1.
└──▷ BREAKING ON UPGRADE
- !The Rust create_table() and Table.add() now accept RecordBatch and Vec<RecordBatch> directly; callers using the previous input types must update their code.
v0.26.0 Feb 6, 2026 · issue -192

LanceDB v0.26.0 adds VoyageAI v4 embeddings, exposes fast_search in the sync Python API, and introduces storage options APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.26.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.26.0
```
└──▷ TRY IT
Use approximate nearest-neighbor search in synchronous Python code without switching to the async API.
```
$ results = table.search(query_vector).fast_search().limit(10).to_list()
```
- ›Exposes fast_search in the synchronous Python API, enabling approximate nearest-neighbor search without switching to the async client.
- ›Adds initial and latest storage options APIs for configuring object-store settings at table open/create time.
- ›Allows the permutation builder memory limit to be configured via environment variable.
- ›Adds VoyageAI v4 embedding models to the Python integration.
- ›Implements TableProvider::insert_into() for LanceDB tables in the Rust API, enabling DataFusion-native inserts.
python-v0.29.0 Feb 6, 2026 · issue -192

LanceDB python-v0.29.0 adds VoyageAI v4 embeddings, exposes fast_search in the sync API, and introduces storage options APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.29.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.29.0
```
└──▷ USE IT
Run an approximate nearest-neighbor search using the synchronous API without waiting for a full index build.
python
```
results = table.search(query_vector).fast_search().to_list()
```
- ›Exposes fast_search in the synchronous Python API, enabling approximate search without waiting for index readiness.
- ›Adds initial and latest storage options APIs for configuring backend storage parameters.
- ›Adds VoyageAI v4 models as supported embedding providers in the Python client.
- ›Allows the permutation builder memory limit to be configured via an environment variable.
- ›Implements TableProvider::insert_into() for LanceDB tables in the Rust API, enabling DataFusion-native inserts.
v0.25.0-beta.0 Feb 3, 2026 · issue -195

LanceDB v0.25.0-beta.0 adds configurable permutation builder memory limits and VoyageAI v4 embedding models.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.25.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.25.0-beta.0
```
- ›Allows the permutation builder memory limit to be configured via environment variable.
- ›Adds VoyageAI v4 models as embedding options in the Python client.
python-v0.28.0-beta.0 Feb 3, 2026 · issue -195

LanceDB python-v0.28.0-beta.0 adds VoyageAI v4 model support and an env-var-configurable permutation builder memory limit.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.28.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.28.0-beta.0
```
- ›Adds support for VoyageAI v4 embedding models in the Python client.
- ›Allows the permutation builder memory limit to be configured via an environment variable.
python-v0.27.1 Jan 26, 2026 · issue -203

LanceDB python-v0.27.1 adds AZURE_STORAGE_ACCOUNT_NAME environment variable support for remote connections.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.27.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.27.1
```
- ›Reads the AZURE_STORAGE_ACCOUNT_NAME environment variable when establishing remote Azure Storage connections, removing the need to pass the account name explicitly in code.
v0.24.1 Jan 26, 2026 · issue -203

LanceDB v0.24.1 adds AZURE_STORAGE_ACCOUNT_NAME environment variable support for remote connections.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.24.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.24.1
```
- ›Reads the AZURE_STORAGE_ACCOUNT_NAME environment variable when establishing remote Azure Storage connections, removing the need to hard-code the account name.
python-v0.27.0 Jan 22, 2026 · issue -207

LanceDB python-v0.27.0 adds Voyage multimodal-3.5 embeddings, remote IVF-RQ index support, and parallelized embedding computation.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.27.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.27.0
```
- ›Exposes table URI via a new table.uri property, giving callers direct access to the underlying storage path.
- ›Adds support for the voyage-multimodal-3.5 embedding model.
- ›Supports remote IVF-RQ (Inverted File with Residual Quantization) indexes for vector search on remote tables.
- ›Parallelizes embedding computations to reduce latency when embedding large batches.
- ›Enables the HuggingFace embedding feature by default, removing the need to opt in manually.
└──▷ BREAKING ON UPGRADE
- !The Rust crate removes default Cargo features (remove default features); any downstream Rust code relying on those features must now enable them explicitly.
v0.24.0 Jan 22, 2026 · issue -207

LanceDB v0.24.0 adds voyage-multimodal-3.5 embeddings, remote IVF-RQ index support, parallelized embedding computation, and exposes table URI.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.24.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.24.0
```
└──▷ USE IT
Inspect the storage URI of an existing table — useful when you need to pass the raw path to another tool or audit where data lives.
python
```
uri = table.uri
print(uri)  # e.g. s3://my-bucket/my-db/my-table.lance
```
- ›Exposes table URI via the new table.uri property, letting callers inspect the storage location of a table directly.
- ›Adds support for voyage-multimodal-3.5 as an embedding model option.
- ›Supports remote IVF-RQ (Inverted File with Residual Quantization) indexing for remote tables.
- ›Parallelizes embedding computations to accelerate batch ingestion workflows.
- ›Enables the huggingface feature flag by default in the Rust crate, removing the need to opt in manually.
└──▷ BREAKING ON UPGRADE
- !The Rust crate removes its default features; any crate that relied on default features being enabled must now explicitly list them in its Cargo.toml dependency declaration.
python-v0.27.0-beta.0 Jan 21, 2026 · issue -208

LanceDB python-v0.27.0-beta.0 adds Voyage multimodal-3.5 embeddings, remote IVF-RQ indexing, parallel embedding computation, and exposes table URI.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.27.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.27.0-beta.0
```
- ›Exposes table URI via a new uri property on table objects, giving callers direct access to the underlying storage path.
- ›Adds support for remote IVF-RQ (Inverted File with Residual Quantization) indexing, enabling compressed vector search on remote tables.
- ›Parallelizes embedding computations, reducing latency when generating embeddings for large batches.
- ›Adds voyage-multimodal-3.5 as a supported embedding model for multimodal (text + image) retrieval.
- ›Enables the HuggingFace embedding feature by default, removing the need for manual opt-in configuration.
└──▷ BREAKING ON UPGRADE
- !The Rust crate's default Cargo features have been removed; any project relying on default features must now explicitly declare the features it needs in its Cargo.toml.
v0.24.0-beta.0 Jan 21, 2026 · issue -208

LanceDB v0.24.0-beta.0 adds Voyage multimodal embeddings, remote IVF-RQ index support, parallel embedding computation, and exposes table URIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.24.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.24.0-beta.0
```
- ›Exposes table URI via a new uri property on table objects, letting callers retrieve the underlying storage path programmatically.
- ›Adds support for remote IVF-RQ (Inverted File with Residual Quantization) indexing, enabling compressed approximate-nearest-neighbor search on remote tables.
- ›Adds voyage-multimodal-3.5 as a supported embedding model for multimodal vector generation.
- ›Parallelizes embedding computations, reducing latency when generating embeddings for large batches.
- ›Enables the HuggingFace embedding feature by default in the Rust crate, removing the need to opt in via a feature flag.
└──▷ BREAKING ON UPGRADE
- !The Rust crate no longer enables default features; any feature previously on by default (other than huggingface, which is now explicitly enabled) must now be opted into explicitly in Cargo.toml.
v0.23.0 Dec 16, 2025 · issue -244

LanceDB v0.23.0 adds IVF SQ index, async namespace connections, to_pydantic async support, stable row IDs via storage_options, and head() for remote tables.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.23.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.23.0
```
└──▷ USE IT
Enable stable row IDs on a table so that row identifiers survive compaction and updates — useful for building reliable external indexes or caches keyed on row ID.
python
```
table = db.create_table('my_table', data=df, storage_options={'stable_row_ids': 'true'})
```
- ›Adds storage_options support for enabling stable row IDs on tables.
- ›Adds num_attempts field to merge insert results, giving callers visibility into retry behaviour.
- ›Adds to_pydantic support in the async Python API for converting query results directly to Pydantic models.
- ›Implements head() for remote tables, enabling fast row-count-limited fetches against remote backends.
- ›Adds IVF SQ (Scalar Quantization) index support and HNSW aliases for index creation.
+5 moreshow less
- ›Lets Lance determine the default num_partitions parameter automatically rather than requiring the caller to specify it.
- ›Supports namespace credentials vending for scoped, credential-backed namespace access.
- ›Supports async namespace connections and server-side query execution via the namespace layer.
- ›Uses the REST namespace backend for the LanceDB Java SDK, with a generic Java client builder.
- ›Infers vector type as float32 when integer values fall outside the uint8 range, reducing type-mismatch errors on ingestion.
└──▷ BREAKING ON UPGRADE
- !macOS x86 (Intel) support is deprecated and removed.
- !Namespace operations now use namespace models directly; code using the previous namespace operation signatures will break.
python-v0.26.0 Dec 16, 2025 · issue -244

LanceDB python-v0.26.0 adds IVF SQ indexing, async namespace connections, stable row IDs via storage_options, and to_pydantic async support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.26.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.26.0
```
└──▷ USE IT
Enable stable row IDs at table-creation time so row addresses remain constant across compaction and updates.
python
```
import lancedb

db = lancedb.connect("<uri>")
tbl = db.create_table(
    "my_table",
    data=my_data,
    storage_options={"stable_row_ids": "true"}
)
```
Use the new async to_pydantic() to deserialize query results into typed models in an async workflow.
python
```
import lancedb
from pydantic import BaseModel

class Item(BaseModel):
    id: int
    text: str
    vector: list[float]

async def query():
    db = await lancedb.connect_async("<uri>")
    tbl = await db.open_table("my_table")
    results = await tbl.query().limit(10).to_pydantic(Item)
    return results
```
Build an IVF_SQ index on a vector column to get smaller on-disk footprint with scalar quantization.
python
```
import lancedb

db = lancedb.connect("<uri>")
tbl = db.open_table("my_table")
tbl.create_index(metric="cosine", index_type="IVF_SQ", vector_column_name="vector")
```
- ›Adds stable_row_ids support via storage_options for tables that require deterministic row addressing.
- ›Adds num_attempts field to merge-insert results so callers can inspect retry counts.
- ›Adds IVF_SQ index type and HNSW aliases, expanding the vector index options available at index-creation time.
- ›Supports to_pydantic() in async query paths, letting async workflows deserialize results directly into Pydantic models.
- ›Implements head() for remote tables, enabling row-count-limited fetches against remote LanceDB services.
+5 moreshow less
- ›Lets lance automatically determine the default num_partitions parameter for IVF index builds instead of requiring caller-supplied values.
- ›Adds async namespace connection support, bringing namespace-scoped operations into the async API.
- ›Adds namespace credentials vending so namespace clients can obtain scoped credentials at runtime.
- ›Adds namespace server-side query execution, offloading query work to the namespace server.
- ›Infers vector column type as float32 when integer values fall outside the uint8 range, reducing silent precision errors.
└──▷ BREAKING ON UPGRADE
- !Mac x86 (Intel) platform support is dropped; macOS builds are now ARM-only.
- !Namespace operations now use namespace models directly — code that passed raw dicts or non-model types to namespace operation calls will break.
v0.23.0-beta.1 Dec 5, 2025 · issue -255

LanceDB Java SDK gains REST namespace support and a generic client builder.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.23.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.23.0-beta.1
```
- ›Adds REST namespace support to the LanceDB Java SDK client.
- ›Makes the LanceDB Java SDK client builder generic, enabling typed client construction.
python-v0.26.0-beta.0 Dec 4, 2025 · issue -256

LanceDB python-v0.26.0-beta.0 adds IVF SQ index support, HNSW aliases, and namespace server-side query.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.26.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.26.0-beta.0
```
- ›Adds IVF_SQ index support and HNSW aliases for vector index creation.
- ›Supports server-side query scoped to a namespace, enabling filtered search without pulling full table listings client-side.
└──▷ BREAKING ON UPGRADE
- !macOS x86 (Intel) is no longer supported; wheels for that platform will not be published.
- !Namespace operations now use namespace models directly — code calling namespace APIs with the old model types will need to be updated.
v0.23.0-beta.0 Dec 4, 2025 · issue -256

LanceDB v0.23.0-beta.0 adds IVF SQ index support, HNSW aliases, and server-side namespace queries.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.23.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.23.0-beta.0
```
- ›Adds IVF_SQ index support and HNSW aliases for vector index creation.
- ›Supports server-side query execution scoped to a namespace.
└──▷ BREAKING ON UPGRADE
- !Mac x86 (Intel) is no longer supported; macOS users must run on Apple Silicon or another supported platform.
- !Namespace operations now use namespace models directly — code calling namespace APIs must be updated to use the new model-based interface.
v0.22.4-beta.3 Dec 2, 2025 · issue -258

LanceDB v0.22.4-beta.3 adds head() for remote tables and stable row IDs via storage_options.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.4-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.4-beta.3
```
- ›Supports stable row IDs configurable via storage_options when creating or opening tables.
- ›Implements head() method for remote tables, enabling fast row-count-limited retrieval without a full scan.
- ›Updates Codex URL key configuration for remote connectivity.
python-v0.25.4-beta.3 Dec 2, 2025 · issue -258

LanceDB python-v0.25.4-beta.3 adds head() for remote tables and stable row ID support via storage_options.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.4-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.4-beta.3
```
- ›Supports stable row IDs on tables via storage_options, enabling consistent row addressing across compaction and updates.
- ›Implements head() for remote tables, allowing callers to fetch the first N rows from a remote LanceDB table.
- ›Updates the Codex URL key, enabling connectivity to the updated Codex endpoint.
v0.22.4-beta.2 Nov 19, 2025 · issue -271

LanceDB v0.22.4-beta.2 adds num_attempts to merge-insert results, async to_pydantic, and async namespace connections.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.4-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.4-beta.2
```
- ›Adds num_attempts field to merge-insert results, exposing the number of attempts made during a merge-insert operation.
- ›Supports to_pydantic in async Python contexts, enabling Pydantic model conversion in async workflows.
- ›Supports async namespace connections, allowing namespace-scoped operations in async code.
python-v0.25.4-beta.2 Nov 19, 2025 · issue -271

LanceDB python-v0.25.4-beta.2 adds num_attempts in merge-insert results, async to_pydantic, and async namespace connections.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.4-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.4-beta.2
```
└──▷ USE IT
Deserialize async query results into Pydantic models without blocking — useful in async web services or pipelines.
python
```
results = await table.search(query_vector).to_pydantic(MyModel)
```
- ›Adds num_attempts field to merge-insert results, exposing how many attempts were made during a merge-insert operation.
- ›Supports to_pydantic in the async Python API, allowing async table queries to deserialize results directly into Pydantic models.
- ›Adds async namespace connection support, enabling non-blocking namespace-level database connections.
python-v0.25.4-beta.0 Nov 17, 2025 · issue -273

LanceDB python-v0.25.4-beta.0 adds namespace credentials vending and lets Lance auto-tune IVF partition count.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.4-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.4-beta.0
```
- ›Supports namespace credentials vending for scoped, per-namespace authentication.
- ›Lets Lance automatically determine the default num_partitions parameter for IVF index creation instead of requiring manual tuning.
v0.22.4-beta.0 Nov 17, 2025 · issue -273

LanceDB v0.22.4-beta.0 adds namespace credentials vending and auto-tuned IVF partition defaults.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.4-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.4-beta.0
```
- ›Supports namespace credentials vending, enabling credential delegation scoped to namespaces.
- ›Lets Lance automatically determine the default num_partitions parameter for IVF index creation instead of requiring manual tuning.
python-v0.25.3 Nov 7, 2025 · issue -283

LanceDB python-v0.25.3 adds IVF_RQ index, multivector ColPali support, FTS in SQL, and output_schema for queries.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.3
```
└──▷ USE IT
Inspect the result schema of a vector search query before materializing results — useful for validating column types in a pipeline.
python
```
schema = table.search(query_vector).limit(10).output_schema()
print(schema)
```
- ›Adds IVF_RQ index type for approximate nearest neighbor search via a new index option.
- ›Adds output_schema method to query objects so callers can inspect the result schema before executing.
- ›Adds full-text search as a user-defined table function (UDTF) in SQL queries.
- ›Adds a Permutation Python class that mimics the Hugging Face dataset interface and provides a PyTorch DataLoader-compatible permutation view over LanceDB tables.
- ›Exposes storage options directly on table objects, allowing per-table cloud storage configuration.
+2 moreshow less
- ›Expands multivector support for ColPali models with additional enhancements.
- ›Updates the VoyageAI embedding integration.
v0.22.3 Nov 7, 2025 · issue -283

LanceDB v0.22.3 adds IVF_RQ index, FTS in SQL via UDTF, multivector ColPali support, and a new output_schema query method.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.3
```
└──▷ USE IT
Build an IVF_RQ index on a high-cardinality vector column to trade a small recall drop for significantly reduced index size.
python
```
table.create_index("embedding", index_type="IVF_RQ")
```
- ›Adds IVF_RQ index type for approximate nearest-neighbor search, extending the existing IVF index family.
- ›Adds output_schema method to queries, letting callers inspect the schema a query will return before executing it.
- ›Adds full-text-search (FTS) as a user-defined table function (UDTF) callable directly in SQL queries.
- ›Adds a Python Permutation class that mirrors the HuggingFace Dataset API and provides a PyTorch DataLoader interface for shuffled data access.
- ›Exposes storage options on Table objects, giving callers direct control over underlying object-store configuration.
+3 moreshow less
- ›Expands multivector ColPali model support with additional enhancements for multi-vector embedding workflows.
- ›Updates the VoyageAI embedding integration.
- ›Adds source field to TableNotFound errors to identify which storage location was searched.
v0.22.3-beta.4 Oct 31, 2025 · issue -290

LanceDB v0.22.3-beta.4 updates the Voyage AI embedding integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.3-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.3-beta.4
```
- ›Updates the Voyage AI integration for embeddings.
python-v0.25.3-beta.4 Oct 31, 2025 · issue -290

Updates the VoyageAI embedding integration in LanceDB.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.3-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.3-beta.4
```
- ›Updates the VoyageAI embedding integration.
python-v0.25.3-beta.2 Oct 21, 2025 · issue -300

LanceDB python-v0.25.3-beta.2 exposes storage options directly on table objects.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.3-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.3-beta.2
```
- ›Exposes storage options on table objects, enabling per-table storage configuration.
v0.22.3-beta.2 Oct 21, 2025 · issue -300

LanceDB v0.22.3-beta.2 exposes storage options directly on table objects.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.3-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.3-beta.2
```
- ›Exposes storage options on table instances, enabling per-table storage configuration.
python-v0.25.3-beta.1 Oct 19, 2025 · issue -302

LanceDB python-v0.25.3-beta.1 adds output_schema on queries, multivector ColPali support, and a permutation reader.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.3-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.3-beta.1
```
└──▷ USE IT
Inspect the result schema of a vector query before fetching rows, useful for validating downstream pipeline compatibility.
python
```
schema = table.search(query_vector).limit(10).output_schema()
print(schema)
```
- ›Adds output_schema method to query objects, letting callers inspect the schema of query results before materializing them.
- ›Expands multivector support for ColPali models with additional enhancements.
- ›Adds a permutation reader capable of reading permutation views of Lance data.
- ›Removes the DynamoDB default dependency, reducing required install footprint.
v0.22.3-beta.1 Oct 19, 2025 · issue -302

LanceDB v0.22.3-beta.1 adds output_schema on queries, multivector ColPali support, and a permutation reader.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.3-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.3-beta.1
```
- ›Adds output_schema method to query objects, letting callers inspect the schema of query results before materializing them.
- ›Expands support for multivector ColPali models with additional enhancements for multi-vector search workflows.
- ›Adds a permutation reader capable of reading a permutation view over stored data.
- ›Removes the DynamoDB default dependency, reducing the default dependency footprint.
python-v0.25.3-beta.0 Oct 14, 2025 · issue -307

LanceDB python-v0.25.3-beta.0 adds IVF_RQ index type and a permutation-views utility.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.3-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.3-beta.0
```
- ›Adds IVF_RQ as a new index type for vector indexing.
- ›Adds a utility for creating 'permutation views' over datasets.
v0.22.3-beta.0 Oct 14, 2025 · issue -307

LanceDB v0.22.3-beta.0 adds IVF_RQ index type and a permutation-views utility.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.3-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.3-beta.0
```
- ›Adds IVF_RQ index type for vector indexing.
- ›Adds a utility for creating 'permutation views' over data.
python-v0.25.2 Oct 8, 2025 · issue -313

LanceDB python-v0.25.2 adds use_index for merge inserts, namespace-backed databases, and bitmap indexes on more column types
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.2
```
- ›Adds use_index parameter to merge insert operations, enabling index-accelerated lookups during upserts.
- ›Supports bitmap indexes on large-string, binary, large-binary, and bitmap column types, expanding index coverage beyond standard string columns.
- ›Adds namespace-backed database support in the Rust backend, enabling namespace-scoped table isolation.
- ›Upgrades lance to 0.38.2.
v0.22.2 Oct 8, 2025 · issue -313

LanceDB v0.22.2 adds use_index for merge-insert, namespace-backed databases, and bitmap indexes on more Arrow types.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.2
```
- ›Adds use_index parameter to merge insert operations, enabling index-accelerated lookups during upsert workflows.
- ›Supports namespace-backed databases in the Rust client, enabling federated multi-namespace database topologies.
- ›Extends bitmap index support to large-string, binary, large-binary, and bitmap Arrow column types.
- ›Adds test_remote_connections support for validating remote connection configurations.
v0.22.2-beta.1 Sep 30, 2025 · issue -320

LanceDB v0.22.2-beta.1 adds bitmap index support for large-string, binary, and large-binary types, plus remote connection testing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.2-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.2-beta.1
```
- ›Extends bitmap indexes to cover large-string, binary, large-binary, and bitmap column types.
- ›Adds support for test_remote_connections to validate remote database connectivity.
python-v0.25.2-beta.1 Sep 30, 2025 · issue -320

LanceDB python-v0.25.2-beta.1 adds bitmap index support for large-string, binary, and large-binary types.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.2-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.2-beta.1
```
- ›Allows bitmap indexes to be created on large-string, binary, large-binary, and bitmap column types.
- ›Adds support for test_remote_connections to validate remote database connectivity.
python-v0.25.2-beta.0 Sep 24, 2025 · issue -326

LanceDB python-v0.25.2-beta.0 adds use_index parameter to merge insert and namespace-backed database support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.2-beta.0
```
- ›Adds use_index parameter to merge insert operations, letting callers control whether an index is used during the merge step.
- ›Adds namespace-backed database support in the Rust backend, enabling namespace-scoped database connections.
v0.22.2-beta.0 Sep 24, 2025 · issue -326

LanceDB v0.22.2-beta.0 adds use_index parameter to merge-insert and namespace-backed database support in Rust.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.2-beta.0
```
- ›Adds use_index parameter to merge insert operations, allowing callers to control whether an index is used during the merge.
- ›Adds namespace-backed database support in the Rust client, enabling namespace-scoped database connections.
python-v0.25.1 Sep 23, 2025 · issue -327

LanceDB python-v0.25.1 adds mTLS, per-request headers, shallow clone, MRR reranker, and a new target_partition_size index param.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.1
```
- ›Adds target_partition_size parameter for index creation, giving callers direct control over partition sizing.
- ›Supports mTLS (mutual TLS) for remote database connections, enabling certificate-based client authentication.
- ›Supports per-request header overrides for remote connections, allowing request-scoped credential or routing headers.
- ›Adds shallow clone support for tables, enabling lightweight copy operations without full data duplication.
- ›Adds a Mean Reciprocal Rank (MRR) reranker for hybrid search result fusion.
+1 moreshow less
- ›Upgrades Lance to v0.37.0, pulling in the latest storage-layer capabilities.
v0.22.1 Sep 23, 2025 · issue -327

LanceDB v0.22.1 adds mTLS, per-request header overrides, shallow clone, MRR reranker, and a new target_partition_size index param.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.1
```
- ›Adds target_partition_size parameter for index configuration to control partition sizing during index builds.
- ›Supports mTLS for remote database connections, enabling mutual TLS authentication.
- ›Supports per-request header overrides for remote database clients, allowing dynamic header injection on individual requests.
- ›Adds shallow clone support for tables, enabling faster cloning without copying full data history.
- ›Adds a Mean Reciprocal Rank (MRR) reranker for hybrid search result reranking.
+1 moreshow less
- ›Upgrades Lance to v0.37.0.
v0.22.1-beta.3 Sep 22, 2025 · issue -328

LanceDB v0.22.1-beta.3 adds shallow clone support for tables.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.1-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.1-beta.3
```
- ›Adds shallow clone capability for tables, enabling fast duplication without copying all underlying data.
python-v0.25.1-beta.3 Sep 22, 2025 · issue -328

LanceDB python-v0.25.1-beta.3 adds shallow clone support for tables.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.1-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.1-beta.3
```
- ›Adds shallow clone capability for LanceDB tables, enabling fast copy-on-write table duplication without copying all underlying data.
python-v0.25.1-beta.2 Sep 18, 2025 · issue -332

LanceDB python-v0.25.1-beta.2 adds target_partition_size parameter for index tuning.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.1-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.1-beta.2
```
- ›Adds target_partition_size parameter to control partition sizing during index creation.
v0.22.1-beta.2 Sep 18, 2025 · issue -332

LanceDB v0.22.1-beta.2 adds target_partition_size parameter for index tuning.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.1-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.1-beta.2
```
- ›Adds target_partition_size parameter to control partition sizing during index creation.
python-v0.25.1-beta.0 Sep 10, 2025 · issue -340

LanceDB python-v0.25.1-beta.0 adds mutual TLS (mTLS) support for remote database connections.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.1-beta.0
```
- ›Supports mTLS (mutual TLS) authentication for remote database connections.
v0.22.1-beta.0 Sep 10, 2025 · issue -340

LanceDB v0.22.1-beta.0 adds mutual TLS (mTLS) support for remote database connections.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.1-beta.0
```
- ›Adds mTLS (mutual TLS) support for remote database connections, enabling certificate-based client authentication.
v0.22.0 Sep 4, 2025 · issue -346

LanceDB v0.22.0 adds multi-level namespace support, named indices, and PyTorch __getitems__ integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.0
```
└──▷ USE IT
Create a named vector index with deferred training so you can manage and reference the index by name later.
python
```
table.create_index(metric='cosine', name='my_vector_index', train=False)
```
- ›Adds train=False and name parameters to index creation calls, allowing indices to be named and deferred training to be configured.
- ›Adds name parameter to remaining Python create_index calls for consistent named-index support across the API.
- ›Supports multi-level namespace, enabling hierarchical organization of databases and tables.
- ›Integrates Python SDK with lance namespace for namespace-aware database operations.
- ›Adds __getitems__ method implementation for PyTorch integration, enabling direct dataset access patterns.
└──▷ BREAKING ON UPGRADE
- !Multi-level namespace support changes namespace semantics — existing code that assumes a single-level namespace may break on upgrade.
- !Doctest fix in query.py changes the documented query API behavior — code mirroring the old doctest examples may need updating.
python-v0.25.0 Sep 4, 2025 · issue -346

LanceDB python-v0.25.0 adds multi-level namespace support, named indices, and PyTorch __getitems__ integration.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.0
```
└──▷ USE IT
Define a named IVF-PQ index without triggering training immediately, useful when you want to stage index creation in a pipeline.
python
```
table.create_index("vector", index_type="IVF_PQ", name="my_vector_index", train=False)
```
- ›Adds train=False parameter to index creation calls, allowing indices to be defined without immediately training them.
- ›Adds name parameter to all Python create_index calls so indices can be created and referenced by a user-defined name.
- ›Supports multi-level namespaces for organizing tables and databases hierarchically, with full Python SDK integration via lance namespace.
- ›Adds __getitems__ method to enable native PyTorch dataset integration for batch item retrieval.
- ›Upgrades lance to 0.33.0-beta.3, pulling in upstream performance and capability improvements.
└──▷ BREAKING ON UPGRADE
- !Multi-level namespace support changes how namespaces are addressed; existing single-level namespace usage may need updates to conform to the new hierarchy model.
python-v0.25.0-beta.0 Aug 29, 2025 · issue -352

LanceDB python-v0.25.0-beta.0 adds multi-level namespace support, named index creation, and PyTorch batch indexing.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.25.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.25.0-beta.0
```
└──▷ USE IT
Create a named vector index so you can reference or manage it by name later.
python
```
table.create_index("embedding", name="my_vector_index")
```
- ›Adds name parameter to Python create_index calls, allowing indexes to be created with explicit names.
- ›Supports multi-level namespace for organizing tables and datasets within a LanceDB connection.
- ›Adds __getitems__ method to the LanceDB dataset interface for native PyTorch batch-indexing integration.
└──▷ BREAKING ON UPGRADE
- !Multi-level namespace support changes how namespaces are structured; existing single-level namespace setups may require migration.
v0.22.0-beta.0 Aug 29, 2025 · issue -352

LanceDB v0.22.0-beta.0 adds multi-level namespace support, named index creation, and PyTorch __getitems__ integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.22.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.22.0-beta.0
```
└──▷ USE IT
Assign an explicit name to an index at creation time so it can be referenced unambiguously later.
python
```
table.create_index("embedding", name="my_embedding_idx")
```
- ›Adds name parameter to remaining Python create_index calls, allowing indexes to be explicitly named at creation time.
- ›Supports multi-level namespace for organizing tables and datasets hierarchically.
- ›Adds __getitems__ method to enable batch-indexing access for PyTorch dataset integration.
└──▷ BREAKING ON UPGRADE
- !Multi-level namespace support changes namespace handling in a breaking way — existing single-level namespace usage may require migration.
v0.21.4-beta.0 Aug 19, 2025 · issue -362

LanceDB v0.21.4-beta.0 adds train=False and name parameters for index creation.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.21.4-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.21.4-beta.0
```
- ›Adds train=False and name parameters when creating indices, enabling untrained index creation and explicit index naming.
python-v0.24.4-beta.0 Aug 19, 2025 · issue -362

LanceDB python-v0.24.4-beta.0 adds train=False and name parameters for index creation.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.24.4-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.24.4-beta.0
```
- ›Adds train=False and name parameters when creating indices, allowing users to name indices and skip the training step.
- ›Upgrades bundled Lance to 0.33.0-beta.3.
python-v0.24.3 Aug 15, 2025 · issue -363

LanceDB v0.24.3 adds SigLIP embeddings, overall remote timeout, smarter vector-column inference, and new low-level row access APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.24.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.24.3
```
└──▷ USE IT
Set a hard overall timeout on a remote LanceDB client so long-running requests fail fast rather than hanging indefinitely.
python
```
import lancedb

db = lancedb.connect(
    "db://my-project",
    api_key="<api_key>",
    region="us-east-1",
    timeout=30,  # seconds
)
```
- ›Adds timeout parameter to the remote client to set an overall request timeout, preventing indefinitely hanging calls.
- ›Adds take_offsets and take_row_ids methods for low-level row access by offset or row ID.
- ›Automatically infers vector columns when the column name contains 'vector' or 'embedding', reducing manual schema configuration.
- ›Adds SigLIP embedding support to the embeddings registry for vision-language model workflows.
- ›Upgrades the underlying lance engine to v0.33.0.
v0.21.3 Aug 15, 2025 · issue -363

LanceDB v0.21.3 adds SigLIP embeddings, overall remote timeout, smarter vector column inference, and new Rust APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.21.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.21.3
```
- ›Adds overall timeout parameter to the remote client, letting callers cap end-to-end request time.
- ›Adds take_offsets and take_row_ids APIs for low-level row retrieval by offset or row ID.
- ›Adds SigLIP embedding support to the LanceDB embeddings integration.
- ›Automatically infers vector columns when the column name contains 'vector' or 'embedding', reducing manual configuration.
- ›Adds hybrid search example in Rust, demonstrating combined vector and full-text search.
+1 moreshow less
- ›Upgrades bundled Lance to v0.33.0.
v0.21.2 Jul 25, 2025 · issue -364

LanceDB v0.21.2 adds ngram tokenizer, multivector JS support, return-all-scores reranking, and custom Session management.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.21.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.21.2
```
- ›Adds Session creation for Python and TypeScript users, enabling custom session configuration on ListingDatabase.
- ›Adds ngram tokenizer support for full-text search indexing.
- ›Adds multivector support to the JavaScript/TypeScript SDK.
- ›Adds support for returning all scores from rerankers, not just the top result.
- ›Integrates lance-namespace into the LanceDB Java SDK.
+1 moreshow less
- ›Upgrades bundled Lance to v0.32.0.
python-v0.24.2 Jul 25, 2025 · issue -364

LanceDB python-v0.24.2 adds ngram tokenizer, all-scores reranking, Session support, and multivector for JS SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.24.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.24.2
```
- ›Adds ngram tokenizer support for full-text search indexing.
- ›Adds support for returning all scores with rerankers, not just the top result.
- ›Allows Python and TypeScript users to create Session objects for custom connection management.
- ›Allows setting a custom Session on ListingDatabase for object-storage authentication.
- ›Integrates lance-namespace into the LanceDB Java SDK.
+2 moreshow less
- ›Adds multivector support to the JavaScript SDK.
- ›Upgrades underlying Lance version to v0.32.0.
v0.21.2-beta.1 Jul 22, 2025 · issue -364

LanceDB v0.21.2-beta.1 adds lance-namespace integration for Java, custom Session support for ListingDatabase, and multivector support in the JS SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.21.2-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.21.2-beta.1
```
- ›Adds lance-namespace integration to the LanceDB Java SDK.
- ›Supports setting a custom Session on ListingDatabase for the Rust/Python SDK.
- ›Adds multivector support to the JavaScript SDK.
python-v0.24.2-beta.1 Jul 22, 2025 · issue -364

LanceDB python-v0.24.2-beta.1 adds lance-namespace integration for Java, custom Session on ListingDatabase, and multivector support for the JS SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.24.2-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.24.2-beta.1
```
- ›Supports setting a custom Session on ListingDatabase for configurable storage/auth behavior.
- ›Integrates lance-namespace into the LanceDB Java SDK.
- ›Adds multivector support to the JavaScript SDK.
v0.21.2-beta.0 Jul 18, 2025 · issue -364

LanceDB v0.21.2-beta.0 adds ngram tokenizer support and full score return from rerankers.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.21.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.21.2-beta.0
```
- ›Supports ngram tokenizer for full-text search indexing.
- ›Rerankers can now return all scores, not just the top result.
python-v0.24.2-beta.0 Jul 18, 2025 · issue -364

LanceDB python-v0.24.2-beta.0 adds ngram tokenizer support and full-score return from rerankers.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.24.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.24.2-beta.0
```
- ›Supports ngram tokenizer for full-text search indexing.
- ›Rerankers can now return all scores, not just top results.
python-v0.24.1 Jul 10, 2025 · issue -364

LanceDB python-v0.24.1 adds batched Ollama embeddings and configurable IVF-PQ index parameters.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.24.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.24.1
```
- ›Supports specifying num_partitions and num_bits when building vector indexes.
- ›Batches Ollama embedding calls for improved throughput when using the Ollama embedder.
- ›Upgrades underlying Lance storage engine to 0.31.1.
v0.21.1 Jul 10, 2025 · issue -364

LanceDB v0.21.1 adds batched Ollama embedding calls and new num_partitions/num_bits index parameters.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.21.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.21.1
```
- ›Adds num_partitions and num_bits parameters to index configuration, giving callers direct control over vector quantization settings.
- ›Batches Ollama embedding calls in the Python client to reduce round-trips when embedding large datasets.
- ›Upgrades underlying Lance storage engine to v0.31.1.
python-v0.24.1-beta.0 Jul 7, 2025 · issue -364

LanceDB python-v0.24.1-beta.0 adds batched Ollama embedding calls and upgrades to lance 0.31.0-beta.1.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.24.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.24.1-beta.0
```
- ›Batches Ollama embed calls for improved throughput when generating embeddings via the Ollama integration.
- ›Upgrades the underlying lance dependency to 0.31.0-beta.1.
v0.21.1-beta.0 Jul 7, 2025 · issue -364

LanceDB v0.21.1-beta.0 adds batched Ollama embedding calls and upgrades to lance 0.31.0-beta.1.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.21.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.21.1-beta.0
```
- ›Adds batched Ollama embed calls in the Python client, improving throughput when generating embeddings via Ollama.
- ›Upgrades the underlying lance storage engine to lance 0.31.0-beta.1.
python-v0.24.0 Jun 20, 2025 · issue -365

LanceDB python-v0.24.0 switches to native lance FTS by default and adds prefix matching, must_not clauses, and nprobes bounds.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.24.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.24.0
```
- ›Adds maximum and minimum nprobes properties to control ANN search probe bounds.
- ›Supports prefix matching and must_not clause in full-text search queries.
- ›Expands native FTS feature support in the Python SDK.
- ›Expands native FTS feature support in the JavaScript SDK.
└──▷ BREAKING ON UPGRADE
- !The default full-text search engine is now native lance FTS; setups relying on the previous default FTS backend may behave differently on upgrade.
v0.21.0 Jun 20, 2025 · issue -365

LanceDB v0.21.0 switches default FTS to native Lance engine and adds prefix matching, must_not clauses, and nprobes bounds
└──▷ GET THIS VERSION
```
$ git clone --branch v0.21.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.21.0
```
- ›Adds maximum and minimum nprobes properties to control ANN search probe bounds at query time.
- ›Supports prefix matching and must_not clause in full-text search queries for both Python and JS SDKs.
- ›Expands FTS feature support across the Python SDK and JS SDK, bringing both to parity with native Lance FTS capabilities.
- ›Switches the default full-text search engine to native Lance FTS in both SDKs.
└──▷ BREAKING ON UPGRADE
- !The default FTS engine is now native Lance FTS; existing setups relying on the previous default FTS backend will use the new engine after upgrading.
v0.20.1-beta.0 Jun 16, 2025 · issue -365

LanceDB v0.20.1-beta.0 adds new Full-Text Search capabilities to Python and JS SDKs and exposes minimum_nprobes/maximum_nprobes ANN index properties.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.20.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.20.1-beta.0
```
- ›Adds minimum_nprobes and maximum_nprobes properties to control ANN search probe bounds.
- ›Expands Full-Text Search (FTS) feature support in the Python SDK.
- ›Expands Full-Text Search (FTS) feature support in the JavaScript SDK.
python-v0.23.1-beta.0 Jun 16, 2025 · issue -365

LanceDB python-v0.23.1-beta.0 adds new FTS search capabilities and maximum/minimum nprobes properties for ANN index tuning.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.23.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.23.1-beta.0
```
- ›Adds maximum and minimum nprobes properties for controlling ANN index probe bounds.
- ›Expands full-text search (FTS) feature support in the Python SDK.
- ›Expands full-text search (FTS) feature support in the JavaScript SDK.
python-v0.22.1 May 22, 2025 · issue -366

LanceDB python-v0.22.1 adds tag management, table stats, merge stats, per-write versioning, and a merge_insert timeout parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.1
```
└──▷ USE IT
Prevent a long-running merge_insert from hanging indefinitely in a pipeline by setting an explicit timeout.
python
```
table.merge_insert("id").when_matched_update_all().when_not_matched_insert_all().execute(new_data, timeout=30)
```
Bookmark a known-good dataset state and later restore it by name instead of tracking raw version numbers.
python
```
table.create_tag("v1-baseline", version=5)
# ... later ...
table.checkout_tag("v1-baseline")
```
Inspect table storage statistics after ingestion to understand data distribution and fragment counts.
python
```
stats = table.stats()
print(stats)
```
- ›Adds timeout parameter to merge_insert to control how long the operation waits before failing.
- ›Adds tag management API — list, create, delete, update, and checkout operations for named dataset tags.
- ›Adds table.stats() API to retrieve statistics about a table.
- ›Returns merge statistics from merge_insert via new bindings exposing merge stats.
- ›Returns the resulting version number from all write operations, enabling callers to track dataset versions after every mutation.
v0.19.1 May 22, 2025 · issue -366

LanceDB v0.19.1 adds tag management APIs, table stats, merge stats bindings, versioned writes, and a timeout parameter for merge_insert.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.1
```
- ›Adds timeout parameter to merge_insert to control how long the operation waits before failing.
- ›Adds list, create, delete, update, and checkout tag API for managing dataset versions via tags.
- ›Adds table stats API to retrieve statistics about a table.
- ›Adds bindings to return merge statistics after a merge operation.
- ›All write operations now return the resulting table version number.
v0.19.1-beta.4 May 8, 2025 · issue -366

LanceDB v0.19.1-beta.4 adds a timeout parameter to merge_insert operations.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.1-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.1-beta.4
```
- ›Adds timeout parameter to merge_insert to cap how long a merge-insert operation may run.
python-v0.22.1-beta.4 May 8, 2025 · issue -366

LanceDB python-v0.22.1-beta.4 adds a timeout parameter to merge_insert.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.1-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.1-beta.4
```
└──▷ USE IT
Set a timeout on a merge_insert operation to avoid indefinitely blocking pipelines when upserting large batches.
python
```
table.merge_insert("id").when_matched_update_all().when_not_matched_insert_all().execute(new_data, timeout=30)
```
- ›Adds timeout parameter to merge_insert to control how long the operation waits before failing.
v0.19.1-beta.2 May 6, 2025 · issue -366

LanceDB v0.19.1-beta.2 adds merge stats from merge operations and version numbers from all write operations.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.1-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.1-beta.2
```
- ›Returns merge statistics from merge operations via new bindings.
- ›Returns the resulting version number from all write operations.
python-v0.22.1-beta.2 May 6, 2025 · issue -366

LanceDB python-v0.22.1-beta.2 adds merge stats and version numbers on all write operations.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.1-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.1-beta.2
```
- ›Returns the resulting dataset version number for all write operations, enabling callers to track dataset lineage after every write.
v0.19.1-beta.1 Apr 29, 2025 · issue -367

LanceDB v0.19.1-beta.1 adds a table statistics API for inspecting table internals.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.1-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.1-beta.1
```
- ›Adds a table stats API, enabling programmatic inspection of table-level statistics.
python-v0.22.1-beta.1 Apr 29, 2025 · issue -367

LanceDB python-v0.22.1-beta.1 adds a table statistics API for inspecting table internals.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.1-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.1-beta.1
```
- ›Adds a table stats API to expose internal statistics for LanceDB tables.
v0.19.1-beta.0 Apr 28, 2025 · issue -367

LanceDB v0.19.1-beta.0 adds tag management APIs for listing, creating, deleting, updating, and checking out tags.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.1-beta.0
```
- ›Adds list, create, delete, update, and checkout tag API for managing dataset version tags.
python-v0.22.1-beta.0 Apr 28, 2025 · issue -367

LanceDB python-v0.22.1-beta.0 adds a tag management API for listing, creating, deleting, updating, and checking out tags.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.1-beta.0
```
- ›Adds list, create, delete, update, and checkout tag API methods for managing dataset tags programmatically.
v0.19.0 Apr 25, 2025 · issue -367

LanceDB v0.19.0 adds explain/analyze plan APIs, ColPali multi-vector embeddings, FTS on string lists, query timeouts, and index prewarming.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.0
```
- ›Adds explain_plan remote API to inspect query execution plans before running them.
- ›Adds analyze_plan API to retrieve runtime execution statistics for queries.
- ›Adds restore remote API to roll a table back to a previous version.
- ›Adds prewarm_index function to load an index into memory ahead of query time.
- ›Adds timeout option to query execution options for bounding long-running remote queries.
+5 moreshow less
- ›Adds new table API to wait for async indexing to complete, enabling reliable post-ingest query patterns.
- ›Supports creating Full-Text Search (FTS) indexes on columns of type list-of-strings.
- ›Adds ColPali embedding support with the MultiVector type for multi-vector retrieval workflows.
- ›Supports adding columns using a PyArrow schema directly.
- ›Adds retries to the remote client for requests with stream bodies, improving reliability of large uploads.
python-v0.22.0 Apr 25, 2025 · issue -367

LanceDB python-v0.22.0 adds ColPali/MultiVector embeddings, FTS on string lists, prewarm_index, explain/analyze plan APIs, and query timeouts.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.0
```
- ›Adds explain_plan remote API to inspect query execution plans before running them.
- ›Adds analyze_plan API to retrieve runtime execution statistics for queries.
- ›Adds restore remote API to roll a table back to a previous version.
- ›Adds prewarm_index function to load an index into memory before serving queries.
- ›Adds a timeout option to query execution options, letting callers bound how long a query may run.
+6 moreshow less
- ›Adds a new table API to wait for async indexing to complete.
- ›Supports creating a Full-Text Search (FTS) index on columns containing lists of strings.
- ›Supports Fixed-Size Binary (FSB) columns as the source for B-tree indices.
- ›Adds ColPali embedding support with the MultiVector type for multi-vector retrieval workflows.
- ›Supports adding columns using a PyArrow schema for schema-driven column definitions.
- ›Adds retries to the remote client for requests with stream bodies, improving reliability of large uploads.
v0.19.0-beta.9 Apr 21, 2025 · issue -367

LanceDB v0.19.0-beta.9 adds ColPali/MultiVector embedding support and a new async indexing wait API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.0-beta.9 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.0-beta.9
```
- ›Adds MultiVector type with ColPali embedding support, enabling multi-vector retrieval workflows for vision-language models.
- ›Adds a new table API method to wait for async indexing to complete, allowing callers to block until an index is ready before querying.
python-v0.22.0-beta.9 Apr 21, 2025 · issue -367

LanceDB python-v0.22.0-beta.9 adds ColPali/MultiVector embedding support and a new async indexing wait API.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.0-beta.9 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.0-beta.9
```
- ›Adds MultiVector type with ColPali embedding support for multi-vector similarity search workflows.
- ›Adds a new table API method to wait for async indexing to complete, enabling reliable post-index operations.
v0.19.0-beta.8 Apr 17, 2025 · issue -367

LanceDB v0.19.0-beta.8 adds a prewarm_index function to load indexes into cache before query time.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.0-beta.8 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.0-beta.8
```
- ›Adds prewarm_index function to load vector indexes into memory ahead of query time, reducing first-query latency.
python-v0.22.0-beta.8 Apr 17, 2025 · issue -367

LanceDB python-v0.22.0-beta.8 adds prewarm_index for loading ANN indexes into memory ahead of queries.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.0-beta.8 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.0-beta.8
```
- ›Adds prewarm_index function to load ANN indexes into memory before query time, reducing cold-start latency.
v0.19.0-beta.5 Apr 4, 2025 · issue -367

LanceDB v0.19.0-beta.5 adds timeout support to query execution options.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.0-beta.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.0-beta.5
```
- ›Adds timeout configuration to query execution options, enabling callers to bound how long a query runs before it is cancelled.
python-v0.22.0-beta.5 Apr 4, 2025 · issue -367

LanceDB python-v0.22.0-beta.5 adds timeout support to query execution options.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.0-beta.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.0-beta.5
```
- ›Adds timeout to query execution options, enabling callers to cap how long a query is allowed to run.
v0.19.0-beta.0 Mar 30, 2025 · issue -368

LanceDB v0.19.0-beta.0 adds analyze_plan API and changes default read_consistency_interval to 5 seconds.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.19.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.19.0-beta.0
```
- ›Adds analyze_plan API for query plan analysis.
- ›Changes default read_consistency_interval from its previous value to 5s.
└──▷ BREAKING ON UPGRADE
- !The default read_consistency_interval is now 5s; any setup relying on the previous default will now read with a 5-second consistency window instead.
python-v0.22.0-beta.0 Mar 30, 2025 · issue -368

LanceDB python-v0.22.0-beta.0 adds analyze_plan API and changes default read_consistency_interval to 5 seconds.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.22.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.22.0-beta.0
```
- ›Adds analyze_plan API for query plan analysis.
- ›Changes default read_consistency_interval to 5s (previously unset/0), enabling automatic consistency checks for remote tables by default.
└──▷ BREAKING ON UPGRADE
- !The default read_consistency_interval is changed to 5s; remote table reads that previously returned immediately without a consistency check will now incur a consistency poll on every read unless explicitly overridden.
python-v0.21.3-beta.0 Mar 28, 2025 · issue -368

LanceDB python-v0.21.3-beta.0 adds explain-plan and restore remote APIs plus PyArrow schema column support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.21.3-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.21.3-beta.0
```
- ›Adds an explain plan remote API for inspecting query execution plans on remote tables.
- ›Adds a restore remote API for reverting remote tables to a previous state.
- ›Supports adding columns to a table using a PyArrow schema definition.
v0.18.3-beta.0 Mar 28, 2025 · issue -368

LanceDB v0.18.3-beta.0 adds explain-plan and restore remote APIs plus PyArrow schema support for adding columns.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.18.3-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.18.3-beta.0
```
- ›Adds a remote API for explain plan, enabling inspection of query execution plans against remote LanceDB tables.
- ›Adds a remote API for restore, enabling programmatic rollback of remote LanceDB tables to previous versions.
- ›Supports adding columns to a table using a PyArrow schema definition.
v0.18.2 Mar 26, 2025 · issue -368

LanceDB v0.18.2 adds binary vector and IVF_FLAT support in TypeScript, catalog URL connections in Rust, and a fork warning in Python.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.18.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.18.2
```
- ›Adds connect_catalog method in Rust to connect to a catalog via URL.
- ›Supports parsing Arrow types in alterColumns() in the Node.js client.
- ›Adds get_dataset method on NativeTable to retrieve the underlying dataset.
- ›Adds to_query_object method for converting queries to a serializable object.
- ›Supports binary vector and IVF_FLAT index type in TypeScript.
+1 moreshow less
- ›Emits a warning in Python when the process is forked, to help catch unsafe multiprocessing patterns.
python-v0.21.2 Mar 26, 2025 · issue -368

LanceDB v0.21.2 adds catalog URL connections, binary vector support in TypeScript, and fork warnings for Python.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.21.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.21.2
```
- ›Adds connect_catalog method (Rust) to connect to a catalog via URL.
- ›Adds alterColumns() support in Node.js for parsing Arrow types directly.
- ›Adds to_query_object method to convert query state to a serializable object.
- ›Adds get_dataset method on NativeTable to retrieve the underlying Lance dataset.
- ›Supports binary vector type and IVF_FLAT index in the TypeScript client.
+1 moreshow less
- ›Warns when a Python process forks while a LanceDB connection is open, preventing silent data corruption.
v0.18.2-beta.1 Mar 26, 2025 · issue -368

LanceDB v0.18.2-beta.1 adds a fork-safety warning for Python users.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.18.2-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.18.2-beta.1
```
- ›Adds a warning when the LanceDB Python client detects a forked process, helping practitioners avoid data-corruption or connection issues in multiprocessing workloads.
python-v0.21.2-beta.1 Mar 26, 2025 · issue -368

LanceDB Python v0.21.2-beta.1 adds a fork-safety warning to catch multiprocessing pitfalls early.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.21.2-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.21.2-beta.1
```
- ›Adds a warning when the LanceDB Python client detects it is running in a forked process, helping surface multiprocessing safety issues at runtime.
python-v0.21.2-beta.0 Mar 21, 2025 · issue -368

LanceDB python-v0.21.2-beta.0 adds catalog URL connections, binary vector support in TypeScript, and a new to_query_object method.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.21.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.21.2-beta.0
```
- ›Adds connect_catalog method to connect to a catalog via URL (Rust backend).
- ›Adds to_query_object method to convert queries to a serializable object representation.
- ›Adds get_dataset method on NativeTable to retrieve the underlying dataset directly.
- ›Supports parsing Arrow types in alterColumns() for the Node.js client.
- ›Supports binary vector type and IVF_FLAT index in the TypeScript client.
v0.18.2-beta.0 Mar 21, 2025 · issue -368

LanceDB v0.18.2-beta.0 adds catalog URL connections, binary vector + IVF_FLAT in TypeScript, and new query/dataset methods.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.18.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.18.2-beta.0
```
- ›Adds connect_catalog method in Rust to connect to a catalog via URL.
- ›Adds alterColumns() in Node.js now parses Arrow types directly, enabling schema alterations with Arrow type objects.
- ›Adds get_dataset method on NativeTable to retrieve the underlying dataset.
- ›Adds to_query_object method for converting queries to a serializable object representation.
- ›Supports binary vector indexing and IVF_FLAT index type in the TypeScript client.
+1 moreshow less
- ›Upgrades bundled Lance to v0.25.0-beta.5, bringing upstream engine improvements.
python-v0.21.0 Mar 10, 2025 · issue -368

LanceDB python-v0.21.0 adds streaming create_table input, field metadata editing, and makes pylance an optional dependency.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.21.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.21.0
```
└──▷ USE IT
Ingest a large generator of record batches into a new table without loading everything into memory first.
python
```
import lancedb
import pyarrow as pa

def batch_generator():
    for i in range(10):
        yield pa.record_batch({"vec": [[float(i)] * 128], "id": [i]},
                              schema=pa.schema([pa.field("vec", pa.list_(pa.float32(), 128)),
                                                pa.field("id", pa.int64())]))

db = lancedb.connect("./mydb")
table = db.create_table("embeddings", data=batch_generator())
```
- ›Adds support for modifying field metadata in the Python API via feat: support modifying field metadata in lancedb python.
- ›Adds streaming input support to create_table, enabling large or lazy iterables to be ingested without materializing them first.
- ›Drops the hard dependency on pylance; it is now optional, reducing mandatory install footprint.
- ›Reverts query scan limit to unbounded by default — scans no longer apply an implicit row limit.
- ›Records the server version for remote table connections, surfacing version metadata for LanceDB Cloud clients.
+1 moreshow less
- ›Respects DataFusion's configured batch size when LanceDB runs as a DataFusion table provider.
└──▷ BREAKING ON UPGRADE
- !Query scans are now unbounded by default (no implicit row limit); any code that relied on the previous default limit to cap result size will now return all matching rows.
v0.18.0 Mar 10, 2025 · issue -368

LanceDB v0.18.0 adds a Catalog trait, field metadata editing, streaming table creation, and drops the hard pylance dependency.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.18.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.18.0
```
└──▷ USE IT
Update field-level metadata on an existing table column without altering the underlying data.
python
```
import lancedb

db = lancedb.connect("./mydb")
tbl = db.open_table("my_table")

tbl.alter_columns({"path": "embedding", "metadata": {"model": "text-embedding-3-small", "dim": "1536"}})
```
- ›Introduces Catalog trait and ListingCatalog implementation in the Rust crate, providing a structured abstraction for catalog operations.
- ›Adds support for modifying field metadata on existing tables in the Python API.
- ›Adds streaming input support to create_table, enabling table creation from streaming data sources without buffering the full dataset.
- ›Drops the hard dependency on pylance in the Python package, making it an optional dependency.
- ›Respects DataFusion's batch size configuration when LanceDB runs as a DataFusion table provider.
+2 moreshow less
- ›Records the server version for remote tables, surfacing version metadata for remote connections.
- ›Reverts query limit to be unbounded for scans, removing the previously imposed default row limit on full-table scans.
└──▷ BREAKING ON UPGRADE
- !Query limit is now unbounded for scans by default — full-table scans that previously returned a capped number of rows will now return all rows, which may significantly increase memory usage and query time for callers that relied on the implicit limit.
python-v0.21.0-beta.1 Mar 6, 2025 · issue -368

LanceDB python-v0.21.0-beta.1 drops the hard pylance dependency and adds field-metadata modification support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.21.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.21.0-beta.1
```
- ›Drops the hard dependency on pylance, making the Python package installable without it.
- ›Records the server version for remote table connections, enabling version-aware client behaviour.
- ›Introduces a Catalog trait in the Rust layer with a ListingCatalog implementation, laying groundwork for multi-catalog support.
python-v0.21.0-beta.0 Feb 26, 2025 · issue -369

LanceDB python-v0.21.0-beta.0 makes table scans unbounded by default, removing the previous query limit.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.21.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.21.0-beta.0
```
- ›Table scans are now unbounded by default — queries without an explicit limit will return all matching rows instead of being capped.
└──▷ BREAKING ON UPGRADE
- !The default query limit has been reverted to unbounded for scans: queries that previously returned a capped result set will now return all rows, which may affect memory usage and performance in existing code.
python-v0.20.0 Feb 26, 2025 · issue -369

LanceDB python-v0.20.0 adds async search(), multivector on remote tables, and a variable store in the embeddings registry.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.20.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.20.0
```
└──▷ USE IT
Run a non-blocking vector similarity search in an async application using the new search() method on AsyncTable.
python
```
import asyncio
import lancedb

async def main():
    db = await lancedb.connect_async("~/.lancedb")
    table = await db.open_table("my_vectors")
    results = await table.search([0.1, 0.2, 0.3]).limit(10).to_pandas()
    print(results)

asyncio.run(main())
```
- ›Adds search() method to the async Python API (AsyncTable), bringing parity with the sync interface for non-blocking vector search workflows.
- ›Supports multivector queries on remote tables, enabling multi-embedding search against LanceDB Cloud/remote endpoints.
- ›Adds a variable store to the embeddings registry, allowing parameterized embedding function configuration at registry level.
- ›Pushes filters down into the DataFusion table provider, improving query performance for filtered vector searches.
└──▷ BREAKING ON UPGRADE
- !The variable store addition to the embeddings registry (feat!: add variable store to embeddings registry) changes the embeddings registry interface — existing code that constructs or interacts with the registry directly may break on upgrade.
v0.17.0 Feb 26, 2025 · issue -369

LanceDB v0.17.0 adds multivector remote table support, async search(), variable store in embeddings registry, and filter pushdown.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.17.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.17.0
```
- ›Adds search() method to the Python async API, bringing parity with the sync interface for async workflows.
- ›Adds variable store to the embeddings registry, enabling parameterized embedding configurations (breaking change — see below).
- ›Supports multivector search on remote tables.
- ›Pushes filters down into the DataFusion table provider, improving query performance for filtered vector searches.
└──▷ BREAKING ON UPGRADE
- !The embeddings registry now includes a variable store; existing code that constructs or extends the registry may require updates to accommodate the new parameter.
v0.16.1-beta.3 Feb 20, 2025 · issue -369

LanceDB v0.16.1-beta.3 adds multivector search support on remote tables.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.16.1-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.16.1-beta.3
```
- ›Supports multivector queries on remote tables, enabling multi-vector search workflows against remotely hosted LanceDB tables.
- ›Upgrades the underlying Lance library to 0.23.1-beta.4.
python-v0.19.1-beta.3 Feb 20, 2025 · issue -369

LanceDB python-v0.19.1-beta.3 adds multivector support on remote tables.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.19.1-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.19.1-beta.3
```
- ›Supports multivector search on remote tables, enabling multi-vector queries against LanceDB Cloud/remote table endpoints.
- ›Upgrades underlying Lance storage engine to 0.23.1-beta.4.
v0.16.0 Feb 7, 2025 · issue -369

LanceDB v0.16.0 adds drop_index(), streaming large writes, extra headers in client options, and subschema upserts for Node
└──▷ GET THIS VERSION
```
$ git clone --branch v0.16.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.16.0
```
└──▷ USE IT
Set an explicit distance metric when running a vector similarity search in Python sync code.
python
```
results = table.search(query_vector).distance_type("cosine").limit(10).to_list()
```
- ›Adds drop_index() method (local and remote implementations) to programmatically remove indexes from tables.
- ›Adds distance_type() parameter and metric() alias to Python sync query builders for explicit distance metric selection.
- ›Adds extra_headers parameter in client options for passing custom HTTP headers to remote connections.
- ›Adds streaming larger-than-memory writes in the Python SDK, enabling ingestion of datasets that exceed available RAM.
- ›Adds support for inserting and upserting subschemas in the Node.js SDK.
+2 moreshow less
- ›Exposes the Table trait in Rust, enabling custom table implementations.
- ›Upgrades Lance to v0.23.0.
└──▷ BREAKING ON UPGRADE
- !drop_db / drop_database are renamed to drop_all_tables; any code calling the old names will break.
- !ConnectionInternal is refactored into a Database trait in Rust; code depending on ConnectionInternal directly must be updated.
python-v0.19.0 Feb 7, 2025 · issue -369

LanceDB python-v0.19.0 adds drop_index(), streaming writes, distance_type() query param, and extra headers in client options.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.19.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.19.0
```
└──▷ USE IT
Remove a stale or mis-configured index from a table without recreating it.
python
```
table.drop_index("my_vector_index")
```
Run a nearest-neighbor query with an explicit distance metric rather than relying on the index default.
python
```
results = table.search(query_vector).distance_type("cosine").limit(10).to_list()
```
- ›Adds drop_index() method (including remote implementation) to remove indexes from tables programmatically.
- ›Adds distance_type() parameter to Python sync query builders, with metric() as an alias, for explicit control over vector distance calculations.
- ›Adds extra_headers parameter in client options for passing custom HTTP headers to remote connections.
- ›Supports streaming larger-than-memory writes in Python, enabling ingestion of datasets that exceed available RAM.
- ›Renames drop_db / drop_database to drop_all_tables and exposes the database object directly from the connection.
+1 moreshow less
- ›Upgrades Lance to v0.23.0, bringing in upstream engine improvements.
└──▷ BREAKING ON UPGRADE
- !drop_db and drop_database are renamed to drop_all_tables; any code calling the old names will break on upgrade.
- !ConnectionInternal is refactored into a Database trait, which changes the internal API surface and may break code that depended on ConnectionInternal directly.
v0.15.1-beta.1 Jan 28, 2025 · issue -370

LanceDB v0.15.1-beta.1 adds distance_type() and metric() alias to Python sync query builders
└──▷ GET THIS VERSION
```
$ git clone --branch v0.15.1-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.15.1-beta.1
```
- ›Adds distance_type() parameter to Python sync query builders, plus metric() as an alias, for specifying vector distance metrics at query time.
python-v0.18.1-beta.2 Jan 28, 2025 · issue -370

LanceDB python-v0.18.1-beta.2 adds distance_type() and metric() alias to sync query builders.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.18.1-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.18.1-beta.2
```
└──▷ USE IT
Set the distance metric on a synchronous vector query to use cosine similarity instead of the index default.
python
```
results = table.search(query_vector).distance_type('cosine').limit(10).to_list()
```
- ›Adds distance_type() parameter to Python sync query builders, plus metric() as an alias, for controlling vector distance calculations inline with query construction.
python-v0.18.1-beta.1 Jan 23, 2025 · issue -370

LanceDB python-v0.18.1-beta.1 adds a drop_index() method for programmatic index removal.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.18.1-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.18.1-beta.1
```
└──▷ USE IT
Remove a vector index from a table when you want to rebuild it with different parameters or free resources.
python
```
table.drop_index("index_name")
```
- ›Adds drop_index() method to tables, enabling programmatic removal of vector indexes.
v0.15.1-beta.0 Jan 23, 2025 · issue -370

LanceDB v0.15.1-beta.0 adds a drop_index() method and upgrades the Lance storage engine to v0.23.0-beta.2.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.15.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.15.1-beta.0
```
└──▷ USE IT
Remove a vector index from a table when you want to rebuild it with different parameters or free resources.
python
```
table.drop_index("vector_idx")
```
- ›Adds drop_index() method to tables, enabling programmatic removal of vector indexes.
- ›Upgrades the underlying Lance storage engine to v0.23.0-beta.2, incorporating the latest storage improvements.
v0.15.0 Jan 14, 2025 · issue -370

LanceDB v0.15.0 adds hybrid search to Node/Rust SDKs, distance thresholds and ranges, multivector type, and flips default filtering to prefiltering.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.15.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.15.0
```
└──▷ USE IT
Stream query results directly into a Polars DataFrame in the Python async API for downstream analysis.
python
```
result = await table.query().nearest_to(vector).to_polars()
```
- ›Adds to_polars method to AsyncQueryBase in Python, returning query results as a Polars DataFrame.
- ›Adds flatten method to AsyncQuery in Python for flattening nested query results.
- ›Supports .rerank() on non-hybrid queries in the Python Async API.
- ›Adds hybrid search to Node and Rust SDKs.
- ›Supports vector search with distance thresholds, enabling results to be filtered by a maximum distance value.
+6 moreshow less
- ›Supports distance range filtering in queries, allowing minimum and maximum distance bounds.
- ›Supports inserting and upserting subschemas in Python, allowing partial-schema writes without providing all columns.
- ›Adds IVF_FLAT index creation on remote tables (Python and Rust SDKs).
- ›Exposes dataset config for inspection and configuration of underlying Lance datasets.
- ›Supports multivector type, enabling columns that store multiple vectors per row.
- ›Upgrades underlying Lance dependency to v0.22.0.
└──▷ BREAKING ON UPGRADE
- !The default filtering mode for sync Python changed from postfiltering to prefiltering; existing queries that relied on postfiltering behavior will now behave differently without explicit configuration.
python-v0.18.0 Jan 14, 2025 · issue -370

LanceDB python-v0.18.0 adds distance thresholds, multivector support, hybrid search in Node/Rust, and to_polars for async queries.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.18.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.18.0
```
└──▷ USE IT
Return async vector search results directly as a Polars DataFrame for downstream analysis.
python
```
results = await table.search(query_vector).to_polars()
print(results)
```
- ›Adds .to_polars() method to AsyncQueryBase for returning async query results as Polars DataFrames.
- ›Adds .flatten() method to AsyncQuery for flattening nested struct columns in async query results.
- ›Adds .rerank() support on non-hybrid queries in the Async API.
- ›Supports vector search with distance thresholds, letting queries filter results by a maximum distance value.
- ›Supports distance range filtering in queries, enabling min/max distance bounds on vector search results.
+6 moreshow less
- ›Supports inserting and upserting subschemas, allowing partial-schema writes without specifying all columns.
- ›Adds IVF_FLAT index creation support on remote tables (Python and Rust SDKs).
- ›Adds hybrid search to the Node and Rust SDKs.
- ›Supports multivector type for indexing and querying multi-vector embeddings.
- ›Exposes dataset config via the API, making underlying Lance dataset configuration accessible.
- ›Default filtering mode for sync Python changes from postfiltering to prefiltering.
└──▷ BREAKING ON UPGRADE
- !The default filtering mode for sync Python changed from postfiltering to prefiltering; existing queries that relied on postfiltering behavior will now produce different result counts.
- !Insert and upsert operations now support subschemas — callers passing full schemas where column sets no longer match may see changed behavior.
python-v0.18.0-beta.0 Jan 10, 2025 · issue -370

LanceDB python-v0.18.0-beta.0 adds distance-range queries, subschema upserts, reranking on non-hybrid queries, and switches sync Python to prefiltering by default.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.18.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.18.0-beta.0
```
- ›Adds to_polars() method to AsyncQueryBase, enabling direct Polars DataFrame output from async queries.
- ›Adds flatten to AsyncQuery, allowing nested struct columns to be flattened in async query results.
- ›Adds .rerank() support on non-hybrid queries in the Async API, extending reranking beyond hybrid search.
- ›Supports distance range filtering in queries, letting callers bound results by minimum and maximum vector distances.
- ›Supports inserting and upserting subschemas, so partial-schema data can be written without supplying all columns.
+1 moreshow less
- ›Exposes dataset config, making underlying dataset configuration accessible from the Python API.
└──▷ BREAKING ON UPGRADE
- !The default filtering mode for sync Python queries has changed from postfiltering to prefiltering; existing queries that relied on postfiltering behavior will now produce different results unless prefilter is explicitly set.
- !Inserting and upserting subschemas changes how partial-schema writes are handled; existing insert/upsert code that depended on strict full-schema enforcement may need review.
v0.15.0-beta.0 Jan 10, 2025 · issue -370

LanceDB v0.15.0-beta.0 adds distance range queries, subschema upserts, reranking on non-hybrid queries, and switches default filtering to prefiltering.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.15.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.15.0-beta.0
```
└──▷ USE IT
Return async vector search results directly as a Polars DataFrame instead of Arrow or Pandas.
python
```
results = await table.search([0.1, 0.2, 0.3]).limit(10).to_polars()
```
- ›Adds to_polars() method to AsyncQueryBase for returning async query results as Polars DataFrames.
- ›Adds flatten support to AsyncQuery for flattening nested struct columns in async query results.
- ›Adds .rerank() support on non-hybrid queries in the Async API, extending reranking beyond hybrid search.
- ›Adds support for distance range filtering in vector queries, enabling min/max distance bounds on ANN results.
- ›Adds support for inserting and upserting subschemas, allowing partial-schema writes without specifying all columns.
+1 moreshow less
- ›Exposes dataset config through the LanceDB API.
└──▷ BREAKING ON UPGRADE
- !The default filtering mode for sync Python API changes from postfiltering to prefiltering; existing queries that relied on postfiltering behavior will now behave differently without explicit configuration.
- !Inserting and upserting subschemas changes how partial-schema inserts are handled in the Python API; existing code that inserted data with mismatched schemas may behave differently.
v0.14.2-beta.0 Jan 6, 2025 · issue -370

LanceDB v0.14.2-beta.0 adds hybrid search to Node and Rust SDKs, IVF_FLAT on remote tables, and vector search distance thresholds.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.14.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.14.2-beta.0
```
- ›Supports vector search with distance thresholds, allowing searches to filter results beyond a maximum distance cutoff.
- ›Adds IVF_FLAT index creation on remote tables, available in both the primary SDK and the Rust SDK.
- ›Adds hybrid search capability to the Node and Rust SDKs, combining vector and full-text search in a single query.
python-v0.17.2-beta.2 Jan 6, 2025 · issue -370

LanceDB python-v0.17.2-beta.2 adds distance threshold filtering for vector search queries.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.2-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.2-beta.2
```
- ›Supports distance thresholds in vector search, letting queries filter out results beyond a maximum distance from the query vector.
python-v0.17.2-beta.0 Dec 25, 2024 · issue -371

LanceDB python-v0.17.2-beta.0 adds IVF_FLAT index creation support on remote tables.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.2-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.2-beta.0
```
- ›Adds IVF_FLAT index creation on remote tables, enabling ANN search index building against hosted LanceDB instances from the Python client.
- ›Adds IVF_FLAT index support on remote tables in the Rust backend, underpinning the Python remote table feature.
v0.14.1 Dec 24, 2024 · issue -371

LanceDB v0.14.1 adds hybrid search in async SDK, 4-bit PQ, IVF_FLAT with binary vectors, and FTS options for Node.js.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.14.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.14.1
```
└──▷ USE IT
Skip the ANN vector index and force an exact search in the Python sync API — useful when index recall is insufficient and you need ground-truth results.
python
```
results = table.search(query_vector).bypass_vector_index(True).limit(10).to_list()
```
Safely drop a table in an async workflow without raising an error if it has already been deleted.
python
```
await db.drop_table("my_table", ignore_missing=True)
```
Create an IVF_FLAT index on binary vectors using Hamming distance for fast binary similarity search.
python
```
table.create_index(metric="hamming", index_type="IVF_FLAT", vector_column_name="binary_vec")
```
- ›Adds bypass_vector_index to the Python sync API, letting queries skip the vector index for exact search.
- ›Adds ignore_missing parameter to the async drop_table() method in Python, suppressing errors when the table does not exist.
- ›Supports Full-Text Search (FTS) options in the Node.js SDK via FtsOptions.
- ›Supports offset in the remote client, enabling paginated result retrieval against LanceDB Cloud.
- ›Supports Azure account name storage options in sync db.connect, enabling Azure Blob Storage connections by account name.
+4 moreshow less
- ›Adds hybrid search support in the Python async SDK, enabling combined vector and full-text search in async workflows.
- ›Supports 4-bit Product Quantization (PQ) for significantly compressed vector index storage.
- ›Supports IVF_FLAT index type, binary vectors, and Hamming distance metric for binary vector similarity search.
- ›Achieves async/sync feature parity on Table in the Python SDK.
python-v0.17.1 Dec 24, 2024 · issue -371

LanceDB python-v0.17.1 adds hybrid search in async SDK, 4-bit PQ, IVF_FLAT with binary vectors, and async/sync Table parity.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.1
```
└──▷ USE IT
Force a brute-force scan on a sync table query when you need exact results and want to bypass the ANN index.
python
```
results = table.search(query_vector).bypass_vector_index(True).limit(10).to_list()
```
Drop a table in async code without raising an error if it has already been deleted.
python
```
await db.drop_table("my_table", ignore_missing=True)
```
- ›Adds bypass_vector_index to the sync query API, letting callers force a brute-force scan instead of using an ANN index.
- ›Adds ignore_missing parameter to the async drop_table() method, suppressing errors when the table does not exist.
- ›Adds FTS (full-text search) options support to the Node.js SDK.
- ›Supports hybrid search in the async Python SDK, bringing it to parity with the sync SDK.
- ›Supports offset in the remote client, enabling paginated result retrieval against LanceDB Cloud.
+4 moreshow less
- ›Supports Azure account name as a storage option in db.connect() for the sync client.
- ›Supports 4-bit Product Quantization (PQ) for more aggressive vector compression.
- ›Supports IVF_FLAT index type, binary vectors, and Hamming distance as a new distance metric.
- ›Achieves async/sync feature parity on the Table API in the Python SDK.
python-v0.17.1-beta.5 Dec 13, 2024 · issue -371

LanceDB python-v0.17.1-beta.5 brings async-sync feature parity on the Table API.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.1-beta.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.1-beta.5
```
- ›Adds async-sync feature parity on the Table class, enabling all synchronous Table operations to have async equivalents.
v0.14.1-beta.5 Dec 13, 2024 · issue -371

LanceDB v0.14.1-beta.5 brings async-sync feature parity on the Python Table API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.14.1-beta.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.14.1-beta.5
```
- ›Adds async-sync feature parity on the Python Table class, enabling the same operations across both synchronous and asynchronous usage patterns.
python-v0.17.1-beta.4 Dec 13, 2024 · issue -371

LanceDB python-v0.17.1-beta.4 adds FTS options support in Node.js and upgrades to lance 0.21.0b3.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.1-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.1-beta.4
```
- ›Supports full-text search (FTS) options in the Node.js client.
- ›Upgrades the underlying lance engine to version 0.21.0b3.
v0.14.1-beta.4 Dec 13, 2024 · issue -371

LanceDB v0.14.1-beta.4 adds full-text search options for the Node.js client and upgrades the Lance core to 0.21.0b3.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.14.1-beta.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.14.1-beta.4
```
- ›Adds FTS (full-text search) options support to the Node.js client, bringing parity with other language bindings for configuring full-text search behavior.
- ›Upgrades the underlying Lance core library to version 0.21.0b3.
v0.14.1-beta.2 Dec 11, 2024 · issue -371

LanceDB v0.14.1-beta.2 adds offset support in the remote client and 4-bit Product Quantization indexing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.14.1-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.14.1-beta.2
```
- ›Supports 4-bit Product Quantization (PQ) for ANN indexes, reducing memory footprint for large vector datasets.
- ›Adds offset support in the remote client, enabling paginated query results against LanceDB Cloud.
python-v0.17.1-beta.2 Dec 11, 2024 · issue -371

LanceDB python-v0.17.1-beta.2 adds offset support in the remote client and 4-bit PQ index compression.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.1-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.1-beta.2
```
- ›Supports offset in remote client queries, enabling paginated result retrieval against remote LanceDB instances.
- ›Supports 4-bit Product Quantization (PQ) for vector indexes, reducing memory and storage requirements for large-scale ANN search.
v0.14.1-beta.0 Dec 9, 2024 · issue -371

LanceDB v0.14.1-beta.0 adds hybrid search to the async Python SDK and Azure account name storage support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.14.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.14.1-beta.0
```
└──▷ USE IT
Connect to an Azure-backed LanceDB store using an account name in the synchronous SDK.
python
```
import lancedb

db = lancedb.connect(
    "az://my-container/my-db",
    storage_options={"account_name": "mystorageaccount"}
)
```
- ›Supports account_name as an Azure storage option in synchronous db.connect calls.
- ›Adds hybrid search support to the async Python SDK.
python-v0.17.1-beta.0 Dec 9, 2024 · issue -371

LanceDB python-v0.17.1-beta.0 adds hybrid search in the async SDK and Azure account name storage options for sync connections.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.1-beta.0
```
└──▷ USE IT
Connect to an Azure-backed LanceDB instance using an account name in the synchronous client.
python
```
import lancedb

db = lancedb.connect(
    "az://my-container/my-db",
    storage_options={"account_name": "mystorageaccount"}
)
```
- ›Adds account_name as an Azure storage option in the synchronous db.connect call, enabling Azure Blob Storage authentication by account name.
- ›Supports hybrid search in the async SDK, bringing parity with the sync SDK for combined vector and full-text search workflows.
v0.14.0 Dec 6, 2024 · issue -371

LanceDB v0.14.0 adds schema evolution APIs, multimodal Voyage embeddings, Azure OpenAI, PyArrow dataset adapter, and FTS options on RemoteTable across all SDKs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.14.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.14.0
```
- ›Adds ef search parameter support for HNSW index queries, controllable at query time.
- ›Adds checkout and checkout_latest to remote SDKs for version-pinned table access.
- ›Adds list_versions to TypeScript, Rust, and remote Python SDKs for enumerating table versions.
- ›Adds overwrite and exist_ok modes for create_table on remote connections.
- ›Adds FTS options support on RemoteTable, enabling full-text search configuration for remote backends.
+8 moreshow less
- ›Adds schema evolution APIs across all SDKs (Python, TypeScript, Rust, remote).
- ›Adds a PyArrow dataset adapter for LanceDB tables, enabling interoperability with the PyArrow dataset ecosystem.
- ›Adds Azure OpenAI SDK support in the Python embedding integration.
- ›Adds multimodal (text + image) capabilities to the Voyage AI embedder.
- ›Adds rustls TLS backend support in the Rust SDK.
- ›Adds support for remote connection options on remote LanceDB connections.
- ›Adds remote DB URI path support with folder prefix for remote storage organisation.
- ›Upgrades underlying Lance to v0.20.0, incorporating its latest storage and performance improvements.
└──▷ BREAKING ON UPGRADE
- !The Python sync Connection API has been restructured for async-sync feature parity — existing sync Connection usage may require updates.
- !OpenAI embedding error handling now raises on bad embeddings rather than silently continuing — code that relied on the previous lenient behavior will see new exceptions.
python-v0.17.0 Dec 6, 2024 · issue -371

LanceDB python-v0.17.0 adds schema evolution APIs, PyArrow dataset adapter, Azure OpenAI SDK, Voyage multimodal embeddings, and remote SDK parity.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.0
```
└──▷ USE IT
Use the new PyArrow dataset adapter to pass a LanceDB table directly into any PyArrow-compatible workflow.
python
```
import lancedb
import pyarrow.dataset as ds

db = lancedb.connect("./mydb")
table = db.open_table("embeddings")
dataset = table.to_arrow_dataset()
batches = dataset.to_batches()
```
- ›Adds ef search parameter support for HNSW queries, configurable at query time.
- ›Adds checkout and checkout_latest methods to remote SDKs for version pinning.
- ›Adds list_versions to the TypeScript, Rust, and remote Python SDKs.
- ›Adds overwrite and exist_ok mode options for remote create_table.
- ›Adds schema evolution APIs across all SDKs — Python, TypeScript, and Rust.
+9 moreshow less
- ›Adds FTS options support on RemoteTable for full-text search configuration.
- ›Adds a PyArrow dataset adapter for LanceDB tables, enabling interoperability with the PyArrow ecosystem.
- ›Adds support for the Azure OpenAI SDK in the Python client.
- ›Adds multimodal (text + image) capabilities to the Voyage embedder.
- ›Adds support for remote connection options on the remote LanceDB connection.
- ›Adds remote database URI path with folder prefix support.
- ›Adds rustls TLS backend support in the Rust SDK.
- ›Async-sync feature parity on Connections brings the synchronous Python API in line with the async API.
- ›Upgrades to Lance v0.20.0, pulling in all upstream engine improvements.
└──▷ BREAKING ON UPGRADE
- !The async-sync feature parity change on Connections (feat(python)!: async-sync feature parity on Connections) alters the synchronous Connection API — existing code relying on the previous sync behavior may break.
- !OpenAI embedding error handling now raises differently for bad embeddings (fix(python)!: handle bad openai embeddings gracefully) — callers that caught or relied on the previous exception type or behavior will be affected.
python-v0.17.0-beta.3 Dec 4, 2024 · issue -371

LanceDB python-v0.17.0-beta.3 adds multimodal Voyage embeddings, a PyArrow dataset adapter, and remote DB folder-prefix URI support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.0-beta.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.0-beta.3
```
- ›Adds a PyArrow dataset adapter for LanceDB tables, enabling LanceDB tables to be consumed directly as pyarrow.dataset.Dataset objects.
- ›Adds multimodal capabilities to the Voyage embedder, allowing image and text inputs to be embedded together via the Voyage integration.
- ›Supports folder-prefix paths in remote DB URIs, enabling scoped access to a subdirectory within a remote LanceDB store.
v0.14.0-beta.2 Dec 4, 2024 · issue -371

LanceDB v0.14.0-beta.2 adds multimodal Voyage embeddings, a PyArrow dataset adapter, and remote DB URI folder prefixes.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.14.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.14.0-beta.2
```
- ›Adds a PyArrow dataset adapter for LanceDB tables, enabling LanceDB tables to be used directly as PyArrow datasets.
- ›Adds multimodal capabilities to the Voyage embedder, enabling embedding of non-text modalities via Voyage.
- ›Adds folder prefix support for remote database URI paths.
v0.14.0-beta.1 Nov 29, 2024 · issue -372

LanceDB v0.14.0-beta.1 adds overwrite/exist_ok modes for remote table creation and remote connection options support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.14.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.14.0-beta.1
```
- ›Supports overwrite and exist_ok modes for remote create_table, letting callers control behavior when a table already exists on a remote LanceDB connection.
- ›Supports remote options for remote LanceDB connections, enabling configuration of connection-level settings when using the remote client.
python-v0.17.0-beta.1 Nov 29, 2024 · issue -372

LanceDB python-v0.17.0-beta.1 adds overwrite/exist_ok modes for remote table creation and remote connection options support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.17.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.17.0-beta.1
```
- ›Adds overwrite and exist_ok mode parameters to create_table for remote LanceDB connections, giving callers control over table collision behavior.
- ›Adds support for remote options when establishing a remote LanceDB connection.
v0.13.1-beta.0 Nov 21, 2024 · issue -372

LanceDB v0.13.1-beta.0 adds rustls support, ef search param, list_versions, and checkout APIs across SDKs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.13.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.13.1-beta.0
```
- ›Adds ef search parameter support for HNSW index queries, giving callers fine-grained control over recall vs. latency trade-offs.
- ›Adds list_versions to the TypeScript, Rust, and remote Python SDKs for programmatic version enumeration.
- ›Adds checkout and checkout_latest to remote SDKs for switching between dataset versions.
- ›Adds rustls as a TLS backend option for the Rust SDK, enabling use without OpenSSL dependencies.
python-v0.16.1-beta.0 Nov 21, 2024 · issue -372

LanceDB python-v0.16.1-beta.0 adds ef HNSW search param, list_versions, checkout, and checkout_latest across remote SDKs.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.16.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.16.1-beta.0
```
- ›Adds ef search parameter support for HNSW index queries, letting callers tune recall/speed trade-offs at query time.
- ›Adds list_versions to the TypeScript, Rust, and remote Python SDKs for enumerating table versions.
- ›Adds checkout and checkout_latest to the remote SDKs for switching a table to a specific or latest version.
- ›Adds rustls TLS backend support in the Rust SDK as an alternative to the native TLS stack.
v0.13.0 Nov 15, 2024 · issue -372

LanceDB v0.13.0 adds fast_search, multi-vector queries, VoyageAI and Amazon Bedrock embeddings, and post-filter on FTS.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.13.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.13.0
```
└──▷ USE IT
Run a fast approximate vector search to trade recall for speed in latency-sensitive pipelines.
python
```
results = await table.search([0.1, 0.2, 0.3]).fast_search().limit(10).to_list()
```
Batch multiple query vectors into a single call to reduce round-trips when scoring several embeddings at once.
python
```
results = await table.search([[0.1, 0.2], [0.3, 0.4]]).limit(5).to_list()
```
Include internal row IDs in FTS results to correlate matches back to raw storage positions.
python
```
results = await table.search('malware signature').with_row_id(True).limit(20).to_list()
```
- ›Adds fast_search option in Python and Node for faster approximate index searches.
- ›Adds with_row_id support in Python and remote SDK to include internal row IDs in query results.
- ›Adds post-filter support on full-text search (FTS) queries in Python.
- ›Adds optimize_indices support in the synchronous API.
- ›Supports searching multiple query vectors as a single batch query in Python and Node.
+6 moreshow less
- ›Adds VoyageAI embedding function integration.
- ›Adds Amazon Bedrock embedding function integration.
- ›Adds flexible null handling and insert subschemas support in Python.
- ›Supports remote empty queries.
- ›Transitions the Python remote SDK to use the Rust implementation, improving consistency with other language clients.
- ›Upgrades to lance 0.19.2-beta.3 as the underlying storage layer.
└──▷ BREAKING ON UPGRADE
- !The Python remote SDK now uses the Rust implementation instead of the previous Python implementation — existing code relying on internal Python remote SDK behavior may break on upgrade.
- !In the Node package, openai and huggingface are now optional dependencies and must be installed separately if used.
python-v0.16.0 Nov 15, 2024 · issue -372

LanceDB v0.16.0 adds fast_search, multi-vector queries, VoyageAI/Bedrock embeddings, and FTS post-filtering.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.16.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.16.0
```
└──▷ USE IT
Run a fast approximate nearest-neighbor search to reduce query latency in high-throughput pipelines.
python
```
results = table.search(query_vector).fast_search().to_list()
```
Search multiple query vectors in a single batched call to reduce round-trips.
python
```
results = table.search([vec1, vec2, vec3]).to_list()
```
Apply a post-filter to full-text search results to narrow down matches after FTS retrieval.
python
```
results = table.search('threat actor', query_type='fts').where("severity = 'high'").to_list()
```
- ›Adds fast_search parameter to vector search in Python and Node for approximate, lower-latency ANN queries.
- ›Adds with_row_id support in Python and remote queries, exposing internal row identifiers in search results.
- ›Adds support for post-filtering on full-text search (FTS) results in Python.
- ›Adds optimize_indices to the synchronous Python API, enabling index optimization without async context.
- ›Supports searching multiple query vectors as a single batched query in one call.
+5 moreshow less
- ›Adds remote empty query support, allowing full-table scans via the remote SDK.
- ›Adds VoyageAI embedding function integration for generating embeddings.
- ›Adds Amazon Bedrock embedding function integration.
- ›Transitions the Python remote SDK to use the Rust implementation, improving performance and consistency.
- ›Adds flexible null handling and insert subschemas support in Python for more permissive data ingestion.
└──▷ BREAKING ON UPGRADE
- !The Python remote SDK now uses the Rust implementation; behavior of remote operations (delete, update, query, FTS, open_table) may differ from the previous Python implementation.
v0.13.0-beta.2 Nov 14, 2024 · issue -372

LanceDB v0.13.0-beta.2 adds VoyageAI embeddings, multi-vector search, sync index optimization, and remote empty query support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.13.0-beta.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.13.0-beta.2
```
- ›Adds optimize_indices to the synchronous API, allowing index optimization without async wrappers.
- ›Supports searching multiple query vectors as a single query, enabling batch nearest-neighbor lookups in one call.
- ›Adds VoyageAI as a supported embedding provider for automatic vector generation.
- ›Supports remote empty queries, enabling table scans over remote LanceDB connections without a vector or filter predicate.
- ›Publishes win32-arm64-msvc builds to npm, extending native library support to ARM64 Windows environments.
└──▷ BREAKING ON UPGRADE
- !Remote empty query behavior has changed: the support remote empty query change may alter how existing remote query code handles empty/null query inputs on upgrade.
python-v0.16.0-beta.1 Nov 14, 2024 · issue -372

LanceDB python-v0.16.0-beta.1 adds multi-vector search, VoyageAI embeddings, sync index optimization, and remote empty query support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.16.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.16.0-beta.1
```
- ›Adds optimize_index to the synchronous API, enabling index optimization without async context.
- ›Supports searching multiple query vectors as a single query, enabling batch nearest-neighbor lookups in one call.
- ›Adds VoyageAI as a supported embedding provider integration.
- ›Supports remote empty query, allowing queries against remote tables with no filter or vector specified.
└──▷ BREAKING ON UPGRADE
- !Remote empty query behavior has changed: queries against remote tables that previously required a vector or filter may now behave differently on upgrade.
v0.13.0-beta.0 Nov 5, 2024 · issue -372

LanceDB v0.13.0-beta.0 adds fast_search, post-filter on FTS, and with_row_id support in Python and Node.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.13.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.13.0-beta.0
```
- ›Adds fast_search option to vector search in Python and Node for faster approximate query execution.
- ›Adds post-filter support on full-text search (FTS) queries in Python.
- ›Adds with_row_id support in Python and remote environments, enabling row-level result identification.
- ›Transitions the Python remote SDK to use the Rust implementation, improving performance and consistency with other language clients.
python-v0.16.0-beta.0 Nov 5, 2024 · issue -372

LanceDB python-v0.16.0-beta.0 adds fast_search, FTS post-filtering, and with_row_id support for Python and remote clients.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.16.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.16.0-beta.0
```
- ›Adds fast_search option to vector search in Python and Node SDKs for lower-latency approximate queries.
- ›Adds post-filter support on full-text search (FTS) queries in the Python SDK.
- ›Adds with_row_id support in the Python SDK and remote client, exposing internal row IDs in query results.
- ›Transitions the Python remote SDK to use the Rust implementation, backed by lance 0.19.2-beta.3.
python-v0.15.0 Oct 29, 2024 · issue -373

LanceDB python-v0.15.0 adds fast_search on remote tables, distance type control in hybrid search, and add_embedding on empty tables.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.15.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.15.0
```
- ›Enables fast_search on Python remote tables for approximate nearest-neighbor queries against cloud-hosted indexes.
- ›Allows distance type (metric) to be specified during hybrid search, giving control over similarity scoring per query.
- ›Supports add_embedding on create_empty_table in Rust, letting embedding functions be attached at table-creation time before any data is added.
- ›Upgrades underlying Lance storage to 0.19.1, bringing its associated storage and performance improvements.
└──▷ BREAKING ON UPGRADE
- !Upgrading Lance to 0.19.1 is a breaking change; any setup depending on Lance 0.18.x behavior or on-disk format compatibility should review the Lance 0.19.1 changelog before upgrading.
v0.12.0 Oct 29, 2024 · issue -373

LanceDB v0.12.0 adds hybrid search distance types, fast_search on remote tables, and embedding support on empty table creation.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.12.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.12.0
```
- ›Allows distance type (metric) to be specified during hybrid search queries.
- ›Enables fast_search on Python remote tables.
- ›Supports add_embedding on create_empty_table in the Rust client.
- ›Enables logging and full error display in the Node.js client.
└──▷ BREAKING ON UPGRADE
- !Upgrades lance to 0.19.1, which may break existing setups dependent on prior lance behavior.
v0.11.1-beta.0 Oct 17, 2024 · issue -373

LanceDB v0.11.1-beta.0 adds fast_search on Python remote tables and add_embedding support on empty table creation in Rust.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.11.1-beta.0
```
- ›Enables add_embedding on create_empty_table in the Rust API, allowing embedding configurations to be attached at table creation time.
- ›Supports fast_search on Python remote tables, extending the fast search capability to remote table workflows.
- ›Upgrades lance to 0.18.3, bringing underlying engine improvements.
python-v0.14.1-beta.0 Oct 17, 2024 · issue -373

LanceDB python-v0.14.1-beta.0 adds fast_search on remote tables and embedding support on empty table creation.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.14.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.14.1-beta.0
```
- ›Enables fast_search on Python remote tables for accelerated vector search against remote LanceDB deployments.
- ›Allows add_embedding to be used on create_empty_table in the Rust client, enabling embedding configuration at table creation time before data is added.
python-v0.14.0 Oct 9, 2024 · issue -373

LanceDB python-v0.14.0 adds async merge_insert, fast_search, hybrid search in SaaS, trust_remote_code for HF embeddings, and a Rust-backed remote SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.14.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.14.0
```
└──▷ USE IT
Run a faster approximate vector search by enabling fast_search to skip full index traversal.
python
```
results = table.search(query_vector).fast_search().limit(10).to_list()
```
Load a Hugging Face embedding model that requires remote code execution.
python
```
embeddings = get_registry().get("huggingface").create(name="trust-remote/model", trust_remote_code=True)
```
- ›Adds merge_insert to the async Python API, enabling upsert workflows without blocking the event loop.
- ›Adds fast_search option to vector queries for approximate nearest-neighbor searches that trade recall for speed.
- ›Adds trust_remote_code support in Hugging Face embeddings, allowing models that require remote code execution to be loaded directly.
- ›Enables explicit hybrid search query patterns in the SaaS (remote) Python SDK, reaching feature parity with the local SDK.
- ›Adds with_row_id to the Rust SDK for queries that need to surface internal row identifiers.
+12 moreshow less
- ›Adds list_indices endpoint to the remote Rust SDK for inspecting available indexes on a table.
- ›Exposes the underlying dataset URI of a table, making it possible to access the raw Lance dataset path programmatically.
- ›Upgrades Lance to v0.18.2, pulling in the latest engine improvements.
- ›Binds the async Python remote client to the Rust client implementation, replacing the prior pure-Python remote backend.
- ›Binds the Node remote SDK to the Rust implementation for consistency and performance.
- ›Adds remote index stats retrieval to the remote SDK.
- ›Adds remote query and create_index endpoints to the Rust remote client.
- ›Adds remote rename table capability to the Rust remote client.
- ›Adds remote endpoints for schema, version, and count_rows to the Rust remote client.
- ›Adds a write data endpoint to the Rust remote client.
- ›Adds client configuration options for the Rust remote client.
- ›Sets embedding values to Null when an embedding function returns invalid results, rather than propagating errors.
└──▷ BREAKING ON UPGRADE
- !Embedding functions that return invalid results now produce Null embeddings instead of raising an error, which changes downstream query behaviour for any pipeline that previously relied on the error being surfaced.
- !Table.add no longer accepts a plain dictionary as input; callers must migrate to a supported data format (e.g. list of dicts, Arrow RecordBatch, pandas DataFrame).
v0.11.0 Oct 9, 2024 · issue -373

LanceDB v0.11.0 adds full remote SDK support in Rust and Node, fast search, async merge_insert, and hybrid search parity in SaaS.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.11.0
```
└──▷ TRY IT
Load a Hugging Face embedding model that requires custom remote code, such as a fine-tuned model with non-standard architecture.
```
$ embeddings = get_registry().get('huggingface').create(name='org/custom-model', trust_remote_code=True)
```
- ›Adds with_row_id option to the Rust SDK for queries that need to retrieve internal row identifiers.
- ›Adds fast_search option to vector search, enabling approximate search without scanning the full index.
- ›Adds trust_remote_code support in Hugging Face embeddings via Python SDK, allowing custom model code to run during embedding.
- ›Adds merge_insert to the async Python API, enabling upsert workflows without blocking the event loop.
- ›Adds list_indices endpoint to the Rust remote SDK for programmatic index discovery.
+8 moreshow less
- ›Adds index_stats to the remote SDK; all index_stats APIs now accept index name instead of UUID.
- ›Adds hybrid search query support in the Python SaaS (remote) client, reaching feature parity with the local client.
- ›Exposes the underlying dataset URI of a table, making it possible to access raw Lance data directly.
- ›Implements full remote connection support for the Rust SDK, including query, create_index, rename_table, schema, version, count_rows, and write-data endpoints.
- ›Binds the Python async remote client to the Rust client implementation, and similarly binds the Node remote SDK to the Rust implementation.
- ›Sets embedding column values to Null (instead of erroring) when an embedding function returns invalid results.
- ›NODE API region now defaults to us-east-1 when no region is specified.
- ›Upgrades Lance to v0.18.2, bringing underlying storage engine improvements.
└──▷ BREAKING ON UPGRADE
- !The return value of the index_stats method has changed shape, and all index_stats APIs now take an index name instead of a UUID; several deprecated index statistics methods were removed.
- !Embedding functions that return invalid results now set the embedding column to Null instead of propagating an error — pipelines that relied on the error to detect bad embeddings will no longer see one.
- !Table.add no longer accepts a dictionary as input in the Python SDK; callers must pass a supported tabular type instead.
- !Lance upgraded to 0.18.0 (and subsequently 0.18.2); any behavior changes introduced by Lance 0.18.x apply on upgrade.
v0.11.0-beta.1 Sep 24, 2024 · issue -374

LanceDB v0.11.0-beta.1 adds with_row_id to the Rust SDK and fast_search for vector queries.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.11.0-beta.1
```
- ›Adds with_row_id method to the Rust SDK, enabling row-ID retrieval in query results.
- ›Adds fast_search option to vector queries for accelerated approximate search.
- ›Embedding functions that return invalid results now produce Null embeddings instead of failing silently or erroring.
└──▷ BREAKING ON UPGRADE
- !Embedding functions that return invalid results now set embeddings to Null rather than the previous behavior — any code relying on the prior error or passthrough behavior will be affected.
python-v0.14.0-beta.0 Sep 19, 2024 · issue -374

LanceDB python-v0.14.0-beta.0 upgrades to Lance 0.18.0, defaults to file format v2.0, and expands Rust remote client coverage.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.14.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.14.0-beta.0
```
└──▷ USE IT
Create a new table using the legacy Lance v1.x file format to preserve compatibility with older tooling.
python
```
table = db.create_table("my_table", schema=schema, data_storage_version="legacy")
```
- ›Passes data_storage_version="legacy" when creating a table to opt out of the new Lance file format v2.0 default.
- ›Adds remote connection support to the LanceDB Rust client, including endpoints for schema, version, count_rows, and write data.
- ›Supports creating empty tables and creating tables from a list of RecordBatch objects in the remote Python SDK.
- ›Defaults the Node API region to us-east-1 when no region is specified for remote connections.
└──▷ BREAKING ON UPGRADE
- !Lance file format v2.0 is now the default for new tables; existing workflows that rely on v1.x must pass data_storage_version="legacy" when creating a table.
v0.11.0-beta.0 Sep 19, 2024 · issue -374

LanceDB v0.11.0-beta.0 adds Rust remote connection support and upgrades Lance to 0.18.0.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.11.0-beta.0
```
- ›Adds remote endpoints for schema, version, and count_rows in the Rust SDK.
- ›Adds remote client write data endpoint in the Rust SDK.
- ›Implements Remote connection support for LanceDB Rust client.
- ›Defaults the Node API region to us-east-1 for remote connections.
- ›Supports creating empty tables and creating tables from a list of RecordBatch in the remote Python SDK.
└──▷ BREAKING ON UPGRADE
- !Lance dependency upgraded to 0.18.0; any code relying on Lance 0.17.x behavior may break on upgrade.
v0.10.0 Sep 10, 2024 · issue -374

LanceDB v0.10.0 migrates FTS to lance-index, adds bitmap/label-list scalar indexes, reranker improvements, and query offsets across Python, Rust, and Node.js.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.10.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.10.0
```
└──▷ USE IT
Run a hybrid search with phrase-level FTS matching enabled.
python
```
results = table.search('attack vector', query_type='hybrid').phrase_query(True).to_list()
```
- ›Migrates full-text search (FTS) from tantivy to lance-index, enabling FTS query and indexing on RemoteTable and AsyncTable.
- ›Adds phrase_query(bool) parameter to hybrid search queries to enable phrase-level FTS matching.
- ›Supports building FTS indexes without positional data for leaner indexes when phrase queries are not needed.
- ›Adds bitmap and label list scalar index types to the Python async API, Node.js API, and remote tables.
- ›Exposes offset in query API across Python, Rust, and Node.js for paginated result retrieval.
+7 moreshow less
- ›Adds to_list() to the Python async query API.
- ›Adds delete_unverified parameter to Python and Node.js delete APIs.
- ›Adds answerdotai rerankers support and updates the default reranker to RRF (Reciprocal Rank Fusion).
- ›Introduces a revised API for manual hybrid queries.
- ›Supports creating a table from a record batch iterator.
- ›Adds a flag to enable faster manifest paths for improved storage performance.
- ›Exposes HNSW indices through the API.
└──▷ BREAKING ON UPGRADE
- !FTS backend migrated from tantivy to lance-index — existing tantivy-based FTS indexes must be rebuilt.
- !The API for manual hybrid queries has changed — existing hybrid query call sites must be updated to the new API.
python-v0.13.0 Sep 10, 2024 · issue -374

LanceDB python-v0.13.0 migrates FTS to lance-index, adds bitmap/label-list scalar indexes, AnswerDotAI rerankers, phrase queries, and offset support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.13.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.13.0
```
└──▷ USE IT
Run a hybrid search with phrase matching enabled and RRF reranking (now the default reranker).
python
```
results = table.search('exact phrase here').phrase_query(True).limit(10).to_list()
```
Create a bitmap scalar index on a low-cardinality column using the async Python API for fast filtering.
python
```
await table.create_scalar_index('category', index_type='BITMAP')
```
- ›Migrates full-text search (FTS) from tantivy to lance-index, enabling FTS query and indexing on RemoteTable and AsyncTable.
- ›Supports building FTS indexes without positions, reducing index size when phrase queries are not needed.
- ›Enables phrase_query(bool) on hybrid search queries to toggle phrase matching mode.
- ›Adds BitmapIndex and LabelListIndex scalar index types to the Python async API, Node.js API, and remote tables.
- ›Adds answerdotai rerankers support for hybrid search result reranking.
+8 moreshow less
- ›Changes the default reranker to RRF (Reciprocal Rank Fusion).
- ›Exposes offset in query for both Python and Rust APIs, enabling paginated query results.
- ›Adds to_list() to the Python async query API.
- ›Adds a delete_unverified parameter to the Python and Node.js delete APIs.
- ›Supports creating a table from a record batch iterator.
- ›Adds a flag to enable faster manifest paths (backed by lance v0.17.0 upgrade).
- ›Exposes HNSW indices in the API.
- ›Revamps the hybrid query API for manual hybrid queries with a cleaner interface.
└──▷ BREAKING ON UPGRADE
- !FTS backend is migrated from tantivy to lance-index — existing tantivy-based FTS indexes must be rebuilt.
- !The hybrid query API for manual hybrid queries has changed — existing code using the old hybrid query interface will break and must be updated to the new API.
python-v0.13.0-beta.1 Aug 23, 2024 · issue -375

LanceDB python-v0.13.0-beta.1 adds scalar index support on remote tables, FTS query/index on RemoteTable/AsyncTable, and a new delete_unverified parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.13.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.13.0-beta.1
```
- ›Adds delete_unverified parameter to the Python delete API, enabling unverified deletes on tables.
- ›Supports querying and indexing full-text search (FTS) on RemoteTable and AsyncTable.
- ›Allows new scalar index types to be created on remote tables.
v0.10.0-beta.1 Aug 23, 2024 · issue -375

LanceDB v0.10.0-beta.1 adds scalar index types on remote tables, FTS query/index on RemoteTable/AsyncTable, and a delete unverified parameter for Python and Node.js.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.10.0-beta.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.10.0-beta.1
```
- ›Adds delete unverified parameter to the Python client, enabling unverified deletes via the Python API.
- ›Adds delete unverified support to the Node.js client for unverified delete operations.
- ›Supports querying and indexing Full-Text Search (FTS) on RemoteTable and AsyncTable.
- ›Allows new scalar index types to be created on remote tables.
python-v0.13.0-beta.0 Aug 12, 2024 · issue -375

LanceDB python-v0.13.0-beta.0 migrates FTS to lance-index and adds bitmap/label-list scalar index support to the async API.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.13.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.13.0-beta.0
```
└──▷ USE IT
Collect async query results into a Python list without manually awaiting an iterator.
python
```
results = await table.query().where("category = 'news'").to_list()
```
Create a bitmap scalar index on a column via the Python async API for fast low-cardinality filtering.
python
```
await table.create_scalar_index("category", index_type="BITMAP")
```
- ›Adds to_list() to the async Python API, enabling async result collection from query results.
- ›Adds bitmap and label list scalar index creation via the Python async API.
- ›Migrates full-text search (FTS) backend from tantivy to lance-index, replacing the previous FTS engine.
- ›Adds bitmap and label list index types to the Node.js API.
└──▷ BREAKING ON UPGRADE
- !Full-text search (FTS) is migrated from tantivy to lance-index; any existing tantivy-based FTS indexes or configurations will break on upgrade.
v0.10.0-beta.0 Aug 12, 2024 · issue -375

LanceDB v0.10.0-beta.0 migrates FTS to lance-index and adds bitmap/label-list scalar indexes in Python and Node.js
└──▷ GET THIS VERSION
```
$ git clone --branch v0.10.0-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.10.0-beta.0
```
- ›Adds to_list() to the Python async API for collecting query results asynchronously.
- ›Adds bitmap and label-list scalar index creation via the Python async API.
- ›Adds bitmap and label-list index types to the Node.js API.
- ›Migrates full-text search (FTS) from tantivy to lance-index, replacing the underlying FTS engine.
└──▷ BREAKING ON UPGRADE
- !FTS indexes are migrated from tantivy to lance-index; existing tantivy-backed FTS indexes will not be compatible and must be rebuilt.
python-v0.12.0 Aug 7, 2024 · issue -375

LanceDB Python v0.12.0 adds WatsonX embeddings, multi-vector reranking, and remote table embedding support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.12.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.12.0
```
- ›Adds WatsonX embeddings to the embedding function registry for use with LanceDB tables.
- ›Adds multi-vector reranking support, enabling reranking across multiple vector search results in a single query.
- ›Supports embedding functions on remote tables, bringing parity with local table embedding workflows.
- ›Upgrades lance to v0.16, improving the underlying storage and query engine.
└──▷ BREAKING ON UPGRADE
- !Upgrading lance to 0.16 is a breaking change; existing setups depending on the prior lance version may require migration.
python-v0.11.0 Jul 26, 2024 · issue -376

LanceDB python-v0.11.0 adds reciprocal rank fusion reranking and HuggingFace-compatible transformers in Node.js
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.11.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.11.0
```
- ›Adds a reciprocal rank fusion (RRF) reranker for combining multiple retrieval result sets.
- ›Adds HuggingFace-compatible transformers embedding support to the Node.js SDK.
- ›Upgrades the underlying Lance storage engine to v0.15.0.
└──▷ BREAKING ON UPGRADE
- !The timeout argument in the LanceDB Node.js SDK has been corrected; existing code passing timeout values may break if the previous (incorrect) argument name or position was relied upon.
v0.8.0 Jul 26, 2024 · issue -376

LanceDB v0.8.0 adds reciprocal rank fusion reranking, HuggingFace-compatible transformers for Node.js, and upgrades Lance to 0.15.0
└──▷ GET THIS VERSION
```
$ git clone --branch v0.8.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.8.0
```
- ›Adds a reciprocal rank fusion (RRF) reranker for combining hybrid search result rankings.
- ›Adds HuggingFace-compatible transformers embedding support in the Node.js SDK.
- ›Upgrades the underlying Lance storage engine to v0.15.0.
└──▷ BREAKING ON UPGRADE
- !The timeout argument in the LanceDB Node.js SDK has been corrected — existing code passing timeout in the old form may break on upgrade.
python-v0.10.2 Jul 23, 2024 · issue -376

LanceDB python-v0.10.2 adds native HuggingFace sentence-transformers embedding support via Rust.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.10.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.10.2
```
- ›Adds HuggingFace sentence-transformers as a natively supported embedding provider via the Rust backend.
v0.7.2 Jul 23, 2024 · issue -376

LanceDB v0.7.2 adds Hugging Face sentence-transformers embedding support for the Rust SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.7.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.7.2
```
- ›Adds Hugging Face sentence-transformers embedding integration to the Rust SDK.
v0.7.1 Jul 17, 2024 · issue -376

LanceDB v0.7.1 adds configurable timeout support to the VectorDB Node SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.7.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.7.1
```
- ›Adds configurable timeout support to the VectorDB Node SDK.
python-v0.10.0 Jul 13, 2024 · issue -376

LanceDB python-v0.10.0 adds DynamoDB commit store, Jina embeddings/reranking, explain_plan, fast search, and binary field updates.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.10.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.10.0
```
└──▷ USE IT
Use Jina embeddings and the Jina reranker together in a LanceDB retrieval pipeline.
python
```
from lancedb.embeddings import get_registry
from lancedb.rerankers import JinaReranker

jina_embed = get_registry().get('jina').create()
reranker = JinaReranker()

results = table.search('cybersecurity threat intelligence') \
    .rerank(reranker=reranker) \
    .to_pandas()
```
- ›Adds explain_plan function to inspect query execution plans.
- ›Adds fast search flag support in Rust-backed queries.
- ›Enables DynamoDB as a commit store backend for distributed coordination.
- ›Adds Jina integration for both embedding generation and reranking in Python.
- ›Supports creating additional vector index types beyond the previous set.
+1 moreshow less
- ›Supports update operations over binary fields.
v0.7.0 Jul 13, 2024 · issue -376

LanceDB v0.7.0 adds DynamoDB commit store, Jina embeddings/reranking, new vector index types, and explain_plan for query inspection.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.7.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.7.0
```
└──▷ TRY IT
Update rows in a Node.js table using a SQL expression for dynamic value computation.
```
$ await tbl.update({ valuesSql: { price: 'price * 1.1' } })
```
- ›Adds update({values | valuesSql}) to the Node.js table API, enabling row updates via value maps or raw SQL expressions.
- ›Adds explain_plan function for inspecting query execution plans.
- ›Makes tbl.search() chainable in the Node.js client.
- ›Adds DynamoDB commit store support for distributed, cloud-backed transaction coordination.
- ›Adds Jina integration in Python for both embedding generation and reranking.
+4 moreshow less
- ›Enables the fast search flag in the Rust client.
- ›Supports creating additional vector index types beyond the previously available options.
- ›Supports updates over binary fields.
- ›Adds compatibility with multiple Arrow versions in the Node.js public interface.
python-v0.9.0 Jun 25, 2024 · issue -377

LanceDB python-v0.9.0 adds stemming support, merge insert, index stats, and broad Node.js feature parity.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.9.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.9.0
```
- ›Adds table.indexStats to the Node.js client for querying index statistics.
- ›Adds 'name' field to IndexConfig returned by listIndices in the Node.js client.
- ›Adds query.filter() as an alias for query filtering in the Node.js client.
- ›Adds table.name property and named-argument form lancedb.connect({args}) to the Node.js client.
- ›Adds createTable({name, data, ...options}) named-options signature to the Node.js client.
+4 moreshow less
- ›Adds merge-insert support to the Node.js client.
- ›Adds remote table support to the Node.js client.
- ›Enables stemming support for full-text search.
- ›Upgrades underlying Lance engine to 0.13.0.
v0.6.0 Jun 25, 2024 · issue -377

LanceDB v0.6.0 adds Node.js merge insert, stemming support, remote table parity, and index stats to the Node.js SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.6.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.6.0
```
- ›Adds table.name property and named-argument form lancedb.connect({args}) to the Node.js SDK.
- ›Adds createTable({name, data, ...options}) named-argument form to the Node.js SDK.
- ›Adds 'name' field to IndexConfig returned by listIndices in the Node.js SDK.
- ›Adds query.filter() as an alias for query filtering in the Node.js SDK.
- ›Adds table.indexStats method to the Node.js SDK for retrieving index statistics.
+4 moreshow less
- ›Adds merge insert support to the Node.js SDK.
- ›Adds remote table support to the Node.js SDK, advancing feature parity with the Python SDK.
- ›Enables stemming support for full-text search.
- ›Upgrades underlying Lance storage engine to v0.13.0.
v0.5.2 Jun 5, 2024 · issue -377

LanceDB v0.5.2 adds OpenAI and new Cohere embedding functions, Node.js table search and Arrow export, and opt-in v2 format support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.5.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.5.2
```
- ›Adds table.search functionality to the Node.js SDK, enabling vector search directly on table objects.
- ›Adds table.toArrow function to the Node.js SDK to export table data as Apache Arrow.
- ›Adds OpenAI embedding function for the Rust client.
- ›Adds support for new Cohere models in both the Cohere and Bedrock embedding functions.
- ›Enables opt-in use of the v2 Lance file format for writes.
+2 moreshow less
- ›Allows creation of execution plans on queries in the Rust client.
- ›Adds fast-path optimizations for dataset reload and checkout_latest to reduce latency on repeated table opens.
python-v0.8.2 Jun 5, 2024 · issue -377

LanceDB v0.8.2 adds new Cohere/Bedrock model support, OpenAI embeddings, Node.js search/Arrow export, and opt-in v2 format.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.8.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.8.2
```
- ›Adds opt-in v2 storage format support via a new configuration option (make it possible to opt in to using the v2 format).
- ›Adds table.search functionality to the Node.js client, enabling vector search from the JS/TS SDK.
- ›Adds table.toArrow function to the Node.js client for exporting table data as Apache Arrow.
- ›Adds OpenAI embedding function to the Rust client.
- ›Adds support for new Cohere models in both the Cohere and Bedrock embedding functions.
+2 moreshow less
- ›Adds execution plan creation on queries in the Rust client.
- ›Adds fast-path optimizations for dataset reload and checkout_latest to improve performance at scale.
python-v0.8.1 May 30, 2024 · issue -378

LanceDB python-v0.8.1 adds IVF_HNSW_PQ index support and upgrades the Lance core to v0.11.1.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.8.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.8.1
```
- ›Adds IVF_HNSW_PQ index type, combining IVF partitioning, HNSW graph search, and product quantization for high-recall approximate nearest-neighbor search.
- ›Upgrades the bundled Lance core to v0.11.1.
- ›Adds a JavaScript embedding registry for managing embedding functions in the Node.js SDK.
- ›Adds Arrow version compatibility support in the Node.js SDK.
- ›Adds a tableNames Java API for listing tables in a LanceDB connection.
v0.5.1 May 30, 2024 · issue -378

LanceDB v0.5.1 adds IVF_HNSW_PQ index support, a JS embedding registry, and a Java table-names API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.5.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.5.1
```
- ›Adds IVF_HNSW_PQ index type, combining IVF, HNSW, and product quantization for approximate nearest-neighbor search.
- ›Adds tableNames Java API for listing tables in a LanceDB connection from the Java client.
- ›Introduces a JavaScript embedding registry, enabling registration and lookup of embedding functions in the Node.js SDK.
- ›Adds Arrow version compatibility across the Node.js SDK, supporting multiple Arrow versions interoperably.
python-v0.7.0 May 23, 2024 · issue -378

LanceDB python-v0.7.0 adds IVF_HNSW_SQ index support, an async optimize function, and Ollama embeddings integration.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.7.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.7.0
```
└──▷ USE IT
Run async index and storage optimization on a table after bulk inserts to keep query performance high.
python
```
await table.optimize()
```
- ›Adds optimize function to async Python and Node.js APIs for index and storage optimization.
- ›Supports new IVF_HNSW_SQ index type, combining IVF, HNSW, and scalar quantization for approximate nearest-neighbor search.
- ›Adds Ollama embeddings function, enabling local LLM-backed embedding generation within LanceDB pipelines.
- ›Upgrades underlying Lance to version 0.11.0, bringing its new storage and indexing capabilities.
v0.5.0 May 23, 2024 · issue -378

LanceDB v0.5.0 adds IVF_HNSW_SQ index support, an optimize function for Node.js and async Python, and Ollama embeddings integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.5.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.5.0
```
- ›Adds optimize function to the Node.js and async Python APIs for index and storage optimization.
- ›Adds support for the IVF_HNSW_SQ index type, combining IVF, HNSW, and scalar quantization for ANN search.
- ›Adds Ollama embeddings function, enabling local LLM-backed embeddings via Ollama.
v0.4.19 May 7, 2024 · issue -378

LanceDB v0.4.19 adds Polars DataFrame interop and an embedding registry to the Rust SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.19 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.19
```
- ›Adds an embedding registry to the Rust SDK, enabling model registration and lookup for vector embedding workflows.
- ›Implements Polars DataFrame converters (to and from) in the Rust SDK via C FFI, enabling direct interop between LanceDB tables and Polars DataFrames in Rust.
v0.4.18 Apr 30, 2024 · issue -379

LanceDB v0.4.18 adds rename_table, richer index_stats, and configurable index_cache_size when opening tables.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.18 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.18
```
- ›Adds rename_table function to rename existing tables.
- ›Adds index_cache_size configuration option when opening a table to control index cache size.
- ›Expands index_stats to return more data about index state.
python-v0.6.11 Apr 28, 2024 · issue -379

LanceDB v0.6.11 adds table renaming, richer index stats, and configurable index cache size on table open.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.11 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.11
```
└──▷ USE IT
Tune index cache size at table-open time to trade memory for faster ANN query throughput.
python
```
table = db.open_table("my_vectors", index_cache_size=512)
```
Rename a table without recreating it, useful when reorganising a LanceDB database.
python
```
db.rename_table("old_name", "new_name")
```
- ›Adds index_cache_size configuration option when opening a table, enabling tuning of in-memory index cache allocation.
- ›Adds rename_table function to rename tables in a LanceDB database.
- ›Expands data returned by index_stats to surface more index metadata.
python-v0.6.8 Apr 10, 2024 · issue -379

LanceDB v0.6.8 adds storage_options for passing auth and config to object stores.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.8 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.8
```
- ›Adds storage_options argument to pass authentication and other configurations down to object stores.
└──▷ BREAKING ON UPGRADE
- !Opening a remote table now checks whether it exists (with caching); setups that relied on opening non-existent remote tables without error will break.
v0.4.17 Apr 10, 2024 · issue -379

LanceDB v0.4.17 exposes storage_options for passing auth and config to object stores.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.17 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.17
```
- ›Adds storage_options argument to pass authentication and other configuration directly to object stores.
└──▷ BREAKING ON UPGRADE
- !Opening a remote table now checks whether it exists (with caching); tables that do not exist will raise an error at open time rather than later.
python-v0.6.7 Apr 5, 2024 · issue -379

LanceDB v0.6.7 adds filterable count_rows on the remote API and ships fp16 kernels in Python wheels.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.7 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.7
```
- ›Adds filter support to count_rows on the remote API, enabling row counts scoped to a query predicate.
- ›Ships fp16 kernels directly in Python wheels, enabling half-precision vector operations without extra installation.
v0.4.16 Apr 5, 2024 · issue -379

LanceDB v0.4.16 adds filterable count_rows to the remote API and aligns search defaults with the Python SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.16 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.16
```
- ›Adds filter support to count_rows on the remote API, enabling row counts scoped to a query predicate.
- ›Sets a default value for search.limit in the remote API to match the Python SDK's behavior.
python-v0.6.6 Apr 1, 2024 · issue -379

LanceDB Python SDK gains an async API backed by the Rust SDK, aligning Python with long-term cross-SDK feature parity.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.6
```
- ›Introduces an async Python API that replaces the pylance backend with the Rust SDK, enabling asynchronous database operations from Python.
v0.4.14 Mar 25, 2024 · issue -380

LanceDB v0.4.14 adds reranking, async query API, HuggingFace dataset writes, FTS order-by, and Node.js client middleware.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.14 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.14
```
└──▷ USE IT
Write a HuggingFace dataset directly into LanceDB without manual conversion.
python
```
from datasets import load_dataset
ds = load_dataset("squad", split="train")
table = db.create_table("squad", ds)
```
- ›Adds to_batches API for streaming query results as Arrow record batches.
- ›Adds reranking support for vector and full-text search (FTS) queries in the Python SDK.
- ›Adds query support to the Python async API via a refactored query API.
- ›Supports writing HuggingFace Dataset and DatasetDict objects directly to a LanceDB table in Python.
- ›Adds order_by field support for full-text search (FTS) queries.
+4 moreshow less
- ›Introduces ArrowNative wrapper struct in Rust for adding data that is already a RecordBatchReader.
- ›Adds client middleware support for HTTP requests in the Node.js SDK.
- ›Makes DistanceType an independent type in Rust, no longer reusing lance_linalg.
- ›Promotes the Rust SDK to stable, removing all 'unstable/experimental' designations from documentation.
python-v0.6.5 Mar 21, 2024 · issue -380

LanceDB python-v0.6.5 adds async query support, reranking, HuggingFace dataset writing, and a to_batches API
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.5
```
└──▷ USE IT
Ingest a HuggingFace dataset directly into LanceDB without manual conversion.
python
```
from datasets import load_dataset
ds = load_dataset("squad")
table = db.create_table("squad", data=ds)
```
- ›Adds to_batches API for streaming query results as Arrow record batches.
- ›Adds reranking support for vector and full-text search (FTS) queries in the Python API.
- ›Adds query support to the Python async API, including a refactored query interface.
- ›Supports writing HuggingFace Dataset and DatasetDict objects directly to LanceDB tables.
- ›Adds order_by field support for full-text search (FTS) queries.
+2 moreshow less
- ›Introduces ArrowNative wrapper struct for adding data already in RecordBatchReader form without conversion.
- ›Makes DistanceType an independent type, decoupling it from lance_linalg.
python-v0.6.4 Mar 16, 2024 · issue -380

LanceDB python-v0.6.4 expands the async API with index creation, time travel, update, list_indices, and index_stats.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.4
```
- ›Adds create_index to the async Python API, enabling non-blocking index builds.
- ›Adds list_indices to the async Python API for querying available indices asynchronously.
- ›Adds index_stats to the Python API for retrieving statistics about a specific index.
- ›Adds update to the async Python API, enabling asynchronous record updates.
- ›Adds time travel operations to the async Python API, allowing point-in-time dataset queries asynchronously.
+2 moreshow less
- ›Supports optional vector fields in Pydantic models, allowing schema definitions where the vector column is not required.
- ›Adds Azure Blob Storage read support for Python.
v0.4.13 Mar 16, 2024 · issue -380

LanceDB v0.4.13 expands the async Python API with index creation, time travel, update, list_indices, and index_stats.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.13 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.13
```
- ›Adds create_index to the async Python API, enabling non-blocking index builds.
- ›Adds list_indices to the async Python API for querying available indexes asynchronously.
- ›Adds index_stats to the Python API for inspecting index statistics.
- ›Adds update to the async Python API for asynchronous record updates.
- ›Adds time-travel operations (version rollback/query) to the async Python API.
+3 moreshow less
- ›Adds configurable timeout for LanceDB Cloud queries.
- ›Supports optional vector fields in Pydantic models for schema flexibility.
- ›Adds Azure Blob Storage read support for Python.
python-v0.6.3 Mar 11, 2024 · issue -380

LanceDB Cloud queries now support a configurable timeout parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.3
```
- ›Adds configurable timeout for LanceDB Cloud queries, allowing callers to control how long a query waits before failing.
v0.4.12 Mar 6, 2024 · issue -380

LanceDB v0.4.12 adds column management APIs, scalar index creation, remote table support in Rust, and paginated table listing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.12 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.12
```
- ›Adds add_columns, alter_columns, and drop_columns APIs for in-place schema and data manipulation on tables.
- ›Adds create scalar index to the SDK, enabling scalar (non-vector) index creation from client code.
- ›Adds page_token and limit parameters to the native table_names function for paginated table listing.
- ›Adds initial remote table implementation for the Rust SDK, enabling Rust clients to operate against remote LanceDB tables.
- ›Changes arrow from a direct dependency to a peer dependency in the TypeScript/Node.js package, giving callers control over the Arrow version.
└──▷ BREAKING ON UPGRADE
- !arrow is now a peer dependency rather than a direct dependency in the Node.js package; projects that relied on LanceDB pulling in Arrow transitively must now declare and install arrow explicitly.
python-v0.6.2 Mar 6, 2024 · issue -380

LanceDB v0.6.2 adds async create_table/add, scalar index creation, model_names() for OpenAI embeddings, and API URL override.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.2
```
└──▷ USE IT
Discover which OpenAI models are available for use as embedding functions before configuring a table.
python
```
from lancedb.embeddings import get_registry

openai = get_registry().get('openai').create()
print(openai.model_names())
```
- ›Adds model_names() method to the OpenAI embedding function to list available models programmatically.
- ›Adds create_scalar_index to the Python SDK, enabling scalar index creation directly from the client.
- ›Adds page_token and limit parameters to the native table_names function for paginated table listing.
- ›Allows users to override the API URL, enabling custom or self-hosted LanceDB remote endpoints.
- ›Ports create_table to the async Python API and the remote Rust API.
+1 moreshow less
- ›Adds add support to the async Python API for non-blocking data ingestion.
python-v0.6.1 Feb 29, 2024 · issue -381

LanceDB python-v0.6.1 adds initial remote table support for the Rust backend.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.1
```
- ›Adds initial remote table implementation for the Rust backend, enabling LanceDB's Rust client to interact with remote tables.
python-v0.6.0 Feb 29, 2024 · issue -381

LanceDB python-v0.6.0 adds column management APIs and an async Python client.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.6.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.6.0
```
└──▷ USE IT
Drop an unwanted column from an existing table without rewriting your pipeline.
python
```
table.drop_columns(["embedding"])
```
- ›Adds add_columns, alter_columns, and drop_columns APIs for programmatic schema management on tables.
- ›Introduces a basic async Python client as a new starting point for async workflows.
└──▷ BREAKING ON UPGRADE
- !Vector queries no longer return the vector column when select() is called without explicitly including the vector column.
v0.4.11 Feb 23, 2024 · issue -381

LanceDB v0.4.11 adds ImageBind embeddings, a batch-request threadpool, and read-consistency control for Node/Rust.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.11 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.11
```
- ›Adds read_consistency_interval configuration to the Node and Rust clients, enabling control over read consistency for distributed/cloud-backed tables.
- ›Adds an optional threadpool for batch embedding requests in the Python client, improving throughput for bulk vectorization workloads.
- ›Adds ImageBind embedding function support in the Python client, enabling multimodal (image, text, audio, etc.) embeddings natively in LanceDB.
└──▷ BREAKING ON UPGRADE
- !The experimental Rust crate vectordb is being replaced by a new crate named lancedb; there will be breaking changes migrating from vectordb to lancedb (migration details to follow).
python-v0.5.7 Feb 22, 2024 · issue -381

LanceDB python-v0.5.7 adds ImageBind embedding function support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.7 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.5.7
```
- ›Adds ImageBind embedding function support for multimodal vector generation.
python-v0.5.6 Feb 20, 2024 · issue -381

LanceDB python-v0.5.6 adds an optional threadpool for batch requests.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.5.6
```
- ›Adds an optional threadpool for batch requests to improve throughput on concurrent workloads.
v0.4.10 Feb 14, 2024 · issue -381

LanceDB v0.4.10 makes it easier to create empty tables and makes the vector column optional.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.10 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.10
```
- ›Simplifies creation of empty tables without requiring upfront data.
- ›Makes the vector column optional when creating tables.
python-v0.5.5 Feb 13, 2024 · issue -381

LanceDB python-v0.5.5 makes the vector column optional and ships hybrid search updates with latency benchmarks.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.5.5
```
- ›Makes the vector column optional when creating or querying tables, enabling use cases where vector embeddings are not required.
- ›Updates hybrid search with new examples and latency benchmarks to support performance-aware retrieval workflows.
v0.4.9 Feb 9, 2024 · issue -381

LanceDB v0.4.9 adds filterable count_rows across all APIs and filter support during merge-insert match conditions.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.9 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.9
```
- ›Adds count_rows with filter support to all LanceDB APIs, enabling row counts scoped to a predicate.
- ›Adds filter support for the 'when matched' branch of merge insert operations across all LanceDB APIs.
python-v0.5.4 Feb 9, 2024 · issue -381

LanceDB python-v0.5.4 adds new OpenAI embedding functions, read consistency control, filterable row counts, and merge-insert match filtering.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.5.4
```
└──▷ USE IT
Enforce read-your-writes consistency in a multi-writer setup by setting a consistency interval on connect.
python
```
import lancedb

db = lancedb.connect(
    "s3://my-bucket/lancedb",
    read_consistency_interval=5  # seconds
)
table = db.open_table("my_table")
```
Count only the rows matching a filter condition, useful for quick cardinality checks without a full scan.
python
```
import lancedb

db = lancedb.connect("~/.lancedb")
table = db.open_table("my_table")
count = table.count_rows(filter="category = 'critical'")
print(count)
```
- ›Adds read_consistency_interval argument to control read consistency for LanceDB connections.
- ›Adds filterable count_rows to all LanceDB APIs, enabling row counts with predicate pushdown.
- ›Adds support for filter conditions during merge_insert when rows are matched, enabling conditional upsert logic.
- ›Adds support for new OpenAI embedding functions in the Python embedding function registry.
- ›Improves Reranker developer experience with DX improvements to the reranker API.
v0.4.8 Feb 2, 2024 · issue -381

LanceDB v0.4.8 adds merge_insert to the Node.js and Rust APIs for upsert-style table operations.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.8 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.8
```
- ›Adds merge_insert to the Node.js and Rust APIs, enabling upsert-style (merge/insert) operations on LanceDB tables.
python-v0.5.2 Feb 2, 2024 · issue -381

LanceDB python-v0.5.2 adds hybrid search, AWS Bedrock embeddings, merge_insert, and a reworked Node.js SDK via NAPI
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.5.2
```
└──▷ USE IT
Run a hybrid search with reranking to combine vector similarity and full-text relevance scores.
python
```
results = (
    table.search("your query", query_type="hybrid")
    .rerank(reranker=reranker)
    .limit(10)
    .to_pandas()
)
```
Generate embeddings with AWS Bedrock inside a LanceDB embedding function for serverless vector ingestion.
python
```
from lancedb.embeddings import get_registry

bedrock = get_registry().get("bedrock").create()

class MyTable(LanceModel):
    text: str = bedrock.SourceField()
    vector: Vector(bedrock.ndims()) = bedrock.VectorField()
```
- ›Adds a Hybrid Search and Reranker API to the Python SDK for combining vector and scalar search results.
- ›Adds AWS Bedrock embeddings integration to the Python embedding functions.
- ›Adds gte-mlx/gte-large embedding function support to the Python SDK.
- ›Adds connect and connect_with_options functions to the Rust SDK.
- ›Reworks the Node.js SDK using NAPI, providing a new createIndex API and query issuing capability.
+2 moreshow less
- ›Improves the Rust table query API with updated documentation.
- ›Exposes cleanup_old_versions and compact_files on the Table API.
v0.4.6 Jan 26, 2024 · issue -382

LanceDB v0.4.6 adds query execution to the Node SDK and connect/connect_with_options to the Rust SDK.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.6
```
- ›Adds connect and connect_with_options functions to the Rust SDK for establishing database connections.
- ›Enables issuing queries via the Node (napi) SDK.
v0.4.5 Jan 25, 2024 · issue -382

LanceDB v0.4.5 adds Gemini embeddings, Polars integration, exist_ok table creation, and a reworked Node.js SDK via napi.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.5
```
└──▷ USE IT
Create a table without raising an error if it already exists — useful in idempotent pipeline setup.
python
```
table = db.create_table('my_table', data=df, exist_ok=True)
```
Convert a full LanceDB table to a Polars DataFrame for downstream analysis.
python
```
df = table.to_polars()
```
- ›Adds exist_ok option to create_table in the Python SDK, preventing errors when creating a table that already exists.
- ›Adds Gemini text embedding function to the Python embedding API.
- ›Adds basic Polars integration to the Python SDK, including converting an entire table to a Polars DataFrame.
- ›Adds a helper function in the JavaScript SDK to create an Arrow Table with a schema.
- ›Reworks the Node.js SDK using napi, providing a new native binding layer.
+6 moreshow less
- ›Adds an improved createIndex API in the napi (Node.js) SDK.
- ›Improves the Rust table query API.
- ›Improves the Rust create index API.
- ›Supports passing the API key as an environment variable.
- ›Updates Node.js SDK to support OpenAI SDK version ^4.24.1 embeddings API.
- ›Updates create_table to accept an Arrow Table directly.
v0.4.4 Jan 25, 2024 · issue -382

LanceDB v0.4.4 adds Gemini embeddings, Polars integration, exist_ok table creation, and a reworked Node.js SDK via napi.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.4
```
└──▷ USE IT
Create a table without failing if it already exists — useful in idempotent pipeline or notebook setups.
python
```
import lancedb

db = lancedb.connect("./my_db")
table = db.create_table("my_table", data=my_data, exist_ok=True)
```
Convert an entire LanceDB table to a Polars DataFrame for downstream analysis.
python
```
import lancedb

db = lancedb.connect("./my_db")
table = db.open_table("my_table")
df = table.to_polars()
```
- ›Adds exist_ok option to create_table in the Python SDK, allowing idempotent table creation without raising an error if the table already exists.
- ›Adds Gemini text embedding function to the Python embedding API, joining existing OpenAI embeddings support.
- ›Adds basic Polars integration for the Python SDK, including support for ingesting Polars DataFrames and converting an entire table to a Polars DataFrame.
- ›Supports passing the API key as an environment variable, in addition to explicit parameter passing.
- ›Updates the Node.js SDK to support OpenAI SDK version ^4.24.1 embeddings API.
+5 moreshow less
- ›Reworks the Node.js SDK using napi for improved native performance and compatibility.
- ›Adds a new createIndex API in the napi-based Node.js SDK.
- ›Improves the Rust create index API and table query API.
- ›Adds a helper function in the JavaScript SDK to create an Arrow Table with a schema.
- ›Changes create_table to accept an Arrow Table directly as input.
python-v0.5.1 Jan 23, 2024 · issue -382

LanceDB python-v0.5.1 adds API key env var support, OpenAI SDK v4 embeddings, and Arrow table improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.5.1
```
- ›Allows passing the LanceDB API key as an environment variable instead of hardcoding it in code.
- ›Supports OpenAI SDK version ^4.24.1 embeddings API in the Node.js client.
- ›Changes create_table to accept an Arrow Table directly as input.
- ›Adds a helper function in the JS SDK to create an Arrow Table with a schema.
python-v0.5.0 Jan 18, 2024 · issue -382

LanceDB v0.5.0 adds Polars DataFrame integration, Gemini embeddings, and an exist_ok option for table creation.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.5.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.5.0
```
└──▷ USE IT
Safely create a table only if it does not already exist, avoiding errors in repeated pipeline runs.
python
```
import lancedb

db = lancedb.connect("./my_db")
table = db.create_table("items", data=[{"vector": [1.0, 2.0], "label": "a"}], exist_ok=True)
```
- ›Adds exist_ok option to create_table to avoid errors when a table already exists.
- ›Adds GeminiTextEmbeddingFunction for generating text embeddings via Google Gemini.
- ›Supports ingesting Polars DataFrames directly into LanceDB tables.
- ›Supports exporting LanceDB tables and search results as Polars DataFrames or a Polars LazyFrame.
v0.4.3 Jan 11, 2024 · issue -382

LanceDB v0.4.3 adds list-of-string vector inputs and table schema access for Node.js
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.3
```
- ›Adds table.schema property to LocalTable in the Node.js SDK, exposing the Arrow schema of a table at runtime.
- ›Supports list-of-string as a valid input type for vector search queries in the JavaScript SDK.
- ›Automatically aligns incoming data to the target table schema on insert in the Node.js SDK, reducing manual casting.
python-v0.4.4 Jan 11, 2024 · issue -382

LanceDB python-v0.4.4 adds phrase query support for FTS and a count_rows filter option.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.4.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.4.4
```
- ›Adds phrase query option for full-text search via the FTS API, enabling exact phrase matching in search queries.
- ›Adds count_rows with a filter option, allowing row counts to be scoped to a subset of data.
- ›Faster full-text search indexing performance via heap size tuning in the Python client.
- ›Switches the underlying HTTP client from aiohttp to requests for remote LanceDB connections.
- ›Supports new-style optional syntax in Python type annotations across the library.
v0.4.2 Dec 30, 2023 · issue -383

LanceDB v0.4.2 adds timezone-aware datetime handling in Pydantic schema definitions.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.2
```
- ›Adds timezone handling for datetime fields in Pydantic models, enabling timezone-aware timestamps to be correctly represented in LanceDB schemas.
python-v0.4.3 Dec 30, 2023 · issue -383

LanceDB python-v0.4.3 adds batch query support for the remote API.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.4.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.4.3
```
- ›Adds batch queries for the remote API, enabling multiple vector searches to be submitted in a single call.
python-v0.4.2 Dec 29, 2023 · issue -383

LanceDB v0.4.2 adds post-filtering for full-text search, list-of-list Pydantic fields, and timezone-aware datetime support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.4.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.4.2
```
- ›Adds post-filtering support for full-text search queries, enabling result refinement after FTS retrieval.
- ›Supports list-of-list fields when defining schemas via Pydantic models.
- ›Adds timezone handling for datetime fields in Pydantic schemas.
python-v0.4.1 Dec 26, 2023 · issue -383

LanceDB v0.4.1 adds scalar index creation, FTS nested field references, and a pandas flatten option.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.4.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.4.1
```
└──▷ USE IT
Flatten nested struct columns into a flat pandas DataFrame when retrieving results.
python
```
df = table.search(query_vector).to_pandas(flatten=True)
```
Create a scalar index on a column to accelerate filtered lookups at query time.
python
```
table.create_scalar_index("price")
```
- ›Adds create_scalar_index() capability to create scalar indices on table columns, enabling faster filtered queries.
- ›Adds flatten option to to_pandas() to flatten nested/struct output into a flat DataFrame.
- ›Supports nested field references in full-text search (FTS) queries, allowing search over nested document fields.
v0.4.1 Dec 26, 2023 · issue -383

LanceDB v0.4.1 adds Node.js Schema, index creation, scalar indices, and paginated table listing APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.1
```
- ›Adds scalar index creation support via the new scalar indices API, enabling fast filtering on non-vector columns.
- ›Adds Node.js Schema API for inspecting and working with table schemas in JavaScript/TypeScript.
- ›Adds Node.js createIndex API, bringing vector index creation to the Node client.
- ›Adds pagination support for listTables in the Node.js client to handle large numbers of tables.
v0.4.0 Dec 18, 2023 · issue -383

LanceDB v0.4.0 adds GPU index creation, scalar indexes, prefiltering, update queries, Cohere embeddings, and remote table operations.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.4.0
```
└──▷ USE IT
Pre-filter rows by a scalar condition before ANN search to exclude ineligible candidates early and improve result quality.
python
```
results = (
    table.search([0.1, 0.2, 0.3])
        .where("category = 'public'")
        .prefilter(True)
        .limit(10)
        .to_list()
)
```
Bulk-update rows matching a filter condition directly on a Python table, avoiding a delete-and-reinsert cycle.
python
```
table.update(where="status = 'pending'", values={"status": "reviewed"})
```
- ›Adds prefilter flag to vector search queries, enabling pre-filtering with an index before performing ANN search (Python, Node.js, and Rust).
- ›Adds update query support for Python via a new update query API, and implements update for remote clients.
- ›Adds to_list and to_pandas APIs for retrieving query results in Python.
- ›Adds RemoteTable.version property in Python to inspect the version of a remote table.
- ›Adds index cache size exposure in Python for tuning ANN search memory usage.
+16 moreshow less
- ›Enables GPU-accelerated index creation.
- ›Adds Cohere embedding function to the embeddings API.
- ›Supports multi-task Instructor model with quantization support, and adds weak_lru cache for embedding function models.
- ›Adds exponential back-off retry support for rate-limited embedding functions.
- ›Adds checkout method to table for reusing existing stores and connections.
- ›Exposes optimize_index and remap_index APIs.
- ›Adds dataset stats APIs for both Python and Node.js.
- ›Adds create_index API for SaaS (remote) tables.
- ›Enables LocalTable to support filters without requiring a vector search.
- ›Allows specifying a custom vector column name in queries.
- ›Supports nested Pydantic schemas for table schema definition.
- ›Adds PyArrow date and timestamp type conversion from Pydantic models.
- ›Adds deletion operation on remote tables (Python and JavaScript).
- ›Implements mirroring object store, including manifest files, for replicating data across storage backends.
- ›Adds cleanup and compaction operations for managing table storage.
- ›Adds list table pagination for remote/SaaS connections.
└──▷ BREAKING ON UPGRADE
- !Table names returned by table_names are now sorted (previously unsorted); code that depended on a specific insertion-order listing will see a different order.
python-v0.4.0 Dec 18, 2023 · issue -383

LanceDB v0.4.0 adds GPU indexing, scalar indexes, prefilter support, Cohere embeddings, update queries, and remote table operations.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.4.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.4.0
```
└──▷ TRY IT
Update rows in a table matching a filter condition — useful for patching labels or metadata in place.
```
$ table.update(where="status = 'pending'", values={"status": "processed"})
```
Query a table using only scalar filters, no vector search required, to retrieve matching rows as a list.
```
$ results = table.search().where("score > 0.9").to_list()
```
- ›Adds prefilter flag to queries, enabling pre-filtering with an index before vector search (available in Python, Node.js, and Rust).
- ›Adds update query support for Python via update API, and implements update for remote clients.
- ›Adds to_list and to_pandas APIs for query result retrieval.
- ›Adds RemoteTable.version property in Python to inspect the version of a remote table.
- ›Adds index cache size configuration via expose index cache size API in Python.
+17 moreshow less
- ›Adds checkout method to table for reusing existing stores and connections.
- ›Adds optimize_index and remap_index APIs for index management.
- ›Adds data stats APIs (added data stats apis) for both Python and Node.js.
- ›Adds create_index API for SaaS (remote) tables.
- ›Supports GPU-accelerated index creation.
- ›Adds scalar index support and stats-based predicate pushdown for faster filtered queries.
- ›Adds Cohere embedding function integration.
- ›Adds multi-task Instructor model support with quantization and weak_lru cache for embedding function models.
- ›Adds exponential backoff retry support for rate-limited embedding functions.
- ›Adds support for custom vector column names in queries.
- ›Supports nested Pydantic schemas for table definitions.
- ›Adds PyArrow date and timestamp type conversion from Pydantic models.
- ›Enables LocalTable to support filters without vector search.
- ›Implements mirroring object store, including manifest files.
- ›Adds deletion operation on remote tables for both Python and JavaScript.
- ›Adds list table pagination for remote/SaaS connections.
- ›Adds telemetry, error tracking, CLI, and config manager.
└──▷ BREAKING ON UPGRADE
- !New cosine distance calculation for Product Quantization changes distance results for existing PQ indexes.
- !PyArrow minimum version bumped to 12.0+; older pyarrow installations will break.
python-v0.3.6 Dec 15, 2023 · issue -383

LanceDB v0.3.6 adds nested Pydantic schema support, custom vector column queries, and remote update operations.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.3.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.3.6
```
- ›Supports nested Pydantic schemas for table definitions, enabling richer data models to be used directly with LanceDB.
- ›Allows a custom vector column name to be specified in queries, letting users target non-default vector columns during search.
- ›Passes the vector column name through to the remote backend, enabling custom column naming in remote query workflows.
- ›Implements update operations for remote clients, bringing remote LanceDB deployments to parity with local update support.
v0.3.11 Dec 15, 2023 · issue -383

LanceDB v0.3.11 adds custom vector column naming in queries and update support for remote clients.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.11 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.11
```
- ›Enables custom column names in vector queries instead of requiring a fixed default column.
- ›Implements update for remote clients, bringing remote table mutations to parity with local usage.
v0.3.10 Dec 14, 2023 · issue -383

LanceDB v0.3.10 adds filter-only table scans and row updates to the Node.js client.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.10 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.10
```
└──▷ USE IT
Update a specific row's vector and name fields in-place using a filter predicate (OSS only).
typescript
```
await tbl.update({
  filter: "id = 2",
  updates: { vector: [2, 2], name: "Michael" },
})
```
- ›Adds .filter(<expression>).execute() to the Node.js table API, enabling table scans with a predicate but without a vector search.
- ›Adds .update({ filter, updates }) to the Node.js tbl API (OSS only), allowing in-place row updates by filter expression.
python-v0.3.5 Dec 14, 2023 · issue -383

LanceDB Python v0.3.5 promotes update queries out of experimental with a new Python API.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.3.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.3.5
```
- ›Adds update query support for Python via the new update API, allowing in-place modification of table records without experimental caveats.
v0.3.9 Dec 4, 2023 · issue -383

LanceDB v0.3.9 exposes prefilter in Rust and Node.js clients for pre-query filter application.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.9 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.9
```
- ›Exposes prefilter option in the Rust client, enabling filter application before vector search rather than post-filtering.
- ›Enables prefilter support in the Node.js client, bringing pre-query filtering parity with other LanceDB clients.
python-v0.3.4 Nov 19, 2023 · issue -384

LanceDB v0.3.4 adds retry logic for rate-limited embeddings, multi-task Instructor model with quantization, and new remote/SaaS APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.3.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.3.4
```
- ›Adds RemoteTable.version property in Python to retrieve the current version of a remote table.
- ›Adds create_index API for SaaS (remote) tables, bringing index management to the hosted offering.
- ›Exposes index cache size configuration via Python (feat(python): expose index cache size).
- ›Adds exponential backoff retry support for rate-limited embedding functions.
- ›Adds multi-task Instructor model support with quantization support for embedding functions.
+1 moreshow less
- ›Adds weak_lru cache for embedding function models to reduce redundant model loads.
v0.3.8 Nov 19, 2023 · issue -384

LanceDB v0.3.8 adds SaaS create_index API and exposes index cache size in Python.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.8 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.8
```
- ›Exposes index cache size configuration in the Python client (feat(python): expose index cache size).
- ›Adds a create_index API for SaaS (cloud-hosted) LanceDB deployments.
v0.3.7 Nov 15, 2023 · issue -384

LanceDB v0.3.7 adds exponential backoff for rate-limited embeddings, multi-task Instructor model with quantization, and RemoteTable.version in Python.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.7 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.7
```
- ›Adds RemoteTable.version property in the Python SDK to retrieve the current version of a remote table.
- ›Adds exponential backoff retry support for embedding functions that hit rate limits.
- ›Adds multi-task Instructor model support with quantization, plus a weak_lru cache for embedding function models to reduce redundant model loads.
v0.3.6 Nov 1, 2023 · issue -384

LanceDB v0.3.6 adds prefilter support for ANN index queries.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.6
```
- ›Adds prefilter flag to allow prefiltering with an index during approximate nearest neighbor queries, enabling filtered vector search without a post-filter pass.
└──▷ BREAKING ON UPGRADE
- !Table names are now returned in sorted order (changed by the fix!: sort table names commit); any code that depended on the previous unordered listing behavior may be affected.
python-v0.3.3 Nov 1, 2023 · issue -384

LanceDB v0.3.3 adds optimize/remap index APIs, dataset stats APIs, and prefilter support for indexed queries.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.3.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.3.3
```
- ›Adds optimize_index API to allow index optimization on existing tables.
- ›Adds remap_index API to support index remapping operations.
- ›Adds data/dataset stats APIs for retrieving dataset statistics (exposed in both Python and Node SDKs).
- ›Adds prefilter flag to allow prefiltering with an index during queries.
└──▷ BREAKING ON UPGRADE
- !Table names returned by the API are now sorted (fix!: sort table names), which may change ordering assumptions in existing code.
v0.3.5 Oct 26, 2023 · issue -385

LanceDB v0.3.5 adds checkout, optimize/remap index, and dataset stats APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.5
```
- ›Adds checkout method to table for reusing existing stores and connections across sessions.
- ›Exposes optimize index API for programmatic index optimization.
- ›Exposes remap index API for index remapping operations.
- ›Adds dataset stats APIs (Python and Node.js) surfacing data statistics for tables.
- ›Includes manifest files in mirror store, improving versioning support for mirrored datasets.
v0.3.4 Oct 26, 2023 · issue -385

LanceDB v0.3.4 adds checkout, optimize index, remap index, and dataset stats APIs for Python and Node.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.4
```
- ›Adds checkout method to table objects to reuse existing store and connections.
- ›Exposes optimize index API for managing vector indexes programmatically.
- ›Exposes remap index API for index remapping operations.
- ›Adds dataset stats APIs to both Python and Node bindings for inspecting table data statistics.
- ›Includes manifest files in mirror store, broadening mirrored-store coverage.
python-v0.3.2 Oct 24, 2023 · issue -385

LanceDB python-v0.3.2 adds remote table deletion, PyArrow date/timestamp type support, and a table checkout method.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.3.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.3.2
```
- ›Adds delete operation on remote tables, enabling row deletion via the remote API for both Python and JS clients.
- ›Adds checkout method to Table to reuse an existing store and connections without re-opening.
- ›Adds PyArrow date and timestamp type conversion from Pydantic models.
- ›Adds list-table pagination support for remote table listings.
- ›Adds incremental index update and index compaction capabilities via the underlying Lance 0.8.5 upgrade.
+2 moreshow less
- ›Improves vector search performance when deletions are present (Lance 0.8.6) and improves vector index performance generally (Lance 0.8.7).
- ›Supports customizing file size during Lance dataset writes (Lance 0.8.7).
v0.3.3 Oct 19, 2023 · issue -385

LanceDB v0.3.3 adds PyArrow date/timestamp type conversion from Pydantic and refactors the Embeddings API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.3
```
- ›Adds PyArrow date and timestamp type conversion from Pydantic models, enabling richer schema definitions without manual type mapping.
- ›Refactors the Embeddings API (Python) with updated embedding function support.
v0.3.2 Oct 16, 2023 · issue -385

LanceDB v0.3.2 adds deletion operations on remote tables for both Python and JavaScript clients.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.2
```
- ›Adds deletion operation on remote tables in the Python and JavaScript clients, enabling row removal from cloud-hosted LanceDB tables.
- ›Implements remote API calls for table mutation, extending write capabilities to the remote backend.
v0.3.1 Oct 13, 2023 · issue -385

LanceDB v0.3.1 adds GPU index creation, Cohere embeddings, mirroring object store, compaction, and new query APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.3.1
```
└──▷ USE IT
Query a LanceDB table and load results into a pandas DataFrame for downstream analysis.
python
```
df = table.search(query_vector).limit(10).to_pandas()
```
- ›Adds to_list and to_pandas APIs for querying table data directly into Python-native structures.
- ›Adds Cohere embedding function for generating embeddings via the Cohere API.
- ›Adds GPU support for index creation to accelerate vector index builds.
- ›Implements a mirroring object store for replicating data across storage backends.
- ›Adds cleanup and compaction support for managing table storage and reducing file fragmentation.
+1 moreshow less
- ›Adds telemetry, error tracking, CLI, and config manager capabilities.
python-v0.3.1 Oct 13, 2023 · issue -385

LanceDB v0.3.1 adds GPU index creation, Cohere embeddings, object-store mirroring, table compaction, and new query APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.3.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.3.1
```
└──▷ USE IT
Retrieve query results as a Pandas DataFrame for immediate analysis in a notebook or pipeline.
python
```
results = table.search(query_vector).limit(10).to_pandas()
```
- ›Adds to_list() and to_pandas() APIs for querying tables directly into Python-native result types.
- ›Adds Cohere embedding function for generating embeddings via the Cohere API.
- ›Supports GPU-accelerated index creation for faster ANN index builds.
- ›Implements object store mirroring to replicate data across storage backends.
- ›Adds table cleanup and compaction to reduce small-file overhead and reclaim storage.
python-v0.2.6 Oct 1, 2023 · issue -385

LanceDB adds opt-in pre-filtering via prefilter=True on .where(), applying filters before vector search rather than after.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.2.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.2.6
```
└──▷ USE IT
Narrow the vector search space to a subset of rows before computing KNN, rather than filtering the results afterwards.
python
```
table.search(query_vector).where("category = 'malware'", prefilter=True).limit(10).to_df()
```
- ›Adds prefilter=True parameter to .where() to apply filters BEFORE running KNN vector search, reducing the candidate set before similarity scoring.
python-v0.2.5 Sep 19, 2023 · issue -386

LanceDB v0.2.5 adds OpenCLIP multi-modal embeddings and a lancedb.__version__ attribute.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.2.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.2.5
```
└──▷ TRY IT
Generate text-to-image embeddings using the new OpenCLIP integration when building a multi-modal search table.
```
$ pip install lancedb[clip]
```
- ›Adds lancedb.__version__ for programmatic version introspection.
- ›Adds OpenCLIP-backed multi-modal embedding function for text-to-image embeddings, installable via pip install lancedb[clip] (requires torch, pillow, and open-clip).
v0.2.6 Sep 19, 2023 · issue -386

LanceDB v0.2.6 adds multi-modal embedding functions and a lancedb.__version__ attribute.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.2.6
```
└──▷ USE IT
Check the installed LanceDB version at runtime, useful in diagnostics or CI pipelines.
python
```
import lancedb
print(lancedb.__version__)
```
- ›Adds lancedb.__version__ attribute for programmatic version introspection.
- ›Introduces multi-modal embedding function support, enabling embedding pipelines that handle more than one data modality.
- ›Improves Pydantic 1.x compatibility for schema definitions.
python-v0.2.4 Sep 15, 2023 · issue -386

LanceDB python-v0.2.4 adds pydantic-backed embedding function persistence, temporary table updates, and URI query string propagation to Lance.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.2.4 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.2.4
```
- ›Adds pydantic-based persistence for embedding functions, enabling embedding configurations to be saved and restored reliably.
- ›Supports default values on pydantic vector fields, allowing model definitions to omit explicit vector initialization.
- ›Adds temporary update feature for Python tables, enabling in-place modifications without committing a permanent write.
- ›Propagates URI query string parameters through to the underlying Lance storage layer, unlocking AWS-specific storage options via connection strings.
v0.2.5 Sep 10, 2023 · issue -386

LanceDB v0.2.5 adds schema evolution, temporary updates, and pydantic embedding persistence for local Python tables.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.5 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.2.5
```
- ›Supports schema evolution in local LanceDB Python tables, allowing columns to be added or changed without recreating the table.
- ›Adds temporary update feature for Python, enabling in-place row modifications that can be staged before committing.
- ›Uses Pydantic for embedding function persistence, allowing embedding configurations to be serialized and reloaded reliably.
- ›Supports Pydantic vector fields with default values, reducing boilerplate when defining vector schemas.
- ›Propagates URI query strings through to Lance, enabling AWS-specific connection parameters to be passed via the connection URI.
+2 moreshow less
- ›Adds schema coerce and vector column inference in the Rust client, reducing manual schema specification when working with vector data.
- ›Upgrades the underlying Lance dependency to v0.7.3.
python-v0.2.2 Aug 24, 2023 · issue -387

LanceDB python-v0.2.2 adds schema evolution — new columns without data rewrites, reversible via LanceTable.restore.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.2.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.2.2
```
- ›Supports schema evolution in local LanceDB, allowing new columns to be added to an existing table without rewriting underlying data.
- ›Adds LanceTable.restore to reverse schema evolution operations, rolling a table back to a prior state.
python-v0.2.1 Aug 24, 2023 · issue -387

LanceDB v0.2.1 restores table-restore capability and makes Iterator-based table creation more flexible.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.2.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.2.1
```
- ›Restores the ability to restore a previous version of a table (temporarily re-enabled feature).
- ›Makes creating and adding to tables via Python Iterators more flexible and intuitive, reducing boilerplate when streaming data into LanceDB.
v0.2.3 Aug 22, 2023 · issue -387

LanceDB v0.2.3 adds empty-table creation in Node.js, configurable AWS region, and flexible Iterator-based table writes.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.2.3
```
- ›Exposes awsRegion as a configurable option for connections, enabling explicit AWS region selection for cloud-backed tables.
- ›Adds support in the Node.js client for creating empty tables and Arrow-schema tables without pre-loading data.
- ›Makes creating and appending to tables via Python Iterators more flexible, supporting lazy or streamed data ingestion.
v0.2.0 Aug 14, 2023 · issue -387

LanceDB v0.2.0 adds drop-table/drop-database support, improved Pydantic integration, and renames the distance result column.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.2.0
```
- ›Implements drop_database to programmatically remove an entire database.
- ›Adds drop table if exists support, including a remote drop-table call, to safely remove tables without errors when the table is absent.
- ›Improves Pydantic integration with LanceModel for schema-driven table definitions.
- ›Makes pandas an optional dependency, reducing required installs for non-DataFrame workflows.
- ›Improves Node.js concurrency in the native bridge layer.
└──▷ BREAKING ON UPGRADE
- !The score column returned by vector search is renamed to _distance; any code filtering or referencing score in query results will break.
- !schema is now a property rather than a method; call sites that invoke schema() as a function will break.
python-v0.2.0 Aug 12, 2023 · issue -387

LanceDB python-v0.2.0 adds iterator-based ingestion, pydantic auto-conversion, drop_database, and renames the distance column.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.2.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.2.0
```
└──▷ USE IT
Ingest a large dataset from a generator without loading it all into memory at once.
python
```
import lancedb

def record_generator():
    for i in range(100_000):
        yield {"id": i, "vector": [float(i), float(i)], "text": f"item {i}"}

db = lancedb.connect("./mydb")
table = db.open_table("items")
table.add(record_generator())
```
Use the renamed _distance field to filter and rank vector search results after upgrading from v0.1.x.
python
```
results = table.search([0.1, 0.2]).limit(10).to_pandas()
print(results[["id", "text", "_distance"]].sort_values("_distance"))
```
- ›Adds drop_database method to programmatically delete an entire database.
- ›Supports adding records via Python iterators with table.add(), enabling streaming or lazily-generated data ingestion without materializing the full dataset in memory.
- ›Automatically converts Pydantic models to the appropriate schema when adding records, removing manual Arrow conversion steps.
- ›Makes schema a property on table objects for direct attribute-style access.
└──▷ BREAKING ON UPGRADE
- !The score column returned by vector search is renamed to _distance; any code reading result['score'] must be updated to result['_distance'].
- !schema is now a property instead of a method; any code calling .schema() must be updated to .schema.
python-v0.1.16 Jul 31, 2023 · issue -388

LanceDB v0.1.16 adds a Pydantic ORM layer with LanceModel and to_pydantic(), plus drop_table if-exists support.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.1.16 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.1.16
```
└──▷ USE IT
Define a typed vector schema with Pydantic and convert similarity-search results directly back to model instances.
python
```
import lancedb
from lancedb.pydantic import LanceModel, vector

class Document(LanceModel):
    text: str
    vector: vector(384)

db = lancedb.connect("/tmp/mydb")
table = db.create_table("docs", schema=Document.to_arrow_schema())
table.add([Document(text="hello world", vector=[0.1] * 384)])

results = table.search([0.0] * 384).limit(5).to_pydantic(Document)
print(results)
```
- ›Adds LanceModel base class and vector() field type from lancedb.pydantic, enabling schema generation via LanceModel.to_arrow_schema() and round-tripping search results back to Pydantic models with .to_pydantic(<ModelClass>).
- ›Implements drop table if exists support.
- ›Makes pandas an optional dependency in LanceDB, reducing default install size.
v0.1.17 Jul 21, 2023 · issue -388

LanceDB v0.1.17 adds Linux ARM build support for the Node.js package.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.17 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.17
```
- ›Adds Linux ARM build for the Node.js package, enabling LanceDB to run on ARM-based Linux hosts.
v0.1.15 Jul 19, 2023 · issue -388

LanceDB v0.1.15 adds Node.js remote SDK support, host override, and AWS_ENDPOINT passthrough.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.15 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.15
```
- ›Passes the AWS_ENDPOINT environment variable through to storage layer, enabling custom S3-compatible endpoint configuration.
- ›Adds initial Node.js remote SDK support, allowing Node clients to connect to a remote LanceDB server.
- ›Implements db.TableNames() for the remote Node.js SDK, enabling table discovery against a remote instance.
- ›Adds host override support in the Node.js remote SDK for directing client connections to a custom host.
python-v0.1.12 Jul 19, 2023 · issue -388

LanceDB python-v0.1.12 passes the AWS_ENDPOINT environment variable for custom S3-compatible storage endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.1.12 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.1.12
```
- ›Supports the AWS_ENDPOINT environment variable to direct LanceDB at custom S3-compatible storage backends (e.g. MinIO, LocalStack).
v0.1.14 Jul 17, 2023 · issue -388

LanceDB v0.1.14 adds Windows support for the Node.js SDK and exposes table schema and version in the Rust API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.14 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.14
```
- ›Exposes table schema and version via the Rust SDK (Table now surfaces schema and version fields).
- ›Adds Windows support for the Node.js SDK.
v0.1.11-python Jul 17, 2023 · issue -388

LanceDB v0.1.11 adds remote table listing, Pydantic-to-Arrow schema conversion, and Iterator[RecordBatch] table creation
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.11-python https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.11-python
```
- ›Supports creating a table by passing an Iterator[RecordBatch] as the data source, enabling streaming ingestion of large datasets.
- ›Adds conversion of Pydantic models to Arrow Schema, letting callers define table structure with typed Python models.
- ›Adds schema serialization to JSON via a new schema-to-JSON conversion path.
- ›Exposes table schema and version in the Rust layer, surfacing them through the Python get table schema API.
- ›Enables listing tables from a remote LanceDB service via the Python client.
+1 moreshow less
- ›Supports adding records to a remote table via the Python remote API.
v0.1.13 Jul 13, 2023 · issue -388

LanceDB v0.1.13 adds an options object to the Node.js connect method and splits Node binaries into separate packages.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.13 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.13
```
- ›Adds an options object parameter to the Node.js connect method for configurable database connections.
- ›Splits Node.js binaries into separate packages for leaner installs.
v0.1.10-python Jul 10, 2023 · issue -388

LanceDB v0.1.10 adds empty table creation and changes the default write mode to error on conflict.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.10-python https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.10-python
```
- ›Changes the default write mode from drop to error, so accidental overwrites now raise an error instead of silently dropping data.
- ›Supports creation of an empty table without requiring initial data to be provided.
- ›AWS credentials are now cached until 30 seconds before expiry, reducing redundant credential fetches in cloud-backed datasets.
└──▷ BREAKING ON UPGRADE
- !The default write mode is changed from drop to error: existing code that relied on the silent drop-and-overwrite behavior will now raise an error on conflicting writes.
v0.1.10 Jul 6, 2023 · issue -388

LanceDB v0.1.10 adds named vector column targeting, dot product support, IVF PQ config exposure, and WriteMode for Node table creation.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.10 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.10
```
└──▷ USE IT
Overwrite an existing index without recreating the table, useful after bulk data updates.
javascript
```
await table.createIndex({ replace: true });
```
Create or overwrite a table with explicit WriteMode to safely re-run ingestion pipelines.
javascript
```
const table = await db.createTable('embeddings', data, { writeMode: WriteMode.Overwrite });
```
- ›Exposes IVF PQ index configuration in the Node.js client, letting callers tune partitioning and quantization parameters when building vector indexes.
- ›Adds replace flag to the JavaScript createIndex API, allowing an existing index to be overwritten in place without dropping the table.
- ›Supports WriteMode in the Node.js createTable API (re-exported from lancedb in Rust), enabling append, overwrite, or create-or-append semantics at table creation time.
- ›Supports specifying a named vector column for vector search, so tables with multiple vector columns can target the correct one explicitly.
- ›Adds dot product distance metric support in the JavaScript/Node.js client for vector similarity search.
+1 moreshow less
- ›Makes the object store construction hook public, enabling custom storage backend injection.
python-v0.1.9 Jun 26, 2023 · issue -389

LanceDB v0.1.9 adds row deletion support and a drop-table API for Node, plus a remote connection client.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.1.9 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.1.9
```
- ›Adds deletion support for Python, enabling rows to be removed from a table.
- ›Adds a drop table API for the Node client.
- ›Ports the remote connection client into the LanceDB library.
v0.1.9 Jun 26, 2023 · issue -389

LanceDB v0.1.9 adds record deletion and a Node.js drop-table API
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.9 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.9
```
- ›Adds drop_table API for Node.js to remove tables from a LanceDB database.
- ›Supports deletion of records from a LanceDB table.
v0.1.7 Jun 15, 2023 · issue -389

LanceDB v0.1.7 adds Table.countRows() for Node, a remote connection client, and split Node binaries.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.7 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.7
```
└──▷ USE IT
Count the number of rows in a LanceDB table from Node.js after inserting or filtering data.
javascript
```
const count = await table.countRows();
console.log(`Row count: ${count}`);
```
- ›Adds Table.countRows() method to the Node.js client for counting rows in a table.
- ›Ports a remote connection client into the lancedb library, enabling connections to remote LanceDB instances.
- ›Splits Node.js binaries into separate packages for more modular installs.
v0.1.6 Jun 15, 2023 · issue -389

LanceDB v0.1.6 adds a where method to the Node.js query builder for SQL-style filtering.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.6 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.6
```
- ›Adds where method to the Node.js query builder, enabling SQL-style predicate filtering on vector search queries.
python-v0.1.8 Jun 12, 2023 · issue -389

LanceDB python-v0.1.8 adds expression escaping, timestamp/date/cast support, and index recreation on existing columns.
└──▷ GET THIS VERSION
```
$ git clone --branch python-v0.1.8 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.1.8
```
- ›Expressions now support escaping column names, timestamp literals, date literals, and cast expressions.
- ›Allows recreating an index with the same name on the same column without error.
- ›Various Python API improvements.
v0.1.5-python Jun 2, 2023 · issue -389

LanceDB v0.1.5 adds S3/GCS cloud storage support, drop table, image embeddings, and OpenAI embeddings for Node.js
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.5-python https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.5-python
```
- ›Supports storing and listing tables directly on S3 and GCS via fsspec-based cloud storage backend.
- ›Adds drop table support for the Python client.
- ›Adds image embedding generation capability.
- ›Adds OpenAI embedding function to the Node.js client.
v0.1.3 May 25, 2023 · issue -390

LanceDB v0.1.3 ships a JavaScript/Node.js library with full CRUD, indexing, and basic full-text search for Python.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.3 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.3
```
└──▷ USE IT
Create a table and run a vector similarity search from Node.js in a new project.
javascript
```
const lancedb = require('vectordb');
const db = await lancedb.connect('/tmp/mydb');
const table = await db.createTable('embeddings', [
  { vector: [0.1, 0.2, 0.3], text: 'hello world' }
]);
const results = await table.search([0.1, 0.2, 0.3]).limit(5).execute();
```
- ›Adds a JavaScript/Node.js library for LanceDB, exposing connect, openTable, createTable, and vector search APIs for Node.js and TypeScript consumers.
- ›Adds create_index to the Node.js client, enabling ANN index creation directly from JavaScript.
- ›Adds append records API to the Node.js client for incrementally adding rows to an existing table.
- ›Adds query parameters (e.g. limit) to the Node.js client's vector search interface via the exposed limit parameter.
- ›Adds basic full-text search capabilities to the Python library (backed by tantivy-py, installed separately from the wheel).
+2 moreshow less
- ›Adds Linux support for the JavaScript client native binary.
- ›Adds a TypeScript example demonstrating typed usage of the Node.js library.
└──▷ BREAKING ON UPGRADE
- !tantivy-py is no longer bundled in the Python wheel and must be installed separately to use full-text search.
v0.1.2 May 5, 2023 · issue -390

LanceDB v0.1.2 adds cloud storage support for S3 and GCS buckets and begins a Rust core implementation.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.2 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.2
```
- ›Adds cloud storage support, enabling LanceDB tables to be stored directly on S3 or GCS buckets.
- ›Introduces a Rust core implementation for improved performance.
v0.1.1 Apr 27, 2023 · issue -391

LanceDB v0.1.1 adds configurable distance metrics (L2 and Cosine) for ANN vector search.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1.1
```
- ›Distance metric for ANN queries is now configurable, with support for L2 and Cosine distance.
v0.1 Apr 20, 2023 · issue -391

LanceDB v0.1 adds table versioning methods and an overwrite mode for existing tables.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.1 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.1
```
- ›Exposes methods to work with versioning in tables, enabling version history access and management.
- ›Adds mode parameter to overwrite an existing table on creation rather than raising an error.

LanceDB

Summary

What LanceDB answers

Examples

Command line

Release history