@lancedb/lancedb 0.5.1 → 0.5.2

package/dist/arrow.d.ts

@@ -3,6 +3,7 @@ import { Table as ArrowTable, Binary, DataType, FixedSizeBinary, FixedSizeList,
 import { type EmbeddingFunction } from "./embedding/embedding_function";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
 export * from "apache-arrow";
+export type IntoVector = Float32Array | Float64Array | number[];
 export declare function isArrowTable(value: object): value is ArrowTable;
 export declare function isDataType(value: unknown): value is DataType;
 export declare function isNull(value: unknown): value is Null;
@@ -36,6 +37,7 @@ export declare class MakeArrowTableOptions {
     schema?: Schema;
     vectorColumns: Record<string, VectorColumnOptions>;
     embeddings?: EmbeddingFunction<unknown>;
+    embeddingFunction?: EmbeddingFunctionConfig;
     /**
      * If true then string columns will be encoded with dictionary encoding
      *

package/dist/arrow.js

@@ -184,6 +184,7 @@ class MakeArrowTableOptions {
         vector: new VectorColumnOptions(),
     };
     embeddings;
+    embeddingFunction;
     /**
      * If true then string columns will be encoded with dictionary encoding
      *
@@ -299,7 +300,7 @@ function makeArrowTable(data, options, metadata) {
     const opt = new MakeArrowTableOptions(options !== undefined ? options : {});
     if (opt.schema !== undefined && opt.schema !== null) {
         opt.schema = (0, sanitize_1.sanitizeSchema)(opt.schema);
-        opt.schema = validateSchemaEmbeddings(opt.schema, data, opt.embeddings);
+        opt.schema = validateSchemaEmbeddings(opt.schema, data, options?.embeddingFunction);
     }
     const columns = {};
     // TODO: sample dataset to find missing columns

package/dist/connection.d.ts

@@ -40,6 +40,12 @@ export interface CreateTableOptions {
      * The available options are described at https://lancedb.github.io/lancedb/guides/storage/
      */
     storageOptions?: Record<string, string>;
+    /**
+     * If true then data files will be written with the legacy format
+     *
+     * The default is true while the new format is in beta
+     */
+    useLegacyFormat?: boolean;
     schema?: Schema;
     embeddingFunction?: EmbeddingFunctionConfig;
 }

package/dist/connection.js

@@ -116,7 +116,7 @@ class Connection {
             table = (0, arrow_1.makeArrowTable)(data, options);
         }
         const buf = await (0, arrow_1.fromTableToBuffer)(table, options?.embeddingFunction, options?.schema);
-        const innerTable = await this.inner.createTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions));
+        const innerTable = await this.inner.createTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions), options?.useLegacyFormat);
         return new table_1.Table(innerTable);
     }
     /**
@@ -138,7 +138,7 @@ class Connection {
         }
         const table = (0, arrow_1.makeEmptyTable)(schema, metadata);
         const buf = await (0, arrow_1.fromTableToBuffer)(table);
-        const innerTable = await this.inner.createEmptyTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions));
+        const innerTable = await this.inner.createEmptyTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions), options?.useLegacyFormat);
         return new table_1.Table(innerTable);
     }
     /**

package/dist/embedding/embedding_function.d.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { DataType, Float } from "../arrow";
+import { DataType, Float, type IntoVector } from "../arrow";
 /**
  * Options for a given embedding function
  */
@@ -51,7 +51,7 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
      *
      * @see {@link lancedb.LanceSchema}
      */
-    vectorField(options?: Partial<FieldOptions>): [DataType, Map<string, EmbeddingFunction>];
+    vectorField(optionsOrDatatype?: Partial<FieldOptions> | DataType): [DataType, Map<string, EmbeddingFunction>];
     /** The number of dimensions of the embeddings */
     ndims(): number | undefined;
     /** The datatype of the embeddings */
@@ -63,7 +63,7 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
     /**
     Compute the embeddings for a single query
    */
-    computeQueryEmbeddings(data: T): Promise<number[] | Float32Array | Float64Array>;
+    computeQueryEmbeddings(data: T): Promise<IntoVector>;
 }
 export interface FieldOptions<T extends DataType = DataType> {
     datatype: T;

package/dist/embedding/embedding_function.js

@@ -47,32 +47,50 @@ class EmbeddingFunction {
      *
      * @see {@link lancedb.LanceSchema}
      */
-    vectorField(options) {
+    vectorField(optionsOrDatatype) {
         let dtype;
-        const dims = this.ndims() ?? options?.dims;
-        if (!options?.datatype) {
-            if (dims === undefined) {
-                throw new Error("ndims is required for vector field");
-            }
-            dtype = new arrow_1.FixedSizeList(dims, new arrow_1.Field("item", new arrow_1.Float32(), true));
+        let vectorType;
+        let dims = this.ndims();
+        // `func.vectorField(new Float32())`
+        if ((0, arrow_1.isDataType)(optionsOrDatatype)) {
+            dtype = optionsOrDatatype;
         }
         else {
-            if ((0, arrow_1.isFixedSizeList)(options.datatype)) {
-                dtype = options.datatype;
+            // `func.vectorField({
+            //  datatype: new Float32(),
+            //  dims: 10
+            // })`
+            dims = dims ?? optionsOrDatatype?.dims;
+            dtype = optionsOrDatatype?.datatype;
+        }
+        if (dtype !== undefined) {
+            // `func.vectorField(new FixedSizeList(dims, new Field("item", new Float32(), true)))`
+            // or `func.vectorField({datatype: new FixedSizeList(dims, new Field("item", new Float32(), true))})`
+            if ((0, arrow_1.isFixedSizeList)(dtype)) {
+                vectorType = dtype;
+                // `func.vectorField(new Float32())`
+                // or `func.vectorField({datatype: new Float32()})`
             }
-            else if ((0, arrow_1.isFloat)(options.datatype)) {
+            else if ((0, arrow_1.isFloat)(dtype)) {
+                // No `ndims` impl and no `{dims: n}` provided;
                 if (dims === undefined) {
                     throw new Error("ndims is required for vector field");
                 }
-                dtype = (0, arrow_1.newVectorType)(dims, options.datatype);
+                vectorType = (0, arrow_1.newVectorType)(dims, dtype);
             }
             else {
                 throw new Error("Expected FixedSizeList or Float as datatype for vector field");
             }
         }
+        else {
+            if (dims === undefined) {
+                throw new Error("ndims is required for vector field");
+            }
+            vectorType = new arrow_1.FixedSizeList(dims, new arrow_1.Field("item", new arrow_1.Float32(), true));
+        }
         const metadata = new Map();
         metadata.set("vector_column_for", this);
-        return [dtype, metadata];
+        return [vectorType, metadata];
     }
     /** The number of dimensions of the embeddings */
     ndims() {

package/dist/embedding/registry.d.ts

@@ -21,6 +21,7 @@ export declare class EmbeddingFunctionRegistry {
      * Register an embedding function
      * @param name The name of the function
      * @param func The function to register
+     * @throws Error if the function is already registered
      */
     register<T extends EmbeddingFunctionFactory = EmbeddingFunctionFactory>(this: EmbeddingFunctionRegistry, alias?: string): (ctor: T) => any;
     /**
@@ -32,6 +33,9 @@ export declare class EmbeddingFunctionRegistry {
      * reset the registry to the initial state
      */
     reset(this: EmbeddingFunctionRegistry): void;
+    /**
+     * @ignore
+     */
     parseFunctions(this: EmbeddingFunctionRegistry, metadata: Map<string, string>): Map<string, EmbeddingFunctionConfig>;
     functionToMetadata(conf: EmbeddingFunctionConfig): Record<string, any>;
     getTableMetadata(functions: EmbeddingFunctionConfig[]): Map<string, string>;

package/dist/embedding/registry.js

@@ -27,6 +27,7 @@ class EmbeddingFunctionRegistry {
      * Register an embedding function
      * @param name The name of the function
      * @param func The function to register
+     * @throws Error if the function is already registered
      */
     register(alias) {
         const self = this;
@@ -63,6 +64,9 @@ class EmbeddingFunctionRegistry {
     reset() {
         this.#functions.clear();
     }
+    /**
+     * @ignore
+     */
     parseFunctions(metadata) {
         if (!metadata.has("embedding_functions")) {
             return new Map();

package/dist/native.d.ts

@@ -102,6 +102,7 @@ export const enum WriteMode {
 }
 /** Write options when creating a Table. */
 export interface WriteOptions {
+  /** Write mode for writing to a table. */
   mode?: WriteMode
 }
 export interface OpenTableOptions {
@@ -123,8 +124,8 @@ export class Connection {
    * - buf: The buffer containing the IPC file.
    *
    */
-  createTable(name: string, buf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
-  createEmptyTable(name: string, schemaBuf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null): Promise<Table>
+  createTable(name: string, buf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null, useLegacyFormat?: boolean | undefined | null): Promise<Table>
+  createEmptyTable(name: string, schemaBuf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null, useLegacyFormat?: boolean | undefined | null): Promise<Table>
   openTable(name: string, storageOptions?: Record<string, string> | undefined | null, indexCacheSize?: number | undefined | null): Promise<Table>
   /** Drop table with the name. Or raise an error if the table does not exist. */
   dropTable(name: string): Promise<void>
@@ -142,7 +143,7 @@ export class Query {
   select(columns: Array<[string, string]>): void
   limit(limit: number): void
   nearestTo(vector: Float32Array): VectorQuery
-  execute(): Promise<RecordBatchIterator>
+  execute(maxBatchLength?: number | undefined | null): Promise<RecordBatchIterator>
 }
 export class VectorQuery {
   column(column: string): void
@@ -154,7 +155,7 @@ export class VectorQuery {
   onlyIf(predicate: string): void
   select(columns: Array<[string, string]>): void
   limit(limit: number): void
-  execute(): Promise<RecordBatchIterator>
+  execute(maxBatchLength?: number | undefined | null): Promise<RecordBatchIterator>
 }
 export class Table {
   display(): string

package/dist/query.d.ts

@@ -1,4 +1,4 @@
-import { Table as ArrowTable, RecordBatch } from "./arrow";
+import { Table as ArrowTable, type IntoVector, RecordBatch } from "./arrow";
 import { RecordBatchIterator as NativeBatchIterator, Query as NativeQuery, Table as NativeTable, VectorQuery as NativeVectorQuery } from "./native";
 export declare class RecordBatchIterator implements AsyncIterator<RecordBatch> {
     private promisedInner?;
@@ -6,6 +6,18 @@ export declare class RecordBatchIterator implements AsyncIterator<RecordBatch> {
     constructor(promise?: Promise<NativeBatchIterator>);
     next(): Promise<IteratorResult<RecordBatch<any>>>;
 }
+/**
+ * Options that control the behavior of a particular query execution
+ */
+export interface QueryExecutionOptions {
+    /**
+     * The maximum number of rows to return in a single batch
+     *
+     * Batches may have fewer rows if the underlying data is stored
+     * in smaller chunks.
+     */
+    maxBatchLength?: number;
+}
 /** Common methods supported by all query types */
 export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVectorQuery, QueryType> implements AsyncIterable<RecordBatch> {
     protected inner: NativeQueryType;
@@ -53,7 +65,7 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
      * uses `Object.entries` which should preserve the insertion order of the object.  However,
      * object insertion order is easy to get wrong and `Map` is more foolproof.
      */
-    select(columns: string[] | Map<string, string> | Record<string, string>): QueryType;
+    select(columns: string[] | Map<string, string> | Record<string, string> | string): QueryType;
     /**
      * Set the maximum number of results to return.
      *
@@ -61,7 +73,7 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
      * called then every valid row from the table will be returned.
      */
     limit(limit: number): QueryType;
-    protected nativeExecute(): Promise<NativeBatchIterator>;
+    protected nativeExecute(options?: Partial<QueryExecutionOptions>): Promise<NativeBatchIterator>;
     /**
      * Execute the query and return the results as an @see {@link AsyncIterator}
      * of @see {@link RecordBatch}.
@@ -73,12 +85,12 @@ export declare class QueryBase<NativeQueryType extends NativeQuery | NativeVecto
      * single query)
      *
      */
-    protected execute(): RecordBatchIterator;
+    protected execute(options?: Partial<QueryExecutionOptions>): RecordBatchIterator;
     [Symbol.asyncIterator](): AsyncIterator<RecordBatch<any>>;
     /** Collect the results as an Arrow @see {@link ArrowTable}. */
-    toArrow(): Promise<ArrowTable>;
+    toArrow(options?: Partial<QueryExecutionOptions>): Promise<ArrowTable>;
     /** Collect the results as an array of objects. */
-    toArray(): Promise<unknown[]>;
+    toArray(options?: Partial<QueryExecutionOptions>): Promise<any[]>;
 }
 /**
  * An interface for a query that can be executed
@@ -244,5 +256,5 @@ export declare class Query extends QueryBase<NativeQuery, Query> {
      * Vector searches always have a `limit`.  If `limit` has not been called then
      * a default `limit` of 10 will be used.  @see {@link Query#limit}
      */
-    nearestTo(vector: unknown): VectorQuery;
+    nearestTo(vector: IntoVector): VectorQuery;
 }

package/dist/query.js

@@ -43,6 +43,18 @@ class RecordBatchIterator {
 }
 exports.RecordBatchIterator = RecordBatchIterator;
 /* eslint-enable */
+class RecordBatchIterable {
+    inner;
+    options;
+    constructor(inner, options) {
+        this.inner = inner;
+        this.options = options;
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: skip
+    [Symbol.asyncIterator]() {
+        return new RecordBatchIterator(this.inner.execute(this.options?.maxBatchLength));
+    }
+}
 /** Common methods supported by all query types */
 class QueryBase {
     inner;
@@ -98,6 +110,9 @@ class QueryBase {
      */
     select(columns) {
         let columnTuples;
+        if (typeof columns === "string") {
+            columns = [columns];
+        }
         if (Array.isArray(columns)) {
             columnTuples = columns.map((c) => [c, c]);
         }
@@ -120,8 +135,8 @@ class QueryBase {
         this.inner.limit(limit);
         return this;
     }
-    nativeExecute() {
-        return this.inner.execute();
+    nativeExecute(options) {
+        return this.inner.execute(options?.maxBatchLength);
     }
     /**
      * Execute the query and return the results as an @see {@link AsyncIterator}
@@ -134,8 +149,8 @@ class QueryBase {
      * single query)
      *
      */
-    execute() {
-        return new RecordBatchIterator(this.nativeExecute());
+    execute(options) {
+        return new RecordBatchIterator(this.nativeExecute(options));
     }
     // biome-ignore lint/suspicious/noExplicitAny: skip
     [Symbol.asyncIterator]() {
@@ -143,17 +158,17 @@ class QueryBase {
         return new RecordBatchIterator(promise);
     }
     /** Collect the results as an Arrow @see {@link ArrowTable}. */
-    async toArrow() {
+    async toArrow(options) {
         const batches = [];
-        for await (const batch of this) {
+        for await (const batch of new RecordBatchIterable(this.inner, options)) {
             batches.push(batch);
         }
         return new arrow_1.Table(batches);
     }
     /** Collect the results as an array of objects. */
-    async toArray() {
-        const tbl = await this.toArrow();
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    // biome-ignore lint/suspicious/noExplicitAny: arrow.toArrow() returns any[]
+    async toArray(options) {
+        const tbl = await this.toArrow(options);
         return tbl.toArray();
     }
 }
@@ -339,7 +354,6 @@ class Query extends QueryBase {
      * a default `limit` of 10 will be used.  @see {@link Query#limit}
      */
     nearestTo(vector) {
-        // biome-ignore lint/suspicious/noExplicitAny: skip
         const vectorQuery = this.inner.nearestTo(Float32Array.from(vector));
         return new VectorQuery(vectorQuery);
     }

package/dist/table.d.ts

@@ -1,4 +1,4 @@
-import { Data, Schema } from "./arrow";
+import { Table as ArrowTable, Data, IntoVector, Schema } from "./arrow";
 import { IndexOptions } from "./indices";
 import { AddColumnsSql, ColumnAlteration, IndexConfig, OptimizeStats, Table as _NativeTable } from "./native";
 import { Query, VectorQuery } from "./query";
@@ -56,6 +56,7 @@ export interface OptimizeOptions {
  * collected.
  */
 export declare class Table {
+    #private;
     private readonly inner;
     /** Construct a Table. Internal use only. */
     constructor(inner: _NativeTable);
@@ -186,6 +187,19 @@ export declare class Table {
      * @returns {Query} A builder that can be used to parameterize the query
      */
     query(): Query;
+    /**
+     * Create a search query to find the nearest neighbors
+     * of the given query vector
+     * @param {string} query - the query. This will be converted to a vector using the table's provided embedding function
+     * @rejects {Error} If no embedding functions are defined in the table
+     */
+    search(query: string): Promise<VectorQuery>;
+    /**
+     * Create a search query to find the nearest neighbors
+     * of the given query vector
+     * @param {IntoVector} query - the query vector
+     */
+    search(query: IntoVector): VectorQuery;
     /**
      * Search the table with a given query vector.
      *
@@ -193,7 +207,7 @@ export declare class Table {
      * is the same thing as calling `nearestTo` on the builder returned
      * by `query`.  @see {@link Query#nearestTo} for more details.
      */
-    vectorSearch(vector: unknown): VectorQuery;
+    vectorSearch(vector: IntoVector): VectorQuery;
     /**
      * Add new columns with defined values.
      * @param {AddColumnsSql[]} newColumnTransforms pairs of column names and
@@ -301,4 +315,6 @@ export declare class Table {
     optimize(options?: Partial<OptimizeOptions>): Promise<OptimizeStats>;
     /** List all indices that have been created with {@link Table.createIndex} */
     listIndices(): Promise<IndexConfig[]>;
+    /** Return the table as an arrow table */
+    toArrow(): Promise<ArrowTable>;
 }

package/dist/table.js

@@ -53,6 +53,11 @@ class Table {
     display() {
         return this.inner.display();
     }
+    async #getEmbeddingFunctions() {
+        const schema = await this.schema();
+        const registry = (0, registry_1.getRegistry)();
+        return registry.parseFunctions(schema.metadata);
+    }
     /** Get the schema of the table. */
     async schema() {
         const schemaBuf = await this.inner.schema();
@@ -68,7 +73,7 @@ class Table {
         const schema = await this.schema();
         const registry = (0, registry_1.getRegistry)();
         const functions = registry.parseFunctions(schema.metadata);
-        const buffer = await (0, arrow_1.fromDataToBuffer)(data, functions.values().next().value);
+        const buffer = await (0, arrow_1.fromDataToBuffer)(data, functions.values().next().value, schema);
         await this.inner.add(buffer, mode);
     }
     /**
@@ -200,6 +205,24 @@ class Table {
     query() {
         return new query_1.Query(this.inner);
     }
+    search(query) {
+        if (typeof query !== "string") {
+            return this.vectorSearch(query);
+        }
+        else {
+            return this.#getEmbeddingFunctions().then(async (functions) => {
+                // TODO: Support multiple embedding functions
+                const embeddingFunc = functions
+                    .values()
+                    .next().value;
+                if (!embeddingFunc) {
+                    return Promise.reject(new Error("No embedding functions are defined in the table"));
+                }
+                const embeddings = await embeddingFunc.function.computeQueryEmbeddings(query);
+                return this.query().nearestTo(embeddings);
+            });
+        }
+    }
     /**
      * Search the table with a given query vector.
      *
@@ -342,5 +365,9 @@ class Table {
     async listIndices() {
         return await this.inner.listIndices();
     }
+    /** Return the table as an arrow table */
+    async toArrow() {
+        return await this.query().toArrow();
+    }
 }
 exports.Table = Table;

package/lancedb/arrow.ts

@@ -31,7 +31,7 @@ import {
   Schema,
   Struct,
   Utf8,
-  type Vector,
+  Vector,
   makeBuilder,
   makeData,
   type makeTable,
@@ -42,6 +42,8 @@ import { EmbeddingFunctionConfig, getRegistry } from "./embedding/registry";
 import { sanitizeField, sanitizeSchema, sanitizeType } from "./sanitize";
 export * from "apache-arrow";
 
+export type IntoVector = Float32Array | Float64Array | number[];
+
 export function isArrowTable(value: object): value is ArrowTable {
   if (value instanceof ArrowTable) return true;
   return "schema" in value && "batches" in value;
@@ -182,6 +184,7 @@ export class MakeArrowTableOptions {
     vector: new VectorColumnOptions(),
   };
   embeddings?: EmbeddingFunction<unknown>;
+  embeddingFunction?: EmbeddingFunctionConfig;
 
   /**
    * If true then string columns will be encoded with dictionary encoding
@@ -306,7 +309,11 @@ export function makeArrowTable(
   const opt = new MakeArrowTableOptions(options !== undefined ? options : {});
   if (opt.schema !== undefined && opt.schema !== null) {
     opt.schema = sanitizeSchema(opt.schema);
-    opt.schema = validateSchemaEmbeddings(opt.schema, data, opt.embeddings);
+    opt.schema = validateSchemaEmbeddings(
+      opt.schema,
+      data,
+      options?.embeddingFunction,
+    );
   }
   const columns: Record<string, Vector> = {};
   // TODO: sample dataset to find missing columns
@@ -545,7 +552,6 @@ async function applyEmbeddingsFromMetadata(
           dtype,
       );
     }
-
     const vector = makeVector(vectors, destType);
     columns[destColumn] = vector;
   }
@@ -835,7 +841,7 @@ export function createEmptyTable(schema: Schema): ArrowTable {
 function validateSchemaEmbeddings(
   schema: Schema,
   data: Array<Record<string, unknown>>,
-  embeddings: EmbeddingFunction<unknown> | undefined,
+  embeddings: EmbeddingFunctionConfig | undefined,
 ) {
   const fields = [];
   const missingEmbeddingFields = [];

package/lancedb/connection.ts

@@ -71,6 +71,12 @@ export interface CreateTableOptions {
    * The available options are described at https://lancedb.github.io/lancedb/guides/storage/
    */
   storageOptions?: Record<string, string>;
+  /**
+   * If true then data files will be written with the legacy format
+   *
+   * The default is true while the new format is in beta
+   */
+  useLegacyFormat?: boolean;
   schema?: Schema;
   embeddingFunction?: EmbeddingFunctionConfig;
 }
@@ -221,6 +227,7 @@ export class Connection {
       buf,
       mode,
       cleanseStorageOptions(options?.storageOptions),
+      options?.useLegacyFormat,
     );
 
     return new Table(innerTable);
@@ -256,6 +263,7 @@ export class Connection {
       buf,
       mode,
       cleanseStorageOptions(options?.storageOptions),
+      options?.useLegacyFormat,
     );
     return new Table(innerTable);
   }

package/lancedb/embedding/embedding_function.ts

@@ -19,6 +19,7 @@ import {
   FixedSizeList,
   Float,
   Float32,
+  type IntoVector,
   isDataType,
   isFixedSizeList,
   isFloat,
@@ -100,33 +101,55 @@ export abstract class EmbeddingFunction<
    * @see {@link lancedb.LanceSchema}
    */
   vectorField(
-    options?: Partial<FieldOptions>,
+    optionsOrDatatype?: Partial<FieldOptions> | DataType,
   ): [DataType, Map<string, EmbeddingFunction>] {
-    let dtype: DataType;
-    const dims = this.ndims() ?? options?.dims;
-    if (!options?.datatype) {
-      if (dims === undefined) {
-        throw new Error("ndims is required for vector field");
-      }
-      dtype = new FixedSizeList(dims, new Field("item", new Float32(), true));
+    let dtype: DataType | undefined;
+    let vectorType: DataType;
+    let dims: number | undefined = this.ndims();
+
+    // `func.vectorField(new Float32())`
+    if (isDataType(optionsOrDatatype)) {
+      dtype = optionsOrDatatype;
     } else {
-      if (isFixedSizeList(options.datatype)) {
-        dtype = options.datatype;
-      } else if (isFloat(options.datatype)) {
+      // `func.vectorField({
+      //  datatype: new Float32(),
+      //  dims: 10
+      // })`
+      dims = dims ?? optionsOrDatatype?.dims;
+      dtype = optionsOrDatatype?.datatype;
+    }
+
+    if (dtype !== undefined) {
+      // `func.vectorField(new FixedSizeList(dims, new Field("item", new Float32(), true)))`
+      // or `func.vectorField({datatype: new FixedSizeList(dims, new Field("item", new Float32(), true))})`
+      if (isFixedSizeList(dtype)) {
+        vectorType = dtype;
+        // `func.vectorField(new Float32())`
+        // or `func.vectorField({datatype: new Float32()})`
+      } else if (isFloat(dtype)) {
+        // No `ndims` impl and no `{dims: n}` provided;
         if (dims === undefined) {
           throw new Error("ndims is required for vector field");
         }
-        dtype = newVectorType(dims, options.datatype);
+        vectorType = newVectorType(dims, dtype);
       } else {
         throw new Error(
           "Expected FixedSizeList or Float as datatype for vector field",
         );
       }
+    } else {
+      if (dims === undefined) {
+        throw new Error("ndims is required for vector field");
+      }
+      vectorType = new FixedSizeList(
+        dims,
+        new Field("item", new Float32(), true),
+      );
     }
     const metadata = new Map<string, EmbeddingFunction>();
     metadata.set("vector_column_for", this);
 
-    return [dtype, metadata];
+    return [vectorType, metadata];
   }
 
   /** The number of dimensions of the embeddings */
@@ -147,9 +170,7 @@ export abstract class EmbeddingFunction<
   /**
   Compute the embeddings for a single query
  */
-  async computeQueryEmbeddings(
-    data: T,
-  ): Promise<number[] | Float32Array | Float64Array> {
+  async computeQueryEmbeddings(data: T): Promise<IntoVector> {
     return this.computeSourceEmbeddings([data]).then(
       (embeddings) => embeddings[0],
     );

package/lancedb/embedding/registry.ts

@@ -42,6 +42,7 @@ export class EmbeddingFunctionRegistry {
    * Register an embedding function
    * @param name The name of the function
    * @param func The function to register
+   * @throws Error if the function is already registered
    */
   register<T extends EmbeddingFunctionFactory = EmbeddingFunctionFactory>(
     this: EmbeddingFunctionRegistry,
@@ -89,6 +90,9 @@ export class EmbeddingFunctionRegistry {
     this.#functions.clear();
   }
 
+  /**
+   * @ignore
+   */
   parseFunctions(
     this: EmbeddingFunctionRegistry,
     metadata: Map<string, string>,