# LanceDB

> Source: https://aiwiki.ai/wiki/lancedb
> Updated: 2026-06-25
> Categories: AI Companies, AI Infrastructure, Developer Tools, Information Retrieval, Open Source AI
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution to "AI Wiki (aiwiki.ai)".

## What is LanceDB?

LanceDB is an open-source, developer-friendly [vector database](/wiki/vector_database) and multimodal lakehouse built on the Lance columnar storage format, designed to store [vector embeddings](/wiki/vector_embeddings), images, video, audio, and structured metadata in a single unified table without a separate vector store alongside a data lake.[2] It runs embedded inside the application process (in-process, with no server to manage) as well as in managed cloud and enterprise tiers, and the core library is released under the Apache 2.0 license for Python, TypeScript, Rust, and a REST API.[16] LanceDB was founded in 2022 by Chang She and Lei Xu through Y Combinator's Winter 2022 batch and is headquartered in San Francisco, California; the company (LanceDB Inc.) raised a $30 million Series A in June 2025, reaching roughly $41 million in total funding.[1][2]

The project separates into two related but distinct components: the Lance file format, an open-source columnar container format licensed under Apache 2.0 and maintained independently at the lance-format GitHub organization, and LanceDB itself, the database library and managed service built on top of Lance.[15] As of mid-2026 the LanceDB repository on GitHub had accumulated roughly 10,700 stars and the standalone Lance format repository roughly 6,700 stars,[16][15] while Lance open-source packages had been downloaded more than 20 million times.[1] Production deployments include companies such as Midjourney, Runway, Character.ai, ByteDance, WeRide, Netflix, Uber, World Labs, Harvey, and Airtable.[1]

Chang She frames the company's thesis around a single contrast: "Our motto is Lance for AI and Iceberg for BI."[21] He has argued that legacy analytics formats were never built for model-era data, stating that "Parquet is really terrible for search and retrieval because it requires random access," and that "Parquet is terrible for storing larger data types" such as long text, embeddings, images, and video.[21]

## History

### Founders' backgrounds

Chang She spent the first part of his career as a quantitative analyst at hedge fund AQR Capital Management, then at Barclays Capital.[3] He left finance to co-found DataPad with Wes McKinney, the creator of the pandas Python library.[3] DataPad was a cloud-based business intelligence startup that Cloudera acquired in September 2014.[4] She's connection to McKinney made him one of the original core developers of pandas, the foundational Python data manipulation library.[3]

After the acquisition, She spent roughly four and a half years at Cloudera managing engineering teams working on the Hadoop ecosystem.[3] He then joined Tubi TV as VP of Engineering when Fox acquired Tubi in 2020 for $440 million. At Tubi he led machine learning infrastructure covering recommender systems, ML serving, and A/B testing.[3]

Lei Xu holds a Ph.D. in Computer Science from the University of Nebraska-Lincoln and was a core contributor to HDFS (Hadoop Distributed File System), becoming a committer and member of the Apache Hadoop project management committee. He worked at Cloudera from 2014 to 2018 on the HDFS team, where he met Chang She. After Cloudera he led ML infrastructure at Cruise, the autonomous vehicle company.

### When was LanceDB founded?

She and Xu had the initial idea for what became LanceDB in 2022, according to She's own account.[3] The original motivation was not a vector database at all. Both founders had observed the same pattern independently: projects involving multimodal data, particularly computer vision workloads with images and video, consistently took longer to build, were harder to maintain, and were more difficult to deploy to production than equivalent text or tabular data projects.[3] Their diagnosis was that the problem was not at the application or orchestration layer; it was the underlying data infrastructure.[3]

They built the Lance file format first, a new columnar storage format intended to serve computer vision data pipelines.[3] The team initially wrote the format in C++, the language Parquet is implemented in.[3] During a December 2022 holiday project for an early customer, they partially rewrote the Lance read path in Rust.[3] The results were strong enough that the team rewrote the entire codebase in Rust over the following weeks, completing in roughly three weeks what the C++ version had taken six months to build.[3] Beyond speed, Rust's memory safety eliminated the segmentation faults that had prevented the team from releasing confidently in C++.[3] Reflecting on the early skepticism, She later recalled: "In 2022, we had our first Lance 0.01 release, we were widely seen as a little bit crazy for suggesting that there was a better alternative to Parquet."[21]

When ChatGPT launched in late 2022, the open-source community around Lance quickly began using it for vector search in generative AI applications.[3] The team noticed that it was easier to explain a vector database than a new columnar format, so they separated the vector database functionality into a dedicated repository and shifted their public positioning.[3] The company participated in Y Combinator's Winter 2022 batch.[2]

### How is LanceDB funded?

LanceDB raised a $3 million pre-seed round in its early period, bringing total funding at that stage to $3 million. In May 2024 the company announced an $8 million seed round led by CRV, with additional participation from Y Combinator, Essence VC, and Swift Ventures.[5] That brought total funding to $11 million.[5]

On June 24, 2025, LanceDB closed a $30 million Series A led by Theory Ventures.[1] Participating investors included CRV, Y Combinator, Databricks Ventures, RunwayML, Zero Prime, and Swift.[1] Total funding reached approximately $41 million across three rounds and roughly 10 investors.[1] The round is earmarked for expanding the Multimodal Lakehouse, growing the Lance open-source community, scaling the enterprise platform, and building partnerships with AI labs and research institutions.[1]

| Round | Date | Amount | Lead investor | Cumulative total |
|---|---|---|---|---|
| Pre-seed | Early stage | $3M | (early backers) | $3M |
| Seed | May 2024 | $8M | CRV | $11M |
| Series A | June 24, 2025 | $30M | Theory Ventures | $41M |

At the time of the Series A, Chang She described the company's broader ambition: to establish Lance as the standard data format for multimodal AI, in the way that Parquet became standard for tabular analytics.[1] The Series A blog post framed the founding question directly: "Why is working with embeddings, images, and video still so difficult, when compared to tabular data?"[1]

## What is the Lance file format?

The Lance file format is the open-source columnar container format that LanceDB is built on, described by the project as an "Open Lakehouse Format for Multimodal AI" that lets users "convert from Parquet in 2 lines of code for 100x faster random access, vector index, and data versioning."[15]

### Design goals

Lance was designed to address limitations that Parquet presents for machine learning workloads. Parquet organizes data into row groups, each a self-contained slice of rows compressed and stored together. This structure works well for analytical queries that scan large contiguous ranges of rows, but it performs poorly for random access patterns where a query needs to read a small number of individual rows scattered across the file.

In machine learning training, random access is common: training loops typically shuffle datasets and read mini-batches of non-contiguous samples. Benchmarks from the Lance team showed Lance providing approximately 100 times faster random access than Parquet or Apache Iceberg for these workloads, while preserving competitive full-scan performance for analytical queries.[15] As She put it, "the data is laid out differently, and the access patterns are changed, so that we guarantee both faster scans than Parquet, and we also guarantee really fast random access."[21]

### Columnar structure and fragments

Internally, a Lance dataset stores data in fragments, which are small independent columnar files. Each fragment has its own statistics and min/max zone maps that allow a query engine to skip fragments entirely when they cannot contain relevant rows. Unlike a single Parquet file with multiple row groups, Lance fragments are separate files on disk or object storage, which enables concurrent writes without a central locking mechanism.

A Lance file conceptually acts as a single row group with no fixed size boundary. The Lance v2 format, introduced in 2024, eliminated row groups as a structural unit and replaced them with variable-length pages within columns.[7] Each column's pages can be sized independently based on what is optimal for the storage backend, such as 8 MiB aligned pages for Amazon S3.[7] This solved the traditional "Goldilocks problem" with Parquet row groups, where groups that are too small create excessive metadata overhead and groups that are too large waste I/O when reading partial data.[7]

### Encodings and compression

Lance v2 treats encodings as pluggable extensions rather than built-in components.[7] The format uses Protocol Buffer "any" messages to describe encodings, so new encodings can be added without changing the core reader or writer.[7] This design allows the format to evolve without breaking backward compatibility.[7]

The format supports two broad categories of structural encoding. The first is suitable for dense fixed-width numeric data, including embedding vectors. The second handles variable-length and nested data such as strings, lists, and binary blobs. Lance selects between them automatically based on the column's data type.[7]

Lance v2.2, the subject of a 2026 rollout, achieved storage size reductions exceeding 50% compared to v1 for many workloads, and up to 68 times faster reads for blob columns containing large binary objects such as images and video frames.[22]

### Versioning

Every write to a Lance dataset produces a new version via an append-only transaction log. Each version captures fragment metadata and schema evolution. This gives applications instant dataset rollback, reproducing exact training snapshots, and branching for experimentation without data duplication. The format describes this as "zero-copy versioning" with ACID transactions, time travel, tags, and Git-style branches.[15] The versioning model is conceptually similar to Delta Lake or Apache Iceberg but lighter, because the underlying storage is per-fragment rather than a global log over row groups.

### Compatibility

Lance datasets are built on Apache Arrow's in-memory format, which means any language with an Arrow binding can read Lance data without a dedicated Lance SDK. The lance-format GitHub organization also maintains integration libraries for Apache Spark, making Lance readable from existing Spark-based data pipelines.[15] Additional compatible tools include DuckDB, Pandas, Polars, PyArrow, Ray, Trino, Apache Flink, and PyTorch dataloaders, with catalog integrations for Apache Polaris, Unity Catalog, and Apache Gravitino.[15]

## How is LanceDB deployed?

### Embedded mode

LanceDB's primary deployment model for development and self-hosted production is embedded: the database runs as a library inside the application process, with no separate server process to start or manage.[2] The application reads and writes Lance files directly to local disk or to a cloud object storage bucket such as Amazon S3, Google Cloud Storage, or Azure Blob Storage.

This design makes LanceDB well suited for serverless functions: because there is no persistent server, a Lambda function can open a LanceDB dataset stored in S3, run queries, and terminate without needing to connect to or disconnect from a server.[2] The trade-off is that concurrency control is at the file system level; multiple writers to the same dataset must use external coordination or rely on Lance's optimistic concurrency.

Because the database is file-based, scaling in embedded mode is bounded by what a single host can provide in CPU, memory, and storage I/O. For datasets up to hundreds of millions of vectors on a single host, embedded mode is sufficient for most production RAG and search workloads. A January 2026 LanceDB benchmark reported 1.5 million IOPS on modern NVMe hardware after a scheduler redesign using `io_uring`, noting that "high random-access throughput depends more on reducing CPU overhead and context switching than on single-read latency."[23]

### LanceDB Cloud

LanceDB Cloud is a managed serverless service. It exposes the same API as the embedded library but moves storage and query execution to LanceDB's infrastructure. Because the service is serverless, users pay only for storage consumed and queries executed, with no minimum monthly fee. The service entered public beta in 2025.

LanceDB Cloud targets teams that want managed hosting without operating infrastructure but do not yet need the scale or compliance requirements of the enterprise tier. It is accessible through the same Python, TypeScript, and REST clients used for the embedded library. Second Dinner, the studio behind the card game Marvel Snap, has described using LanceDB Cloud to cut prototyping from months to hours and to automate QA test generation.[24]

### LanceDB Enterprise

LanceDB Enterprise is a distributed cluster designed for production-scale AI workloads at companies handling tens of billions of vectors and petabytes of training data.[9] The architecture separates work across routers, execution nodes, and background workers.[9] A load balancer distributes queries to the least-loaded execution node, so throughput scales roughly linearly as nodes are added.[9]

Enterprise is available in two configurations. The Bring-Your-Own-Cloud template installs the control plane, routers, and nodes inside the customer's own cloud VPC, so data does not leave the customer's account.[9] The managed SaaS option delegates day-to-day operations to LanceDB, including patching, scaling, and around-the-clock monitoring.[9]

Enterprise is available on the AWS Marketplace.[9] Customers include Midjourney, Character.ai, and Runway, each running tens of billions of vectors.[1]

### Storage layer

Because Lance datasets are standard files on object storage, LanceDB does not require a proprietary storage backend. A dataset can be moved between local disk, S3, GCS, and Azure Blob Storage by simply copying the files. This portability distinguishes LanceDB from vector databases that store index structures in a proprietary binary format tied to a specific server. In February 2026, Lance introduced a multi-base (multi-bucket) table layout that lets a single dataset span multiple S3 buckets for parallel reads and writes, developed with Uber to scale distributed datasets without rewriting metadata.[25]

AWS published a reference architecture for searching 3.5 billion 960-dimensional protein embeddings using LanceDB tables stored in S3, processed via AWS Lambda for individual queries and AWS Batch for large-scale queries.[10] Storage for the indexed dataset was 12.9 TB on S3.[10] Individual queries cost fractions of a cent.[10]

## How does vector indexing work in LanceDB?

LanceDB supports several [approximate nearest neighbor](/wiki/approximate_nearest_neighbor) (ANN) index types. All are built on an IVF (Inverted File) partitioning layer that first divides the vector space into clusters, then applies a secondary algorithm within each partition.[8]

### IVF_FLAT

IVF_FLAT stores raw, uncompressed vectors within each IVF partition. Search compares the query vector against partition centroids to find the closest partitions, then does exact comparisons against the raw vectors in those partitions.[8] This provides the highest possible recall at the cost of higher memory usage and slower queries than quantized variants. It is appropriate when accuracy is the primary concern and the dataset fits comfortably in memory.

### IVF_SQ

IVF_SQ uses scalar quantization to compress each vector component to an 8-bit integer, producing approximately four times compression compared to raw float32 vectors.[8] Scalar quantization introduces a small accuracy loss but is faster to decode than product quantization and well-suited to datasets where storage is the primary constraint.

### IVF_PQ

IVF_PQ combines IVF partitioning with product quantization (PQ). PQ divides each vector into sub-vectors and replaces each sub-vector with a code from a learned codebook.[8] This can achieve compression ratios of 16x to 64x compared to raw float32 vectors.[8] IVF_PQ is a good general-purpose choice for high-dimensional vectors up to roughly 256 dimensions, where PQ provides stronger accuracy than more aggressive methods.[8]

### IVF_RQ

IVF_RQ uses RabitQ quantization, which quantizes each vector dimension to approximately one bit.[8] This produces extreme compression at some accuracy cost. IVF_RQ is recommended for filtered search workloads where vector search is combined with metadata predicates, because HNSW-backed indexes can show higher latency variance under filtering.[8]

### IVF_HNSW variants

HNSW (Hierarchical Navigable Small World) is a graph-based index algorithm that provides efficient search through a multi-layer proximity graph. In LanceDB, HNSW is not a standalone index; it operates as a sub-index within IVF partitions.[8] This hybrid approach combines IVF's scalability with HNSW's graph-based search within each partition.

Three HNSW-backed variants are available:

- IVF_HNSW_FLAT uses raw unquantized vectors within each partition's HNSW graph, giving highest recall.[8]
- IVF_HNSW_SQ combines HNSW with scalar quantization, providing strong quality at lower latency.[8]
- IVF_HNSW_PQ combines HNSW with product quantization for larger datasets where compression is needed.[8]

Key HNSW tuning parameters are `m` (number of neighbors per vector in the graph), `ef_construction` (candidates evaluated during graph building), and `ef` (exploration factor at query time, typically 1.5 to 10 times k).[8]

### Binary vectors

For binary vector data, LanceDB supports IVF_FLAT with Hamming distance.[8] Vectors must be packed as uint8 arrays with dimensions divisible by 8.[8] Binary indexes are used in applications such as image fingerprinting and near-duplicate detection.

### Full-text search and hybrid search

Beyond vector indexes, LanceDB includes a native full-text search (FTS) engine using BM25, the same term frequency-inverse document frequency algorithm used by Elasticsearch and OpenSearch.[8] FTS indexes are column-level and must be created explicitly before keyword search is available.[8]

Hybrid search combines vector similarity and BM25 keyword results, then re-ranks them.[8] LanceDB ships three built-in rerankers: LinearCombinationReranker (the default, which blends vector and FTS scores with configurable weights, defaulting to 0.7 for vector and 0.3 for FTS), CohereReranker (using Cohere's Rerank API), and ColBERTReranker (running a ColBERT model locally via Hugging Face).[8] Additional rerankers include a cross-encoder reranker and an experimental OpenAI reranker.[8]

Queries can combine vector search, full-text search, SQL predicates, and geographic filters in a single call, without joining results from separate systems. In 2026, LanceDB shipped a DuckDB extension that, in the project's words, "turns DuckDB into a SQL compute engine over Lance datasets, exposing vector, full-text, and hybrid retrieval as SQL table functions."[23]

## What is the multimodal lakehouse?

LanceDB's positioning as a "multimodal lakehouse" refers to its ability to store raw files (images, video frames, audio, point clouds), structured metadata, and embedding vectors in the same Lance table.[1] A typical Parquet-based data lake would store tabular metadata in Parquet files and keep images as separate files in a bucket, requiring a separate vector index to link embeddings back to the source data.

In Lance, each row can contain scalar columns, vector columns, and blob columns in a single record. The Lance v2.2 format introduced Lance Blob v2, a storage layout optimized for large binary objects that achieves up to 68 times faster reads than the previous approach for blobs exceeding 4 KB.[22] This makes it practical to store full image thumbnails or audio waveforms directly in the Lance table rather than as references to external files.

The multimodal design allows a single query to filter by metadata, search by vector similarity, and retrieve the associated raw file bytes in one operation. Teams building autonomous vehicle datasets, generative AI training pipelines, and content moderation systems have used this capability to avoid building and maintaining pipelines that synchronize multiple storage systems.

The Lance format integrates with Hugging Face Datasets, allowing datasets published on the Hugging Face Hub to be downloaded and manipulated with Lance tooling. Integration with Apache Spark, DuckDB, Ray, and Daft allows Lance tables to participate in large-scale distributed data processing without converting formats.

## How does LanceDB differ from other vector databases?

| Feature | LanceDB | [Pinecone](/wiki/pinecone) | [Weaviate](/wiki/weaviate) | [Qdrant](/wiki/qdrant) | [Milvus](/wiki/milvus) |
|---|---|---|---|---|---|
| Open source | Yes (Apache 2.0) | No | Yes (BSD-3) | Yes (Apache 2.0) | Yes (Apache 2.0) |
| Deployment | Embedded / cloud / enterprise | Managed cloud only | Self-hosted / cloud | Self-hosted / cloud | Self-hosted / cloud |
| Storage backend | Files on disk or object storage | Proprietary | Proprietary | Proprietary | Proprietary |
| Multimodal blobs in same table | Yes | No | Limited | No | No |
| Built-in data versioning | Yes (Lance format) | No | No | No | No |
| Full-text search | Yes (BM25) | No (via metadata only) | Yes | Yes | Yes |
| Hybrid search | Yes | Limited | Yes | Yes | Yes |
| Serverless / embedded | Yes | No | No | No | No |
| Programming language | Rust core | Proprietary | Go | Rust | C++ / Go |
| Max vectors per node (documented) | 100B+ rows per table | N/A (managed) | ~100M practical | Billions | Billions |
| License | Apache 2.0 | Proprietary | BSD-3 | Apache 2.0 | Apache 2.0 |

LanceDB differs from [Pinecone](/wiki/pinecone) primarily in deployment model: Pinecone is a fully managed cloud service with no open-source offering, while LanceDB runs embedded inside the application process and stores data in standard files that the user controls. Teams that cannot send data to a third-party service, or that want to avoid per-query cloud costs at development time, tend to choose LanceDB for that reason.

Compared to [Weaviate](/wiki/weaviate), LanceDB does not include built-in knowledge graph or object relationship features. Weaviate's GraphQL interface and cross-reference linking between objects have no direct equivalent in LanceDB. Weaviate also has a longer production history and larger community. However, Weaviate's resource usage grows quickly above 100 million vectors, while LanceDB's file-based design scales more linearly with data size.

Compared to [Qdrant](/wiki/qdrant), LanceDB has a different performance profile for filtered search. Qdrant's HNSW implementation is mature and shows strong throughput in standard ANN benchmarks. LanceDB's IVF_RQ and IVF_PQ indexes are generally preferred over HNSW variants for heavily filtered workloads. For unfiltered ANN search at moderate scale, Qdrant benchmarks are frequently faster, but LanceDB provides capabilities (multimodal storage, data versioning, full lakehouse integration) that Qdrant does not.

Compared to [Milvus](/wiki/milvus), LanceDB is lighter to operate. Milvus requires etcd, MinIO or S3, a message queue (Kafka or Pulsar), and multiple microservices. LanceDB embedded requires no infrastructure. Milvus targets organizations running hundreds of millions to billions of vectors in distributed clusters, and it has a longer track record at that scale. LanceDB Enterprise is designed for the same scale but was introduced later.

A structural difference underlying all of these comparisons is that LanceDB ships the storage format as a separate open standard rather than an internal index. She summarizes the division of labor as "Lance for AI and Iceberg for BI," positioning Lance as the model-era counterpart to the analytics formats that preceded it.[21]

## Integrations

### LangChain

[LangChain](/wiki/langchain) includes a LanceDB vector store integration, available as `langchain_community.vectorstores.LanceDB`.[18] The integration allows any LangChain retrieval chain to use LanceDB for document storage and similarity search.[18] A LanceDB table is created on the first insert; subsequent inserts append to the existing table.[18]

### LlamaIndex

[LlamaIndex](/wiki/llamaindex) ships a `LancDBVectorStore` integration installed via `llama-index-vector-stores-lancedb`.[19] The store creates or opens a LanceDB dataset and supports the standard LlamaIndex query interface for RAG pipelines.[19]

### Letta (formerly MemGPT)

[Letta](/wiki/letta), the agent memory framework previously known as MemGPT, uses LanceDB as the default archival storage backend.[20] When an agent's context window fills up, MemGPT pages content to archival storage and retrieves it via vector search.[20] LanceDB was chosen as the default because it requires no setup: the archival store is a set of files on disk with no server process.[20] This setup-free experience and the ability to scale from gigabytes to terabytes without infrastructure changes made it the practical default for local MemGPT deployments.[20]

### AnythingLLM

AnythingLLM, an open-source all-in-one local LLM application, uses LanceDB as its default vector database.[11] Because LanceDB is the only embedded vector database with a Node.js SDK, it was selected as the zero-configuration default that works without requiring users to configure an external vector store.[12] All document embeddings stay local to the AnythingLLM installation.[11]

### DuckDB

LanceDB and DuckDB share the Apache Arrow memory layout, so Lance tables can be queried directly from DuckDB using the lance extension. Analytical queries over scalar columns run in DuckDB while vector search runs in LanceDB; the results are joined using Arrow record batches without serialization overhead. The 2026 DuckDB extension exposes vector, full-text, and hybrid retrieval as SQL table functions.[23]

### Hugging Face

The Lance format integrates with Hugging Face Datasets, allowing datasets to be published to and downloaded from the Hugging Face Hub in Lance format. This is used for sharing large multimodal datasets such as image-caption pairs and video clips.

### Other integrations

Additional integrations include Apache Spark (via lance-spark), Ray (via ray-lance), Daft, Polars, Pandas, PyArrow, and PyTorch DataLoaders.

## What is LanceDB used for?

### Retrieval-augmented generation

[Retrieval-augmented generation](/wiki/retrieval_augmented_generation) (RAG) applications store document chunks and their [embeddings](/wiki/embedding) in LanceDB. At query time, the application encodes the user's question, performs a vector similarity search to retrieve the most relevant chunks, and passes them as context to a language model. LanceDB's hybrid search capability, combining BM25 and vector search in one query, improves retrieval quality for terms where keyword matching outperforms semantic similarity, such as proper nouns, version numbers, and technical identifiers.

### AI model training and data curation

Generative AI companies such as Runway and Midjourney use LanceDB's multimodal lakehouse capabilities to manage training datasets.[1] The Lance format's random access speed reduces data loading bottlenecks during training. The built-in versioning allows teams to snapshot a dataset before a training run, roll back if quality degrades, and branch for ablation experiments without duplicating terabytes of data. WeRide used LanceDB to restructure its autonomous driving data pipeline, reducing data mining time from one week to one hour, a 90x improvement in developer productivity.[13]

### Semantic search and recommendation

LanceDB is used in content recommendation pipelines where items (articles, videos, songs, products) are represented as embeddings and recommendations are served by finding nearest neighbors in embedding space. TwelveLabs uses LanceDB to store video embeddings that encode narrative and mood alongside metadata, enabling vector search over video content.

### Agent memory

AI agent frameworks that need persistent memory across sessions store past observations, conversation summaries, and facts in LanceDB. The MemGPT/Letta use case is the canonical example: an agent's long-term memory is stored in LanceDB, and the agent retrieves relevant memories by semantic similarity before generating a response.[20]

### Multimodal search applications

Image and video search applications use LanceDB to store CLIP embeddings alongside the source images or video frames. A query can be a text string or an image; the application encodes the query, searches LanceDB for nearest neighbors, and returns the original media. Fashion search, medical image retrieval, and satellite imagery analysis have been demonstrated with LanceDB.

### Large-scale scientific data

AWS documented using LanceDB to index 3.5 billion protein sequence embeddings for biological research.[10] The architecture stored indexed data in S3 and served queries via Lambda functions, with larger batch queries running on i4i.8xlarge instances.[10] Individual queries for 50,000 nearest neighbors were returned in seconds at a cost of fractions of a cent per query.[10]

## How much does LanceDB cost?

LanceDB has three tiers.

The OSS tier is free. Users download the library and run it against local storage or their own object storage bucket. There are no usage limits and no fees. The OSS library is released under the Apache 2.0 license.[16]

LanceDB Cloud is a serverless managed service with usage-based pricing and no monthly minimum. The Cloud tier entered public beta in 2025. For moderate workloads at roughly 100,000 queries per day, estimated costs are in the $50 to $200 per month range, though exact pricing depends on index size and query complexity.

LanceDB Enterprise is priced by annual contract. It is available on the AWS Marketplace.[9] Pricing requires contacting the sales team. Typical enterprise vector database contracts in this tier range from roughly $2,000 to $10,000 per month depending on data scale, cluster size, and support tier.

## Who uses LanceDB?

Publicly confirmed LanceDB customers include Midjourney (text-to-image model serving and training data management), Runway (generative video model training pipelines), Character.ai (conversational AI serving), ByteDance, WeRide (autonomous driving data), Netflix (media data lake), Uber (distributed multimodal data lake), Airtable, and CodeRabbit.[1] The company also cites Harvey, World Labs, and Uber among its user base.[1]

At the time of the June 2025 Series A announcement, LanceDB reported that enterprise customers were searching over tens of billions of vectors and managing petabytes of training data.[1] Chang She has stated that "a very significant percentage of all the top generative AI companies doing image and video generation are now using Lance format."[26] Revenue reached approximately $2.3 million in 2024, according to public reports, with a 15-person team at the time.[17]

## Is LanceDB open source?

Yes. Both the Lance file format and the LanceDB library are released under the Apache 2.0 license.[15][16] The Lance format is governed in the open under the lance-format (Lance) organization, separate from the company, so the storage standard is not tied to LanceDB Inc.[15] The commercial business is layered on top: LanceDB Cloud and LanceDB Enterprise are paid managed offerings, while the embedded library and the underlying format remain free to use, self-host, and fork. As of mid-2026 the LanceDB repository had roughly 10,700 GitHub stars and the Lance format repository roughly 6,700 stars, with Lance open-source packages downloaded more than 20 million times.[16][15][1]

## Limitations

LanceDB in embedded mode has no built-in multi-tenant access control. All data in a LanceDB dataset is accessible to any process that can read the underlying files. Applications that need row-level or table-level access control must implement it at the application layer or use the enterprise tier, which adds authentication and authorization.

Concurrent writes to the same Lance dataset from multiple processes require care. Lance uses optimistic concurrency: each writer reads the current version, applies changes, and attempts to commit. If two writers commit simultaneously, one will fail and must retry. This is sufficient for most workloads but requires application-level handling for high-concurrency write scenarios.

Real-time index updates are not instantaneous. Creating or modifying a vector index is an explicit operation; newly inserted rows are searchable via a slow linear scan until the index is rebuilt or the index build completes. This contrasts with some competing databases that build indexes incrementally in the background.

Public performance benchmarks comparing LanceDB directly against Qdrant, Weaviate, Milvus, and Pinecone in controlled conditions were not widely available as of mid-2026. Independent ANN benchmarks such as ann-benchmarks.com did not include LanceDB in their standard suite, making objective recall and QPS comparisons at the same parameters difficult.

The enterprise and cloud tiers are newer than equivalent offerings from [Qdrant](/wiki/qdrant) and [Milvus](/wiki/milvus). Organizations that require long production track records at multi-billion vector scale may prefer those alternatives until LanceDB accumulates more publicly documented enterprise deployments.

The LanceDB documentation, while improving, had gaps in architectural diagrams and detailed configuration references as of the early 2025 period. The embedded library's API has changed between versions, creating migration friction for early adopters.

## See also

- [Vector database](/wiki/vector_database)
- [Vector embeddings](/wiki/vector_embeddings)
- [Pinecone](/wiki/pinecone)
- [Weaviate](/wiki/weaviate)
- [Qdrant](/wiki/qdrant)
- [Milvus](/wiki/milvus)
- [Letta](/wiki/letta)
- [LangChain](/wiki/langchain)
- [LlamaIndex](/wiki/llamaindex)
- [Approximate nearest neighbor](/wiki/approximate_nearest_neighbor)
- [Retrieval-augmented generation](/wiki/retrieval_augmented_generation)

## References

1. LanceDB. "LanceDB Raises $30M Series A to Build the Multimodal Lakehouse." lancedb.com/blog/series-a-funding, June 24, 2025.
2. Y Combinator. "LanceDB: Open-source, serverless vectordb for production-scale generative AI." ycombinator.com.
3. Practical AI Podcast, episode 250. "Open source, on-disk vector search with LanceDB featuring Chang She." changelog.com, December 2023.
4. Cloudera. "Cloudera Acquires DataPad Technology Assets and Team." globenewswire.com, October 2014.
5. VentureBeat. "LanceDB raises $11M to build an open-source multimodal AI database for app development." venturebeat.com, May 2024.
6. TechCrunch. "LanceDB, which counts Midjourney as a customer, is building databases for multimodal AI." techcrunch.com, May 2024.
7. LanceDB Blog. "Lance v2: A New Columnar Container Format." blog.lancedb.com.
8. LanceDB Docs. "Vector Indexes." docs.lancedb.com/indexing/vector-index.
9. LanceDB Docs. "LanceDB Enterprise Overview." lancedb.com/docs/enterprise/overview.
10. AWS Architecture Blog. "A scalable, elastic database and search solution for 1B+ vectors built on LanceDB and Amazon S3." aws.amazon.com, 2024.
11. AnythingLLM Docs. "Lance DB Vector Database." docs.anythingllm.com.
12. LanceDB Blog. "AnythingLLM's Competitive Edge: LanceDB for Seamless RAG and Agent Workflows." lancedb.com/blog.
13. LanceDB. "WeRide Case Study." lancedb.com/customers.
14. LanceDB. "Netflix's Media Data Lake and the Rise of the Multimodal Lakehouse." lancedb.com/blog.
15. GitHub. "lance-format/lance." github.com/lance-format/lance.
16. GitHub. "lancedb/lancedb." github.com/lancedb/lancedb.
17. Latka, Nathan. "How LanceDB hit $2.3M revenue with a 15 person team in 2024." getlatka.com.
18. LangChain Docs. "LanceDB integration." python.langchain.com.
19. LlamaIndex Docs. "Lancedb - LlamaIndex." docs.llamaindex.ai.
20. Medium / LanceDB. "MemGPT: OS inspired LLMs that manage their own memory." medium.com/etoai.
21. The Register. "Lance takes aim at Parquet in file format joust" (interview with Chang She). theregister.com, October 14, 2025.
22. LanceDB Blog. "Lance v2.2" / "Lance Blob V2." lancedb.com/blog, 2026.
23. LanceDB. "Lance x DuckDB SQL Retrieval, Uber-Scale Storage, 1.5M IOPS" (January 2026 newsletter). lancedb.com/blog/newsletter-january-2026.
24. LanceDB. "Second Dinner / Marvel Snap LanceDB Cloud case study." lancedb.com/blog.
25. LanceDB. "Rethinking Table File Paths with Uber: Lance's Multi-Base Layout." lancedb.com/blog/rethinking-table-file-paths-lance-multi-base-layout, February 2026.
26. Chang She, public talks and interviews on Lance format adoption among generative AI companies, 2024-2025.