LanceDB 中文文档

外观

本页尚未翻译

本页内容仍为英文原文，源自官方文档 embedding/quickstart。中文翻译正在分批进行中。

Embeddings: Quickstart ​

Quickstart guide for generating and working with embeddings.

LanceDB will automatically vectorize the data both at ingestion and query time. All you need to do is specify which model to use. Popular embedding models like OpenAI, HuggingFace, Sentence Transformers, CLIP, and more, are supported.

Step 1: Import Required Libraries ​

First, import the necessary LanceDB components:

python
from lancedb.pydantic import LanceModel, Vector
from lancedb.embeddings import get_registry
typescript
import * as lancedb from "@lancedb/lancedb";
import "@lancedb/lancedb/embedding/transformers";
import { Utf8 } from "apache-arrow";
  • lancedb: The main database connection and operations
  • LanceModel: Pydantic model for defining table schemas
  • Vector: Field type for storing vector embeddings
  • get_registry(): Access to the embedding function registry. It has all the supported as well as custom embedding functions registered by the user
  • TypeScript uses lancedb.embedding.getRegistry() and lancedb.embedding.LanceSchema() for the same registry/schema workflow
  • In TypeScript, import the provider module before calling getRegistry().get(...); the provider import is what registers names such as "huggingface" or "openai"

Step 2: Connect to LanceDB ​

Establish a connection to your LanceDB Embedded directory or Enterprise cluster:

python
# Enter your LanceDB connection URI for LanceDB Embedded or Enterprise here
db = lancedb.connect(...)
typescript
const db = await lancedb.connect("data/sample-lancedb");

Step 3: Initialize the Embedding Function ​

Choose and configure your embedding model:

python
model = get_registry().get("sentence-transformers").create(name="BAAI/bge-small-en-v1.5", )
typescript
const model = (await lancedb.embedding
  .getRegistry()
  .get("huggingface")
  ?.create()) as lancedb.embedding.EmbeddingFunction;

This creates an embedding function from the local embedding registry. The Python snippet uses the sentence-transformers provider with the BGE model; the TypeScript snippet uses the Transformers-backed huggingface provider. You can:

  • Change "sentence-transformers" to other providers like "openai", "cohere", etc.
  • Modify the model name for different embedding models
  • Set device="cuda" for GPU acceleration if available

Step 4: Define Your Schema ​

Create a Pydantic model that defines your table structure:

python
class Words(LanceModel):
    text: str = model.SourceField()  
    vector: Vector(model.ndims()) = model.VectorField()
typescript
const wordsSchema = lancedb.embedding.LanceSchema({
  text: model.sourceField(new Utf8()),
  vector: model.vectorField(),
});
  • SourceField(): This field will be embedded
  • VectorField(): This stores the embeddings
  • model.ndims(): Sets vector dimensions for your model
  • In TypeScript, use model.sourceField(...) and model.vectorField() inside LanceSchema(...)

Step 5: Create Table and Ingest Data ​

Create a table with your schema and add data:

python
table = db.create_table("words", schema=Words)
table.add([
    {"text": "hello world"},
    {"text": "goodbye world"}
])
typescript
const table = await db.createEmptyTable("words", wordsSchema, {
  mode: "overwrite",
});
await table.add([{ text: "hello world" }, { text: "goodbye world" }]);

The table.add() call automatically:

  • Takes the text from each document
  • Generates embeddings using your chosen model
  • Stores both the original text and the vector embeddings

If your input already includes the vector column, automatic embedding only runs when that column is absent or entirely null for the batch. Partially supplied vectors are treated as manual data, so LanceDB preserves them instead of filling only the missing rows.

Step 6: Query with Automatic Embedding ​

Note: On LanceDB Enterprise, the server does not generate embeddings from query text. When the Python SDK connects to Enterprise, table.search("greetings") can still work when the table schema includes embedding metadata, because the client computes the query embedding before sending the vector search. If there is no embedding metadata for that search, search("greetings") in auto mode is treated as FTS instead.

Search your data using natural language queries:

python
query = "greetings"
actual = table.search(query).limit(1).to_pydantic(Words)[0]
print(actual.text)
typescript
const query = "greetings";
const actual = (await table.search(query).limit(1).toArray())[0];
console.log(actual.text);

The search process:

  1. Automatically converts your query text to embeddings
  2. Finds the most similar vectors in your table
  3. Returns the matching documents

Automatic text search depends on the table's embedding metadata. If the client cannot reconstruct an embedding function from that metadata, compute the query embedding yourself and search with the vector directly.