agentlang 0.9.6 → 0.9.7

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

@@ -228,9 +228,10 @@ function makeSqliteDataSource(
 ): DataSource {
   const synchronize = needSync();
   //const runMigrations = isRuntimeMode_migration() || isRuntimeMode_undo_migration() || !synchronize;
-  return new DataSource({
+  const dbPath = config?.dbname || mkDbName();
+  const ds = new DataSource({
     type: 'better-sqlite3',
-    database: config?.dbname || mkDbName(),
+    database: dbPath,
     synchronize: synchronize,
     entities: entities,
     migrationsRun: false,
@@ -240,6 +241,25 @@ function makeSqliteDataSource(
       undefined: 'ignore',
     },
   });
+  const originalInit = ds.initialize.bind(ds);
+  ds.initialize = async () => {
+    const res = await originalInit();
+    try {
+      const { load } = await import('sqlite-vec');
+      const driver = ds.driver as any;
+      const db = driver.databaseConnection || driver.nativeDatabase;
+      if (db) {
+        load(db);
+        logger.info('sqlite-vec extension loaded successfully');
+      }
+    } catch (err: any) {
+      logger.warn(
+        `Failed to load sqlite-vec extension: ${err.message}. Vector operations may not be available.`
+      );
+    }
+    return res;
+  };
+  return ds;
 }
 
 async function execMigrationSql(dataSource: DataSource, sql: string[]) {
@@ -371,9 +391,18 @@ export function isUsingSqljs(): boolean {
   return getDbType(AppConfig?.store) == 'sqljs';
 }
 
-export function isVectorStoreSupported(): boolean {
-  // Only Postgres supports pgvector
-  return getDbType(AppConfig?.store) === 'postgres';
+export async function isVectorStoreSupported(): Promise<boolean> {
+  const dbType = getDbType(AppConfig?.store);
+  if (dbType === 'postgres') return true;
+  if (dbType === 'sqlite') {
+    try {
+      const sqliteVecModule = await import('sqlite-vec');
+      return !!sqliteVecModule;
+    } catch {
+      return false;
+    }
+  }
+  return false;
 }
 
 export async function initDatabase(config: DatabaseConfig | undefined) {
@@ -442,50 +471,69 @@ export async function addRowForFullTextSearch(
   vect: number[],
   ctx: DbContext
 ) {
-  if (!isVectorStoreSupported()) return;
+  if (!(await isVectorStoreSupported())) return;
   try {
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).createQueryBuilder();
     const tenantId = await ctx.getTenantId();
-    const { default: pgvector } = await import('pgvector');
-    await qb
-      .insert()
-      .into(vecTableName)
-      .values([{ id: id, embedding: pgvector.toSql(vect), __tenant__: tenantId }])
-      .execute();
+    const dbType = getDbType(AppConfig?.store);
+    if (dbType === 'postgres') {
+      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) }])
+        .execute();
+    }
   } catch (err: any) {
     logger.error(`Failed to add row to vector store - ${err}`);
   }
 }
 
 export async function initVectorStore(tableNames: string[], ctx: DbContext) {
-  if (!isVectorStoreSupported()) {
+  if (!(await isVectorStoreSupported())) {
     logger.info(`Vector store not supported for ${getDbType(AppConfig?.store)}, skipping init...`);
     return;
   }
+  const dbType = getDbType(AppConfig?.store);
   let notInited = true;
-  tableNames.forEach(async (vecTableName: string) => {
+  for (const vecTableName of tableNames) {
     const vecRepo = getDatasourceForTransaction(ctx.txnId).getRepository(vecTableName);
-    if (notInited) {
-      let failure = false;
-      try {
-        await vecRepo.query('CREATE EXTENSION IF NOT EXISTS vector');
-      } catch (err: any) {
-        logger.error(`Failed to initialize vector store - ${err}`);
-        failure = true;
+    if (dbType === 'postgres') {
+      if (notInited) {
+        let failure = false;
+        try {
+          await vecRepo.query('CREATE EXTENSION IF NOT EXISTS vector');
+        } catch (err: any) {
+          logger.error(`Failed to initialize vector store - ${err}`);
+          failure = true;
+        }
+        if (failure) continue;
+        notInited = false;
       }
-      if (failure) return;
-      notInited = false;
+      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}])`
+      );
     }
-    await vecRepo.query(
-      `CREATE TABLE IF NOT EXISTS ${vecTableName} (
-          id varchar PRIMARY KEY,
-          embedding vector(${DefaultVectorDimension}),
-          ${TenantAttributeName} varchar,
-          __is_deleted__ boolean default false
-        )`
-    );
-  });
+  }
 }
 
 export async function vectorStoreSearch(
@@ -494,7 +542,7 @@ export async function vectorStoreSearch(
   limit: number,
   ctx: DbContext
 ): Promise<any> {
-  if (!isVectorStoreSupported()) {
+  if (!(await isVectorStoreSupported())) {
     // Not supported on sqljs/sqlite
     return [];
   }
@@ -508,18 +556,31 @@ export async function vectorStoreSearch(
     }
     const vecTableName = tableName + VectorSuffix;
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
-    const { default: pgvector } = await import('pgvector');
-    let ownersJoinCond: string = '';
+    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
+    let ownersJoinCond: string = '';
     if (!hasGlobalPerms) {
       const ot = ownersTable(tableName);
       ownersJoinCond = `inner join ${ot} on
-${ot}.path = ${vecTableName}.id and ${ot}.user_id = '${ctx.authInfo.userId}' and ${ot}.r = true
-and ${ot}.${TenantAttributeName} = '${tenantId}' and ${vecTableName}.${TenantAttributeName} = '${tenantId}'`;
+ ${ot}.path = ${vecTableName}.id and ${ot}.user_id = '${ctx.authInfo.userId}' and ${ot}.r = true
+ and ${ot}.${TenantAttributeName} = '${tenantId}'`;
+    }
+    if (dbType === 'postgres') {
+      const { default: pgvector } = await import('pgvector');
+      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]);
     }
-    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]);
   } catch (err: any) {
     logger.error(`Vector store search failed - ${err}`);
     return [];
@@ -531,16 +592,30 @@ export async function vectorStoreSearchEntryExists(
   id: string,
   ctx: DbContext
 ): Promise<boolean> {
-  if (!isVectorStoreSupported()) return false;
+  if (!(await isVectorStoreSupported())) return false;
   try {
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
+    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
-    const result: any[] = await qb.query(
-      `select id from ${vecTableName} where id = $1 and ${TenantAttributeName} = '${tenantId}'`,
-      [id]
-    );
-    return result !== null && result.length > 0;
+
+    if (dbType === 'postgres') {
+      const result: any[] = await qb.query(
+        `select id from ${vecTableName} where id = $1 and ${TenantAttributeName} = '${tenantId}'`,
+        [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}`);
   }
@@ -548,15 +623,22 @@ export async function vectorStoreSearchEntryExists(
 }
 
 export async function deleteFullTextSearchEntry(tableName: string, id: string, ctx: DbContext) {
-  if (!isVectorStoreSupported()) return;
+  if (!(await isVectorStoreSupported())) return;
   try {
     const qb = getDatasourceForTransaction(ctx.txnId).getRepository(tableName).manager;
     const vecTableName = tableName + VectorSuffix;
+    const dbType = getDbType(AppConfig?.store);
     const tenantId = await ctx.getTenantId();
-    await qb.query(
-      `delete from ${vecTableName} where id = $1 and ${TenantAttributeName} = '${tenantId}'`,
-      [id]
-    );
+
+    if (dbType === 'postgres') {
+      await qb.query(
+        `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}`);
   }

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

@@ -25,32 +25,96 @@ import {
 import { JoinInfo, Resolver, WhereClause } from '../interface.js';
 import { asColumnReference, asTableReference } from './dbutil.js';
 import {
-  getMany,
-  insertRow,
-  updateRow,
-  getAllConnected,
-  startDbTransaction,
+  addRowForFullTextSearch,
   commitDbTransaction,
-  rollbackDbTransaction,
-  hardDeleteRow,
   DbContext,
-  insertBetweenRow,
-  addRowForFullTextSearch,
-  vectorStoreSearch,
-  vectorStoreSearchEntryExists,
   deleteFullTextSearchEntry,
+  getAllConnected,
+  getMany,
+  getManyByJoin,
+  hardDeleteRow,
+  insertBetweenRow,
+  insertRow,
+  isVectorStoreSupported,
   JoinClause,
   JoinOn,
   makeJoinOn,
-  getManyByJoin,
   QuerySpec,
+  rollbackDbTransaction,
+  startDbTransaction,
+  updateRow,
+  vectorStoreSearch,
+  vectorStoreSearchEntryExists,
 } from './database.js';
 import { AggregateFunctionCall, Environment } from '../../interpreter.js';
-import { OpenAIEmbeddings } from '@langchain/openai';
-import { Embeddings } from '@langchain/core/embeddings';
-import { DeletedFlagAttributeName, ParentAttributeName, PathAttributeName } from '../../defs.js';
+import {
+  DeletedFlagAttributeName,
+  ParentAttributeName,
+  PathAttributeName,
+  TenantAttributeName,
+} from '../../defs.js';
 import { logger } from '../../logger.js';
 import { JoinSpec } from '../../../language/generated/ast.js';
+import { EmbeddingProvider, EmbeddingProviderConfig } from '../../embeddings/provider.js';
+import { embeddingProvider } from '../../embeddings/registry.js';
+import { TextChunker } from '../../embeddings/chunker.js';
+
+interface EmbeddingServiceConfig extends EmbeddingProviderConfig {
+  provider?: string;
+}
+
+export class EmbeddingService {
+  private provider: EmbeddingProvider;
+  private config: EmbeddingServiceConfig;
+  private chunker: TextChunker;
+
+  constructor(config?: EmbeddingServiceConfig) {
+    this.config = config || {};
+    const providerClass = embeddingProvider(this.config.provider || 'openai');
+    this.provider = new providerClass(this.config);
+    this.chunker = new TextChunker(this.getChunkSize(), this.getChunkOverlap());
+  }
+
+  private getChunkSize(): number {
+    return this.config.chunkSize || 1000;
+  }
+
+  private getChunkOverlap(): number {
+    return this.config.chunkOverlap || 200;
+  }
+
+  async embedText(text: string): Promise<number[]> {
+    const chunks = this.chunker.splitText(text);
+
+    if (chunks.length === 1) {
+      return await this.provider.embedText(chunks[0]);
+    }
+
+    const chunkEmbeddings = await Promise.all(
+      chunks.map((chunk: string) => this.provider.embedText(chunk))
+    );
+
+    return this.averageEmbeddings(chunkEmbeddings);
+  }
+
+  async embedQuery(query: string): Promise<number[]> {
+    return await this.provider.embedText(query);
+  }
+
+  private averageEmbeddings(embeddings: number[][]): number[] {
+    if (embeddings.length === 0) return [];
+    const dimension = embeddings[0].length;
+    const averaged = new Array(dimension).fill(0);
+
+    for (const embedding of embeddings) {
+      for (let i = 0; i < dimension; i++) {
+        averaged[i] += embedding[i];
+      }
+    }
+
+    return averaged.map((v: number) => v / embeddings.length);
+  }
+}
 
 function maybeFindIdAttributeName(inst: Instance): string | undefined {
   const attrEntry: AttributeEntry | undefined = findIdAttribute(inst);
@@ -62,12 +126,18 @@ function maybeFindIdAttributeName(inst: Instance): string | undefined {
 
 export class SqlDbResolver extends Resolver {
   private txnId: string | undefined;
-  private embeddings: Embeddings;
+  private _embeddingService: EmbeddingService | undefined;
 
   constructor(name: string) {
     super();
     this.name = name;
-    this.embeddings = new OpenAIEmbeddings();
+  }
+
+  private get embeddingService(): EmbeddingService {
+    if (!this._embeddingService) {
+      this._embeddingService = new EmbeddingService();
+    }
+    return this._embeddingService;
   }
 
   public override getName(): string {
@@ -93,6 +163,45 @@ export class SqlDbResolver extends Resolver {
     return entryName;
   }
 
+  private extractTextForEmbedding(rowObj: object, searchAttributes: string[] | undefined): string {
+    const obj = rowObj as Record<string, any>;
+    const ftsAttrs =
+      !searchAttributes || searchAttributes.length === 0 || searchAttributes[0] === '*'
+        ? Object.keys(obj).filter(k => this.shouldIncludeAttribute(k))
+        : searchAttributes;
+
+    const parts: string[] = [];
+    for (const attr of ftsAttrs) {
+      const value = obj[attr];
+      if (value !== undefined && value !== null) {
+        parts.push(this.valueToString(value));
+      }
+    }
+
+    return parts.join(' ');
+  }
+
+  private shouldIncludeAttribute(key: string): boolean {
+    const excludedAttrs = [
+      PathAttributeName,
+      DeletedFlagAttributeName,
+      TenantAttributeName,
+      '__tenant__',
+      '__is_deleted__',
+    ];
+    return !excludedAttrs.includes(key);
+  }
+
+  private valueToString(value: any): string {
+    if (Array.isArray(value)) {
+      return value.join(' ');
+    }
+    if (typeof value === 'object' && value !== null) {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+
   private async insertInstance(inst: Instance, orUpdate = false): Promise<Instance> {
     const ctx = this.getDbContext(inst.getFqName());
     if (isBetweenRelationship(inst.name, inst.moduleName)) {
@@ -107,35 +216,43 @@ export class SqlDbResolver extends Resolver {
         ctx.activeEnv.isInDeleteMode()
       );
       return inst;
-    } else {
-      const idAttrName: string | undefined = maybeFindIdAttributeName(inst);
-      ensureOneToOneAttributes(inst);
-      const attrs: InstanceAttributes = inst.attributes;
-      const idAttrVal: any = idAttrName ? attrs.get(idAttrName) : crypto.randomUUID();
-      if (idAttrVal !== undefined) {
-        const pp: string | undefined = attrs.get(PathAttributeName);
-        const n: string = `${inst.moduleName}/${inst.name}`;
-        let p: string = '';
-        if (pp !== undefined) p = `${pp}/${escapeFqName(n)}/${idAttrVal}`;
-        else p = `${n.replace('/', '$')}/${idAttrVal}`;
-        attrs.set(PathAttributeName, p);
-      }
-      const n: string = asTableReference(inst.moduleName, inst.name);
-      const rowObj: object = inst.attributesWithStringifiedObjects();
-      await insertRow(n, rowObj, ctx, orUpdate);
-      if (inst.record.getFullTextSearchAttributes()) {
-        const path = attrs.get(PathAttributeName);
-        try {
-          if (!(await vectorStoreSearchEntryExists(n, path, ctx))) {
-            const res = await this.embeddings.embedQuery(JSON.stringify(rowObj));
-            await addRowForFullTextSearch(n, path, res, ctx);
-          }
-        } catch (reason: any) {
-          logger.warn(`Full text indexing failed for ${path} - ${reason}`);
+    }
+    const idAttrName: string | undefined = maybeFindIdAttributeName(inst);
+    ensureOneToOneAttributes(inst);
+    const attrs: InstanceAttributes = inst.attributes;
+    const idAttrVal: any = idAttrName ? attrs.get(idAttrName) : crypto.randomUUID();
+    if (idAttrVal !== undefined) {
+      const pp: string | undefined = attrs.get(PathAttributeName);
+      const n: string = `${inst.moduleName}/${inst.name}`;
+      let p: string = '';
+      if (pp !== undefined) p = `${pp}/${escapeFqName(n)}/${idAttrVal}`;
+      else p = `${n.replace('/', '$')}/${idAttrVal}`;
+      attrs.set(PathAttributeName, p);
+    }
+    const n: string = asTableReference(inst.moduleName, inst.name);
+    const rowObj: object = inst.attributesWithStringifiedObjects();
+    await insertRow(n, rowObj, ctx, orUpdate);
+    if (inst.record.getEmbeddingConfig() || inst.record.getFullTextSearchAttributes()) {
+      const path = attrs.get(PathAttributeName);
+      try {
+        if (
+          (await isVectorStoreSupported()) &&
+          !(await vectorStoreSearchEntryExists(n, path, ctx))
+        ) {
+          const ftsAttrs = inst.record.getFullTextSearchAttributes() || ['*'];
+          const textToEmbed = this.extractTextForEmbedding(rowObj, ftsAttrs);
+          const embeddingConfig = inst.record.getEmbeddingConfig();
+          const embeddingService = embeddingConfig
+            ? new EmbeddingService(embeddingConfig)
+            : this.embeddingService;
+          const res = await embeddingService.embedText(textToEmbed);
+          await addRowForFullTextSearch(n, path, res, ctx);
         }
+      } catch (reason: any) {
+        logger.warn(`Full text indexing failed for ${path} - ${reason}`);
       }
-      return inst;
     }
+    return inst;
   }
 
   public override async createInstance(inst: Instance): Promise<Instance> {
@@ -211,9 +328,42 @@ export class SqlDbResolver extends Resolver {
       : undefined;
     const orderByDesc = inst.orderByDesc ? 'DESC' : 'ASC';
     const aggregates = SqlDbResolver.normalizedAggregates(inst, tableName);
+
+    let vectorResult: Instance[] | undefined;
+    const embeddingConfig = inst.record.getEmbeddingConfig();
+    const ftsAttrs = inst.record.getFullTextSearchAttributes();
+    if (
+      (await isVectorStoreSupported()) &&
+      embeddingConfig &&
+      qattrs &&
+      (ftsAttrs || Object.keys(qattrs).some(k => k.endsWith('?')))
+    ) {
+      const vectorSearchAttr = Object.keys(qattrs).find(k => k.endsWith('?'));
+      if (vectorSearchAttr) {
+        const queryVal = qvals[vectorSearchAttr];
+        const searchString = this.valueToString(queryVal);
+        const embeddingService = new EmbeddingService(embeddingConfig);
+        const queryVec = await embeddingService.embedQuery(searchString);
+        const rslt: any = await vectorStoreSearch(tableName, queryVec, 10, ctx);
+        if (rslt instanceof Array) {
+          vectorResult = new Array<Instance>();
+          rslt.forEach((r: any) => {
+            const attrs: InstanceAttributes = maybeNormalizeAttributeNames(
+              tableName,
+              new Map(Object.entries(r))
+            );
+            attrs.delete(DeletedFlagAttributeName);
+            vectorResult!.push(Instance.newWithAttributes(inst, attrs));
+          });
+        }
+        delete qattrs[vectorSearchAttr];
+        delete qvals[vectorSearchAttr];
+      }
+    }
+
     const qspec: QuerySpec = {
-      queryObj: qattrs,
-      queryVals: qvals,
+      queryObj: Object.keys(qattrs || {}).length > 0 ? qattrs : undefined,
+      queryVals: Object.keys(qvals || {}).length > 0 ? qvals : undefined,
       distinct,
       groupBy,
       orderBy,
@@ -224,20 +374,47 @@ export class SqlDbResolver extends Resolver {
       whereClauses: undefined,
     };
     const readOnlyAttrs = inst.record.getWriteOnlyAttributes();
-    const rslt: any = await getMany(tableName, qspec, ctx);
+    const rslt: any =
+      vectorResult !== undefined && qspec.queryObj === undefined
+        ? vectorResult
+        : await getMany(tableName, qspec, ctx);
     if (rslt instanceof Array) {
-      result = new Array<Instance>();
-      rslt.forEach((r: object) => {
-        const attrs: InstanceAttributes = maybeNormalizeAttributeNames(
-          tableName,
-          new Map(Object.entries(r))
-        );
-        attrs.delete(DeletedFlagAttributeName);
-        readOnlyAttrs?.forEach((n: string) => {
-          attrs.delete(n);
+      if (vectorResult !== undefined && qspec.queryObj !== undefined) {
+        // Merge results if both vector and standard queries were performed
+        const vectorPaths = new Set(vectorResult.map(i => i.lookup(PathAttributeName)));
+        result = new Array<Instance>();
+        rslt.forEach((r: any) => {
+          const attrs: InstanceAttributes = maybeNormalizeAttributeNames(
+            tableName,
+            new Map(Object.entries(r))
+          );
+          if (vectorPaths.has(attrs.get(PathAttributeName))) {
+            attrs.delete(DeletedFlagAttributeName);
+            readOnlyAttrs?.forEach((n: string) => {
+              attrs.delete(n);
+            });
+            result.push(Instance.newWithAttributes(inst, attrs));
+          }
         });
-        result.push(Instance.newWithAttributes(inst, attrs));
-      });
+      } else {
+        result =
+          vectorResult !== undefined && qspec.queryObj === undefined
+            ? vectorResult
+            : new Array<Instance>();
+        if (vectorResult === undefined || qspec.queryObj !== undefined) {
+          rslt.forEach((r: any) => {
+            const attrs: InstanceAttributes = maybeNormalizeAttributeNames(
+              tableName,
+              new Map(Object.entries(r))
+            );
+            attrs.delete(DeletedFlagAttributeName);
+            readOnlyAttrs?.forEach((n: string) => {
+              attrs.delete(n);
+            });
+            result.push(Instance.newWithAttributes(inst, attrs));
+          });
+        }
+      }
     }
     return result;
   }
@@ -555,7 +732,7 @@ export class SqlDbResolver extends Resolver {
     query: string,
     options?: any
   ): Promise<any> {
-    const queryVec = await this.embeddings.embedQuery(query);
+    const queryVec = await this.embeddingService.embedQuery(query);
     const ctx = this.getDbContext(makeFqName(moduleName, entryName));
     let limit = 5;
     if (options && options.limit) {