Skip to main content
The LanceDB agent skill gives coding agents a maintained reference for the Python and TypeScript APIs. It also covers portable OSS and Enterprise code, ingestion performance, and branch operations. Install it in your project:
The skill supplements the agent’s training data with current LanceDB instructions. The installer downloads the lancedb skills plugin and makes it available to the agents you select. The installation directory depends on the agent client. Universal agents typically use .agents/skills.
The installer also creates or updates skills-lock.json. This file records where the skill came from, its path in the source repository, and a hash of the installed content.
Commit the lockfile if you want skill updates to go through code review. Before committing a new hash, inspect the changes to SKILL.md and its reference files. The repository history will then show which snapshot each revision used.

​
Get started with the LanceDB agent skill

This tutorial uses the Camelot dataset from the quickstart, with a portrait added for each character. Each LanceDB row contains validated metadata and raw JPEG bytes. Text, images, and any embeddings you add later remain in the same table.

​
1. Download the multimodal dataset

From a new project directory, download the JSON file and portraits:
Each JSON record has this shape:
JSON input may have missing fields, unexpected fields, or values of the wrong type. The LanceDB skill tells the agent to validate each record with strict Pydantic models before writing it. After the agent writes the pipeline, inspect the schema, batching, and write path rather than assuming it followed the skill correctly.

​
2. Prompt your agent to build the pipeline

Install the Python packages used by the example:
If you’re using LanceDB Enterprise, ask the agent to ingest into an Enterprise table, provide the relevant environment variables for connecting to your Enterprise deployment in a local .env file, and point the agent to it.
.env
If you’re using LanceDB OSS, no connection settings are required, as it runs as an embedded retrieval library. A simple prompt like this should work:
Agent prompt
Agents that scan .agents/skills should find the skill automatically. If your agent does not find it automatically, simply ask it to use the lancedb skill in the prompt. That should be enough! The agent will create ingest_multimodal.py, or similar. The following sections inspect the script to verify that it follows the skill’s guidance.

​
Data validation

The skill encourages the agent to validate each record with Pydantic before writing it. The agent should ideally define a schema for the table and a nested schema for the stats field. In this case, our agent correctly defined Character and Stats Pydantic models and validated the JSON before adding it to the table.

​
Batched ingestion

Naively calling table.add() once per row is slow, and is considered an anti-pattern in LanceDB. The skill encourages the agent to collect incoming rows into batches and write them with a single table.add() call. When you use the skill, the agent should produce something like this: The script calls Character.model_validate(...) before adding a record to the batch. If validation fails, that batch is never written. The function yields up to batch_size rows at a time, providing an iterable of batches for the ingestion step, shown next.

​
Table maintenance

For LanceDB OSS, the skill instructs the agent to call table.optimize() after the ingestion loop. This compacts small fragments, cleans up old versions according to the retention policy, and incorporates new data into indexes. If you’re using LanceDB Enterprise, the skill mentions that this step is not needed because LanceDB Enterprise handles maintenance automatically.
This example dataset has only eight rows, so the default batch size writes it in one call. Larger inputs should still avoid single-row write commits.

​
3. Run the OSS pipeline

The table now contains the validated character records and their JPEG bytes. Here are the first three rows: Once your pipeline works, you can run experiments on branches to try new embedding models, parsers, or search settings without touching main.

​
Takeaways

The example in this tutorial was small, but similar ideas apply to other workflows, too. Give the agent the data source, the constraints it must respect, and the artifacts it should return. The skill supplies LanceDB-specific guidance, but it’s the user’s responsibility to ensure the output makes sense for the application.

​
Try the skill with your own dataset

The skills shown in this tutorial should generalize reasonably well to other use cases. If you find any issues, open an issue on GitHub, clearly describing the intended behavior. You can choose OSS or Enterprise based on how the work will run: Start with LanceDB OSS during the early stages of a project when an agent is helping you prototype, explore a dataset, or run small workflows on a subset of the data. The application owns the storage and lifecycle work, so ask the agent to validate inputs, write in batches, and it will include table maintenance operations such as optimize() where appropriate. Choose LanceDB Enterprise when the resulting table becomes shared production infrastructure, and the workload needs distributed capacity, private deployment, or platform-managed operations. The underlying data format and table API stay the same, so the pipeline does not need to be redesigned. The agent instead connects to a remote db:// table and lets the cluster handle maintenance and background work.