@bridgerust/embex 0.1.13 → 0.1.14

package/README.md

@@ -1,139 +1,112 @@
 # Embex (Node.js)
 
-**The Universal Vector Database ORM.** One API for Qdrant, Pinecone, Chroma, LanceDB, and more.
+**The fastest way to add vector search to your app.**
 
-Embex is a high-performance, universal client for vector databases, built on a shared Rust core related to [BridgeRust](https://github.com/bridgerust/bridgerust).
+Embex is a universal vector database client that lets you start with zero setup and scale to production without rewriting code.
 
 ## 🚀 Features
 
-- **Unified API**: Switch providers instantly. "Write once, run anywhere."
-- **Performance**: Powered by Rust with SIMD acceleration.
+- **Start Simple**: Use LanceDB (embedded) for zero-setup local development.
+- **Unified API**: Switch to Qdrant, Pinecone, or Milvus just by changing the config.
+- **Performance**: Powered by a shared Rust core with SIMD acceleration.
 - **Type Safety**: Full TypeScript support.
 
 ## 📦 Installation
 
 ```bash
-npm install @bridgerust/embex
-```
-
-```bash
-yarn add @bridgerust/embex
-```
-
-```bash
-bun add @bridgerust/embex
+npm install @bridgerust/embex lancedb @xenova/transformers
 ```
 
 ## ⚡ Quick Start
 
-**Try Embex in 30 seconds - No setup required!** Uses LanceDB embedded mode (no server needed).
+Build semantic search in 5 minutes using **LanceDB** (embedded) and local embeddings. No API keys or Docker needed!
 
 ```typescript
-import { EmbexClient } from "@bridgerust/embex";
+import { EmbexClient, Vector } from "@bridgerust/embex";
+import { pipeline } from "@xenova/transformers";
 
 async function main() {
-  // LanceDB embedded - zero setup, just a local path
-  const client = await EmbexClient.newAsync("lancedb", "./data");
-  const collection = client.collection("documents");
-
-  // Create collection
-  await collection.create(768, "cosine");
-
-  // Insert data
-  await collection.insert([
-    {
-      id: "1",
-      vector: Array(768).fill(0.1),
-      metadata: { text: "Hello World" },
-    },
-  ]);
-
-  // Search
-  const results = await collection.search(Array(768).fill(0.1), 5);
-  console.log(results.results);
+  // 1. Setup Embedding Model
+  const generateEmbedding = await pipeline(
+    "feature-extraction",
+    "Xenova/all-MiniLM-L6-v2"
+  );
+  const embed = async (text: string) => {
+    const output = await generateEmbedding(text, {
+      pooling: "mean",
+      normalize: true,
+    });
+    return Array.from(output.data);
+  };
+
+  // 2. Initialize Client (uses LanceDB embedded)
+  const client = await EmbexClient.newAsync("lancedb://./data");
+
+  // 3. Create Collection (384 dimensions for MiniLM)
+  await client.createCollection("products", 384);
+
+  // 4. Insert Data
+  const documents = [
+    { id: "1", text: "Apple iPhone 15", category: "electronics" },
+    { id: "2", text: "Samsung Galaxy S24", category: "electronics" },
+  ];
+
+  const vectors: Vector[] = [];
+  for (const doc of documents) {
+    vectors.push({
+      id: doc.id,
+      vector: await embed(doc.text),
+      metadata: { text: doc.text },
+    });
+  }
+
+  await client.insert("products", vectors);
+
+  // 5. Search
+  const query = "smartphone";
+  const results = await client.search({
+    collection_name: "products",
+    vector: await embed(query),
+    limit: 1,
+  });
+
+  console.log(`Query: '${query}'`);
+  console.log(`Match: ${results[0].metadata.text}`);
 }
 
 main();
 ```
 
-**Run it:** `npx tsx examples/lancedb/node/quickstart.ts`
-
-### All Provider Quick Starts
+## 🗺️ Development → Production Roadmap
 
-Try Embex with any provider! Same API, different backend:
+| Stage               | Recommendation        | Why?                                |
+| :------------------ | :-------------------- | :---------------------------------- |
+| **Day 1: Learning** | **LanceDB**           | Embedded. Zero setup. Free.         |
+| **Week 2: Staging** | **Qdrant / Pinecone** | Managed cloud. Connection pooling.  |
+| **Month 1: Scale**  | **Milvus**            | Distributed. Billion-scale vectors. |
+| **Anytime**         | **PgVector**          | You already use PostgreSQL.         |
 
-| Provider     | Setup           | Quick Start                                    |
-| ------------ | --------------- | ---------------------------------------------- |
-| **LanceDB**  | None (embedded) | `npx tsx examples/lancedb/node/quickstart.ts`  |
-| **Qdrant**   | Docker server   | `npx tsx examples/qdrant/node/quickstart.ts`   |
-| **Pinecone** | API key         | `npx tsx examples/pinecone/node/quickstart.ts` |
-| **Chroma**   | Optional server | `npx tsx examples/chroma/node/quickstart.ts`   |
+## ☁️ Switch Provider (Zero Code Changes)
 
-> 💡 **Same API everywhere!** Just change the provider name - all code stays the same. See [examples/README.md](../../../../examples/README.md) for setup instructions.
+Ready for production? Just change the initialization line.
 
-### 5. Filtered Search (Builder Pattern)
+**From LanceDB (Dev):**
 
 ```typescript
-const results = await collection.buildSearch([0.1, 0.2, ...])
-  .limit(10)
-  .filter({
-    course: "CS101"
-  })
-  .execute();
+const client = await EmbexClient.newAsync("lancedb://./data");
 ```
 
-## ☁️ Connecting to Cloud Providers
-
-To connect to managed services like Pinecone, Qdrant Cloud, or Zilliz (Milvus), simply provide your API key and endpoint URL.
+**To Qdrant Cloud (Prod):**
 
 ```typescript
-import { EmbexClient } from "@bridgerust/embex";
-
-// Connect to Pinecone
 const client = new EmbexClient(
-  "pinecone",
-  "https://index-name.svc.pinecone.io",
-  process.env.PINECONE_API_KEY
-);
-
-// Connect to Qdrant Cloud
-const qdrantClient = new EmbexClient(
   "qdrant",
-  "https://xyz-example.eu-central.aws.cloud.qdrant.io:6333",
+  "https://your-cluster.qdrant.io",
   process.env.QDRANT_API_KEY
 );
 ```
 
-### Official Documentation & API Keys
-
-Need help finding your API key? Check the official provider documentation:
-
-- **Pinecone**: [Authentication & API Keys](https://docs.pinecone.io/guides/get-started/quickstart#2-get-an-api-key)
-- **Qdrant**: [Cloud Authentication](https://qdrant.tech/documentation/cloud/authentication/)
-- **Milvus (Zilliz)**: [Manage Credentials](https://docs.zilliz.com/docs/manage-api-keys)
-- **Weaviate**: [Authentication](https://weaviate.io/developers/weaviate/configuration/authentication)
-- **Chroma**: [Auth & Client Settings](https://docs.trychroma.com/guides#authentication)
-
-## 🔌 Supported Providers
-
-| Provider | Key        | Async Init? |
-| -------- | ---------- | ----------- |
-| Qdrant   | `qdrant`   | No          |
-| Chroma   | `chroma`   | No          |
-| Pinecone | `pinecone` | No          |
-| Weaviate | `weaviate` | No          |
-| LanceDB  | `lancedb`  | **Yes**     |
-| Milvus   | `milvus`   | **Yes**     |
-| PgVector | `pgvector` | **Yes**     |
-
-## ⭐ Star Us
-
-If you find Embex useful, please star the repository! It helps others discover the project.
-
-[⭐ Star on GitHub](https://github.com/bridgerust/bridgerust)
-
 ## 🔗 Resources
 
-- **Main Repository**: [github.com/bridgerust/bridgerust](https://github.com/bridgerust/bridgerust)
-- **Issues**: [github.com/bridgerust/bridgerust/issues](https://github.com/bridgerust/bridgerust/issues)
-- **Documentation**: [Full Docs](https://github.com/bridgerust/bridgerust/tree/main/bindings/node/%40bridgerust/embex)
+- **Full Documentation**: [bridgerust.dev/embex](https://bridgerust.dev/embex/introduction)
+- **GitHub**: [bridgerust/bridgerust](https://github.com/bridgerust/bridgerust)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./src";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC"}

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src"), exports);

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+import { Collection, EmbexClient, QueryBuilder, SearchBuilder, cli, Point } from "../native";
+declare module "../native" {
+    interface Collection {
+        insertStream(points: AsyncIterable<Point>, parallel?: number): Promise<void>;
+    }
+}
+export { Collection, EmbexClient, QueryBuilder, SearchBuilder, cli, Point };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,YAAY,EACZ,aAAa,EAEb,GAAG,EACH,KAAK,EACN,MAAM,WAAW,CAAC;AAEnB,OAAO,QAAQ,WAAW,CAAC;IACzB,UAAU,UAAU;QAClB,YAAY,CACV,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,EAC5B,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAAC;KAClB;CACF;AAwBD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cli = exports.SearchBuilder = exports.QueryBuilder = exports.EmbexClient = exports.Collection = void 0;
+const native_1 = require("../native");
+Object.defineProperty(exports, "Collection", { enumerable: true, get: function () { return native_1.Collection; } });
+Object.defineProperty(exports, "EmbexClient", { enumerable: true, get: function () { return native_1.EmbexClient; } });
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return native_1.QueryBuilder; } });
+Object.defineProperty(exports, "SearchBuilder", { enumerable: true, get: function () { return native_1.SearchBuilder; } });
+Object.defineProperty(exports, "cli", { enumerable: true, get: function () { return 
+    // @ts-ignore
+    native_1.cli; } });
+// Monkey patch
+native_1.Collection.prototype.insertStream = async function (points, parallel = 5) {
+    const BATCH_SIZE = 100;
+    let batch = [];
+    for await (const point of points) {
+        batch.push(point);
+        if (batch.length >= BATCH_SIZE) {
+            await this.insertBatch(batch, BATCH_SIZE, parallel);
+            batch = [];
+        }
+    }
+    if (batch.length > 0) {
+        await this.insertBatch(batch, BATCH_SIZE, parallel);
+    }
+};

package/dist/src/tests/integration/adapters.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Embex Integration Tests - Node.js
+ * Tests all adapter implementations against real database instances.
+ *
+ * Run Docker Compose first: docker-compose up -d
+ *
+ * Usage:
+ *   cd bindings/node/@bridgerust/embex
+ *   npm run build
+ *   npm test tests/integration/
+ */
+export {};
+//# sourceMappingURL=adapters.test.d.ts.map

package/dist/src/tests/integration/adapters.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.test.d.ts","sourceRoot":"","sources":["../../../../src/tests/integration/adapters.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/src/tests/integration/adapters.test.js

@@ -0,0 +1,372 @@
+"use strict";
+/**
+ * Embex Integration Tests - Node.js
+ * Tests all adapter implementations against real database instances.
+ *
+ * Run Docker Compose first: docker-compose up -d
+ *
+ * Usage:
+ *   cd bindings/node/@bridgerust/embex
+ *   npm run build
+ *   npm test tests/integration/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../../index");
+const crypto_1 = require("crypto");
+const os_1 = require("os");
+const path_1 = require("path");
+const TEST_DIMENSION = 128;
+const TEST_COLLECTION = "embex_integration_test_node";
+function randomVector(dim = TEST_DIMENSION) {
+    return Array.from({ length: dim }, () => Math.random());
+}
+(0, vitest_1.describe)("Qdrant Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(() => {
+        client = new index_1.EmbexClient("qdrant", "http://localhost:6334");
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should create collection", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+    });
+    (0, vitest_1.it)("should insert and search points", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "A" } },
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "B" } },
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "A" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBe(2);
+    });
+    (0, vitest_1.it)("should use search() method with direct parameters", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "A" } },
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { category: "B" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.search(randomVector(), 2, null, true, false);
+        (0, vitest_1.expect)(results.results.length).toBe(2);
+        (0, vitest_1.expect)(results.results[0].id).toBeDefined();
+        (0, vitest_1.expect)(results.results[0].score).toBeDefined();
+    });
+    (0, vitest_1.it)("should search with filters", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            {
+                id: (0, crypto_1.randomUUID)(),
+                vector: randomVector(),
+                metadata: { status: "active", score: 10 },
+            },
+            {
+                id: (0, crypto_1.randomUUID)(),
+                vector: randomVector(),
+                metadata: { status: "inactive", score: 20 },
+            },
+            {
+                id: (0, crypto_1.randomUUID)(),
+                vector: randomVector(),
+                metadata: { status: "active", score: 30 },
+            },
+        ];
+        await collection.insert(points);
+        const filter = {
+            op: "key",
+            args: ["status", { eq: "active" }],
+        };
+        const results = await collection.search(randomVector(), 10, filter, true, false);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(2);
+        results.results.forEach((r) => {
+            (0, vitest_1.expect)(r.metadata?.status).toBe("active");
+        });
+    });
+    (0, vitest_1.it)("should use search builder pattern", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: (0, crypto_1.randomUUID)(), vector: randomVector(), metadata: { type: "test" } },
+        ];
+        await collection.insert(points);
+        const builder = collection.buildSearch(randomVector());
+        const results = await builder
+            .limit(5)
+            .includeMetadata(true)
+            .includeVector(false)
+            .execute();
+        (0, vitest_1.expect)(results.results).toBeDefined();
+        (0, vitest_1.expect)(Array.isArray(results.results)).toBe(true);
+    });
+    (0, vitest_1.it)("should insert batch with parallel option", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = Array.from({ length: 50 }, () => ({
+            id: (0, crypto_1.randomUUID)(),
+            vector: randomVector(),
+            metadata: { batch: "test" },
+        }));
+        await collection.insertBatch(points, 10, 3);
+        const results = await collection.query(randomVector(), { limit: 50 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(50);
+    });
+    (0, vitest_1.it)("should delete points", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const delId = (0, crypto_1.randomUUID)();
+        await collection.insert([
+            { id: delId, vector: randomVector(), metadata: {} },
+        ]);
+        await collection.delete([delId]);
+        const results = await collection.query(randomVector(), { limit: 10 });
+        const ids = results.results.map((r) => r.id);
+        (0, vitest_1.expect)(ids).not.toContain(delId);
+    });
+});
+(0, vitest_1.describe)("Chroma Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(() => {
+        client = new index_1.EmbexClient("chroma", "http://localhost:8000");
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "c1", vector: randomVector(), metadata: { type: "test" } },
+            { id: "c2", vector: randomVector(), metadata: { type: "test" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBe(2);
+    });
+    (0, vitest_1.it)("should use search() method", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "c3", vector: randomVector(), metadata: { type: "search" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.search(randomVector(), 1);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("should create collection with auto dimension inference", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.createAuto(undefined, "cosine");
+        const points = [
+            { id: "c4", vector: randomVector(), metadata: { type: "auto" } },
+            { id: "c5", vector: randomVector(), metadata: { type: "auto" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBe(2);
+        await collection.deleteCollection();
+    });
+});
+(0, vitest_1.describe)("Weaviate Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(() => {
+        client = new index_1.EmbexClient("weaviate", "http://localhost:8080");
+        collection = client.collection("EmbexNodeTest");
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "w1", vector: randomVector(), metadata: { name: "test1" } },
+            { id: "w2", vector: randomVector(), metadata: { name: "test2" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+});
+(0, vitest_1.describe)("Milvus Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(async () => {
+        // Milvus requires async initialization
+        client = await index_1.EmbexClient.newAsync("milvus", "http://localhost:19530");
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "m1", vector: randomVector(), metadata: {} },
+            { id: "m2", vector: randomVector(), metadata: {} },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("should use search() method", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "m3", vector: randomVector(), metadata: { test: "milvus" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.search(randomVector(), 1);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+});
+(0, vitest_1.describe)("pgvector Adapter", () => {
+    let client;
+    let collection;
+    (0, vitest_1.beforeAll)(async () => {
+        // pgvector requires async initialization
+        client = await index_1.EmbexClient.newAsync("pgvector", "postgresql://embex:embex_test@localhost:5432/embex_test");
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "pg1", vector: randomVector(), metadata: { info: "test" } },
+            { id: "pg2", vector: randomVector(), metadata: { info: "test" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("should use search() method with filters", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "pg3", vector: randomVector(), metadata: { status: "active" } },
+        ];
+        await collection.insert(points);
+        const filter = {
+            op: "key",
+            args: ["status", { eq: "active" }],
+        };
+        const results = await collection.search(randomVector(), 5, filter, true, false);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+});
+(0, vitest_1.describe)("LanceDB Adapter", () => {
+    let client;
+    let collection;
+    const dbPath = (0, path_1.join)((0, os_1.tmpdir)(), `lancedb_node_test_${Date.now()}`);
+    (0, vitest_1.beforeAll)(async () => {
+        client = await index_1.EmbexClient.newAsync("lancedb", dbPath);
+        collection = client.collection(TEST_COLLECTION);
+    });
+    (0, vitest_1.afterAll)(async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+    });
+    (0, vitest_1.it)("should perform CRUD operations", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "l1", vector: randomVector(), metadata: { name: "lance1" } },
+            { id: "l2", vector: randomVector(), metadata: { name: "lance2" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.query(randomVector(), { limit: 2 });
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("should use search() method", async () => {
+        try {
+            await collection.deleteCollection();
+        }
+        catch (e) { }
+        await collection.create(TEST_DIMENSION, "cosine");
+        const points = [
+            { id: "l3", vector: randomVector(), metadata: { name: "lance3" } },
+        ];
+        await collection.insert(points);
+        const results = await collection.search(randomVector(), 1, null, true, false);
+        (0, vitest_1.expect)(results.results.length).toBeGreaterThanOrEqual(1);
+    });
+});