@mastra/qdrant 1.0.0-beta.4 → 1.0.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { createVectorErrorId } from '@mastra/core/storage';
-import { MastraVector } from '@mastra/core/vector';
+import { MastraVector, validateUpsertInput } from '@mastra/core/vector';
 import { QdrantClient } from '@qdrant/js-client-rest';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
@@ -13,11 +13,15 @@ var QdrantFilterTranslator = class extends BaseFilterTranslator {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
       logical: ["$and", "$or", "$not"],
-      array: ["$in", "$nin"],
+      array: ["$in", "$nin", "$all"],
       regex: ["$regex"],
+      element: ["$exists"],
       custom: ["$count", "$geo", "$nested", "$datetime", "$null", "$empty", "$hasId", "$hasVector"]
     };
   }
+  isOperator(key) {
+    return super.isOperator(key) || key === "$not";
+  }
   translate(filter) {
     if (this.isEmpty(filter)) return filter;
     this.validateFilter(filter);
@@ -44,7 +48,7 @@ var QdrantFilterTranslator = class extends BaseFilterTranslator {
       return node.length === 0 ? { is_empty: { key: fieldKey } } : this.createCondition("match", { any: this.normalizeArrayValues(node) }, fieldKey);
     }
     const entries = Object.entries(node);
-    const logicalResult = this.handleLogicalOperators(entries, isNested);
+    const logicalResult = this.handleLogicalOperators(entries, isNested, fieldKey);
     if (logicalResult) {
       return logicalResult;
     }
@@ -66,8 +70,11 @@ var QdrantFilterTranslator = class extends BaseFilterTranslator {
       return { must: conditions };
     }
   }
-  handleLogicalOperators(entries, isNested) {
+  handleLogicalOperators(entries, isNested, fieldKey) {
     const firstKey = entries[0]?.[0];
+    if (firstKey === "$not" && fieldKey) {
+      return null;
+    }
     if (firstKey && this.isLogicalOperator(firstKey) && !this.isCustomOperator(firstKey)) {
       const [key, value] = entries[0];
       const qdrantOp = this.getQdrantLogicalOp(key);
@@ -92,7 +99,34 @@ var QdrantFilterTranslator = class extends BaseFilterTranslator {
         conditions.push(customOp);
       } else if (this.isOperator(key)) {
         const opResult = this.translateOperatorValue(key, value);
-        if (opResult.range) {
+        if (opResult._specialNull) {
+          conditions.push({ is_null: { key: fieldKey } });
+        } else if (opResult._specialNotNull) {
+          conditions.push({ must_not: [{ is_null: { key: fieldKey } }] });
+        } else if (opResult._specialNe) {
+          conditions.push({
+            must_not: [{ key: fieldKey, match: { value: opResult._specialNe } }]
+          });
+        } else if (opResult._specialNin) {
+          conditions.push({
+            must_not: [{ key: fieldKey, match: { any: opResult._specialNin } }]
+          });
+        } else if (opResult._specialAll) {
+          for (const val of opResult._specialAll) {
+            conditions.push({ key: fieldKey, match: { value: val } });
+          }
+        } else if (opResult._specialExists) {
+          conditions.push({
+            must_not: [{ is_null: { key: fieldKey } }, { is_empty: { key: fieldKey } }]
+          });
+        } else if (opResult._specialNotExists) {
+          conditions.push({
+            should: [{ is_null: { key: fieldKey } }, { is_empty: { key: fieldKey } }]
+          });
+        } else if (opResult._specialNot) {
+          const innerResult = this.translateNode(opResult._specialNot, true, fieldKey);
+          conditions.push({ must_not: [innerResult] });
+        } else if (opResult.range) {
           Object.assign(range, opResult.range);
         } else {
           matchCondition = opResult;
@@ -163,9 +197,15 @@ var QdrantFilterTranslator = class extends BaseFilterTranslator {
     const normalizedValue = this.normalizeComparisonValue(value);
     switch (operator) {
       case "$eq":
+        if (value === null) {
+          return { _specialNull: true };
+        }
         return { value: normalizedValue };
       case "$ne":
-        return { except: [normalizedValue] };
+        if (value === null) {
+          return { _specialNotNull: true };
+        }
+        return { _specialNe: normalizedValue };
       case "$gt":
         return { range: { gt: normalizedValue } };
       case "$gte":
@@ -177,15 +217,15 @@ var QdrantFilterTranslator = class extends BaseFilterTranslator {
       case "$in":
         return { any: this.normalizeArrayValues(value) };
       case "$nin":
-        return { except: this.normalizeArrayValues(value) };
+        return { _specialNin: this.normalizeArrayValues(value) };
       case "$regex":
         return { text: value };
-      case "exists":
-        return value ? {
-          must_not: [{ is_null: { key: value } }, { is_empty: { key: value } }]
-        } : {
-          is_empty: { key: value }
-        };
+      case "$all":
+        return { _specialAll: this.normalizeArrayValues(value) };
+      case "$exists":
+        return value ? { _specialExists: true } : { _specialNotExists: true };
+      case "$not":
+        return { _specialNot: value };
       default:
         throw new Error(`Unsupported operator: ${operator}`);
     }
@@ -250,18 +290,55 @@ var QdrantVector = class extends MastraVector {
     super({ id });
     this.client = new QdrantClient(qdrantParams);
   }
-  async upsert({ indexName, vectors, metadata, ids }) {
+  /**
+   * Validates that a named vector exists in the collection.
+   * @param indexName - The name of the collection to check.
+   * @param vectorName - The name of the vector space to validate.
+   * @throws Error if the vector name doesn't exist in the collection.
+   */
+  async validateVectorName(indexName, vectorName) {
+    const { config } = await this.client.getCollection(indexName);
+    const vectorsConfig = config.params.vectors;
+    const isNamedVectors = vectorsConfig && typeof vectorsConfig === "object" && !("size" in vectorsConfig);
+    if (!isNamedVectors || !(vectorName in vectorsConfig)) {
+      throw new Error(`Vector name "${vectorName}" does not exist in collection "${indexName}"`);
+    }
+  }
+  /**
+   * Upserts vectors into the index.
+   * @param indexName - The name of the index to upsert into.
+   * @param vectors - Array of embedding vectors.
+   * @param metadata - Optional metadata for each vector.
+   * @param ids - Optional vector IDs (auto-generated if not provided).
+   * @param vectorName - Optional name of the vector space when using named vectors.
+   */
+  async upsert({ indexName, vectors, metadata, ids, vectorName }) {
+    validateUpsertInput("QDRANT", vectors, metadata, ids);
     const pointIds = ids || vectors.map(() => crypto.randomUUID());
+    if (vectorName) {
+      try {
+        await this.validateVectorName(indexName, vectorName);
+      } catch (validationError) {
+        throw new MastraError(
+          {
+            id: createVectorErrorId("QDRANT", "UPSERT", "INVALID_VECTOR_NAME"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            details: { indexName, vectorName }
+          },
+          validationError
+        );
+      }
+    }
     const records = vectors.map((vector, i) => ({
       id: pointIds[i],
-      vector,
+      vector: vectorName ? { [vectorName]: vector } : vector,
       payload: metadata?.[i] || {}
     }));
     try {
       for (let i = 0; i < records.length; i += BATCH_SIZE) {
         const batch = records.slice(i, i + BATCH_SIZE);
         await this.client.upsert(indexName, {
-          // @ts-expect-error
           points: batch,
           wait: true
         });
@@ -273,19 +350,60 @@ var QdrantVector = class extends MastraVector {
           id: createVectorErrorId("QDRANT", "UPSERT", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, vectorCount: vectors.length }
+          details: { indexName, vectorCount: vectors.length, ...vectorName && { vectorName } }
         },
         error
       );
     }
   }
-  async createIndex({ indexName, dimension, metric = "cosine" }) {
+  /**
+   * Creates a new index (collection) in Qdrant.
+   * Supports both single vector and named vector configurations.
+   *
+   * @param indexName - The name of the collection to create.
+   * @param dimension - Vector dimension (required for single vector mode).
+   * @param metric - Distance metric (default: 'cosine').
+   * @param namedVectors - Optional named vector configurations for multi-vector collections.
+   *
+   * @example
+   * ```ts
+   * // Single vector collection
+   * await qdrant.createIndex({ indexName: 'docs', dimension: 768, metric: 'cosine' });
+   *
+   * // Named vectors collection
+   * await qdrant.createIndex({
+   *   indexName: 'multi-modal',
+   *   dimension: 768, // Used as fallback, can be omitted with namedVectors
+   *   namedVectors: {
+   *     text: { size: 768, distance: 'cosine' },
+   *     image: { size: 512, distance: 'euclidean' },
+   *   },
+   * });
+   * ```
+   */
+  async createIndex({ indexName, dimension, metric = "cosine", namedVectors }) {
     try {
-      if (!Number.isInteger(dimension) || dimension <= 0) {
-        throw new Error("Dimension must be a positive integer");
-      }
-      if (!DISTANCE_MAPPING[metric]) {
-        throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
+      if (namedVectors) {
+        if (Object.keys(namedVectors).length === 0) {
+          throw new Error("namedVectors must contain at least one named vector configuration");
+        }
+        for (const [name, config] of Object.entries(namedVectors)) {
+          if (!Number.isInteger(config.size) || config.size <= 0) {
+            throw new Error(`Named vector "${name}": size must be a positive integer`);
+          }
+          if (!DISTANCE_MAPPING[config.distance]) {
+            throw new Error(
+              `Named vector "${name}": invalid distance "${config.distance}". Must be one of: cosine, euclidean, dotproduct`
+            );
+          }
+        }
+      } else {
+        if (!Number.isInteger(dimension) || dimension <= 0) {
+          throw new Error("Dimension must be a positive integer");
+        }
+        if (!DISTANCE_MAPPING[metric]) {
+          throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
+        }
       }
     } catch (validationError) {
       throw new MastraError(
@@ -293,22 +411,49 @@ var QdrantVector = class extends MastraVector {
           id: createVectorErrorId("QDRANT", "CREATE_INDEX", "INVALID_ARGS"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.USER,
-          details: { indexName, dimension, metric }
+          details: {
+            indexName,
+            dimension,
+            metric,
+            ...namedVectors && { namedVectorNames: Object.keys(namedVectors).join(", ") }
+          }
         },
         validationError
       );
     }
     try {
-      await this.client.createCollection(indexName, {
-        vectors: {
-          size: dimension,
-          distance: DISTANCE_MAPPING[metric]
-        }
-      });
+      if (namedVectors) {
+        const namedVectorsConfig = Object.entries(namedVectors).reduce(
+          (acc, [name, config]) => {
+            acc[name] = {
+              size: config.size,
+              distance: DISTANCE_MAPPING[config.distance]
+            };
+            return acc;
+          },
+          {}
+        );
+        await this.client.createCollection(indexName, {
+          vectors: namedVectorsConfig
+        });
+      } else {
+        await this.client.createCollection(indexName, {
+          vectors: {
+            size: dimension,
+            distance: DISTANCE_MAPPING[metric]
+          }
+        });
+      }
     } catch (error) {
       const message = error?.message || error?.toString();
       if (error?.status === 409 || typeof message === "string" && message.toLowerCase().includes("exists")) {
-        await this.validateExistingIndex(indexName, dimension, metric);
+        if (!namedVectors) {
+          await this.validateExistingIndex(indexName, dimension, metric);
+        } else {
+          this.logger.info(
+            `Collection "${indexName}" already exists. Skipping validation for named vectors configuration.`
+          );
+        }
         return;
       }
       throw new MastraError(
@@ -326,12 +471,23 @@ var QdrantVector = class extends MastraVector {
     const translator = new QdrantFilterTranslator();
     return translator.translate(filter);
   }
+  /**
+   * Queries the index for similar vectors.
+   *
+   * @param indexName - The name of the index to query.
+   * @param queryVector - The query vector to find similar vectors for.
+   * @param topK - Number of results to return (default: 10).
+   * @param filter - Optional metadata filter.
+   * @param includeVector - Whether to include vectors in results (default: false).
+   * @param using - Name of the vector space to query when using named vectors.
+   */
   async query({
     indexName,
     queryVector,
     topK = 10,
     filter,
-    includeVector = false
+    includeVector = false,
+    using
   }) {
     const translatedFilter = this.transformFilter(filter) ?? {};
     try {
@@ -340,15 +496,20 @@ var QdrantVector = class extends MastraVector {
         limit: topK,
         filter: translatedFilter,
         with_payload: true,
-        with_vector: includeVector
+        with_vector: includeVector,
+        ...using ? { using } : {}
       })).points;
       return results.map((match) => {
         let vector = [];
-        if (includeVector) {
+        if (includeVector && match.vector != null) {
           if (Array.isArray(match.vector)) {
             vector = match.vector;
           } else if (typeof match.vector === "object" && match.vector !== null) {
-            vector = Object.values(match.vector).filter((v) => typeof v === "number");
+            const namedVectors = match.vector;
+            const sourceArray = using && Array.isArray(namedVectors[using]) ? namedVectors[using] : Object.values(namedVectors).find((v) => Array.isArray(v));
+            if (sourceArray) {
+              vector = sourceArray.filter((v) => typeof v === "number");
+            }
           }
         }
         return {
@@ -364,7 +525,7 @@ var QdrantVector = class extends MastraVector {
           id: createVectorErrorId("QDRANT", "QUERY", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, topK }
+          details: { indexName, topK, ...using && { using } }
         },
         error
       );