> ## Documentation Index > Fetch the complete documentation index at: https://docs.lancedb.com/llms.txt > Use this file to discover all available pages before exploring further. # Quickstart > Get started with LanceDB in minutes. As described in [the landing page](https://docs.lancedb.com/index.md), LanceDB provides one data layer for curation, feature engineering, search and retrieval, and model training. Whether you are preparing training data, building a RAG or agentic retrieval system, reviewing examples, or adding model-generated features, you'll work with the same underlying table and search primitives. Let's get started in just a few steps! ## 1. Install LanceDB Install LanceDB in your client SDK. ```bash pip icon="terminal" theme={"theme":{"light":"vitesse-light","dark":"catppuccin-mocha"}} pip install lancedb ``` ```bash uv icon="terminal" theme={"theme":{"light":"vitesse-light","dark":"catppuccin-mocha"}} uv add lancedb # Or, in an existing virtual environment: uv pip install lancedb ``` ```bash TypeScript icon=js theme={"theme":{"light":"vitesse-light","dark":"catppuccin-mocha"}} npm install @lancedb/lancedb ``` ```bash Rust icon=Rust theme={"theme":{"light":"vitesse-light","dark":"catppuccin-mocha"}} cargo add lancedb ``` ### Python pre-release builds To pick up the latest features and bug fixes before the next stable release, install a pre-release from LanceDB's Fury index. ```bash pip icon="terminal" theme={"theme":{"light":"vitesse-light","dark":"catppuccin-mocha"}} pip install --pre --extra-index-url https://pypi.fury.io/lancedb/ lancedb ``` ```bash uv icon="terminal" theme={"theme":{"light":"vitesse-light","dark":"catppuccin-mocha"}} uv venv uv pip install --prerelease allow --index https://pypi.fury.io/lancedb/ lancedb # To add to pyproject.toml, use: uv add --prerelease allow --index https://pypi.fury.io/lancedb/ lancedb ``` > [!NOTE] > > Pre-release builds receive the same level of testing as stable releases, but their availability is not guaranteed > for more than 6 months after release. For real-world workloads, we recommend you use the latest stable release > as far as possible. > **Running on older x86\_64 CPUs without AVX2?** > > The default `lancedb` wheel targets `x86-64-haswell` (AVX2 + FMA + F16C). On older x86\_64 CPUs without AVX2 > (Intel Sandy Bridge, Ivy Bridge, Westmere; AMD Bulldozer, Piledriver, Steamroller), `import lancedb` crashes > with `Illegal instruction`. > > Install `lancedb-compat` instead. It exposes the same API (`import lancedb` still works), is built at the > `x86-64-v2` baseline, and uses runtime SIMD dispatch to still leverage AVX2, FMA, or AVX-512 when available: > > ```bash pip icon="terminal" theme={"theme":{"light":"vitesse-light","dark":"catppuccin-mocha"}} > pip install lancedb-compat > ``` > > The two packages share the same `lancedb/` namespace and conflict at install time, so pick one. To switch, > uninstall the other first (`pip uninstall lancedb && pip install lancedb-compat`). ## 2. Connect to a LanceDB database LanceDB supports several URI patterns to connect to a database. * A local filesystem path (when using it as an embedded library) * A `db://...` URI (when using LanceDB Enterprise) * An object storage URI: `s3://...`, `gs://...`, or `az://...` (when connecting directly from the client SDK) ### Connect via local directory path The simplest way to begin is to use LanceDB as an embedded library. Import LanceDB in your client SDK of choice and point to a local directory path. import lancedb uri = "ex\_lancedb" db = lancedb.connect(uri) import lancedb uri = "ex\_lancedb" async\_db = await lancedb.connect\_async(uri) import \* as lancedb from "@lancedb/lancedb"; async function connectExample(uri: string) \{ const db = await lancedb.connect(uri); return db; } use lancedb::connect; async fn connect\_example(uri: \&str) \{ let db = connect(uri).execute().await.unwrap(); let \_ = db; } ### Connect via object storage URIs You can also connect directly to object storage from the client SDK: import lancedb uri = "s3://your-bucket/path" \# You can also use "gs\://your-bucket/path" or "az://your-container/path". db = lancedb.connect(uri) import lancedb uri = "s3://your-bucket/path" \# You can also use "gs\://your-bucket/path" or "az://your-container/path". async\_db = await lancedb.connect\_async(uri) async function connectObjectStorageExample() \{ const uri = "s3://your-bucket/path"; // You can also use "gs\://your-bucket/path" or "az://your-container/path". const db = await lancedb.connect(uri); return db; } let uri = "s3://your-bucket/path"; // You can also use "gs\://your-bucket/path" or "az://your-container/path". For credentials, endpoints, and provider-specific options, see [Configuring storage](https://docs.lancedb.com/storage/configuration.md). ### Connect to LanceDB Enterprise If you're using LanceDB Enterprise, you can connect to the remote database using the `db://` URI along with the API key, region, and cluster endpoint you received from the LanceDB team. Pass the cluster endpoint via `host_override` so the client routes requests to your deployment. import lancedb uri = "db://your-database-uri" api\_key = "your-api-key" region = "us-east-1" host\_override = "https\://your-enterprise-endpoint.com" db = lancedb.connect( uri=uri, api\_key=api\_key, region=region, host\_override=host\_override, ) import \* as lancedb from "@lancedb/lancedb"; const uri = "db://your-database-uri"; const apiKey = "your-api-key"; const region = "us-east-1"; const hostOverride = "https\://your-enterprise-endpoint.com"; const db = await lancedb.connect(uri, \{ apiKey, region, hostOverride, }); use lancedb::connect; let uri = "db://your-database-uri"; let api\_key = "your-api-key"; let region = "us-east-1"; let host\_override = "https\://your-enterprise-endpoint.com"; > [!NOTE] > > `host_override` is the full URL of your cluster endpoint, including the scheme > (`https://`) and a port if your deployment listens on a non-default one > (e.g. `https://your-enterprise-endpoint.com:443`). If you don't have the > endpoint, [contact the LanceDB team](https://www.lancedb.com/contact). To learn more about `RemoteTable` semantics and how Enterprise differs operationally from embedded LanceDB, see the [Enterprise overview](https://docs.lancedb.com/enterprise.md). ## 3. Create a new table Let's create a small table of characters from the kingdom of Camelot. Each row stores source text, metadata, structured fields, and a vector embedding in the same LanceDB table. > [!NOTE] > > The embeddings we use in this example are synthetic and for demonstration purposes only. In a real AI > data workflow, you would generate them from text, images, audio, or video using an embedding model of choice. Each row has source text, metadata, structured fields, and a vector: ```json theme={"theme":{"light":"vitesse-light","dark":"catppuccin-mocha"}} { "id": "2", "name": "Merlin", "role": "Wizard", "description": "Advisor and prophet with deep magical knowledge.", "stats": { "strength": 2, "magic": 5, "leadership": 4, "wisdom": 5 }, "vector": [0.2, 0.9, 0.4, 0.9] } ``` The full raw records are included below: > **View raw character records** > > data = \[ > \{ > "id": "1", > "name": "King Arthur", > "role": "King", > "description": "Leader of Camelot and wielder of Excalibur.", > "stats": \{"strength": 4, "magic": 1, "leadership": 5, "wisdom": 4}, > "vector": \[0.7, 0.1, 0.9, 0.7], > }, > \{ > "id": "2", > "name": "Merlin", > "role": "Wizard", > "description": "Advisor and prophet with deep magical knowledge.", > "stats": \{"strength": 2, "magic": 5, "leadership": 4, "wisdom": 5}, > "vector": \[0.2, 0.9, 0.4, 0.9], > }, > \{ > "id": "3", > "name": "Sir Lancelot", > "role": "Knight", > "description": "Legendary knight known for courage and combat skill.", > "stats": \{"strength": 5, "magic": 1, "leadership": 3, "wisdom": 3}, > "vector": \[0.9, 0.1, 0.5, 0.4], > }, > ] > > const data = \[ > \{ > id: "1", > name: "King Arthur", > role: "King", > description: "Leader of Camelot and wielder of Excalibur.", > stats: \{ strength: 4, magic: 1, leadership: 5, wisdom: 4 }, > vector: \[0.7, 0.1, 0.9, 0.7], > }, > \{ > id: "2", > name: "Merlin", > role: "Wizard", > description: "Advisor and prophet with deep magical knowledge.", > stats: \{ strength: 2, magic: 5, leadership: 4, wisdom: 5 }, > vector: \[0.2, 0.9, 0.4, 0.9], > }, > \{ > id: "3", > name: "Sir Lancelot", > role: "Knight", > description: "Legendary knight known for courage and combat skill.", > stats: \{ strength: 5, magic: 1, leadership: 3, wisdom: 3 }, > vector: \[0.9, 0.1, 0.5, 0.4], > }, > ]; > > // Define structs representing the data schema > \#\[derive(Debug, Clone, Serialize, Deserialize)] > struct Stats \{ > strength: i8, > magic: i8, > leadership: i8, > wisdom: i8, > } > > \#\[derive(Debug, Clone, Serialize, Deserialize)] > struct Character \{ > id: String, > name: String, > role: String, > description: String, > stats: Stats, > vector: \[f32; 4], > } > > fn characters\_schema() -> Arc\ \{ > Arc::new(Schema::new(vec!\[ > Field::new("id", DataType::LargeUtf8, false), > Field::new("name", DataType::LargeUtf8, false), > Field::new("role", DataType::LargeUtf8, false), > Field::new("description", DataType::LargeUtf8, false), > Field::new( > "stats", > DataType::Struct(arrow\_schema::Fields::from(vec!\[ > Arc::new(Field::new("strength", DataType::Int8, false)), > Arc::new(Field::new("magic", DataType::Int8, false)), > Arc::new(Field::new("leadership", DataType::Int8, false)), > Arc::new(Field::new("wisdom", DataType::Int8, false)), > ])), > false, > ), > Field::new( > "vector", > DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float32, true)), 4), > false, > ), > ])) > } > > let data = vec!\[ > Character \{ > id: "1".to\_string(), > name: "King Arthur".to\_string(), > role: "King".to\_string(), > description: "Leader of Camelot and wielder of Excalibur.".to\_string(), > stats: Stats \{ > strength: 4, > magic: 1, > leadership: 5, > wisdom: 4, > }, > vector: \[0.7, 0.1, 0.9, 0.7], > }, > Character \{ > id: "2".to\_string(), > name: "Merlin".to\_string(), > role: "Wizard".to\_string(), > description: "Advisor and prophet with deep magical knowledge.".to\_string(), > stats: Stats \{ > strength: 2, > magic: 5, > leadership: 4, > wisdom: 5, > }, > vector: \[0.2, 0.9, 0.4, 0.9], > }, > Character \{ > id: "3".to\_string(), > name: "Sir Lancelot".to\_string(), > role: "Knight".to\_string(), > description: "Legendary knight known for courage and combat skill.".to\_string(), > stats: Stats \{ > strength: 5, > magic: 1, > leadership: 3, > wisdom: 3, > }, > vector: \[0.9, 0.1, 0.5, 0.4], > }, > ]; You can now create a LanceDB table from those records. The code below creates a LanceDB table with the appropriate schema and ingests the data. table = db.create\_table("characters", data=data, mode="overwrite") async\_table = await async\_db.create\_table( "characters", data=data, mode="overwrite", ) let table = await db.createTable("characters", data, \{ mode: "overwrite" }); let schema = characters\_schema(); let table = db .create\_table("characters", characters\_to\_reader(schema.clone(), \&data)) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); ## 4. Semantic search Search is a useful capability for all kinds of AI data pipelines. Below, we do a vector similarity search for samples similar to a "*wise magical advisor*" (transforming the natural language query to an embedding), and project only the columns needed by the next step. Search (which requires random access) is a ubiquitous access pattern that appears in many workloads: whether you're building a RAG or recommendation system, serving agent memory, or curating a training dataset. \# Search for examples similar to a "wise magical advisor" query\_vector = \[0.2, 0.8, 0.4, 0.9] \# Ensure you run \`pip install polars\` beforehand result = ( table.search(query\_vector) .select(\["name", "role", "description", "\_distance"]) .limit(2) .to\_polars() ) print(result) \# Search for examples similar to a "wise magical advisor" query\_vector = \[0.2, 0.8, 0.4, 0.9] \# Ensure you run \`pip install polars\` beforehand async\_result = await ( await async\_table.search(query\_vector) ).select(\["name", "role", "description", "\_distance"]).limit(2).to\_polars() print(async\_result) // Search for examples similar to a "wise magical advisor" let queryVector = \[0.2, 0.8, 0.4, 0.9]; let result = await table .search(queryVector) .select(\["name", "role", "description", "\_distance"]) .limit(2) .toArray(); console.table(result); // Search for examples similar to a "wise magical advisor" let query\_vector = \[0.2, 0.8, 0.4, 0.9]; let result: DataFrame = table .query() .nearest\_to(\&query\_vector) .unwrap() .select(Select::Columns(vec!\[ "name".to\_string(), "role".to\_string(), "description".to\_string(), "\_distance".to\_string(), ])) .limit(2) .execute() .await .unwrap() .into\_polars() .await .unwrap(); println!("\{result:?}"); The example for Python above shows how to convert results to a Polars DataFrame. Depending on your language, you can collect query results as a list/array of objects or DataFrames to be used downstream in your application. > **Pandas users in Python can get results as a Pandas DataFrame** > > Use the `to_pandas()` method to convert query results into a Pandas DataFrame. > > \# Ensure you run \`pip install pandas\` beforehand > result = table.search(query\_vector).limit(2).to\_pandas() > print(result) ## 5. Curation Searching for relevant results can be more useful when combined with metadata filters. In this tiny example, we filter to examples with high `magic` stats. curated = ( table.search(query\_vector) .where("stats.magic >= 4") .select(\["name", "role", "description", "\_distance"]) .limit(2) .to\_polars() ) print(curated) const curated = await table .search(queryVector) .where("stats.magic >= 4") .select(\["name", "role", "description", "\_distance"]) .limit(2) .toArray(); console.table(curated); let curated: DataFrame = table .query() .nearest\_to(\&query\_vector) .unwrap() .only\_if("stats.magic >= 4") .select(Select::Columns(vec!\[ "name".to\_string(), "role".to\_string(), "description".to\_string(), "\_distance".to\_string(), ])) .limit(2) .execute() .await .unwrap() .into\_polars() .await .unwrap(); println!("\{curated:?}"); When working with large datasets, it's common to use the same pattern to filter on quality labels, train/eval splits, numeric fields, categorical values, timestamp windows, or generated tags and labels. ## 6. Add a derived feature Feature engineering is the process of cleaning up your data and creating new signals that help your model learn, make better predictions, or your agent retrieve more useful information. In the example below, we add a `power_score` column from the structured `stats` fields. Lance supports data evolution, so you can add new columns without rewriting the entire table. table.add\_columns( \{ "power\_score": "cast(((stats.strength + stats.magic + stats.leadership + stats.wisdom) / 4.0) as float)" } ) await table.addColumns(\[ \{ name: "power\_score", valueSql: "cast(((stats.strength + stats.magic + stats.leadership + stats.wisdom) / 4.0) as float)", }, ]); use lancedb::table::NewColumnTransform; table .add\_columns( NewColumnTransform::SqlExpressions(vec!\[( "power\_score".to\_string(), "cast(((stats.strength + stats.magic + stats.leadership + stats.wisdom) / 4.0) as float)" .to\_string(), )]), None, ) .await .unwrap(); Next, you can query a compact view of the new feature: features = table.search().select(\["name", "role", "power\_score"]).to\_polars() print(features) const features = await table .query() .select(\["name", "role", "power\_score"]) .toArray(); console.table(features); let features: DataFrame = table .query() .select(Select::Columns(vec!\[ "name".to\_string(), "role".to\_string(), "power\_score".to\_string(), ])) .execute() .await .unwrap() .into\_polars() .await .unwrap(); println!("\{features:?}"); | name | role | power\_score | | - | - | - | | King Arthur | King | 3.5 | | Merlin | Wizard | 4.0 | | Sir Lancelot | Knight | 3.0 | The same workflow is used for data preparation tasks when adding derived features, cached model signals, review scores, or dataset quality indicators. ## 7. Store multimodal data Multimodal data is a first-class citizen in LanceDB. Binary data (image, audio, video, etc.) is stored as blobs or inline Arrow binary types in a LanceDB column, and they benefit from the same table operations and data versioning semantics as other data types. All the data is governed in the same table, so you can search, filter, and retrieve multimodal records together with structured fields, metadata, and embeddings. In this example, the [`lancedb/magical_kingdom`](https://huggingface.co/datasets/lancedb/magical_kingdom) dataset stores character images, descriptions, structured stats, image embeddings, and text embeddings together. Say we downloaded the image for Sir Lancelot from that dataset locally. You can read the image bytes in your client SDK and store them in a LanceDB column. The image bytes can be used for downstream tasks like retrieval, evaluation, or training. ![Sir Lancelot from the lancedb/magical\_kingdom dataset](https://mintcdn.com/lancedb-bcbb4faf/Uz69s4JF7qGBMsSb/static/assets/images/quickstart/sir-lancelot.jpg?fit=max\&auto=format\&n=Uz69s4JF7qGBMsSb\&q=85\&s=190b2d503dc52d273beaa359627df52f) These snippets load the local image file and store the bytes in an `image` column: from pathlib import Path image\_path = Path("docs/static/assets/images/quickstart/sir-lancelot.jpg") image\_bytes = image\_path.read\_bytes() multimodal\_table = db.create\_table( "character\_images", data=\[ \{ "id": "lancelot", "description": "Portrait of Sir Lancelot", "image": image\_bytes, "vector": \[0.9, 0.1, 0.5, 0.4], } ], mode="overwrite", ) const arrow = await import("apache-arrow"); const path = await import("node:path"); const \{ readFile } = await import("node:fs/promises"); const imagePath = path.resolve( "../../docs/static/assets/images/quickstart/sir-lancelot.jpg", ); const imageBytes = await readFile(imagePath); const imageSchema = new arrow\.Schema(\[ new arrow\.Field("id", new arrow\.Utf8()), new arrow\.Field("description", new arrow\.Utf8()), new arrow\.Field("image", new arrow\.Binary()), new arrow\.Field( "vector", new arrow\.FixedSizeList( 4, new arrow\.Field("item", new arrow\.Float32(), true), ), ), ]); const imageData = lancedb.makeArrowTable( \[ \{ id: "lancelot", description: "Portrait of Sir Lancelot", image: imageBytes, vector: \[0.9, 0.1, 0.5, 0.4], }, ], \{ schema: imageSchema }, ); const multimodalTable = await db.createTable( "character\_images", imageData, \{ mode: "overwrite" }, ); use std::sync::Arc; use arrow\_array::\{ BinaryArray, FixedSizeListArray, LargeStringArray, RecordBatch, RecordBatchIterator, }; use arrow\_schema::\{DataType, Field, Schema}; let image\_path = std::path::Path::new(env!("CARGO\_MANIFEST\_DIR")) .join("../../docs/static/assets/images/quickstart/sir-lancelot.jpg"); let image\_bytes = std::fs::read(image\_path).unwrap(); let image\_schema = Arc::new(Schema::new(vec!\[ Field::new("id", DataType::LargeUtf8, false), Field::new("description", DataType::LargeUtf8, false), Field::new("image", DataType::Binary, false), Field::new( "vector", DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float32, true)), 4), false, ), ])); let image\_vectors = \[\[0.9\_f32, 0.1, 0.5, 0.4]]; let image\_batch = RecordBatch::try\_new( image\_schema.clone(), vec!\[ Arc::new(LargeStringArray::from\_iter\_values(\["lancelot"])), Arc::new(LargeStringArray::from\_iter\_values(\[ "Portrait of Sir Lancelot", ])), Arc::new(BinaryArray::from\_iter\_values(\[image\_bytes.as\_slice()])), Arc::new( FixedSizeListArray::from\_iter\_primitive::\( image\_vectors .iter() .map(|vector| Some(vector.iter().copied().map(Some).collect::\>())), 4, ), ), ], ) .unwrap(); let image\_reader: Box\ = Box::new( RecordBatchIterator::new(vec!\[Ok(image\_batch)].into\_iter(), image\_schema), ); let multimodal\_table = db .create\_table("character\_images", image\_reader) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); For more examples, see the [multimodal data](https://docs.lancedb.com/tables/multimodal.md) section. ## Code See the full code for these examples (including helper functions) in the `quickstart` file for the appropriate client language in the [files provided in the repo](https://github.com/lancedb/docs/tree/main/tests). ## What's next? You've learned how to install LanceDB, connect, create one table for AI data, retrieve related examples, curate with metadata, add a derived feature, and represent multimodal records. These same primitives apply across the AI data lifecycle, from data preparation and feature engineering to retrieval, evaluation, and training. Continue to the table and search guides to build on this example with schema options, appends, updates, versioning, indexing, full-text search, hybrid search, and reranking. > **[Basic table operations](https://docs.lancedb.com/tables.md)** > > Build on this quickstart with table creation, updates, and schema tips. > **[Build a RAG App](https://docs.lancedb.com/tutorials/agents.md)** > > Learn how to build Retrieval-Augmented Generation (RAG) applications using LanceDB. > **[Indexing](https://docs.lancedb.com/indexing.md)** > > Create vector, full-text, and scalar indexes to speed up queries on larger datasets. > **[Data loading and shuffles](https://docs.lancedb.com/training/data-loading.md)** > > Use LanceDB for projected, shuffled, random-access reads in training workflows. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.