agentlang 0.10.2 → 0.10.3

package/src/runtime/resolvers/sqldb/database.ts

@@ -46,6 +46,8 @@ import { saveMigration } from '../../modules/core.js';
 import { getAppSpec } from '../../loader.js';
 import { WhereClause } from '../interface.js';
 import { AppConfig } from '../../state.js';
+import { createLanceDBStore } from '../vector/lancedb-store.js';
+import type { VectorStore } from '../vector/types.js';
 
 export let defaultDataSource: DataSource | undefined;
 
@@ -58,57 +60,8 @@ function isBrowser(): boolean {
   );
 }
 
-// SQLite WASM with built-in sqlite-vec for browsers
-// Loaded from CDN - this has sqlite-vec statically compiled in
-let sqliteVecWasmModule: any = null;
-
-async function loadSqliteVecWasm(): Promise<any> {
-  if (sqliteVecWasmModule) {
-    return sqliteVecWasmModule;
-  }
-
-  try {
-    // Use dynamic import with string to prevent bundlers from analyzing
-    const cdnUrl = 'https://cdn.jsdelivr.net/npm/sqlite-vec-wasm-demo@latest/sqlite3.mjs';
-    const module = await import(/* @vite-ignore */ cdnUrl);
-    sqliteVecWasmModule = await module.default();
-    return sqliteVecWasmModule;
-  } catch (err) {
-    logger.warn('Failed to load sqlite-vec WASM:', err);
-    return null;
-  }
-}
-
-// Helper to load sqlite-vec based on environment
-async function loadSqliteVec(): Promise<any> {
-  // In browser, use WASM version with built-in sqlite-vec
-  // In Node.js, use the npm package
-  if (isBrowser()) {
-    const wasmModule = await loadSqliteVecWasm();
-    if (wasmModule) {
-      // WASM version has sqlite-vec built-in, no need to call load()
-      // Return a compatible interface
-      return {
-        load: () => {
-          // No-op: sqlite-vec is already loaded in WASM version
-          logger.info('sqlite-vec WASM loaded (built-in)');
-        },
-        // Expose the WASM module for direct use if needed
-        _wasmModule: wasmModule,
-      };
-    }
-    return null;
-  }
-
-  // Node.js: use npm package
-  try {
-    // Use variable to prevent bundlers from statically analyzing this import
-    const moduleName = 'sqlite-vec';
-    return await import(/* @vite-ignore */ moduleName);
-  } catch {
-    return null;
-  }
-}
+// LanceDB vector store cache - keyed by module name
+const lanceDBStores: Map<string, VectorStore> = new Map();
 
 export class DbContext {
   txnId: string | undefined;
@@ -306,17 +259,27 @@ function makeSqliteDataSource(
   ds.initialize = async () => {
     const res = await originalInit();
     try {
-      const sqliteVec = await loadSqliteVec();
       const driver = ds.driver as any;
       const db = driver.databaseConnection || driver.nativeDatabase;
-      if (db && sqliteVec?.load) {
-        sqliteVec.load(db);
-        logger.info('sqlite-vec extension loaded successfully');
+      // Enable WAL mode and additional pragmas for better write performance
+      if (db?.pragma) {
+        db.pragma('journal_mode = WAL');
+
+        const syncMode = process.env.SQLITE_SYNC_MODE || 'NORMAL';
+        const busyTimeout = process.env.SQLITE_BUSY_TIMEOUT || '5000';
+        const cacheSize = process.env.SQLITE_CACHE_SIZE || '-20000';
+
+        db.pragma(`synchronous = ${syncMode}`);
+        db.pragma(`busy_timeout = ${busyTimeout}`);
+        db.pragma(`cache_size = ${cacheSize}`);
+        db.pragma('temp_store = MEMORY');
+
+        logger.info(
+          `SQLite pragmas enabled: WAL mode, synchronous=${syncMode}, busy_timeout=${busyTimeout}, cache_size=${cacheSize}, temp_store=MEMORY`
+        );
       }
     } catch (err: any) {
-      logger.warn(
-        `Failed to load sqlite-vec extension: ${err.message}. Vector operations may not be available.`
-      );
+      logger.warn(`Failed to enable SQLite pragmas: ${err.message}.`);
     }
     return res;
   };
@@ -412,6 +375,20 @@ function forceGetDbType(config: DatabaseConfig | undefined): string {
 
 let DbType: string | undefined;
 
+function getVectorStoreType(): string {
+  // Check explicit vectorStore config first
+  const vectorStoreConfig = AppConfig?.vectorStore;
+  if (vectorStoreConfig?.type) {
+    if (vectorStoreConfig.type === 'pgvector') return 'postgres';
+    if (vectorStoreConfig.type === 'lancedb') return 'lancedb';
+  }
+
+  // Fallback to main store type
+  const dbType = getDbType(AppConfig?.store);
+  if (dbType === 'postgres') return 'postgres';
+  return 'lancedb';
+}
+
 function getDbType(config: DatabaseConfig | undefined): string {
   if (DbType === undefined) DbType = forceGetDbType(config);
   return DbType;
@@ -445,12 +422,9 @@ export function isUsingSqljs(): boolean {
 }
 
 export async function isVectorStoreSupported(): Promise<boolean> {
-  const dbType = getDbType(AppConfig?.store);
-  if (dbType === 'postgres') return true;
-  if (dbType === 'sqlite') {
-    const sqliteVecModule = await loadSqliteVec();
-    return !!sqliteVecModule;
-  }
+  const vectorStoreType = getVectorStoreType();
+  if (vectorStoreType === 'postgres') return true;
+  if (vectorStoreType === 'lancedb') return true;
   return false;
 }
 
@@ -509,9 +483,14 @@ async function insertRowsHelper(
   ctx: DbContext,
   doUpsert: boolean
 ): Promise<void> {
-  const repo = getDatasourceForTransaction(ctx.txnId).getRepository(tableName);
-  if (doUpsert) await repo.save(rows);
-  else await repo.insert(rows);
+  const ds = getDatasourceForTransaction(ctx.txnId);
+  const repo = ds.getRepository(tableName);
+
+  if (doUpsert) {
+    await repo.save(rows);
+  } else {
+    await repo.insert(rows);
+  }
 }
 
 export async function addRowForFullTextSearch(
@@ -520,28 +499,45 @@ export async function addRowForFullTextSearch(
   vect: number[],
   ctx: DbContext
 ) {
-  if (!(await isVectorStoreSupported())) return;
+  if (!(await isVectorStoreSupported())) {
+    logger.warn(`[VECTOR] Vector store not supported, skipping save for ${id}`);
+    return;
+  }
   try {
     const vecTableName = tableName + VectorSuffix;
-    const qb = getDatasourceForTransaction(ctx.txnId).createQueryBuilder();
+    logger.info(
+      `[VECTOR] Saving embedding to ${vecTableName} for ${id} (${vect.length} dimensions)`
+    );
+    const dbType = getVectorStoreType();
     const tenantId = await ctx.getTenantId();
-    const dbType = getDbType(AppConfig?.store);
-    if (dbType === 'postgres') {
+
+    if (dbType === 'lancedb') {
+      let store = lanceDBStores.get(tableName);
+      if (!store) {
+        store = createLanceDBStore({
+          moduleName: tableName,
+          vectorDimension: vect.length,
+        });
+        await store.init();
+        lanceDBStores.set(tableName, store);
+      }
+      await store.addEmbedding({
+        id,
+        embedding: Array.from(vect),
+        tenantId,
+      });
+    } else if (dbType === 'postgres') {
+      const qb = getDatasourceForTransaction(ctx.txnId).createQueryBuilder();
       const { default: pgvector } = await import('pgvector');
       await qb
         .insert()
         .into(vecTableName)
-        .values([{ id: id, embedding: pgvector.toSql(vect), __tenant__: tenantId }])
-        .execute();
-    } else {
-      await qb
-        .insert()
-        .into(vecTableName)
-        .values([{ id: id, embedding: new Float32Array(vect) }])
+        .values([{ id: id, embedding: pgvector.toSql(vect), agentId: tenantId }])
         .execute();
     }
+    logger.info(`[VECTOR] Successfully saved embedding to ${vecTableName} for ${id}`);
   } catch (err: any) {
-    logger.error(`Failed to add row to vector store - ${err}`);
+    logger.error(`[VECTOR] Failed to add row to vector store - ${err}`);
   }
 }
 
@@ -550,11 +546,21 @@ export async function initVectorStore(tableNames: string[], ctx: DbContext) {
     logger.info(`Vector store not supported for ${getDbType(AppConfig?.store)}, skipping init...`);
     return;
   }
-  const dbType = getDbType(AppConfig?.store);
+  const dbType = getVectorStoreType();
   let notInited = true;
   for (const vecTableName of tableNames) {
-    const vecRepo = getDatasourceForTransaction(ctx.txnId).getRepository(vecTableName);
-    if (dbType === 'postgres') {
+    if (dbType === 'lancedb') {
+      if (!lanceDBStores.has(vecTableName)) {
+        const store = createLanceDBStore({
+          moduleName: vecTableName,
+          vectorDimension: DefaultVectorDimension,
+        });
+        await store.init();
+        lanceDBStores.set(vecTableName, store);
+        logger.info(`[VECTOR] Initialized LanceDB store for ${vecTableName}`);
+      }
+    } else if (dbType === 'postgres') {
+      const vecRepo = getDatasourceForTransaction(ctx.txnId).getRepository(vecTableName);
       if (notInited) {
         let failure = false;
         try {
@@ -568,18 +574,11 @@ export async function initVectorStore(tableNames: string[], ctx: DbContext) {
       }
       await vecRepo.query(
         `CREATE TABLE IF NOT EXISTS ${vecTableName} (
-            id varchar PRIMARY KEY,
-            embedding vector(${DefaultVectorDimension}),
-            ${TenantAttributeName} varchar,
-            __is_deleted__ boolean default false
-          )`
-      );
-    } else {
-      // sqlite-vec - vec0 doesn't support type declarations for metadata columns
-      await vecRepo.query(
-        `CREATE VIRTUAL TABLE IF NOT EXISTS ${vecTableName} USING vec0(
-            id TEXT PRIMARY KEY,
-            embedding FLOAT[${DefaultVectorDimension}])`
+          id varchar PRIMARY KEY,
+          embedding vector(${DefaultVectorDimension}),
+          ${TenantAttributeName} varchar,
+          __is_deleted__ boolean default false
+        )`
       );
     }
   }
@@ -596,6 +595,21 @@ export async function vectorStoreSearch(
     return [];
   }
   try {
+    const dbType = getVectorStoreType();
+    const tenantId = await ctx.getTenantId();
+
+    if (dbType === 'lancedb') {
+      const store = lanceDBStores.get(tableName);
+      if (!store) {
+        logger.warn(`[VECTOR] LanceDB store not found for ${tableName}`);
+        return [];
+      }
+      // Extract agentId from resourceFqName for agent-level filtering
+      const agentId = ctx.resourceFqName || undefined;
+      const results = await store.search(searchVec, tenantId, agentId, limit);
+      return results.map(r => ({ id: r.id }));
+    }
+
     let hasGlobalPerms = ctx.isPermitted();
     if (!hasGlobalPerms) {
       const userId = ctx.getUserId();
@@ -605,8 +619,6 @@ export async function vectorStoreSearch(
     }
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
-    const dbType = getDbType(AppConfig?.store);
-    const tenantId = await ctx.getTenantId();
     let ownersJoinCond: string = '';
     if (!hasGlobalPerms) {
       const ot = ownersTable(tableName);
@@ -619,16 +631,6 @@ export async function vectorStoreSearch(
       const sql = `select ${vecTableName}.id from ${vecTableName} ${ownersJoinCond} order by embedding <-> $1 LIMIT ${limit}`;
       const args = pgvector.toSql(searchVec);
       return await qb.query(sql, [args]);
-    } else {
-      // sqlite-vec - join with main table to filter by tenant
-      const alias = tableName.toLowerCase();
-      const sql = `SELECT ${vecTableName}.id FROM ${vecTableName}
-        INNER JOIN ${tableName} ${alias} ON ${alias}.${PathAttributeName} = ${vecTableName}.id
-        ${ownersJoinCond}
-        WHERE ${alias}.${TenantAttributeName} = '${tenantId}' AND ${alias}.${DeletedFlagAttributeName} = false AND ${vecTableName}.embedding MATCH $1
-        LIMIT ${limit}`;
-      const args = new Float32Array(searchVec);
-      return await qb.query(sql, [args]);
     }
   } catch (err: any) {
     logger.error(`Vector store search failed - ${err}`);
@@ -643,9 +645,19 @@ export async function vectorStoreSearchEntryExists(
 ): Promise<boolean> {
   if (!(await isVectorStoreSupported())) return false;
   try {
+    const dbType = getVectorStoreType();
+
+    if (dbType === 'lancedb') {
+      const store = lanceDBStores.get(tableName);
+      if (!store) {
+        logger.warn(`[VECTOR] LanceDB store not found for ${tableName}`);
+        return false;
+      }
+      return await store.exists(id);
+    }
+
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
-    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
 
     if (dbType === 'postgres') {
@@ -654,16 +666,6 @@ export async function vectorStoreSearchEntryExists(
         [id]
       );
       return result !== null && result.length > 0;
-    } else {
-      // sqlite-vec - join with main table to verify tenant
-      const alias = tableName.toLowerCase();
-      const result: any[] = await qb.query(
-        `SELECT ${vecTableName}.id FROM ${vecTableName}
-         INNER JOIN ${tableName} ${alias} ON ${alias}.${PathAttributeName} = ${vecTableName}.id
-         WHERE ${vecTableName}.id = $1 AND ${alias}.${TenantAttributeName} = '${tenantId}'`,
-        [id]
-      );
-      return result !== null && result.length > 0;
     }
   } catch (err: any) {
     logger.error(`Vector store search failed - ${err}`);
@@ -674,9 +676,20 @@ export async function vectorStoreSearchEntryExists(
 export async function deleteFullTextSearchEntry(tableName: string, id: string, ctx: DbContext) {
   if (!(await isVectorStoreSupported())) return;
   try {
+    const dbType = getVectorStoreType();
+
+    if (dbType === 'lancedb') {
+      const store = lanceDBStores.get(tableName);
+      if (!store) {
+        logger.warn(`[VECTOR] LanceDB store not found for ${tableName}`);
+        return;
+      }
+      await store.delete(id);
+      return;
+    }
+
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
-    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
 
     if (dbType === 'postgres') {
@@ -684,9 +697,6 @@ export async function deleteFullTextSearchEntry(tableName: string, id: string, c
         `delete from ${vecTableName} where id = $1 and ${TenantAttributeName} = '${tenantId}'`,
         [id]
       );
-    } else {
-      // sqlite-vec - delete just by id (ownership verified by caller)
-      await qb.query(`delete from ${vecTableName} where id = $1`, [id]);
     }
   } catch (err: any) {
     logger.error(`Vector store delete failed - ${err}`);
@@ -862,7 +872,7 @@ async function createLimitedOwnership(
       r: perms.has(RbacPermissionFlag.READ),
       d: perms.has(RbacPermissionFlag.DELETE),
       u: perms.has(RbacPermissionFlag.UPDATE),
-      __tenant__: tenantId,
+      agentId: tenantId,
     });
   });
   const tname = ownersTable(tableName);
@@ -1055,6 +1065,8 @@ export type QuerySpec = {
   intoSpec: Map<string, string> | undefined;
   whereClauses: WhereClause[] | undefined;
   distinct: boolean;
+  limit: number | undefined;
+  offset: number | undefined;
 };
 
 export function makeSimpleQuerySpec(queryObj: object, queryVals: object): QuerySpec {
@@ -1069,6 +1081,8 @@ export function makeSimpleQuerySpec(queryObj: object, queryVals: object): QueryS
     intoSpec: undefined,
     whereClauses: undefined,
     distinct: false,
+    limit: undefined,
+    offset: undefined,
   };
 }
 
@@ -1144,6 +1158,12 @@ export async function getMany(
   if (querySpec.distinct) {
     qb.distinct(true);
   }
+  if (querySpec.limit !== undefined) {
+    qb.take(querySpec.limit);
+  }
+  if (querySpec.offset !== undefined) {
+    qb.skip(querySpec.offset);
+  }
   qb.where(queryStr, querySpec.queryVals);
   if (hasAggregates) return await qb.getRawMany();
   else return await qb.getMany();
@@ -1233,6 +1253,12 @@ export async function getManyByJoin(
   if (querySpec.orderBy !== undefined) {
     sql = `${sql} ORDER BY ${querySpec.orderBy.join(', ')} ${querySpec.orderByDesc}`;
   }
+  if (querySpec.limit !== undefined) {
+    sql = `${sql} LIMIT ${querySpec.limit}`;
+  }
+  if (querySpec.offset !== undefined) {
+    sql = `${sql} OFFSET ${querySpec.offset}`;
+  }
   logger.debug(`Join Query: ${sql}`);
   const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
   return await qb.query(sql);
@@ -1348,14 +1374,16 @@ async function endTransaction(txnId: string, commit: boolean): Promise<void> {
   const qr: QueryRunner | undefined = transactionsDb.get(txnId);
   if (qr && qr.isTransactionActive) {
     try {
-      if (commit)
-        await qr.commitTransaction().catch((reason: any) => {
-          logger.error(`failed to commit transaction ${txnId} - ${reason}`);
-        });
-      else
-        await qr.rollbackTransaction().catch((reason: any) => {
-          logger.error(`failed to rollback transaction ${txnId} - ${reason}`);
-        });
+      if (commit) {
+        await qr.commitTransaction();
+      } else {
+        await qr.rollbackTransaction();
+      }
+    } catch (err: any) {
+      logger.error(
+        `Failed to ${commit ? 'commit' : 'rollback'} transaction ${txnId}: ${err.message}`
+      );
+      throw err;
     } finally {
       await qr.release();
       transactionsDb.delete(txnId);

package/src/runtime/resolvers/sqldb/dbutil.ts

@@ -99,6 +99,12 @@ export type OrmSchema = {
   fkSpecs: FkSpec[];
 };
 
+const SqlDefaultFunctions = new Set(['uuid()', 'autoincrement()', 'now()']);
+
+function isSqlDefault(d: any): boolean {
+  return typeof d !== 'string' || !d.endsWith('()') || SqlDefaultFunctions.has(d);
+}
+
 export function modulesAsOrmSchema(): OrmSchema {
   const ents: EntitySchema[] = [];
   const vects: EntitySchema[] = [];
@@ -147,6 +153,7 @@ function ormSchemaFromRecordSchema(
     const autoUuid: boolean = d && d == 'uuid()' ? true : false;
     const autoIncr: boolean = !autoUuid && d && d == 'autoincrement()' ? true : false;
     if (autoUuid || autoIncr) d = undefined;
+    else if (!isSqlDefault(d)) d = undefined;
     let genStrat: 'uuid' | 'increment' | undefined = undefined;
     if (autoIncr) genStrat = 'increment';
     else if (autoUuid) genStrat = 'uuid';
@@ -273,6 +280,7 @@ function entitySchemaToTable(scm: RecordSchema): TableSpec {
     const autoUuid: boolean = d && d == 'uuid()' ? true : false;
     const autoIncr: boolean = !autoUuid && d && d == 'autoincrement()' ? true : false;
     if (autoUuid || autoIncr) d = undefined;
+    else if (!isSqlDefault(d)) d = undefined;
     let genStrat: 'uuid' | 'increment' | 'rowid' | 'identity' = 'identity';
     if (autoIncr) genStrat = 'increment';
     else if (autoUuid) genStrat = 'uuid';

package/src/runtime/resolvers/sqldb/impl.ts

@@ -101,6 +101,10 @@ export class EmbeddingService {
     return await this.provider.embedText(query);
   }
 
+  async embedTexts(texts: string[]): Promise<number[][]> {
+    return await this.provider.embedTexts(texts);
+  }
+
   private averageEmbeddings(embeddings: number[][]): number[] {
     if (embeddings.length === 0) return [];
     const dimension = embeddings[0].length;
@@ -402,6 +406,8 @@ export class SqlDbResolver extends Resolver {
       joinClauses: undefined,
       intoSpec: undefined,
       whereClauses: undefined,
+      limit: inst.limit,
+      offset: inst.offset,
     };
     const readOnlyAttrs = inst.record.getWriteOnlyAttributes();
     const rslt: any =
@@ -567,6 +573,8 @@ export class SqlDbResolver extends Resolver {
       joinClauses,
       whereClauses,
       intoSpec,
+      limit: inst.limit,
+      offset: inst.offset,
     };
     const rslt: any = await getManyByJoin(tableName, qspec, this.getDbContext(inst.getFqName()));
     return rslt;

package/src/runtime/resolvers/vector/lancedb-store.ts

@@ -0,0 +1,187 @@
+import * as lancedb from '@lancedb/lancedb';
+import { Schema, Field, Float32, Utf8, FixedSizeList } from 'apache-arrow';
+import { logger } from '../../logger.js';
+import { VectorStore, VectorRecord, SearchResult, VectorStoreConfig } from './types.js';
+
+export class LanceDBVectorStore implements VectorStore {
+  private db: lancedb.Connection | null = null;
+  private table: lancedb.Table | null = null;
+  private config: VectorStoreConfig;
+
+  constructor(config: VectorStoreConfig) {
+    this.config = config;
+  }
+
+  async init(): Promise<void> {
+    try {
+      const dbPath = this.config.inMemory
+        ? 'memory://'
+        : this.config.dbname || `./data/vector-store/${this.config.moduleName}.lance`;
+
+      this.db = await lancedb.connect(dbPath);
+
+      const tableName = 'embeddings';
+      const tableNames = await this.db.tableNames();
+
+      if (tableNames.includes(tableName)) {
+        this.table = await this.db.openTable(tableName);
+        logger.info(`LanceDB table ${tableName} opened`);
+      } else {
+        const schema = new Schema([
+          new Field('id', new Utf8(), false),
+          new Field(
+            'embedding',
+            new FixedSizeList(this.config.vectorDimension, new Field('item', new Float32())),
+            false
+          ),
+          new Field('tenantId', new Utf8(), true),
+          new Field('agentId', new Utf8(), true),
+          new Field('documentId', new Utf8(), true),
+        ]);
+
+        this.table = await this.db.createEmptyTable(tableName, schema);
+        logger.info(`LanceDB table ${tableName} created`);
+      }
+    } catch (error) {
+      logger.error('Failed to initialize LanceDB vector store:', error);
+      throw error;
+    }
+  }
+
+  async addEmbedding(record: VectorRecord): Promise<void> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      await this.table.add([
+        {
+          id: record.id,
+          embedding: record.embedding,
+          tenantId: record.tenantId || null,
+          agentId: record.agentId || null,
+          documentId: record.documentId || null,
+        },
+      ]);
+    } catch (error) {
+      logger.error(`Failed to add embedding ${record.id}:`, error);
+      throw error;
+    }
+  }
+
+  async addEmbeddings(records: VectorRecord[]): Promise<void> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      const data = records.map(record => ({
+        id: record.id,
+        embedding: record.embedding,
+        tenantId: record.tenantId || null,
+        agentId: record.agentId || null,
+        documentId: record.documentId || null,
+      }));
+
+      await this.table.add(data);
+    } catch (error) {
+      logger.error(`Failed to add ${records.length} embeddings:`, error);
+      throw error;
+    }
+  }
+
+  async search(
+    embedding: number[],
+    tenantId?: string,
+    agentId?: string,
+    limit: number = 10
+  ): Promise<SearchResult[]> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      let query = this.table.vectorSearch(embedding).limit(limit);
+
+      // Build filter conditions for agent-level isolation
+      const filters: string[] = [];
+
+      if (tenantId) {
+        // Use parameterized filtering to prevent SQL injection
+        const escapedTenantId = tenantId.replace(/'/g, "''");
+        filters.push(`tenantId = '${escapedTenantId}'`);
+      }
+
+      if (agentId) {
+        // Add agent-level filtering for strict agent isolation
+        const escapedAgentId = agentId.replace(/'/g, "''");
+        filters.push(`agentId = '${escapedAgentId}'`);
+      }
+
+      if (filters.length > 0) {
+        query = query.where(filters.join(' AND '));
+      }
+
+      const results = await query.toArray();
+
+      return results.map((row: any) => ({
+        id: row.id,
+        distance: row._distance || 0,
+        tenantId: row.tenantId,
+        agentId: row.agentId,
+        documentId: row.documentId,
+      }));
+    } catch (error) {
+      logger.error('Failed to search embeddings:', error);
+      throw error;
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      await this.table.delete(`id = '${id}'`);
+    } catch (error) {
+      logger.error(`Failed to delete embedding ${id}:`, error);
+      throw error;
+    }
+  }
+
+  async exists(id: string): Promise<boolean> {
+    if (!this.table) {
+      throw new Error('Vector store not initialized. Call init() first.');
+    }
+
+    try {
+      const results = await this.table.query().where(`id = '${id}'`).limit(1).toArray();
+      return results.length > 0;
+    } catch (error) {
+      logger.error(`Failed to check existence of ${id}:`, error);
+      throw error;
+    }
+  }
+
+  async close(): Promise<void> {
+    try {
+      if (this.table) {
+        // LanceDB tables don't have explicit close method
+        this.table = null;
+      }
+      if (this.db) {
+        // Note: LanceDB connection doesn't have explicit close method
+        this.db = null;
+      }
+      logger.info('LanceDB vector store closed');
+    } catch (error) {
+      logger.error('Failed to close LanceDB vector store:', error);
+      throw error;
+    }
+  }
+}
+
+export function createLanceDBStore(config: VectorStoreConfig): VectorStore {
+  return new LanceDBVectorStore(config);
+}