@mastra/lance 1.1.0 → 1.1.1

package/dist/index.js

@@ -2645,7 +2645,8 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
     includeVector = false,
     topK = 10,
     columns = [],
-    includeAllColumns = false
+    includeAllColumns = false,
+    metric
   }) {
     const resolvedTableName = tableName ?? indexName;
     if (!queryVector) {
@@ -2683,7 +2684,11 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
         return [];
       }
       const table = await this.lanceClient.openTable(resolvedTableName);
-      let query = table.search(queryVector);
+      const resolvedMetric = await this.resolveQueryMetric(table, {
+        columnName: tableName ? indexName : "vector",
+        explicitMetric: metric
+      });
+      let query = table.vectorSearch(queryVector).distanceType(this.mastraMetricToLance(resolvedMetric));
       if (filter && Object.keys(filter).length > 0) {
         const whereClause = this.filterTranslator(filter);
         this.logger.debug(`Where clause generated: ${whereClause}`);
@@ -2704,6 +2709,9 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
         if (!selectColumns.includes("id")) {
           selectColumns.push("id");
         }
+        if (!selectColumns.includes("_distance")) {
+          selectColumns.push("_distance");
+        }
         query = query.select(selectColumns);
       }
       query = query.limit(topK);
@@ -2724,7 +2732,7 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
           metadata,
           vector: includeVector && result.vector ? Array.isArray(result.vector) ? result.vector : Array.from(result.vector) : void 0,
           document: result.document,
-          score: result._distance
+          score: this.distanceToScore(result._distance, resolvedMetric)
         };
       });
     } catch (error) {
@@ -2739,6 +2747,85 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
       );
     }
   }
+  /**
+   * Maps a Mastra distance metric to the LanceDB distance type.
+   */
+  mastraMetricToLance(metric) {
+    switch (metric) {
+      case "euclidean":
+        return "l2";
+      case "dotproduct":
+        return "dot";
+      case "cosine":
+      default:
+        return "cosine";
+    }
+  }
+  /**
+   * Determines the distance metric to use for a query.
+   *
+   * Precedence: the table's vector index metric wins when an index exists because
+   * LanceDB requires indexed searches to use the same distance type the index was
+   * trained with; otherwise an explicitly provided metric is used; otherwise it
+   * defaults to 'cosine'.
+   */
+  async resolveQueryMetric(table, {
+    columnName,
+    explicitMetric
+  }) {
+    try {
+      const indices = await table.listIndices();
+      const matchingIndices = indices.filter((index) => index.columns?.includes(columnName));
+      for (const index of matchingIndices.length > 0 ? matchingIndices : indices) {
+        const stats = await table.indexStats(index.name);
+        const resolved = this.lanceMetricToMastra(stats?.distanceType);
+        if (resolved) {
+          if (explicitMetric && explicitMetric !== resolved) {
+            this.logger.warn(
+              `Ignoring query metric "${explicitMetric}" because Lance index "${index.name}" uses "${resolved}".`
+            );
+          }
+          return resolved;
+        }
+      }
+    } catch (error) {
+      this.logger.debug("Failed to resolve metric from Lance index stats.", error);
+    }
+    return explicitMetric ?? "cosine";
+  }
+  lanceMetricToMastra(metric) {
+    switch (metric) {
+      case "l2":
+        return "euclidean";
+      case "dot":
+        return "dotproduct";
+      case "cosine":
+        return "cosine";
+      default:
+        return void 0;
+    }
+  }
+  /**
+   * Converts a LanceDB `_distance` (smaller = more similar) into a Mastra similarity
+   * `score` (larger = more similar), consistent with every other Mastra vector store.
+   *
+   * - cosine: LanceDB returns cosine distance (`1 - cosine_similarity`), so `1 - distance`
+   *   recovers the cosine similarity.
+   * - dotproduct: LanceDB's dot distance is `1 - dot_product`, so `1 - distance` recovers
+   *   the dot product (matching `@mastra/pg`).
+   * - euclidean: LanceDB returns squared L2 distance for `l2`, so use its square root
+   *   before mapping into (0, 1] (matching `@mastra/pg`).
+   */
+  distanceToScore(distance, metric) {
+    switch (metric) {
+      case "euclidean":
+        return 1 / (1 + Math.sqrt(distance));
+      case "dotproduct":
+      case "cosine":
+      default:
+        return 1 - distance;
+    }
+  }
   filterTranslator(filter) {
     const processFilterKeys = (filterObj) => {
       const result = {};
@@ -3031,14 +3118,7 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
       } else {
         table = await this.lanceClient.openTable(resolvedTableName);
       }
-      let metricType;
-      if (metric === "euclidean") {
-        metricType = "l2";
-      } else if (metric === "dotproduct") {
-        metricType = "dot";
-      } else if (metric === "cosine") {
-        metricType = "cosine";
-      }
+      const metricType = this.mastraMetricToLance(metric);
       const rowCount = await table.countRows();
       if (rowCount < 256) {
         this.logger.warn(
@@ -3143,7 +3223,7 @@ var LanceVectorStore = class _LanceVectorStore extends MastraVector {
           const dimension = vectorField?.type?.["listSize"] || 0;
           return {
             dimension,
-            metric: stats.distanceType,
+            metric: this.lanceMetricToMastra(stats.distanceType),
             count: stats.numIndexedRows
           };
         }