LanceDB — The AI Toolchain

LanceDB v0.38.0

Mon, 31 Aug 2026 07:39:14 GMT

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. • 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. • 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 changes: • 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.

LanceDB v0.37.1

Mon, 10 Aug 2026 07:55:09 GMT

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. • 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. • 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 changes: • `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.

LanceDB v0.37.1

Mon, 10 Aug 2026 07:55:09 GMT

LanceDB v0.37.1 adds LSM table controls, async Lance access, custom FTS stop-words, blob range reads, and job-handle APIs. • 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. • 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 changes: • `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.

LanceDB python-v0.36.0

Tue, 28 Jul 2026 21:33:04 GMT

LanceDB python-v0.36.0 adds elastic dataloaders, OpenTelemetry metrics, WatsonxReranker, FTS tokenization, Tencent COS/GooseFS support, and remote branch diff/merge APIs. • 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. • 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 changes: • 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.

LanceDB python-v0.36.0

Tue, 28 Jul 2026 21:33:04 GMT

LanceDB python-v0.36.0 adds elastic dataloaders, OpenTelemetry metrics, WatsonxReranker, FTS tokenization, blob v2 API, and Tencent COS/GooseFS support. • 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. • 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 changes: • 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.

LanceDB v0.33.0

Tue, 28 Jul 2026 21:32:52 GMT

LanceDB v0.33.0 adds OpenTelemetry metrics, FTS tokenization, WatsonxReranker, Tencent COS/GooseFS storage, and remote branch diff/merge APIs. • 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. • 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 changes: • Permutation.with_format('torch') now behaves like HuggingFace's set_format('torch'), which may change output format for existing callers.

LanceDB v0.33.0

Tue, 28 Jul 2026 21:32:52 GMT

LanceDB v0.33.0 adds OpenTelemetry metrics, WatsonxReranker, FTS tokenization, Tencent COS/GooseFS support, and remote branch diff/merge APIs. • 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. • 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 changes: • 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.

LanceDB v0.32.0-beta.3

Fri, 24 Jul 2026 22:04:27 GMT

LanceDB v0.32.0-beta.3 adds block size configuration for full-text search indexing. • Adds block size configuration for full-text search (`fts`) index building.

LanceDB v0.32.0-beta.3

Fri, 24 Jul 2026 22:04:27 GMT

LanceDB v0.32.0-beta.3 adds block size configuration for full-text search indexes. • Adds block size configuration for full-text search (FTS) index creation, enabling tuning of on-disk index layout.

LanceDB python-v0.35.0-beta.3

Fri, 24 Jul 2026 22:04:26 GMT

LanceDB adds block size configuration for full-text search indexes. • Adds block size configuration for full-text search (FTS) indexes, enabling tuning of index storage granularity.

LanceDB python-v0.35.0-beta.3

Fri, 24 Jul 2026 22:04:26 GMT

LanceDB python-v0.35.0-beta.3 adds block size configuration for full-text search indexes. • Adds block size configuration for full-text search (FTS) index creation, enabling tuning of index storage layout.

LanceDB python-v0.36.0-beta.0

Fri, 24 Jul 2026 19:34:22 GMT

LanceDB python-v0.36.0-beta.0 adds remote branch diff/merge APIs, distributed plan metrics, and pre-Haswell wheel support. • 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.

LanceDB python-v0.36.0-beta.0

Fri, 24 Jul 2026 19:34:22 GMT

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. • 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.

LanceDB v0.33.0-beta.0

Fri, 24 Jul 2026 19:34:17 GMT

LanceDB v0.33.0-beta.0 adds distributed query plan metrics, pre-Haswell wheel support, and remote branch diff/merge client APIs. • 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.

LanceDB v0.33.0-beta.0

Fri, 24 Jul 2026 19:34:17 GMT

LanceDB v0.33.0-beta.0 adds remote branch diff/merge client APIs, distributed query plan metrics, and pre-Haswell x86_64 wheel support. • 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.

LanceDB python-v0.35.0-beta.2

Tue, 14 Jul 2026 23:28:55 GMT

LanceDB python-v0.35.0-beta.2 adds a blob v2 fetch API, WatsonxReranker support, and FTS query tokenization. • 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.

LanceDB v0.32.0-beta.2

Tue, 14 Jul 2026 23:28:54 GMT

LanceDB v0.32.0-beta.2 adds a blob v2 fetch API, WatsonxReranker support, and FTS query tokenization. • 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.

LanceDB python-v0.35.0-beta.0

Fri, 10 Jul 2026 05:26:26 GMT

LanceDB python-v0.35.0-beta.0 adds an elastic dataloader, OpenTelemetry metrics, Tencent COS/GooseFS support, and expanded expression literal types. • 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. • Adds Tencent COS and GooseFS object store support via new feature flags. Breaking changes: • 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.

LanceDB v0.32.0-beta.0

Fri, 10 Jul 2026 05:26:22 GMT

LanceDB v0.32.0-beta.0 adds an elastic dataloader, OpenTelemetry metrics, Tencent COS/GooseFS support, and richer expression literals. • 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. • Aligns Permutation.with_format('torch') behavior with HuggingFace set_format('torch'). Breaking changes: • Permutation.with_format('torch') now behaves like HuggingFace's set_format('torch'), which may change output format semantics for existing callers.

LanceDB python-v0.34.0

Thu, 02 Jul 2026 16:01:22 GMT

LanceDB v0.34.0 adds FM-Index substring search, table branches, OAuth support, Polars integration, and approx vector query mode. • 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. • 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 changes: • 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.

LanceDB v0.31.0

Thu, 02 Jul 2026 16:01:17 GMT

LanceDB v0.31.0 adds FM-Index substring search, table branching, OAuth auth, approx vector query mode, and Polars integration. • 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. • 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 changes: • 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.

LanceDB python-v0.34.0-beta.6

Thu, 02 Jul 2026 11:34:15 GMT

LanceDB python-v0.34.0-beta.6 re-exports arrow and datafusion crates from the lancedb Rust crate. • Re-exports `arrow` and `datafusion` crates directly from the `lancedb` Rust crate, removing the need for separate dependency declarations. Breaking changes: • 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.

LanceDB v0.31.0-beta.6

Thu, 02 Jul 2026 11:34:14 GMT

LanceDB v0.31.0-beta.6 re-exports arrow and datafusion crates from the lancedb Rust crate. • Re-exports `arrow` and `datafusion` crates directly from the `lancedb` Rust crate, removing the need for separate dependency declarations. Breaking changes: • Multiple `where` filter calls on the same query are now combined with AND instead of the later call replacing the earlier one.

LanceDB python-v0.34.0-beta.5

Tue, 30 Jun 2026 22:25:15 GMT

LanceDB python-v0.34.0-beta.5 adds OAuth connection config, Polars DataFrame integration, and monotonic reads via watermark header. • 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.

LanceDB v0.31.0-beta.5

Tue, 30 Jun 2026 22:25:14 GMT

LanceDB v0.31.0-beta.5 adds OAuth connection config, Polars DataFrame integration, monotonic reads, and branch-aware skills. • 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.

LanceDB v0.31.0-beta.4

Mon, 29 Jun 2026 11:12:42 GMT

LanceDB v0.31.0-beta.4 adds an OAuth header provider for Rust clients. • Adds an OAuth header provider to the Rust client, enabling authenticated requests to LanceDB services via OAuth.

LanceDB python-v0.34.0-beta.4

Mon, 29 Jun 2026 11:12:39 GMT

LanceDB python-v0.34.0-beta.4 adds an OAuth header provider for authenticated connections. • Adds an OAuth header provider for authenticating requests, enabling token-based auth flows when connecting to LanceDB services.

LanceDB python-v0.34.0-beta.2

Tue, 23 Jun 2026 16:23:31 GMT

LanceDB python-v0.34.0-beta.2 adds blob v2 schema declaration, write path, and blob read/materialization APIs in Rust. • Adds blob v2 schema declaration and write path in the Rust backend. • Adds blob read and materialization APIs in the Rust backend.

LanceDB v0.31.0-beta.2

Tue, 23 Jun 2026 16:23:31 GMT

LanceDB v0.31.0-beta.2 adds blob v2 schema declaration, write path, and blob read/materialization APIs in Rust. • Adds blob v2 schema declaration and write path in the Rust API. • Adds blob read and materialization APIs in the Rust API.

LanceDB v0.31.0-beta.0

Thu, 18 Jun 2026 18:43:48 GMT

LanceDB v0.31.0-beta.0 adds table branches, FM-Index substring search, approx vector query mode, and richer IndexConfig metadata. • 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. • 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 changes: • The `loss` field is removed from `IndexStatistics` (dropped as unused).

LanceDB python-v0.34.0-beta.0

Thu, 18 Jun 2026 18:43:47 GMT

LanceDB python-v0.34.0-beta.0 adds FM-Index substring search, table branching, approx vector query mode, and richer IndexConfig metadata. • 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. • 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 changes: • The `loss` field is removed from `IndexStatistics` (dropped as unused).

LanceDB python-v0.33.1-beta.2

Thu, 04 Jun 2026 06:06:03 GMT

LanceDB python-v0.33.1-beta.2 adds DataFusion expression support for merge insert predicates. • Supports DataFusion expressions as predicates in merge insert operations, enabling richer conditional logic when upserting records.

LanceDB v0.30.1-beta.2

Thu, 04 Jun 2026 06:05:57 GMT

LanceDB v0.30.1-beta.2 adds DataFusion expression support for merge insert predicates in Rust. • Supports DataFusion expressions as predicates in merge insert operations via the Rust API.

LanceDB v0.30.1-beta.1

Wed, 03 Jun 2026 11:18:10 GMT

LanceDB v0.30.1-beta.1 adds remote table support in PyTorch dataloaders, per-field metadata editing, and blob mode queries. • 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.

LanceDB python-v0.33.1-beta.1

Wed, 03 Jun 2026 11:18:00 GMT

LanceDB v0.33.1-beta.1 adds remote table PyTorch dataloader support, per-field metadata editing, and blob mode queries. • 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.

LanceDB python-v0.33.1-beta.0

Mon, 01 Jun 2026 12:42:10 GMT

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. • 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.

LanceDB v0.30.1-beta.0

Mon, 01 Jun 2026 12:42:09 GMT

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. • 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.

LanceDB python-v0.33.0

Thu, 28 May 2026 19:36:44 GMT

LanceDB python-v0.33.0 adds namespace management, LSM write spec, unenforced primary keys, and streaming ingestion primitives. • 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. • 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 changes: • Nested field paths in native index creation now behave differently — existing code relying on the previous (broken) path handling may need to be updated.

LanceDB v0.30.0

Thu, 28 May 2026 19:03:43 GMT

LanceDB v0.30.0 adds namespace management, streaming ingestion, unenforced primary keys, LSM write spec, and DataFusion Expr deletions. • 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. • 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.

LanceDB python-v0.33.0-beta.0

Thu, 21 May 2026 21:36:39 GMT

LanceDB python-v0.33.0-beta.0 aligns `to_pandas` kwargs and adds Node.js table rename and add-progress features. • 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 changes: • 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.

LanceDB v0.30.0-beta.0

Thu, 21 May 2026 21:36:38 GMT

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. • 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 changes: • 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.

LanceDB v0.29.1-beta.0

Mon, 18 May 2026 22:08:19 GMT

LanceDB v0.29.1-beta.0 adds namespace management, streaming ingestion, LSM write spec, and unenforced primary keys for Node.js and Python. • 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. • 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.

LanceDB python-v0.32.1-beta.0

Mon, 18 May 2026 22:08:14 GMT

LanceDB python-v0.32.1-beta.0 adds namespace management, streaming ingestion, `bytes` in lit(), unenforced primary keys, and LSM write spec support. • 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. • 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.

LanceDB python-v0.32.0

Wed, 13 May 2026 16:32:55 GMT

LanceDB python-v0.32.0 adds IVF_HNSW_FLAT index, model-backed FTS tokenizers, Enum/Pydantic support, and namespace operations. • 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. • 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 changes: • Namespace-related naming and enterprise integration have been consolidated — existing code referencing the old namespace identifiers or enterprise connection fields may break after upgrade.

LanceDB v0.29.0

Wed, 13 May 2026 16:32:52 GMT

LanceDB v0.29.0 adds IVF_HNSW_FLAT index, model-backed FTS tokenizers, nested namespace ops, and a Node.js prewarmData method. • 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. • 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 changes: • 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.

LanceDB python-v0.31.0-beta.6

Thu, 16 Apr 2026 18:58:17 GMT

LanceDB python-v0.31.0-beta.6 adds nested namespace support for listing databases. • Supports nested namespace operations when listing databases.

LanceDB v0.28.0-beta.6

Thu, 16 Apr 2026 18:57:53 GMT

LanceDB v0.28.0-beta.6 adds nested namespace support for listing databases in Rust. • Supports nested namespace operations when listing databases via the Rust client.

LanceDB v0.28.0-beta.2

Sat, 11 Apr 2026 07:06:21 GMT

LanceDB v0.28.0-beta.2 adds `user_id` field to `ClientConfig` for user identification. • Adds `user_id` field to `ClientConfig` for associating requests with a specific user identity.

LanceDB python-v0.31.0-beta.2

Sat, 11 Apr 2026 07:06:20 GMT

LanceDB python-v0.31.0-beta.2 adds `user_id` field to `ClientConfig` for user identification. • Adds `user_id` field to `ClientConfig` for attaching a user identifier to client connections.

LanceDB python-v0.30.2

Tue, 31 Mar 2026 21:26:24 GMT

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. • 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.

LanceDB v0.27.2

Tue, 31 Mar 2026 21:26:24 GMT

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(). • 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.

LanceDB python-v0.30.2-beta.0

Wed, 25 Mar 2026 03:23:45 GMT

LanceDB python-v0.30.2-beta.0 adds parallel remote inserts via multipart write and a progress bar for add(). • 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.

LanceDB v0.27.2-beta.0

Wed, 25 Mar 2026 03:23:45 GMT

LanceDB v0.27.2-beta.0 adds parallel multipart inserts for remote tables and a progress bar for add(). • Adds progress bar for the add() method to track data ingestion. • Enables parallel inserts for remote tables via multipart write in the Rust client.

LanceDB v0.27.0

Mon, 16 Mar 2026 22:47:34 GMT

LanceDB v0.27.0 adds a Rust expression builder API, fast_search parity, parallel inserts, and num_deleted_rows reporting. • 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` 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. • 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 changes: • create_table() and Table.add() in Rust now accept `RecordBatch` and `Vec` directly; callers previously relying on the old input types will need to update their call sites.

LanceDB python-v0.30.0

Mon, 16 Mar 2026 22:47:28 GMT

LanceDB python-v0.30.0 adds fast_search parity, parallel inserts, expression-builder filters, and more new query and storage capabilities. • 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. • 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 changes: • create_table() and Table.add() in the Rust SDK now accept `RecordBatch` and `Vec` directly; callers passing other input types must update to these forms.

LanceDB v0.27.0-beta.5

Mon, 09 Mar 2026 19:58:33 GMT

LanceDB v0.27.0-beta.5 adds JS native array inference and upgrades Lance to 3.0.0-rc.3. • 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.

LanceDB python-v0.30.0-beta.5

Mon, 09 Mar 2026 19:58:30 GMT

LanceDB python-v0.30.0-beta.5 adds JS native array inference and upgrades Lance to 3.0.0-rc.3. • 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.

LanceDB v0.27.0-beta.4

Mon, 09 Mar 2026 08:47:39 GMT

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() • 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.

LanceDB python-v0.30.0-beta.4

Mon, 09 Mar 2026 08:47:38 GMT

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. • 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.

LanceDB python-v0.30.0-beta.3

Sat, 28 Feb 2026 01:32:11 GMT

LanceDB python-v0.30.0-beta.3 adds bindings for fast_search via lance 3.0.0-rc.2 upgrade • Adds Python bindings for `fast_search` backed by an upgrade to lance 3.0.0-rc.2.

LanceDB v0.27.0-beta.3

Sat, 28 Feb 2026 01:32:11 GMT

LanceDB v0.27.0-beta.3 adds bindings for fast_search via Lance 3.0.0-rc.2 upgrade • Adds bindings for `fast_search` backed by an upgrade to Lance 3.0.0-rc.2.

LanceDB python-v0.30.0-beta.2

Wed, 25 Feb 2026 07:48:16 GMT

LanceDB python-v0.30.0-beta.2 adds parallel local inserts and a type-safe Rust expression builder API for query filters. • 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.

LanceDB v0.27.0-beta.2

Wed, 25 Feb 2026 07:48:14 GMT

LanceDB v0.27.0-beta.2 adds a Rust expression builder API for type-safe query filters and parallel inserts for local tables. • 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.

LanceDB python-v0.30.0-beta.1

Mon, 23 Feb 2026 18:35:13 GMT

LanceDB python-v0.30.0-beta.1 adds background dataset update checks. • Adds background checking for dataset updates, enabling tables to stay consistent without blocking the main thread.

LanceDB v0.27.0-beta.1

Mon, 23 Feb 2026 18:35:13 GMT

LanceDB v0.27.0-beta.1 adds background dataset update checks for improved consistency. • Checks for dataset updates in the background, enabling tables to stay consistent without blocking query operations.

LanceDB v0.27.0-beta.0

Tue, 17 Feb 2026 00:28:44 GMT

LanceDB v0.27.0-beta.0 adds RecordBatch support in Rust, reranker info in hybrid search explain plans, and improved PyTorch Permutation integration. • Accepts `RecordBatch` and `Vec` 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 changes: • The Rust create_table() and Table.add() APIs now accept `RecordBatch` and `Vec` directly; callers using the previous input types may need to update their call sites.

LanceDB python-v0.30.0-beta.0

Tue, 17 Feb 2026 00:28:43 GMT

LanceDB python-v0.30.0-beta.0 adds reranker info in hybrid search explain plans and improves PyTorch Permutation integration. • 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 changes: • The Rust create_table() and Table.add() now accept `RecordBatch` and `Vec` directly; callers using the previous input types must update their code.

LanceDB v0.26.0

Fri, 06 Feb 2026 18:08:53 GMT

LanceDB v0.26.0 adds VoyageAI v4 embeddings, exposes `fast_search` in the sync Python API, and introduces storage options APIs. • 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.

LanceDB python-v0.29.0

Fri, 06 Feb 2026 18:08:49 GMT

LanceDB python-v0.29.0 adds VoyageAI v4 embeddings, exposes `fast_search` in the sync API, and introduces storage options APIs. • 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.

LanceDB v0.25.0-beta.0

Tue, 03 Feb 2026 04:48:55 GMT

LanceDB v0.25.0-beta.0 adds configurable permutation builder memory limits and VoyageAI v4 embedding models. • Allows the permutation builder memory limit to be configured via environment variable. • Adds VoyageAI v4 models as embedding options in the Python client.

LanceDB python-v0.28.0-beta.0

Tue, 03 Feb 2026 04:48:51 GMT

LanceDB python-v0.28.0-beta.0 adds VoyageAI v4 model support and an env-var-configurable permutation builder memory limit. • Adds support for VoyageAI v4 embedding models in the Python client. • Allows the permutation builder memory limit to be configured via an environment variable.

LanceDB python-v0.27.1

Mon, 26 Jan 2026 23:39:57 GMT

LanceDB python-v0.27.1 adds `AZURE_STORAGE_ACCOUNT_NAME` environment variable support for remote connections. • 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.

LanceDB v0.24.1

Mon, 26 Jan 2026 23:39:35 GMT

LanceDB v0.24.1 adds `AZURE_STORAGE_ACCOUNT_NAME` environment variable support for remote connections. • Reads the `AZURE_STORAGE_ACCOUNT_NAME` environment variable when establishing remote Azure Storage connections, removing the need to hard-code the account name.

LanceDB python-v0.27.0

Thu, 22 Jan 2026 01:10:49 GMT

LanceDB python-v0.27.0 adds Voyage multimodal-3.5 embeddings, remote IVF-RQ index support, and parallelized embedding computation. • 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 changes: • The Rust crate removes default Cargo features (`remove default features`); any downstream Rust code relying on those features must now enable them explicitly.

LanceDB v0.24.0

Thu, 22 Jan 2026 01:10:36 GMT

LanceDB v0.24.0 adds voyage-multimodal-3.5 embeddings, remote IVF-RQ index support, parallelized embedding computation, and exposes table URI. • 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 changes: • 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.

LanceDB python-v0.27.0-beta.0

Wed, 21 Jan 2026 12:22:15 GMT

LanceDB python-v0.27.0-beta.0 adds Voyage multimodal-3.5 embeddings, remote IVF-RQ indexing, parallel embedding computation, and exposes table URI. • 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 changes: • 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`.

LanceDB v0.24.0-beta.0

Wed, 21 Jan 2026 12:22:15 GMT

LanceDB v0.24.0-beta.0 adds Voyage multimodal embeddings, remote IVF-RQ index support, parallel embedding computation, and exposes table URIs. • 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 changes: • 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`.

LanceDB v0.23.0

Tue, 16 Dec 2025 16:58:56 GMT

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. • 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. • 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 changes: • macOS x86 (Intel) support is deprecated and removed. • Namespace operations now use namespace models directly; code using the previous namespace operation signatures will break.

LanceDB python-v0.26.0

Tue, 16 Dec 2025 16:58:55 GMT

LanceDB python-v0.26.0 adds IVF SQ indexing, async namespace connections, stable row IDs via storage_options, and `to_pydantic` async support. • 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. • 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 changes: • 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.

LanceDB v0.23.0-beta.1

Fri, 05 Dec 2025 00:36:56 GMT

LanceDB Java SDK gains REST namespace support and a generic client builder. • Adds REST namespace support to the LanceDB Java SDK client. • Makes the LanceDB Java SDK client builder generic, enabling typed client construction.

LanceDB python-v0.26.0-beta.0

Thu, 04 Dec 2025 19:33:55 GMT

LanceDB python-v0.26.0-beta.0 adds IVF SQ index support, HNSW aliases, and namespace server-side query. • 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 changes: • 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.

LanceDB v0.23.0-beta.0

Thu, 04 Dec 2025 19:33:55 GMT

LanceDB v0.23.0-beta.0 adds IVF SQ index support, HNSW aliases, and server-side namespace queries. • Adds `IVF_SQ` index support and HNSW aliases for vector index creation. • Supports server-side query execution scoped to a namespace. Breaking changes: • 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.

LanceDB v0.22.4-beta.3

Tue, 02 Dec 2025 22:02:20 GMT

LanceDB v0.22.4-beta.3 adds head() for remote tables and stable row IDs via `storage_options`. • 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.

LanceDB python-v0.25.4-beta.3

Tue, 02 Dec 2025 22:02:18 GMT

LanceDB python-v0.25.4-beta.3 adds head() for remote tables and stable row ID support via `storage_options`. • 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.

LanceDB v0.22.4-beta.2

Wed, 19 Nov 2025 20:26:03 GMT

LanceDB v0.22.4-beta.2 adds `num_attempts` to merge-insert results, async `to_pydantic`, and async namespace connections. • 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.

LanceDB python-v0.25.4-beta.2

Wed, 19 Nov 2025 20:25:59 GMT

LanceDB python-v0.25.4-beta.2 adds `num_attempts` in merge-insert results, async `to_pydantic`, and async namespace connections. • 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.

LanceDB python-v0.25.4-beta.0

Mon, 17 Nov 2025 08:44:11 GMT

LanceDB python-v0.25.4-beta.0 adds namespace credentials vending and lets Lance auto-tune IVF partition count. • 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.

LanceDB v0.22.4-beta.0

Mon, 17 Nov 2025 08:44:10 GMT

LanceDB v0.22.4-beta.0 adds namespace credentials vending and auto-tuned IVF partition defaults. • 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.

LanceDB python-v0.25.3

Fri, 07 Nov 2025 04:59:37 GMT

LanceDB python-v0.25.3 adds IVF_RQ index, multivector ColPali support, FTS in SQL, and output_schema for queries. • 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. • Expands multivector support for ColPali models with additional enhancements. • Updates the VoyageAI embedding integration.

LanceDB v0.22.3

Fri, 07 Nov 2025 04:59:34 GMT

LanceDB v0.22.3 adds IVF_RQ index, FTS in SQL via UDTF, multivector ColPali support, and a new output_schema query method. • 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. • 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.

LanceDB v0.22.3-beta.4

Fri, 31 Oct 2025 01:15:01 GMT

LanceDB v0.22.3-beta.4 updates the Voyage AI embedding integration. • Updates the Voyage AI integration for embeddings.

LanceDB python-v0.25.3-beta.4

Fri, 31 Oct 2025 01:14:58 GMT

Updates the VoyageAI embedding integration in LanceDB. • Updates the VoyageAI embedding integration.

LanceDB python-v0.25.3-beta.2

Tue, 21 Oct 2025 20:14:49 GMT

LanceDB python-v0.25.3-beta.2 exposes storage options directly on table objects. • Exposes storage options on table objects, enabling per-table storage configuration.

LanceDB v0.22.3-beta.2

Tue, 21 Oct 2025 20:14:43 GMT

LanceDB v0.22.3-beta.2 exposes storage options directly on table objects. • Exposes storage options on table instances, enabling per-table storage configuration.

LanceDB python-v0.25.3-beta.1

Sun, 19 Oct 2025 23:42:05 GMT

LanceDB python-v0.25.3-beta.1 adds output_schema on queries, multivector ColPali support, and a permutation reader. • 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.

LanceDB v0.22.3-beta.1

Sun, 19 Oct 2025 23:42:03 GMT

LanceDB v0.22.3-beta.1 adds `output_schema` on queries, multivector ColPali support, and a permutation reader. • 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.

LanceDB python-v0.25.3-beta.0

Tue, 14 Oct 2025 02:26:19 GMT

LanceDB python-v0.25.3-beta.0 adds IVF_RQ index type and a permutation-views utility. • Adds `IVF_RQ` as a new index type for vector indexing. • Adds a utility for creating 'permutation views' over datasets.

LanceDB v0.22.3-beta.0

Tue, 14 Oct 2025 02:26:18 GMT

LanceDB v0.22.3-beta.0 adds IVF_RQ index type and a permutation-views utility. • Adds `IVF_RQ` index type for vector indexing. • Adds a utility for creating 'permutation views' over data.

LanceDB python-v0.25.2

Wed, 08 Oct 2025 18:13:30 GMT

LanceDB python-v0.25.2 adds `use_index` for merge inserts, namespace-backed databases, and bitmap indexes on more column types • 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.

LanceDB v0.22.2

Wed, 08 Oct 2025 18:13:27 GMT

LanceDB v0.22.2 adds `use_index` for merge-insert, namespace-backed databases, and bitmap indexes on more Arrow types. • 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.

LanceDB v0.22.2-beta.1

Tue, 30 Sep 2025 19:32:05 GMT

LanceDB v0.22.2-beta.1 adds bitmap index support for large-string, binary, and large-binary types, plus remote connection testing. • 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.

LanceDB python-v0.25.2-beta.1

Tue, 30 Sep 2025 19:32:03 GMT

LanceDB python-v0.25.2-beta.1 adds bitmap index support for large-string, binary, and large-binary types. • 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.

LanceDB python-v0.25.2-beta.0

Wed, 24 Sep 2025 22:55:09 GMT

LanceDB python-v0.25.2-beta.0 adds `use_index` parameter to merge insert and namespace-backed database support. • 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.

LanceDB v0.22.2-beta.0

Wed, 24 Sep 2025 22:55:09 GMT

LanceDB v0.22.2-beta.0 adds `use_index` parameter to merge-insert and namespace-backed database support in Rust. • 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.

LanceDB python-v0.25.1

Tue, 23 Sep 2025 22:07:47 GMT

LanceDB python-v0.25.1 adds mTLS, per-request headers, shallow clone, MRR reranker, and a new `target_partition_size` index param. • 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. • Upgrades Lance to v0.37.0, pulling in the latest storage-layer capabilities.

LanceDB v0.22.1

Tue, 23 Sep 2025 22:07:47 GMT

LanceDB v0.22.1 adds mTLS, per-request header overrides, shallow clone, MRR reranker, and a new `target_partition_size` index param. • 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. • Upgrades Lance to v0.37.0.

LanceDB v0.22.1-beta.3

Mon, 22 Sep 2025 04:49:18 GMT

LanceDB v0.22.1-beta.3 adds shallow clone support for tables. • Adds shallow clone capability for tables, enabling fast duplication without copying all underlying data.

LanceDB python-v0.25.1-beta.3

Mon, 22 Sep 2025 04:49:16 GMT

LanceDB python-v0.25.1-beta.3 adds shallow clone support for tables. • Adds shallow clone capability for LanceDB tables, enabling fast copy-on-write table duplication without copying all underlying data.

LanceDB python-v0.25.1-beta.2

Thu, 18 Sep 2025 20:22:52 GMT

LanceDB python-v0.25.1-beta.2 adds `target_partition_size` parameter for index tuning. • Adds `target_partition_size` parameter to control partition sizing during index creation.

LanceDB v0.22.1-beta.2

Thu, 18 Sep 2025 20:22:52 GMT

LanceDB v0.22.1-beta.2 adds `target_partition_size` parameter for index tuning. • Adds `target_partition_size` parameter to control partition sizing during index creation.

LanceDB python-v0.25.1-beta.0

Wed, 10 Sep 2025 14:25:24 GMT

LanceDB python-v0.25.1-beta.0 adds mutual TLS (mTLS) support for remote database connections. • Supports mTLS (mutual TLS) authentication for remote database connections.

LanceDB v0.22.1-beta.0

Wed, 10 Sep 2025 14:25:24 GMT

LanceDB v0.22.1-beta.0 adds mutual TLS (mTLS) support for remote database connections. • Adds mTLS (mutual TLS) support for remote database connections, enabling certificate-based client authentication.

LanceDB v0.22.0

Thu, 04 Sep 2025 08:33:59 GMT

LanceDB v0.22.0 adds multi-level namespace support, named indices, and PyTorch `__getitems__` integration. • 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 changes: • 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.

LanceDB python-v0.25.0

Thu, 04 Sep 2025 08:33:56 GMT

LanceDB python-v0.25.0 adds multi-level namespace support, named indices, and PyTorch `__getitems__` integration. • 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 changes: • Multi-level namespace support changes how namespaces are addressed; existing single-level namespace usage may need updates to conform to the new hierarchy model.

LanceDB python-v0.25.0-beta.0

Fri, 29 Aug 2025 21:21:16 GMT

LanceDB python-v0.25.0-beta.0 adds multi-level namespace support, named index creation, and PyTorch batch indexing. • 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 changes: • Multi-level namespace support changes how namespaces are structured; existing single-level namespace setups may require migration.

LanceDB v0.22.0-beta.0

Fri, 29 Aug 2025 21:21:13 GMT

LanceDB v0.22.0-beta.0 adds multi-level namespace support, named index creation, and PyTorch __getitems__ integration. • 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 changes: • Multi-level namespace support changes namespace handling in a breaking way — existing single-level namespace usage may require migration.

LanceDB v0.21.4-beta.0

Tue, 19 Aug 2025 22:57:10 GMT

LanceDB v0.21.4-beta.0 adds `train=False` and `name` parameters for index creation. • Adds `train=False` and `name` parameters when creating indices, enabling untrained index creation and explicit index naming.

LanceDB python-v0.24.4-beta.0

Tue, 19 Aug 2025 22:57:09 GMT

LanceDB python-v0.24.4-beta.0 adds `train=False` and `name` parameters for index creation. • 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.

LanceDB python-v0.24.3

Fri, 15 Aug 2025 18:03:47 GMT

LanceDB v0.24.3 adds SigLIP embeddings, overall remote timeout, smarter vector-column inference, and new low-level row access APIs. • 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.

LanceDB v0.21.3

Fri, 15 Aug 2025 18:03:42 GMT

LanceDB v0.21.3 adds SigLIP embeddings, overall remote timeout, smarter vector column inference, and new Rust APIs. • 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. • Upgrades bundled Lance to v0.33.0.

LanceDB v0.21.2

Fri, 25 Jul 2025 20:33:00 GMT

LanceDB v0.21.2 adds ngram tokenizer, multivector JS support, return-all-scores reranking, and custom Session management. • 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. • Upgrades bundled Lance to v0.32.0.

LanceDB python-v0.24.2

Fri, 25 Jul 2025 20:32:59 GMT

LanceDB python-v0.24.2 adds ngram tokenizer, all-scores reranking, Session support, and multivector for JS SDK. • 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. • Adds multivector support to the JavaScript SDK. • Upgrades underlying Lance version to v0.32.0.

LanceDB v0.21.2-beta.1

Tue, 22 Jul 2025 15:41:33 GMT

LanceDB v0.21.2-beta.1 adds lance-namespace integration for Java, custom Session support for ListingDatabase, and multivector support in the JS SDK. • 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.

LanceDB python-v0.24.2-beta.1

Tue, 22 Jul 2025 15:41:28 GMT

LanceDB python-v0.24.2-beta.1 adds lance-namespace integration for Java, custom Session on ListingDatabase, and multivector support for the JS SDK. • 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.

LanceDB v0.21.2-beta.0

Fri, 18 Jul 2025 16:03:48 GMT

LanceDB v0.21.2-beta.0 adds ngram tokenizer support and full score return from rerankers. • Supports ngram tokenizer for full-text search indexing. • Rerankers can now return all scores, not just the top result.

LanceDB python-v0.24.2-beta.0

Fri, 18 Jul 2025 16:03:46 GMT

LanceDB python-v0.24.2-beta.0 adds ngram tokenizer support and full-score return from rerankers. • Supports `ngram` tokenizer for full-text search indexing. • Rerankers can now return all scores, not just top results.

LanceDB python-v0.24.1

Thu, 10 Jul 2025 21:37:17 GMT

LanceDB python-v0.24.1 adds batched Ollama embeddings and configurable IVF-PQ index parameters. • 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.

LanceDB v0.21.1

Thu, 10 Jul 2025 21:37:16 GMT

LanceDB v0.21.1 adds batched Ollama embedding calls and new `num_partitions`/`num_bits` index parameters. • 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.

LanceDB python-v0.24.1-beta.0

Mon, 07 Jul 2025 21:01:47 GMT

LanceDB python-v0.24.1-beta.0 adds batched Ollama embedding calls and upgrades to lance 0.31.0-beta.1. • 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.

LanceDB v0.21.1-beta.0

Mon, 07 Jul 2025 21:01:45 GMT

LanceDB v0.21.1-beta.0 adds batched Ollama embedding calls and upgrades to lance 0.31.0-beta.1. • 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.

LanceDB python-v0.24.0

Fri, 20 Jun 2025 05:47:24 GMT

LanceDB python-v0.24.0 switches to native lance FTS by default and adds prefix matching, must_not clauses, and nprobes bounds. • 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 changes: • The default full-text search engine is now native lance FTS; setups relying on the previous default FTS backend may behave differently on upgrade.

LanceDB v0.21.0

Fri, 20 Jun 2025 05:47:22 GMT

LanceDB v0.21.0 switches default FTS to native Lance engine and adds prefix matching, must_not clauses, and nprobes bounds • 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 changes: • 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.

LanceDB v0.20.1-beta.0

Mon, 16 Jun 2025 16:30:35 GMT

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. • 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.

LanceDB python-v0.23.1-beta.0

Mon, 16 Jun 2025 16:30:33 GMT

LanceDB python-v0.23.1-beta.0 adds new FTS search capabilities and `maximum`/`minimum` nprobes properties for ANN index tuning. • 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.

LanceDB python-v0.22.1

Thu, 22 May 2025 05:58:51 GMT

LanceDB python-v0.22.1 adds tag management, table stats, merge stats, per-write versioning, and a merge_insert timeout parameter. • 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.

LanceDB v0.19.1

Thu, 22 May 2025 05:58:51 GMT

LanceDB v0.19.1 adds tag management APIs, table stats, merge stats bindings, versioned writes, and a timeout parameter for merge_insert. • 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.

LanceDB v0.19.1-beta.4

Thu, 08 May 2025 20:20:06 GMT

LanceDB v0.19.1-beta.4 adds a timeout parameter to merge_insert operations. • Adds `timeout` parameter to `merge_insert` to cap how long a merge-insert operation may run.

LanceDB python-v0.22.1-beta.4

Thu, 08 May 2025 20:20:03 GMT

LanceDB python-v0.22.1-beta.4 adds a `timeout` parameter to `merge_insert`. • Adds `timeout` parameter to `merge_insert` to control how long the operation waits before failing.

LanceDB v0.19.1-beta.2

Tue, 06 May 2025 00:09:28 GMT

LanceDB v0.19.1-beta.2 adds merge stats from merge operations and version numbers from all write operations. • Returns merge statistics from merge operations via new bindings. • Returns the resulting version number from all write operations.

LanceDB python-v0.22.1-beta.2

Tue, 06 May 2025 00:09:25 GMT

LanceDB python-v0.22.1-beta.2 adds merge stats and version numbers on all write operations. • Returns the resulting dataset version number for all write operations, enabling callers to track dataset lineage after every write.

LanceDB v0.19.1-beta.1

Tue, 29 Apr 2025 22:19:40 GMT

LanceDB v0.19.1-beta.1 adds a table statistics API for inspecting table internals. • Adds a table stats API, enabling programmatic inspection of table-level statistics.

LanceDB python-v0.22.1-beta.1

Tue, 29 Apr 2025 22:19:39 GMT

LanceDB python-v0.22.1-beta.1 adds a table statistics API for inspecting table internals. • Adds a table stats API to expose internal statistics for LanceDB tables.

LanceDB v0.19.1-beta.0

Mon, 28 Apr 2025 17:21:01 GMT

LanceDB v0.19.1-beta.0 adds tag management APIs for listing, creating, deleting, updating, and checking out tags. • Adds list, create, delete, update, and checkout tag API for managing dataset version tags.

LanceDB python-v0.22.1-beta.0

Mon, 28 Apr 2025 17:20:50 GMT

LanceDB python-v0.22.1-beta.0 adds a tag management API for listing, creating, deleting, updating, and checking out tags. • Adds `list`, `create`, `delete`, `update`, and `checkout` tag API methods for managing dataset tags programmatically.

LanceDB v0.19.0

Fri, 25 Apr 2025 21:16:57 GMT

LanceDB v0.19.0 adds explain/analyze plan APIs, ColPali multi-vector embeddings, FTS on string lists, query timeouts, and index prewarming. • 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. • 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.

LanceDB python-v0.22.0

Fri, 25 Apr 2025 21:16:56 GMT

LanceDB python-v0.22.0 adds ColPali/MultiVector embeddings, FTS on string lists, prewarm_index, explain/analyze plan APIs, and query timeouts. • 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. • 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.

LanceDB v0.19.0-beta.9

Mon, 21 Apr 2025 22:50:52 GMT

LanceDB v0.19.0-beta.9 adds ColPali/MultiVector embedding support and a new async indexing wait API. • 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.

LanceDB python-v0.22.0-beta.9

Mon, 21 Apr 2025 22:50:48 GMT

LanceDB python-v0.22.0-beta.9 adds ColPali/MultiVector embedding support and a new async indexing wait API. • 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.

LanceDB v0.19.0-beta.8

Thu, 17 Apr 2025 22:16:31 GMT

LanceDB v0.19.0-beta.8 adds a `prewarm_index` function to load indexes into cache before query time. • Adds `prewarm_index` function to load vector indexes into memory ahead of query time, reducing first-query latency.

LanceDB python-v0.22.0-beta.8

Thu, 17 Apr 2025 22:16:27 GMT

LanceDB python-v0.22.0-beta.8 adds prewarm_index for loading ANN indexes into memory ahead of queries. • Adds `prewarm_index` function to load ANN indexes into memory before query time, reducing cold-start latency.

LanceDB v0.19.0-beta.5

Fri, 04 Apr 2025 21:50:24 GMT

LanceDB v0.19.0-beta.5 adds timeout support to query execution options. • Adds timeout configuration to query execution options, enabling callers to bound how long a query runs before it is cancelled.

LanceDB python-v0.22.0-beta.5

Fri, 04 Apr 2025 21:50:19 GMT

LanceDB python-v0.22.0-beta.5 adds timeout support to query execution options. • Adds `timeout` to query execution options, enabling callers to cap how long a query is allowed to run.

LanceDB v0.19.0-beta.0

Sun, 30 Mar 2025 18:05:03 GMT

LanceDB v0.19.0-beta.0 adds `analyze_plan` API and changes default `read_consistency_interval` to 5 seconds. • Adds `analyze_plan` API for query plan analysis. • Changes default `read_consistency_interval` from its previous value to `5s`. Breaking changes: • 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.

LanceDB python-v0.22.0-beta.0

Sun, 30 Mar 2025 18:05:00 GMT

LanceDB python-v0.22.0-beta.0 adds `analyze_plan` API and changes default `read_consistency_interval` to 5 seconds. • 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 changes: • 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.

LanceDB python-v0.21.3-beta.0

Fri, 28 Mar 2025 16:03:57 GMT

LanceDB python-v0.21.3-beta.0 adds explain-plan and restore remote APIs plus PyArrow schema column support. • 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.

LanceDB v0.18.3-beta.0

Fri, 28 Mar 2025 16:03:57 GMT

LanceDB v0.18.3-beta.0 adds explain-plan and restore remote APIs plus PyArrow schema support for adding columns. • 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.

LanceDB v0.18.2

Wed, 26 Mar 2025 16:28:40 GMT

LanceDB v0.18.2 adds binary vector and IVF_FLAT support in TypeScript, catalog URL connections in Rust, and a fork warning in Python. • 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. • Emits a warning in Python when the process is forked, to help catch unsafe multiprocessing patterns.

LanceDB python-v0.21.2

Wed, 26 Mar 2025 16:28:37 GMT

LanceDB v0.21.2 adds catalog URL connections, binary vector support in TypeScript, and fork warnings for Python. • 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. • Warns when a Python process forks while a LanceDB connection is open, preventing silent data corruption.

LanceDB v0.18.2-beta.1

Wed, 26 Mar 2025 16:25:08 GMT

LanceDB v0.18.2-beta.1 adds a fork-safety warning for Python users. • Adds a warning when the LanceDB Python client detects a forked process, helping practitioners avoid data-corruption or connection issues in multiprocessing workloads.

LanceDB python-v0.21.2-beta.1

Wed, 26 Mar 2025 16:25:05 GMT

LanceDB Python v0.21.2-beta.1 adds a fork-safety warning to catch multiprocessing pitfalls early. • Adds a warning when the LanceDB Python client detects it is running in a forked process, helping surface multiprocessing safety issues at runtime.

LanceDB python-v0.21.2-beta.0

Fri, 21 Mar 2025 20:03:38 GMT

LanceDB python-v0.21.2-beta.0 adds catalog URL connections, binary vector support in TypeScript, and a new `to_query_object` method. • 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.

LanceDB v0.18.2-beta.0

Fri, 21 Mar 2025 20:03:37 GMT

LanceDB v0.18.2-beta.0 adds catalog URL connections, binary vector + IVF_FLAT in TypeScript, and new query/dataset methods. • 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. • Upgrades bundled Lance to v0.25.0-beta.5, bringing upstream engine improvements.

LanceDB python-v0.21.0

Mon, 10 Mar 2025 23:14:00 GMT

LanceDB python-v0.21.0 adds streaming `create_table` input, field metadata editing, and makes pylance an optional dependency. • 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. • Respects DataFusion's configured batch size when LanceDB runs as a DataFusion table provider. Breaking changes: • 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.

LanceDB v0.18.0

Mon, 10 Mar 2025 23:13:53 GMT

LanceDB v0.18.0 adds a Catalog trait, field metadata editing, streaming table creation, and drops the hard pylance dependency. • 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. • 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 changes: • 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.

LanceDB python-v0.21.0-beta.1

Thu, 06 Mar 2025 19:23:29 GMT

LanceDB python-v0.21.0-beta.1 drops the hard pylance dependency and adds field-metadata modification support. • 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.

LanceDB python-v0.21.0-beta.0

Wed, 26 Feb 2025 20:11:28 GMT

LanceDB python-v0.21.0-beta.0 makes table scans unbounded by default, removing the previous query limit. • Table scans are now unbounded by default — queries without an explicit limit will return all matching rows instead of being capped. Breaking changes: • 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.

LanceDB python-v0.20.0

Wed, 26 Feb 2025 18:16:56 GMT

LanceDB python-v0.20.0 adds async search(), multivector on remote tables, and a variable store in the embeddings registry. • 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 changes: • 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.

LanceDB v0.17.0

Wed, 26 Feb 2025 18:16:56 GMT

LanceDB v0.17.0 adds multivector remote table support, async search(), variable store in embeddings registry, and filter pushdown. • 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 changes: • The embeddings registry now includes a variable store; existing code that constructs or extends the registry may require updates to accommodate the new parameter.

LanceDB v0.16.1-beta.3

Thu, 20 Feb 2025 03:38:37 GMT

LanceDB v0.16.1-beta.3 adds multivector search support on remote tables. • 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.

LanceDB python-v0.19.1-beta.3

Thu, 20 Feb 2025 03:38:36 GMT

LanceDB python-v0.19.1-beta.3 adds multivector support on remote tables. • 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.

LanceDB v0.16.0

Fri, 07 Feb 2025 17:34:01 GMT

LanceDB v0.16.0 adds drop_index(), streaming large writes, extra headers in client options, and subschema upserts for Node • 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. • Exposes the `Table` trait in Rust, enabling custom table implementations. • Upgrades Lance to v0.23.0. Breaking changes: • `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.

LanceDB python-v0.19.0

Fri, 07 Feb 2025 17:33:57 GMT

LanceDB python-v0.19.0 adds drop_index(), streaming writes, distance_type() query param, and extra headers in client options. • 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. • Upgrades Lance to v0.23.0, bringing in upstream engine improvements. Breaking changes: • `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.

LanceDB v0.15.1-beta.1

Tue, 28 Jan 2025 22:32:15 GMT

LanceDB v0.15.1-beta.1 adds distance_type() and metric() alias to Python sync query builders • Adds distance_type() parameter to Python sync query builders, plus metric() as an alias, for specifying vector distance metrics at query time.

LanceDB python-v0.18.1-beta.2

Tue, 28 Jan 2025 22:32:13 GMT

LanceDB python-v0.18.1-beta.2 adds distance_type() and metric() alias to sync query builders. • Adds distance_type() parameter to Python sync query builders, plus metric() as an alias, for controlling vector distance calculations inline with query construction.

LanceDB python-v0.18.1-beta.1

Thu, 23 Jan 2025 23:02:12 GMT

LanceDB python-v0.18.1-beta.1 adds a drop_index() method for programmatic index removal. • Adds drop_index() method to tables, enabling programmatic removal of vector indexes.

LanceDB v0.15.1-beta.0

Thu, 23 Jan 2025 23:02:10 GMT

LanceDB v0.15.1-beta.0 adds a drop_index() method and upgrades the Lance storage engine to v0.23.0-beta.2. • 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.

LanceDB v0.15.0

Tue, 14 Jan 2025 01:03:38 GMT

LanceDB v0.15.0 adds hybrid search to Node/Rust SDKs, distance thresholds and ranges, multivector type, and flips default filtering to prefiltering. • 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. • 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 changes: • 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.

LanceDB python-v0.18.0

Tue, 14 Jan 2025 01:03:34 GMT

LanceDB python-v0.18.0 adds distance thresholds, multivector support, hybrid search in Node/Rust, and `to_polars` for async queries. • 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. • 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 changes: • 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.

LanceDB python-v0.18.0-beta.0

Fri, 10 Jan 2025 19:02:25 GMT

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. • 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. • Exposes dataset config, making underlying dataset configuration accessible from the Python API. Breaking changes: • 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.

LanceDB v0.15.0-beta.0

Fri, 10 Jan 2025 19:02:22 GMT

LanceDB v0.15.0-beta.0 adds distance range queries, subschema upserts, reranking on non-hybrid queries, and switches default filtering to prefiltering. • 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. • Exposes dataset config through the LanceDB API. Breaking changes: • 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.

LanceDB v0.14.2-beta.0

Mon, 06 Jan 2025 05:35:19 GMT

LanceDB v0.14.2-beta.0 adds hybrid search to Node and Rust SDKs, IVF_FLAT on remote tables, and vector search distance thresholds. • 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.

LanceDB python-v0.17.2-beta.2

Mon, 06 Jan 2025 05:35:17 GMT

LanceDB python-v0.17.2-beta.2 adds distance threshold filtering for vector search queries. • Supports distance thresholds in vector search, letting queries filter out results beyond a maximum distance from the query vector.

LanceDB python-v0.17.2-beta.0

Wed, 25 Dec 2024 08:29:21 GMT

LanceDB python-v0.17.2-beta.0 adds IVF_FLAT index creation support on remote tables. • 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.

LanceDB v0.14.1

Tue, 24 Dec 2024 20:51:52 GMT

LanceDB v0.14.1 adds hybrid search in async SDK, 4-bit PQ, IVF_FLAT with binary vectors, and FTS options for Node.js. • 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. • 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.

LanceDB python-v0.17.1

Tue, 24 Dec 2024 18:38:50 GMT

LanceDB python-v0.17.1 adds hybrid search in async SDK, 4-bit PQ, IVF_FLAT with binary vectors, and async/sync Table parity. • 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. • 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.

LanceDB python-v0.17.1-beta.5

Fri, 13 Dec 2024 22:38:14 GMT

LanceDB python-v0.17.1-beta.5 brings async-sync feature parity on the Table API. • Adds async-sync feature parity on the `Table` class, enabling all synchronous Table operations to have async equivalents.

LanceDB v0.14.1-beta.5

Fri, 13 Dec 2024 22:38:13 GMT

LanceDB v0.14.1-beta.5 brings async-sync feature parity on the Python Table API. • Adds async-sync feature parity on the Python `Table` class, enabling the same operations across both synchronous and asynchronous usage patterns.

LanceDB python-v0.17.1-beta.4

Fri, 13 Dec 2024 05:34:36 GMT

LanceDB python-v0.17.1-beta.4 adds FTS options support in Node.js and upgrades to lance 0.21.0b3. • Supports full-text search (FTS) options in the Node.js client. • Upgrades the underlying lance engine to version 0.21.0b3.

LanceDB v0.14.1-beta.4

Fri, 13 Dec 2024 05:34:35 GMT

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. • 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.

LanceDB v0.14.1-beta.2

Wed, 11 Dec 2024 17:58:11 GMT

LanceDB v0.14.1-beta.2 adds offset support in the remote client and 4-bit Product Quantization indexing. • 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.

LanceDB python-v0.17.1-beta.2

Wed, 11 Dec 2024 17:58:09 GMT

LanceDB python-v0.17.1-beta.2 adds offset support in the remote client and 4-bit PQ index compression. • 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.

LanceDB v0.14.1-beta.0

Mon, 09 Dec 2024 04:01:58 GMT

LanceDB v0.14.1-beta.0 adds hybrid search to the async Python SDK and Azure account name storage support. • Supports `account_name` as an Azure storage option in synchronous `db.connect` calls. • Adds hybrid search support to the async Python SDK.

LanceDB python-v0.17.1-beta.0

Mon, 09 Dec 2024 04:01:56 GMT

LanceDB python-v0.17.1-beta.0 adds hybrid search in the async SDK and Azure account name storage options for sync connections. • 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.

LanceDB v0.14.0

Fri, 06 Dec 2024 17:13:50 GMT

LanceDB v0.14.0 adds schema evolution APIs, multimodal Voyage embeddings, Azure OpenAI, PyArrow dataset adapter, and FTS options on RemoteTable across all SDKs. • 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. • 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 changes: • 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.

LanceDB python-v0.17.0

Fri, 06 Dec 2024 17:13:45 GMT

LanceDB python-v0.17.0 adds schema evolution APIs, PyArrow dataset adapter, Azure OpenAI SDK, Voyage multimodal embeddings, and remote SDK parity. • 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. • 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 changes: • 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.

LanceDB python-v0.17.0-beta.3

Wed, 04 Dec 2024 01:14:32 GMT

LanceDB python-v0.17.0-beta.3 adds multimodal Voyage embeddings, a PyArrow dataset adapter, and remote DB folder-prefix URI support. • 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.

LanceDB v0.14.0-beta.2

Wed, 04 Dec 2024 01:14:27 GMT

LanceDB v0.14.0-beta.2 adds multimodal Voyage embeddings, a PyArrow dataset adapter, and remote DB URI folder prefixes. • 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.

LanceDB v0.14.0-beta.1

Fri, 29 Nov 2024 22:46:53 GMT

LanceDB v0.14.0-beta.1 adds overwrite/exist_ok modes for remote table creation and remote connection options support. • 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.

LanceDB python-v0.17.0-beta.1

Fri, 29 Nov 2024 18:16:36 GMT

LanceDB python-v0.17.0-beta.1 adds overwrite/exist_ok modes for remote table creation and remote connection options support. • 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.

LanceDB v0.13.1-beta.0

Thu, 21 Nov 2024 21:53:32 GMT

LanceDB v0.13.1-beta.0 adds rustls support, ef search param, list_versions, and checkout APIs across SDKs. • 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.

LanceDB python-v0.16.1-beta.0

Thu, 21 Nov 2024 21:53:30 GMT

LanceDB python-v0.16.1-beta.0 adds `ef` HNSW search param, `list_versions`, `checkout`, and `checkout_latest` across remote SDKs. • 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.

LanceDB v0.13.0

Fri, 15 Nov 2024 20:56:14 GMT

LanceDB v0.13.0 adds fast_search, multi-vector queries, VoyageAI and Amazon Bedrock embeddings, and post-filter on FTS. • 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. • 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 changes: • 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.

LanceDB python-v0.16.0

Fri, 15 Nov 2024 20:18:23 GMT

LanceDB v0.16.0 adds fast_search, multi-vector queries, VoyageAI/Bedrock embeddings, and FTS post-filtering. • 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. • 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 changes: • 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.

LanceDB v0.13.0-beta.2

Thu, 14 Nov 2024 04:42:49 GMT

LanceDB v0.13.0-beta.2 adds VoyageAI embeddings, multi-vector search, sync index optimization, and remote empty query support. • 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 changes: • 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.

LanceDB python-v0.16.0-beta.1

Thu, 14 Nov 2024 04:42:45 GMT

LanceDB python-v0.16.0-beta.1 adds multi-vector search, VoyageAI embeddings, sync index optimization, and remote empty query support. • 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 changes: • Remote empty query behavior has changed: queries against remote tables that previously required a vector or filter may now behave differently on upgrade.

LanceDB v0.13.0-beta.0

Tue, 05 Nov 2024 23:22:01 GMT

LanceDB v0.13.0-beta.0 adds `fast_search`, post-filter on FTS, and `with_row_id` support in Python and Node. • 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.

LanceDB python-v0.16.0-beta.0

Tue, 05 Nov 2024 23:22:00 GMT

LanceDB python-v0.16.0-beta.0 adds `fast_search`, FTS post-filtering, and `with_row_id` support for Python and remote clients. • 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.

LanceDB python-v0.15.0

Tue, 29 Oct 2024 22:16:59 GMT

LanceDB python-v0.15.0 adds fast_search on remote tables, distance type control in hybrid search, and add_embedding on empty tables. • 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 changes: • 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.

LanceDB v0.12.0

Tue, 29 Oct 2024 22:16:58 GMT

LanceDB v0.12.0 adds hybrid search distance types, fast_search on remote tables, and embedding support on empty table creation. • 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 changes: • Upgrades lance to 0.19.1, which may break existing setups dependent on prior lance behavior.

LanceDB v0.11.1-beta.0

Thu, 17 Oct 2024 18:59:27 GMT

LanceDB v0.11.1-beta.0 adds fast_search on Python remote tables and add_embedding support on empty table creation in Rust. • 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.

LanceDB python-v0.14.1-beta.0

Thu, 17 Oct 2024 18:59:23 GMT

LanceDB python-v0.14.1-beta.0 adds fast_search on remote tables and embedding support on empty table creation. • 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.

LanceDB python-v0.14.0

Wed, 09 Oct 2024 18:54:44 GMT

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. • 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. • 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 changes: • 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).

LanceDB v0.11.0

Wed, 09 Oct 2024 18:54:43 GMT

LanceDB v0.11.0 adds full remote SDK support in Rust and Node, fast search, async merge_insert, and hybrid search parity in SaaS. • 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. • 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 changes: • 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.

LanceDB v0.11.0-beta.1

Tue, 24 Sep 2024 16:51:52 GMT

LanceDB v0.11.0-beta.1 adds `with_row_id` to the Rust SDK and `fast_search` for vector queries. • 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 changes: • 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.

LanceDB python-v0.14.0-beta.0

Thu, 19 Sep 2024 17:53:31 GMT

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. • 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 changes: • 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.

LanceDB v0.11.0-beta.0

Thu, 19 Sep 2024 17:53:30 GMT

LanceDB v0.11.0-beta.0 adds Rust remote connection support and upgrades Lance to 0.18.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 changes: • Lance dependency upgraded to 0.18.0; any code relying on Lance 0.17.x behavior may break on upgrade.

LanceDB v0.10.0

Tue, 10 Sep 2024 20:13:04 GMT

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. • 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. • 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 changes: • 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.

LanceDB python-v0.13.0

Tue, 10 Sep 2024 20:13:01 GMT

LanceDB python-v0.13.0 migrates FTS to lance-index, adds bitmap/label-list scalar indexes, AnswerDotAI rerankers, phrase queries, and offset support. • 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. • 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 changes: • 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.

LanceDB python-v0.13.0-beta.1

Fri, 23 Aug 2024 13:56:54 GMT

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. • 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.

LanceDB v0.10.0-beta.1

Fri, 23 Aug 2024 13:56:54 GMT

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. • 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.

LanceDB python-v0.13.0-beta.0

Mon, 12 Aug 2024 19:48:23 GMT

LanceDB python-v0.13.0-beta.0 migrates FTS to lance-index and adds bitmap/label-list scalar index support to the async API. • 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 changes: • Full-text search (FTS) is migrated from tantivy to lance-index; any existing tantivy-based FTS indexes or configurations will break on upgrade.

LanceDB v0.10.0-beta.0

Mon, 12 Aug 2024 19:48:23 GMT

LanceDB v0.10.0-beta.0 migrates FTS to lance-index and adds bitmap/label-list scalar indexes in Python and Node.js • 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 changes: • FTS indexes are migrated from tantivy to lance-index; existing tantivy-backed FTS indexes will not be compatible and must be rebuilt.

LanceDB python-v0.12.0

Wed, 07 Aug 2024 20:56:21 GMT

LanceDB Python v0.12.0 adds WatsonX embeddings, multi-vector reranking, and remote table embedding support. • 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 changes: • Upgrading lance to 0.16 is a breaking change; existing setups depending on the prior lance version may require migration.

LanceDB python-v0.11.0

Fri, 26 Jul 2024 20:19:00 GMT

LanceDB python-v0.11.0 adds reciprocal rank fusion reranking and HuggingFace-compatible transformers in Node.js • 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 changes: • 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.

LanceDB v0.8.0

Fri, 26 Jul 2024 20:18:59 GMT

LanceDB v0.8.0 adds reciprocal rank fusion reranking, HuggingFace-compatible transformers for Node.js, and upgrades Lance to 0.15.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 changes: • The timeout argument in the LanceDB Node.js SDK has been corrected — existing code passing timeout in the old form may break on upgrade.

LanceDB python-v0.10.2

Tue, 23 Jul 2024 13:49:24 GMT

LanceDB python-v0.10.2 adds native HuggingFace sentence-transformers embedding support via Rust. • Adds HuggingFace sentence-transformers as a natively supported embedding provider via the Rust backend.

LanceDB v0.7.2

Tue, 23 Jul 2024 13:49:23 GMT

LanceDB v0.7.2 adds Hugging Face sentence-transformers embedding support for the Rust SDK. • Adds Hugging Face sentence-transformers embedding integration to the Rust SDK.

LanceDB v0.7.1

Wed, 17 Jul 2024 18:20:16 GMT

LanceDB v0.7.1 adds configurable timeout support to the VectorDB Node SDK. • Adds configurable timeout support to the VectorDB Node SDK.

LanceDB python-v0.10.0

Sat, 13 Jul 2024 08:56:24 GMT

LanceDB python-v0.10.0 adds DynamoDB commit store, Jina embeddings/reranking, explain_plan, fast search, and binary field updates. • 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. • Supports `update` operations over binary fields.

LanceDB v0.7.0

Sat, 13 Jul 2024 08:56:22 GMT

LanceDB v0.7.0 adds DynamoDB commit store, Jina embeddings/reranking, new vector index types, and `explain_plan` for query inspection. • 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. • 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.

LanceDB python-v0.9.0

Tue, 25 Jun 2024 00:26:21 GMT

LanceDB python-v0.9.0 adds stemming support, merge insert, index stats, and broad Node.js feature parity. • 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. • 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.

LanceDB v0.6.0

Tue, 25 Jun 2024 00:26:21 GMT

LanceDB v0.6.0 adds Node.js merge insert, stemming support, remote table parity, and index stats to the Node.js SDK. • 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. • 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.

LanceDB v0.5.2

Wed, 05 Jun 2024 13:47:59 GMT

LanceDB v0.5.2 adds OpenAI and new Cohere embedding functions, Node.js table search and Arrow export, and opt-in v2 format support. • 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. • 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.

LanceDB python-v0.8.2

Wed, 05 Jun 2024 13:47:56 GMT

LanceDB v0.8.2 adds new Cohere/Bedrock model support, OpenAI embeddings, Node.js search/Arrow export, and opt-in v2 format. • 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. • 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.

LanceDB python-v0.8.1

Thu, 30 May 2024 01:00:57 GMT

LanceDB python-v0.8.1 adds IVF_HNSW_PQ index support and upgrades the Lance core to v0.11.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.

LanceDB v0.5.1

Thu, 30 May 2024 01:00:57 GMT

LanceDB v0.5.1 adds IVF_HNSW_PQ index support, a JS embedding registry, and a Java table-names API. • 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.

LanceDB python-v0.7.0

Thu, 23 May 2024 16:31:00 GMT

LanceDB python-v0.7.0 adds IVF_HNSW_SQ index support, an async `optimize` function, and Ollama embeddings integration. • 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.

LanceDB v0.5.0

Thu, 23 May 2024 16:30:56 GMT

LanceDB v0.5.0 adds IVF_HNSW_SQ index support, an optimize function for Node.js and async Python, and Ollama embeddings integration. • 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.

LanceDB v0.4.19

Tue, 07 May 2024 19:30:38 GMT

LanceDB v0.4.19 adds Polars DataFrame interop and an embedding registry to the Rust SDK. • 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.

LanceDB v0.4.18

Tue, 30 Apr 2024 19:23:57 GMT

LanceDB v0.4.18 adds rename_table, richer index_stats, and configurable index_cache_size when opening tables. • 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.

LanceDB python-v0.6.11

Sun, 28 Apr 2024 14:07:14 GMT

LanceDB v0.6.11 adds table renaming, richer index stats, and configurable index cache size on table open. • 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.

LanceDB python-v0.6.8

Wed, 10 Apr 2024 17:54:50 GMT

LanceDB v0.6.8 adds `storage_options` for passing auth and config to object stores. • Adds `storage_options` argument to pass authentication and other configurations down to object stores. Breaking changes: • Opening a remote table now checks whether it exists (with caching); setups that relied on opening non-existent remote tables without error will break.

LanceDB v0.4.17

Wed, 10 Apr 2024 17:53:38 GMT

LanceDB v0.4.17 exposes `storage_options` for passing auth and config to object stores. • Adds `storage_options` argument to pass authentication and other configuration directly to object stores. Breaking changes: • 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.

LanceDB python-v0.6.7

Fri, 05 Apr 2024 00:19:44 GMT

LanceDB v0.6.7 adds filterable `count_rows` on the remote API and ships fp16 kernels in Python wheels. • 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.

LanceDB v0.4.16

Fri, 05 Apr 2024 00:16:24 GMT

LanceDB v0.4.16 adds filterable `count_rows` to the remote API and aligns search defaults with the Python SDK. • 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.

LanceDB python-v0.6.6

Mon, 01 Apr 2024 20:08:45 GMT

LanceDB Python SDK gains an async API backed by the Rust SDK, aligning Python with long-term cross-SDK feature parity. • Introduces an async Python API that replaces the pylance backend with the Rust SDK, enabling asynchronous database operations from Python.

LanceDB v0.4.14

Mon, 25 Mar 2024 15:49:08 GMT

LanceDB v0.4.14 adds reranking, async query API, HuggingFace dataset writes, FTS order-by, and Node.js client middleware. • 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. • 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.

LanceDB python-v0.6.5

Thu, 21 Mar 2024 19:57:47 GMT

LanceDB python-v0.6.5 adds async query support, reranking, HuggingFace dataset writing, and a to_batches API • 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. • Introduces `ArrowNative` wrapper struct for adding data already in `RecordBatchReader` form without conversion. • Makes `DistanceType` an independent type, decoupling it from `lance_linalg`.

LanceDB python-v0.6.4

Sat, 16 Mar 2024 20:01:56 GMT

LanceDB python-v0.6.4 expands the async API with index creation, time travel, update, list_indices, and index_stats. • 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. • 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.

LanceDB v0.4.13

Sat, 16 Mar 2024 19:01:11 GMT

LanceDB v0.4.13 expands the async Python API with index creation, time travel, update, list_indices, and index_stats. • 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. • 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.

LanceDB python-v0.6.3

Mon, 11 Mar 2024 22:28:51 GMT

LanceDB Cloud queries now support a configurable timeout parameter. • Adds configurable timeout for LanceDB Cloud queries, allowing callers to control how long a query waits before failing.

LanceDB v0.4.12

Wed, 06 Mar 2024 23:29:06 GMT

LanceDB v0.4.12 adds column management APIs, scalar index creation, remote table support in Rust, and paginated table listing. • 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 changes: • `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.

LanceDB python-v0.6.2

Wed, 06 Mar 2024 16:31:54 GMT

LanceDB v0.6.2 adds async create_table/add, scalar index creation, model_names() for OpenAI embeddings, and API URL override. • 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. • Adds `add` support to the async Python API for non-blocking data ingestion.

LanceDB python-v0.6.1

Thu, 29 Feb 2024 19:58:56 GMT

LanceDB python-v0.6.1 adds initial remote table support for the Rust backend. • Adds initial remote table implementation for the Rust backend, enabling LanceDB's Rust client to interact with remote tables.

LanceDB python-v0.6.0

Thu, 29 Feb 2024 16:38:03 GMT

LanceDB python-v0.6.0 adds column management APIs and an async Python client. • 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 changes: • Vector queries no longer return the vector column when select() is called without explicitly including the vector column.

LanceDB v0.4.11

Fri, 23 Feb 2024 04:14:06 GMT

LanceDB v0.4.11 adds ImageBind embeddings, a batch-request threadpool, and read-consistency control for Node/Rust. • 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 changes: • 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).

LanceDB python-v0.5.7

Thu, 22 Feb 2024 20:10:53 GMT

LanceDB python-v0.5.7 adds ImageBind embedding function support. • Adds ImageBind embedding function support for multimodal vector generation.

LanceDB python-v0.5.6

Tue, 20 Feb 2024 20:48:50 GMT

LanceDB python-v0.5.6 adds an optional threadpool for batch requests. • Adds an optional threadpool for batch requests to improve throughput on concurrent workloads.

LanceDB v0.4.10

Wed, 14 Feb 2024 22:21:58 GMT

LanceDB v0.4.10 makes it easier to create empty tables and makes the vector column optional. • Simplifies creation of empty tables without requiring upfront data. • Makes the vector column optional when creating tables.

LanceDB python-v0.5.5

Tue, 13 Feb 2024 23:51:39 GMT

LanceDB python-v0.5.5 makes the vector column optional and ships hybrid search updates with latency benchmarks. • 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.

LanceDB v0.4.9

Fri, 09 Feb 2024 23:38:59 GMT

LanceDB v0.4.9 adds filterable `count_rows` across all APIs and filter support during merge-insert match conditions. • 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.

LanceDB python-v0.5.4

Fri, 09 Feb 2024 23:36:50 GMT

LanceDB python-v0.5.4 adds new OpenAI embedding functions, read consistency control, filterable row counts, and merge-insert match filtering. • 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.

LanceDB v0.4.8

Fri, 02 Feb 2024 21:58:50 GMT

LanceDB v0.4.8 adds `merge_insert` to the Node.js and Rust APIs for upsert-style table operations. • Adds `merge_insert` to the Node.js and Rust APIs, enabling upsert-style (merge/insert) operations on LanceDB tables.

LanceDB python-v0.5.2

Fri, 02 Feb 2024 21:54:04 GMT

LanceDB python-v0.5.2 adds hybrid search, AWS Bedrock embeddings, merge_insert, and a reworked Node.js SDK via NAPI • 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. • Improves the Rust table query API with updated documentation. • Exposes `cleanup_old_versions` and `compact_files` on the `Table` API.

LanceDB v0.4.6

Fri, 26 Jan 2024 23:03:11 GMT

LanceDB v0.4.6 adds query execution to the Node SDK and `connect`/`connect_with_options` to the Rust SDK. • Adds `connect` and `connect_with_options` functions to the Rust SDK for establishing database connections. • Enables issuing queries via the Node (napi) SDK.

LanceDB v0.4.5

Thu, 25 Jan 2024 21:14:48 GMT

LanceDB v0.4.5 adds Gemini embeddings, Polars integration, exist_ok table creation, and a reworked Node.js SDK via napi. • 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. • 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.

LanceDB v0.4.4

Thu, 25 Jan 2024 20:07:03 GMT

LanceDB v0.4.4 adds Gemini embeddings, Polars integration, exist_ok table creation, and a reworked Node.js SDK via napi. • 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. • 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.

LanceDB python-v0.5.1

Tue, 23 Jan 2024 22:22:51 GMT

LanceDB python-v0.5.1 adds API key env var support, OpenAI SDK v4 embeddings, and Arrow table improvements. • 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.

LanceDB python-v0.5.0

Thu, 18 Jan 2024 02:08:21 GMT

LanceDB v0.5.0 adds Polars DataFrame integration, Gemini embeddings, and an `exist_ok` option for table creation. • 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`.

LanceDB v0.4.3

Thu, 11 Jan 2024 22:02:44 GMT

LanceDB v0.4.3 adds list-of-string vector inputs and table schema access for Node.js • 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.

LanceDB python-v0.4.4

Thu, 11 Jan 2024 21:55:56 GMT

LanceDB python-v0.4.4 adds phrase query support for FTS and a count_rows filter option. • 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.

LanceDB v0.4.2

Sat, 30 Dec 2023 02:58:33 GMT

LanceDB v0.4.2 adds timezone-aware datetime handling in Pydantic schema definitions. • Adds timezone handling for datetime fields in Pydantic models, enabling timezone-aware timestamps to be correctly represented in LanceDB schemas.

LanceDB python-v0.4.3

Sat, 30 Dec 2023 01:05:29 GMT

LanceDB python-v0.4.3 adds batch query support for the remote API. • Adds batch queries for the remote API, enabling multiple vector searches to be submitted in a single call.

LanceDB python-v0.4.2

Fri, 29 Dec 2023 00:40:27 GMT

LanceDB v0.4.2 adds post-filtering for full-text search, list-of-list Pydantic fields, and timezone-aware datetime support. • 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.

LanceDB python-v0.4.1

Tue, 26 Dec 2023 17:05:13 GMT

LanceDB v0.4.1 adds scalar index creation, FTS nested field references, and a pandas flatten option. • 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.

LanceDB v0.4.1

Tue, 26 Dec 2023 17:02:58 GMT

LanceDB v0.4.1 adds Node.js Schema, index creation, scalar indices, and paginated table listing APIs. • 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.

LanceDB v0.4.0

Mon, 18 Dec 2023 17:56:17 GMT

LanceDB v0.4.0 adds GPU index creation, scalar indexes, prefiltering, update queries, Cohere embeddings, and remote table operations. • 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. • 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 changes: • 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.

LanceDB python-v0.4.0

Mon, 18 Dec 2023 17:36:57 GMT

LanceDB v0.4.0 adds GPU indexing, scalar indexes, prefilter support, Cohere embeddings, update queries, and remote table operations. • 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. • 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 changes: • 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.

LanceDB python-v0.3.6

Fri, 15 Dec 2023 18:39:04 GMT

LanceDB v0.3.6 adds nested Pydantic schema support, custom vector column queries, and remote update operations. • 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.

LanceDB v0.3.11

Fri, 15 Dec 2023 18:05:21 GMT

LanceDB v0.3.11 adds custom vector column naming in queries and update support for remote clients. • 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.

LanceDB v0.3.10

Thu, 14 Dec 2023 20:12:18 GMT

LanceDB v0.3.10 adds filter-only table scans and row updates to the Node.js client. • Adds .filter().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.

LanceDB python-v0.3.5

Thu, 14 Dec 2023 19:50:47 GMT

LanceDB Python v0.3.5 promotes update queries out of experimental with a new Python API. • Adds update query support for Python via the new update API, allowing in-place modification of table records without experimental caveats.

LanceDB v0.3.9

Mon, 04 Dec 2023 18:07:15 GMT

LanceDB v0.3.9 exposes `prefilter` in Rust and Node.js clients for pre-query filter application. • 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.

LanceDB python-v0.3.4

Sun, 19 Nov 2023 00:30:30 GMT

LanceDB v0.3.4 adds retry logic for rate-limited embeddings, multi-task Instructor model with quantization, and new remote/SaaS APIs. • 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. • Adds `weak_lru` cache for embedding function models to reduce redundant model loads.

LanceDB v0.3.8

Sun, 19 Nov 2023 00:27:10 GMT

LanceDB v0.3.8 adds SaaS create_index API and exposes index cache size in Python. • 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.

LanceDB v0.3.7

Wed, 15 Nov 2023 02:54:58 GMT

LanceDB v0.3.7 adds exponential backoff for rate-limited embeddings, multi-task Instructor model with quantization, and RemoteTable.version in Python. • 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.

LanceDB v0.3.6

Wed, 01 Nov 2023 21:48:32 GMT

LanceDB v0.3.6 adds prefilter support for ANN index queries. • Adds `prefilter` flag to allow prefiltering with an index during approximate nearest neighbor queries, enabling filtered vector search without a post-filter pass. Breaking changes: • 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.

LanceDB python-v0.3.3

Wed, 01 Nov 2023 21:47:59 GMT

LanceDB v0.3.3 adds optimize/remap index APIs, dataset stats APIs, and prefilter support for indexed queries. • 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 changes: • Table names returned by the API are now sorted (`fix!: sort table names`), which may change ordering assumptions in existing code.

LanceDB v0.3.5

Thu, 26 Oct 2023 22:01:40 GMT

LanceDB v0.3.5 adds checkout, optimize/remap index, and dataset stats APIs. • 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.

LanceDB v0.3.4

Thu, 26 Oct 2023 21:08:55 GMT

LanceDB v0.3.4 adds checkout, optimize index, remap index, and dataset stats APIs for Python and Node. • 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.

LanceDB python-v0.3.2

Tue, 24 Oct 2023 19:25:53 GMT

LanceDB python-v0.3.2 adds remote table deletion, PyArrow date/timestamp type support, and a table checkout method. • 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. • 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).

LanceDB v0.3.3

Thu, 19 Oct 2023 20:07:25 GMT

LanceDB v0.3.3 adds PyArrow date/timestamp type conversion from Pydantic and refactors the Embeddings API. • 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.

LanceDB v0.3.2

Mon, 16 Oct 2023 15:36:02 GMT

LanceDB v0.3.2 adds deletion operations on remote tables for both Python and JavaScript clients. • 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.

LanceDB v0.3.1

Fri, 13 Oct 2023 21:56:52 GMT

LanceDB v0.3.1 adds GPU index creation, Cohere embeddings, mirroring object store, compaction, and new query APIs. • 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. • Adds telemetry, error tracking, CLI, and config manager capabilities.

LanceDB python-v0.3.1

Fri, 13 Oct 2023 21:55:44 GMT

LanceDB v0.3.1 adds GPU index creation, Cohere embeddings, object-store mirroring, table compaction, and new query APIs. • 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.

LanceDB python-v0.2.6

Sun, 01 Oct 2023 17:56:31 GMT

LanceDB adds opt-in pre-filtering via `prefilter=True` on .where(), applying filters before vector search rather than after. • Adds `prefilter=True` parameter to .where() to apply filters BEFORE running KNN vector search, reducing the candidate set before similarity scoring.

LanceDB python-v0.2.5

Tue, 19 Sep 2023 17:18:44 GMT

LanceDB v0.2.5 adds OpenCLIP multi-modal embeddings and a `lancedb.__version__` attribute. • 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`).

LanceDB v0.2.6

Tue, 19 Sep 2023 12:35:18 GMT

LanceDB v0.2.6 adds multi-modal embedding functions and a `lancedb.__version__` attribute. • 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.

LanceDB python-v0.2.4

Fri, 15 Sep 2023 14:44:08 GMT

LanceDB python-v0.2.4 adds pydantic-backed embedding function persistence, temporary table updates, and URI query string propagation to Lance. • 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.

LanceDB v0.2.5

Sun, 10 Sep 2023 03:57:50 GMT

LanceDB v0.2.5 adds schema evolution, temporary updates, and pydantic embedding persistence for local Python tables. • 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. • 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.

LanceDB python-v0.2.2

Thu, 24 Aug 2023 23:20:06 GMT

LanceDB python-v0.2.2 adds schema evolution — new columns without data rewrites, reversible via `LanceTable.restore`. • 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.

LanceDB python-v0.2.1

Thu, 24 Aug 2023 04:28:57 GMT

LanceDB v0.2.1 restores table-restore capability and makes Iterator-based table creation more flexible. • 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.

LanceDB v0.2.3

Tue, 22 Aug 2023 20:39:30 GMT

LanceDB v0.2.3 adds empty-table creation in Node.js, configurable AWS region, and flexible Iterator-based table writes. • 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.

LanceDB v0.2.0

Mon, 14 Aug 2023 16:35:47 GMT

LanceDB v0.2.0 adds drop-table/drop-database support, improved Pydantic integration, and renames the distance result column. • 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 changes: • 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.

LanceDB python-v0.2.0

Sat, 12 Aug 2023 04:56:47 GMT

LanceDB python-v0.2.0 adds iterator-based ingestion, pydantic auto-conversion, drop_database, and renames the distance column. • 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 changes: • 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`.

LanceDB python-v0.1.16

Mon, 31 Jul 2023 18:46:47 GMT

LanceDB v0.1.16 adds a Pydantic ORM layer with `LanceModel` and to_pydantic(), plus `drop_table` if-exists support. • 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(). • Implements `drop table if exists` support. • Makes `pandas` an optional dependency in LanceDB, reducing default install size.

LanceDB v0.1.17

Fri, 21 Jul 2023 22:52:40 GMT

LanceDB v0.1.17 adds Linux ARM build support for the Node.js package. • Adds Linux ARM build for the Node.js package, enabling LanceDB to run on ARM-based Linux hosts.

LanceDB v0.1.15

Wed, 19 Jul 2023 03:06:25 GMT

LanceDB v0.1.15 adds Node.js remote SDK support, host override, and AWS_ENDPOINT passthrough. • 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.

LanceDB python-v0.1.12

Wed, 19 Jul 2023 02:04:05 GMT

LanceDB python-v0.1.12 passes the `AWS_ENDPOINT` environment variable for custom S3-compatible storage endpoints. • Supports the `AWS_ENDPOINT` environment variable to direct LanceDB at custom S3-compatible storage backends (e.g. MinIO, LocalStack).

LanceDB v0.1.14

Mon, 17 Jul 2023 20:29:08 GMT

LanceDB v0.1.14 adds Windows support for the Node.js SDK and exposes table schema and version in the Rust API. • Exposes table schema and version via the Rust SDK (`Table` now surfaces schema and version fields). • Adds Windows support for the Node.js SDK.

LanceDB v0.1.11-python

Mon, 17 Jul 2023 19:50:14 GMT

LanceDB v0.1.11 adds remote table listing, Pydantic-to-Arrow schema conversion, and Iterator[RecordBatch] table creation • 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. • Supports adding records to a remote table via the Python remote API.

LanceDB v0.1.13

Thu, 13 Jul 2023 22:24:57 GMT

LanceDB v0.1.13 adds an options object to the Node.js connect method and splits Node binaries into separate packages. • 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.

LanceDB v0.1.10-python

Mon, 10 Jul 2023 04:58:19 GMT

LanceDB v0.1.10 adds empty table creation and changes the default write mode to error on conflict. • 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 changes: • 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.

LanceDB v0.1.10

Thu, 06 Jul 2023 03:07:49 GMT

LanceDB v0.1.10 adds named vector column targeting, dot product support, IVF PQ config exposure, and WriteMode for Node table creation. • 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. • Makes the object store construction hook public, enabling custom storage backend injection.

LanceDB python-v0.1.9

Mon, 26 Jun 2023 18:28:37 GMT

LanceDB v0.1.9 adds row deletion support and a drop-table API for Node, plus a remote connection client. • 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.

LanceDB v0.1.9

Mon, 26 Jun 2023 18:14:17 GMT

LanceDB v0.1.9 adds record deletion and a Node.js drop-table API • Adds `drop_table` API for Node.js to remove tables from a LanceDB database. • Supports deletion of records from a LanceDB table.

LanceDB v0.1.7

Thu, 15 Jun 2023 23:45:48 GMT

LanceDB v0.1.7 adds Table.countRows() for Node, a remote connection client, and split Node binaries. • 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.

LanceDB v0.1.6

Thu, 15 Jun 2023 16:54:57 GMT

LanceDB v0.1.6 adds a `where` method to the Node.js query builder for SQL-style filtering. • Adds `where` method to the Node.js query builder, enabling SQL-style predicate filtering on vector search queries.

LanceDB python-v0.1.8

Mon, 12 Jun 2023 22:26:27 GMT

LanceDB python-v0.1.8 adds expression escaping, timestamp/date/cast support, and index recreation on existing columns. • 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.

LanceDB v0.1.5-python

Fri, 02 Jun 2023 16:31:07 GMT

LanceDB v0.1.5 adds S3/GCS cloud storage support, drop table, image embeddings, and OpenAI embeddings for Node.js • 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.

LanceDB v0.1.3

Thu, 25 May 2023 23:58:23 GMT

LanceDB v0.1.3 ships a JavaScript/Node.js library with full CRUD, indexing, and basic full-text search for Python. • 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). • Adds Linux support for the JavaScript client native binary. • Adds a TypeScript example demonstrating typed usage of the Node.js library. Breaking changes: • `tantivy-py` is no longer bundled in the Python wheel and must be installed separately to use full-text search.

LanceDB v0.1.2

Fri, 05 May 2023 18:34:12 GMT

LanceDB v0.1.2 adds cloud storage support for S3 and GCS buckets and begins a Rust core implementation. • Adds cloud storage support, enabling LanceDB tables to be stored directly on S3 or GCS buckets. • Introduces a Rust core implementation for improved performance.

LanceDB v0.1.1

Thu, 27 Apr 2023 00:00:43 GMT

LanceDB v0.1.1 adds configurable distance metrics (L2 and Cosine) for ANN vector search. • Distance metric for ANN queries is now configurable, with support for L2 and Cosine distance.

LanceDB v0.1

Thu, 20 Apr 2023 06:27:36 GMT

LanceDB v0.1 adds table versioning methods and an overwrite mode for existing tables. • 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.