@mastra/qdrant 1.1.1 → 1.1.2

package/dist/index.js

@@ -1,1058 +1,933 @@
-import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { createVectorErrorId } from '@mastra/core/storage';
-import { MastraVector, validateUpsertInput } from '@mastra/core/vector';
-import { QdrantClient } from '@qdrant/js-client-rest';
-import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-
-// src/vector/index.ts
+import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
+import { createVectorErrorId } from "@mastra/core/storage";
+import { MastraVector, validateUpsertInput } from "@mastra/core/vector";
+import { QdrantClient } from "@qdrant/js-client-rest";
+import { BaseFilterTranslator } from "@mastra/core/vector/filter";
+//#region src/vector/filter.ts
+/**
+* Translates MongoDB-style filters to Qdrant compatible filters.
+*
+* Key transformations:
+* - $and -> must
+* - $or -> should
+* - $not -> must_not
+* - { field: { $op: value } } -> { key: field, match/range: { value/gt/lt: value } }
+*
+* Custom operators (Qdrant-specific):
+* - $count -> values_count (array length/value count)
+* - $geo -> geo filters (box, radius, polygon)
+* - $hasId -> has_id filter
+* - $nested -> nested object filters
+* - $hasVector -> vector existence check
+* - $datetime -> RFC 3339 datetime range
+* - $null -> is_null check
+* - $empty -> is_empty check
+*/
 var QdrantFilterTranslator = class extends BaseFilterTranslator {
-  isLogicalOperator(key) {
-    return super.isLogicalOperator(key) || key === "$hasId" || key === "$hasVector";
-  }
-  getSupportedOperators() {
-    return {
-      ...BaseFilterTranslator.DEFAULT_OPERATORS,
-      logical: ["$and", "$or", "$not"],
-      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);
-    return this.translateNode(filter);
-  }
-  createCondition(type, value, fieldKey) {
-    const condition = { [type]: value };
-    return fieldKey ? { key: fieldKey, ...condition } : condition;
-  }
-  translateNode(node, isNested = false, fieldKey) {
-    if (!this.isEmpty(node) && !!node && typeof node === "object" && "must" in node) {
-      return node;
-    }
-    if (this.isPrimitive(node)) {
-      if (node === null) {
-        return { is_null: { key: fieldKey } };
-      }
-      return this.createCondition("match", { value: this.normalizeComparisonValue(node) }, fieldKey);
-    }
-    if (this.isRegex(node)) {
-      throw new Error("Direct regex pattern format is not supported in Qdrant");
-    }
-    if (Array.isArray(node)) {
-      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, fieldKey);
-    if (logicalResult) {
-      return logicalResult;
-    }
-    const { conditions, range, matchCondition } = this.handleFieldConditions(entries, fieldKey);
-    if (Object.keys(range).length > 0) {
-      conditions.push({ key: fieldKey, range });
-    }
-    if (matchCondition) {
-      conditions.push({ key: fieldKey, match: matchCondition });
-    }
-    return this.buildFinalConditions(conditions, isNested);
-  }
-  buildFinalConditions(conditions, isNested) {
-    if (conditions.length === 0) {
-      return {};
-    } else if (conditions.length === 1 && isNested) {
-      return conditions[0];
-    } else {
-      return { must: conditions };
-    }
-  }
-  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);
-      return {
-        [qdrantOp]: Array.isArray(value) ? value.map((v) => this.translateNode(v, true)) : [this.translateNode(value, true)]
-      };
-    }
-    if (entries.length > 1 && !isNested && entries.every(([key]) => !this.isOperator(key) && !this.isCustomOperator(key))) {
-      return {
-        must: entries.map(([key, value]) => this.translateNode(value, true, key))
-      };
-    }
-    return null;
-  }
-  handleFieldConditions(entries, fieldKey) {
-    const conditions = [];
-    let range = {};
-    let matchCondition = null;
-    for (const [key, value] of entries) {
-      if (this.isCustomOperator(key)) {
-        const customOp = this.translateCustomOperator(key, value, fieldKey);
-        conditions.push(customOp);
-      } else if (this.isOperator(key)) {
-        const opResult = this.translateOperatorValue(key, value);
-        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;
-        }
-      } else {
-        const nestedKey = fieldKey ? `${fieldKey}.${key}` : key;
-        const nestedCondition = this.translateNode(value, true, nestedKey);
-        if (nestedCondition.must) {
-          conditions.push(...nestedCondition.must);
-        } else if (!this.isEmpty(nestedCondition)) {
-          conditions.push(nestedCondition);
-        }
-      }
-    }
-    return { conditions, range, matchCondition };
-  }
-  translateCustomOperator(op, value, fieldKey) {
-    switch (op) {
-      case "$count":
-        const countConditions = Object.entries(value).reduce(
-          (acc, [k, v]) => ({
-            ...acc,
-            [k.replace("$", "")]: v
-          }),
-          {}
-        );
-        return { key: fieldKey, values_count: countConditions };
-      case "$geo":
-        const geoOp = this.translateGeoFilter(value.type, value);
-        return { key: fieldKey, ...geoOp };
-      case "$hasId":
-        return { has_id: Array.isArray(value) ? value : [value] };
-      case "$nested":
-        return {
-          nested: {
-            key: fieldKey,
-            filter: this.translateNode(value)
-          }
-        };
-      case "$hasVector":
-        return { has_vector: value };
-      case "$datetime":
-        return {
-          key: fieldKey,
-          range: this.normalizeDatetimeRange(value.range)
-        };
-      case "$null":
-        return { is_null: { key: fieldKey } };
-      case "$empty":
-        return { is_empty: { key: fieldKey } };
-      default:
-        throw new Error(`Unsupported custom operator: ${op}`);
-    }
-  }
-  getQdrantLogicalOp(op) {
-    switch (op) {
-      case "$and":
-        return "must";
-      case "$or":
-        return "should";
-      case "$not":
-        return "must_not";
-      default:
-        throw new Error(`Unsupported logical operator: ${op}`);
-    }
-  }
-  translateOperatorValue(operator, value) {
-    const normalizedValue = this.normalizeComparisonValue(value);
-    switch (operator) {
-      case "$eq":
-        if (value === null) {
-          return { _specialNull: true };
-        }
-        return { value: normalizedValue };
-      case "$ne":
-        if (value === null) {
-          return { _specialNotNull: true };
-        }
-        return { _specialNe: normalizedValue };
-      case "$gt":
-        return { range: { gt: normalizedValue } };
-      case "$gte":
-        return { range: { gte: normalizedValue } };
-      case "$lt":
-        return { range: { lt: normalizedValue } };
-      case "$lte":
-        return { range: { lte: normalizedValue } };
-      case "$in":
-        return { any: this.normalizeArrayValues(value) };
-      case "$nin":
-        return { _specialNin: this.normalizeArrayValues(value) };
-      case "$regex":
-        return { text: 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}`);
-    }
-  }
-  translateGeoFilter(type, value) {
-    switch (type) {
-      case "box":
-        return {
-          geo_bounding_box: {
-            top_left: value.top_left,
-            bottom_right: value.bottom_right
-          }
-        };
-      case "radius":
-        return {
-          geo_radius: {
-            center: value.center,
-            radius: value.radius
-          }
-        };
-      case "polygon":
-        return {
-          geo_polygon: {
-            exterior: value.exterior,
-            interiors: value.interiors
-          }
-        };
-      default:
-        throw new Error(`Unsupported geo filter type: ${type}`);
-    }
-  }
-  normalizeDatetimeRange(value) {
-    const range = {};
-    for (const [op, val] of Object.entries(value)) {
-      if (val instanceof Date) {
-        range[op] = val.toISOString();
-      } else if (typeof val === "string") {
-        range[op] = val;
-      }
-    }
-    return range;
-  }
+	isLogicalOperator(key) {
+		return super.isLogicalOperator(key) || key === "$hasId" || key === "$hasVector";
+	}
+	getSupportedOperators() {
+		return {
+			...BaseFilterTranslator.DEFAULT_OPERATORS,
+			logical: [
+				"$and",
+				"$or",
+				"$not"
+			],
+			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);
+		return this.translateNode(filter);
+	}
+	createCondition(type, value, fieldKey) {
+		const condition = { [type]: value };
+		return fieldKey ? {
+			key: fieldKey,
+			...condition
+		} : condition;
+	}
+	translateNode(node, isNested = false, fieldKey) {
+		if (!this.isEmpty(node) && !!node && typeof node === "object" && "must" in node) return node;
+		if (this.isPrimitive(node)) {
+			if (node === null) return { is_null: { key: fieldKey } };
+			return this.createCondition("match", { value: this.normalizeComparisonValue(node) }, fieldKey);
+		}
+		if (this.isRegex(node)) throw new Error("Direct regex pattern format is not supported in Qdrant");
+		if (Array.isArray(node)) 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, fieldKey);
+		if (logicalResult) return logicalResult;
+		const { conditions, range, matchCondition } = this.handleFieldConditions(entries, fieldKey);
+		if (Object.keys(range).length > 0) conditions.push({
+			key: fieldKey,
+			range
+		});
+		if (matchCondition) conditions.push({
+			key: fieldKey,
+			match: matchCondition
+		});
+		return this.buildFinalConditions(conditions, isNested);
+	}
+	buildFinalConditions(conditions, isNested) {
+		if (conditions.length === 0) return {};
+		else if (conditions.length === 1 && isNested) return conditions[0];
+		else return { must: conditions };
+	}
+	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];
+			return { [this.getQdrantLogicalOp(key)]: Array.isArray(value) ? value.map((v) => this.translateNode(v, true)) : [this.translateNode(value, true)] };
+		}
+		if (entries.length > 1 && !isNested && entries.every(([key]) => !this.isOperator(key) && !this.isCustomOperator(key))) return { must: entries.map(([key, value]) => this.translateNode(value, true, key)) };
+		return null;
+	}
+	handleFieldConditions(entries, fieldKey) {
+		const conditions = [];
+		let range = {};
+		let matchCondition = null;
+		for (const [key, value] of entries) if (this.isCustomOperator(key)) {
+			const customOp = this.translateCustomOperator(key, value, fieldKey);
+			conditions.push(customOp);
+		} else if (this.isOperator(key)) {
+			const opResult = this.translateOperatorValue(key, value);
+			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;
+		} else {
+			const nestedKey = fieldKey ? `${fieldKey}.${key}` : key;
+			const nestedCondition = this.translateNode(value, true, nestedKey);
+			if (nestedCondition.must) conditions.push(...nestedCondition.must);
+			else if (!this.isEmpty(nestedCondition)) conditions.push(nestedCondition);
+		}
+		return {
+			conditions,
+			range,
+			matchCondition
+		};
+	}
+	translateCustomOperator(op, value, fieldKey) {
+		switch (op) {
+			case "$count": return {
+				key: fieldKey,
+				values_count: Object.entries(value).reduce((acc, [k, v]) => ({
+					...acc,
+					[k.replace("$", "")]: v
+				}), {})
+			};
+			case "$geo": return {
+				key: fieldKey,
+				...this.translateGeoFilter(value.type, value)
+			};
+			case "$hasId": return { has_id: Array.isArray(value) ? value : [value] };
+			case "$nested": return { nested: {
+				key: fieldKey,
+				filter: this.translateNode(value)
+			} };
+			case "$hasVector": return { has_vector: value };
+			case "$datetime": return {
+				key: fieldKey,
+				range: this.normalizeDatetimeRange(value.range)
+			};
+			case "$null": return { is_null: { key: fieldKey } };
+			case "$empty": return { is_empty: { key: fieldKey } };
+			default: throw new Error(`Unsupported custom operator: ${op}`);
+		}
+	}
+	getQdrantLogicalOp(op) {
+		switch (op) {
+			case "$and": return "must";
+			case "$or": return "should";
+			case "$not": return "must_not";
+			default: throw new Error(`Unsupported logical operator: ${op}`);
+		}
+	}
+	translateOperatorValue(operator, value) {
+		const normalizedValue = this.normalizeComparisonValue(value);
+		switch (operator) {
+			case "$eq":
+				if (value === null) return { _specialNull: true };
+				return { value: normalizedValue };
+			case "$ne":
+				if (value === null) return { _specialNotNull: true };
+				return { _specialNe: normalizedValue };
+			case "$gt": return { range: { gt: normalizedValue } };
+			case "$gte": return { range: { gte: normalizedValue } };
+			case "$lt": return { range: { lt: normalizedValue } };
+			case "$lte": return { range: { lte: normalizedValue } };
+			case "$in": return { any: this.normalizeArrayValues(value) };
+			case "$nin": return { _specialNin: this.normalizeArrayValues(value) };
+			case "$regex": return { text: 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}`);
+		}
+	}
+	translateGeoFilter(type, value) {
+		switch (type) {
+			case "box": return { geo_bounding_box: {
+				top_left: value.top_left,
+				bottom_right: value.bottom_right
+			} };
+			case "radius": return { geo_radius: {
+				center: value.center,
+				radius: value.radius
+			} };
+			case "polygon": return { geo_polygon: {
+				exterior: value.exterior,
+				interiors: value.interiors
+			} };
+			default: throw new Error(`Unsupported geo filter type: ${type}`);
+		}
+	}
+	normalizeDatetimeRange(value) {
+		const range = {};
+		for (const [op, val] of Object.entries(value)) if (val instanceof Date) range[op] = val.toISOString();
+		else if (typeof val === "string") range[op] = val;
+		return range;
+	}
 };
-
-// src/vector/index.ts
-var BATCH_SIZE = 256;
-var DISTANCE_MAPPING = {
-  cosine: "Cosine",
-  euclidean: "Euclid",
-  dotproduct: "Dot"
+//#endregion
+//#region src/vector/index.ts
+const BATCH_SIZE = 256;
+const DISTANCE_MAPPING = {
+	cosine: "Cosine",
+	euclidean: "Euclid",
+	dotproduct: "Dot"
 };
 var QdrantVector = class extends MastraVector {
-  client;
-  /**
-   * Creates a new QdrantVector client.
-   * @param id - The unique identifier for this vector store instance.
-   * @param url - The URL of the Qdrant server.
-   * @param apiKey - The API key for Qdrant.
-   * @param https - Whether to use HTTPS.
-   */
-  constructor({ id, ...qdrantParams }) {
-    super({ id });
-    this.client = new QdrantClient(qdrantParams);
-  }
-  /**
-   * 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 ? ids.map((id) => this.parsePointId(id)) : 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: 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, {
-          points: batch,
-          wait: true
-        });
-      }
-      return pointIds.map(String);
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "UPSERT", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, vectorCount: vectors.length, ...vectorName && { vectorName } }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * 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 (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(
-        {
-          id: createVectorErrorId("QDRANT", "CREATE_INDEX", "INVALID_ARGS"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.USER,
-          details: {
-            indexName,
-            dimension,
-            metric,
-            ...namedVectors && { namedVectorNames: Object.keys(namedVectors).join(", ") }
-          }
-        },
-        validationError
-      );
-    }
-    try {
-      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")) {
-        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(
-        {
-          id: createVectorErrorId("QDRANT", "CREATE_INDEX", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, dimension, metric }
-        },
-        error
-      );
-    }
-  }
-  transformFilter(filter) {
-    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,
-    using
-  }) {
-    if (!queryVector) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "QUERY", "MISSING_VECTOR"),
-        text: "queryVector is required for Qdrant queries. Metadata-only queries are not supported by this vector store.",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    const translatedFilter = this.transformFilter(filter) ?? {};
-    try {
-      const results = (await this.client.query(indexName, {
-        query: queryVector,
-        limit: topK,
-        filter: translatedFilter,
-        with_payload: true,
-        with_vector: includeVector,
-        ...using ? { using } : {}
-      })).points;
-      return results.map((match) => {
-        let vector = [];
-        if (includeVector && match.vector != null) {
-          if (Array.isArray(match.vector)) {
-            vector = match.vector;
-          } else if (typeof match.vector === "object" && match.vector !== null) {
-            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 {
-          id: match.id,
-          score: match.score || 0,
-          metadata: match.payload,
-          ...includeVector && { vector }
-        };
-      });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "QUERY", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, topK, ...using && { using } }
-        },
-        error
-      );
-    }
-  }
-  async listIndexes() {
-    try {
-      const response = await this.client.getCollections();
-      return response.collections.map((collection) => collection.name) || [];
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "LIST_INDEXES", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY
-        },
-        error
-      );
-    }
-  }
-  /**
-   * Retrieves statistics about a vector index.
-   *
-   * @param {string} indexName - The name of the index to describe
-   * @returns A promise that resolves to the index statistics including dimension, count and metric
-   */
-  async describeIndex({ indexName }) {
-    try {
-      const { config, points_count } = await this.client.getCollection(indexName);
-      const distance = config.params.vectors?.distance;
-      return {
-        dimension: config.params.vectors?.size,
-        count: points_count || 0,
-        metric: Object.keys(DISTANCE_MAPPING).find(
-          (key) => DISTANCE_MAPPING[key] === distance
-        )
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "DESCRIBE_INDEX", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error
-      );
-    }
-  }
-  async deleteIndex({ indexName }) {
-    try {
-      await this.client.deleteCollection(indexName);
-    } catch (error) {
-      const errorMessage = error?.message || error?.toString() || "";
-      if (error?.status === 404 || errorMessage.toLowerCase().includes("not found") || errorMessage.toLowerCase().includes("not exist")) {
-        this.logger.info(`Collection ${indexName} does not exist, treating as already deleted`);
-        return;
-      }
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "DELETE_INDEX", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * Updates a vector by its ID or multiple vectors matching a filter.
-   * @param indexName - The name of the index containing the vector(s).
-   * @param id - The ID of the vector to update (mutually exclusive with filter).
-   * @param filter - Filter to match multiple vectors to update (mutually exclusive with id).
-   * @param update - An object containing the vector and/or metadata to update.
-   * @param update.vector - An optional array of numbers representing the new vector.
-   * @param update.metadata - An optional record containing the new metadata.
-   * @returns A promise that resolves when the update is complete.
-   * @throws Will throw an error if no updates are provided or if the update operation fails.
-   */
-  async updateVector({ indexName, id, filter, update }) {
-    if (id && filter) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "MUTUALLY_EXCLUSIVE"),
-        text: "Cannot specify both id and filter - they are mutually exclusive",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (!id && !filter) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "NO_TARGET"),
-        text: "Either id or filter must be provided",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (!update.vector && !update.metadata) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "NO_PAYLOAD"),
-        text: "No updates provided",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: {
-          indexName,
-          ...id && { id }
-        }
-      });
-    }
-    if (filter && Object.keys(filter).length === 0) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "EMPTY_FILTER"),
-        text: "Filter cannot be an empty filter object",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    try {
-      if (id) {
-        const pointId = this.parsePointId(id);
-        if (update.metadata && !update.vector) {
-          await this.client.setPayload(indexName, { payload: update.metadata, points: [pointId] });
-          return;
-        }
-        if (update.vector && !update.metadata) {
-          await this.client.updateVectors(indexName, {
-            points: [
-              {
-                id: pointId,
-                vector: update.vector
-              }
-            ]
-          });
-          return;
-        }
-        if (update.vector && update.metadata) {
-          const point = {
-            id: pointId,
-            vector: update.vector,
-            payload: update.metadata
-          };
-          await this.client.upsert(indexName, {
-            points: [point]
-          });
-          return;
-        }
-      } else if (filter) {
-        const translatedFilter = this.transformFilter(filter);
-        const matchingPoints = [];
-        let offset = void 0;
-        do {
-          const scrollResult = await this.client.scroll(indexName, {
-            filter: translatedFilter,
-            limit: 100,
-            offset,
-            with_payload: false,
-            with_vector: update.vector ? false : true
-            // Only fetch vectors if not updating them
-          });
-          matchingPoints.push(
-            ...scrollResult.points.map((point) => ({
-              id: point.id,
-              vector: Array.isArray(point.vector) ? point.vector : void 0
-            }))
-          );
-          const nextOffset = scrollResult.next_page_offset;
-          offset = typeof nextOffset === "string" || typeof nextOffset === "number" ? nextOffset : void 0;
-        } while (offset !== void 0);
-        if (matchingPoints.length === 0) {
-          return;
-        }
-        const pointIds = matchingPoints.map((p) => p.id);
-        if (update.metadata && !update.vector) {
-          await this.client.setPayload(indexName, { payload: update.metadata, points: pointIds });
-          return;
-        }
-        if (update.vector) {
-          const points = matchingPoints.map((p) => ({
-            id: p.id,
-            vector: update.vector,
-            payload: update.metadata || {}
-          }));
-          for (let i = 0; i < points.length; i += BATCH_SIZE) {
-            const batch = points.slice(i, i + BATCH_SIZE);
-            await this.client.upsert(indexName, {
-              points: batch,
-              wait: true
-            });
-          }
-          return;
-        }
-      }
-    } catch (error) {
-      if (error instanceof MastraError) throw error;
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...id && { id },
-            ...filter && { filter: JSON.stringify(filter) }
-          }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * Deletes a vector by its ID.
-   * @param indexName - The name of the index containing the vector.
-   * @param id - The ID of the vector to delete.
-   * @returns A promise that resolves when the deletion is complete.
-   * @throws Will throw an error if the deletion operation fails.
-   */
-  async deleteVector({ indexName, id }) {
-    try {
-      const pointId = this.parsePointId(id);
-      await this.client.delete(indexName, {
-        points: [pointId]
-      });
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "DELETE_VECTOR", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...id && { id }
-          }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * Parses and converts a string ID to the appropriate type (string or number) for Qdrant point operations.
-   *
-   * Qdrant supports both numeric and string IDs. This helper method ensures IDs are in the correct format
-   * before sending them to the Qdrant client API.
-   *
-   * @param id - The ID string to parse
-   * @returns The parsed ID as either a number (if string contains only digits) or the original string
-   *
-   * @example
-   * // Numeric ID strings are converted to numbers
-   * parsePointId("123") => 123
-   * parsePointId("42") => 42
-   * parsePointId("0") => 0
-   *
-   * // String IDs containing any non-digit characters remain as strings
-   * parsePointId("doc-123") => "doc-123"
-   * parsePointId("user_42") => "user_42"
-   * parsePointId("abc123") => "abc123"
-   * parsePointId("123abc") => "123abc"
-   * parsePointId("") => ""
-   * parsePointId("uuid-5678-xyz") => "uuid-5678-xyz"
-   *
-   * @remarks
-   * - This conversion is important because Qdrant treats numeric and string IDs differently
-   * - Only positive integers are converted to numbers (negative numbers with minus signs remain strings)
-   * - The method uses base-10 parsing, so leading zeros will be dropped in numeric conversions
-   * - reference: https://qdrant.tech/documentation/concepts/points/?q=qdrant+point+id#point-ids
-   */
-  parsePointId(id) {
-    if (/^\d+$/.test(id)) {
-      return parseInt(id, 10);
-    }
-    return id;
-  }
-  /**
-   * Deletes multiple vectors by IDs or filter.
-   * @param indexName - The name of the index containing the vectors.
-   * @param ids - Array of vector IDs to delete (mutually exclusive with filter).
-   * @param filter - Filter to match vectors to delete (mutually exclusive with ids).
-   * @returns A promise that resolves when the deletion is complete.
-   * @throws Will throw an error if both ids and filter are provided, or if neither is provided.
-   */
-  async deleteVectors({ indexName, filter, ids }) {
-    if (ids && filter) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "MUTUALLY_EXCLUSIVE"),
-        text: "Cannot specify both ids and filter - they are mutually exclusive",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (!ids && !filter) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "NO_TARGET"),
-        text: "Either filter or ids must be provided",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (ids && ids.length === 0) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "EMPTY_IDS"),
-        text: "Cannot delete with empty ids array",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    if (filter && Object.keys(filter).length === 0) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "EMPTY_FILTER"),
-        text: "Cannot delete with empty filter object",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName }
-      });
-    }
-    try {
-      if (ids) {
-        const pointIds = ids.map((id) => this.parsePointId(id));
-        try {
-          await this.client.delete(indexName, {
-            points: pointIds,
-            wait: true
-          });
-        } catch (error) {
-          const message = error?.message || error?.toString() || "";
-          if (message.toLowerCase().includes("bad request")) {
-            return;
-          }
-          throw error;
-        }
-      } else if (filter) {
-        const translatedFilter = this.transformFilter(filter) ?? {};
-        await this.client.delete(indexName, {
-          filter: translatedFilter,
-          wait: true
-        });
-      }
-    } catch (error) {
-      if (error instanceof MastraError) throw error;
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: {
-            indexName,
-            ...filter && { filter: JSON.stringify(filter) },
-            ...ids && { idsCount: ids.length }
-          }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * Creates a payload index on a Qdrant collection to enable efficient filtering on metadata fields.
-   *
-   * This is required for Qdrant Cloud and any Qdrant instance with `strict_mode_config = true`,
-   * where metadata (payload) fields must be explicitly indexed before they can be used for filtering.
-   *
-   * @param params - The parameters for creating the payload index.
-   * @param params.indexName - The name of the collection (index) to create the payload index on.
-   * @param params.fieldName - The name of the payload field to index.
-   * @param params.fieldSchema - The schema type for the field (e.g., 'keyword', 'integer', 'text').
-   * @param params.wait - Whether to wait for the operation to complete. Defaults to true.
-   * @returns A promise that resolves when the index is created (idempotent if index already exists).
-   * @throws Will throw a MastraError if arguments are invalid or if the operation fails.
-   *
-   * @example
-   * ```ts
-   * // Create a keyword index for filtering by source
-   * await qdrant.createPayloadIndex({
-   *   indexName: 'my-collection',
-   *   fieldName: 'source',
-   *   fieldSchema: 'keyword',
-   * });
-   *
-   * // Create an integer index for numeric filtering
-   * await qdrant.createPayloadIndex({
-   *   indexName: 'my-collection',
-   *   fieldName: 'price',
-   *   fieldSchema: 'integer',
-   * });
-   * ```
-   *
-   * @see https://qdrant.tech/documentation/concepts/indexing/#payload-index
-   */
-  async createPayloadIndex({
-    indexName,
-    fieldName,
-    fieldSchema,
-    wait = true
-  }) {
-    const validSchemas = [
-      "keyword",
-      "integer",
-      "float",
-      "geo",
-      "text",
-      "bool",
-      "datetime",
-      "uuid"
-    ];
-    if (!indexName || typeof indexName !== "string" || indexName.trim() === "") {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "CREATE_PAYLOAD_INDEX", "INVALID_ARGS"),
-        text: "indexName must be a non-empty string",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName, fieldName, fieldSchema }
-      });
-    }
-    if (!fieldName || typeof fieldName !== "string" || fieldName.trim() === "") {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "CREATE_PAYLOAD_INDEX", "INVALID_ARGS"),
-        text: "fieldName must be a non-empty string",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName, fieldName, fieldSchema }
-      });
-    }
-    if (!validSchemas.includes(fieldSchema)) {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "CREATE_PAYLOAD_INDEX", "INVALID_ARGS"),
-        text: `fieldSchema must be one of: ${validSchemas.join(", ")}`,
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName, fieldName, fieldSchema }
-      });
-    }
-    try {
-      await this.client.createPayloadIndex(indexName, {
-        field_name: fieldName,
-        field_schema: fieldSchema,
-        wait
-      });
-    } catch (error) {
-      const message = error?.message || error?.toString() || "";
-      if (error?.status === 409 || message.toLowerCase().includes("exists")) {
-        this.logger.info(`Payload index for field "${fieldName}" already exists on collection "${indexName}"`);
-        return;
-      }
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "CREATE_PAYLOAD_INDEX", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, fieldName, fieldSchema }
-        },
-        error
-      );
-    }
-  }
-  /**
-   * Deletes a payload index from a Qdrant collection.
-   *
-   * @param params - The parameters for deleting the payload index.
-   * @param params.indexName - The name of the collection (index) to delete the payload index from.
-   * @param params.fieldName - The name of the payload field index to delete.
-   * @param params.wait - Whether to wait for the operation to complete. Defaults to true.
-   * @returns A promise that resolves when the index is deleted (idempotent if index doesn't exist).
-   * @throws Will throw a MastraError if the operation fails.
-   *
-   * @example
-   * ```ts
-   * await qdrant.deletePayloadIndex({
-   *   indexName: 'my-collection',
-   *   fieldName: 'source',
-   * });
-   * ```
-   */
-  async deletePayloadIndex({ indexName, fieldName, wait = true }) {
-    if (!indexName || typeof indexName !== "string" || indexName.trim() === "") {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "DELETE_PAYLOAD_INDEX", "INVALID_ARGS"),
-        text: "indexName must be a non-empty string",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName, fieldName }
-      });
-    }
-    if (!fieldName || typeof fieldName !== "string" || fieldName.trim() === "") {
-      throw new MastraError({
-        id: createVectorErrorId("QDRANT", "DELETE_PAYLOAD_INDEX", "INVALID_ARGS"),
-        text: "fieldName must be a non-empty string",
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        details: { indexName, fieldName }
-      });
-    }
-    try {
-      await this.client.deletePayloadIndex(indexName, fieldName, { wait });
-    } catch (error) {
-      const message = error?.message || error?.toString() || "";
-      if (error?.status === 404 || message.toLowerCase().includes("not found") || message.toLowerCase().includes("not exist")) {
-        this.logger.info(`Payload index for field "${fieldName}" does not exist on collection "${indexName}"`);
-        return;
-      }
-      throw new MastraError(
-        {
-          id: createVectorErrorId("QDRANT", "DELETE_PAYLOAD_INDEX", "FAILED"),
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { indexName, fieldName }
-        },
-        error
-      );
-    }
-  }
+	client;
+	/**
+	* Creates a new QdrantVector client.
+	* @param id - The unique identifier for this vector store instance.
+	* @param url - The URL of the Qdrant server.
+	* @param apiKey - The API key for Qdrant.
+	* @param https - Whether to use HTTPS.
+	*/
+	constructor({ id, ...qdrantParams }) {
+		super({ id });
+		this.client = new QdrantClient(qdrantParams);
+	}
+	/**
+	* 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;
+		if (!(vectorsConfig && typeof vectorsConfig === "object" && !("size" in vectorsConfig)) || !(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 ? ids.map((id) => this.parsePointId(id)) : 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: 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, {
+					points: batch,
+					wait: true
+				});
+			}
+			return pointIds.map(String);
+		} catch (error) {
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "UPSERT", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					vectorCount: vectors.length,
+					...vectorName && { vectorName }
+				}
+			}, error);
+		}
+	}
+	/**
+	* 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 (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({
+				id: createVectorErrorId("QDRANT", "CREATE_INDEX", "INVALID_ARGS"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.USER,
+				details: {
+					indexName,
+					dimension,
+					metric,
+					...namedVectors && { namedVectorNames: Object.keys(namedVectors).join(", ") }
+				}
+			}, validationError);
+		}
+		try {
+			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")) {
+				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({
+				id: createVectorErrorId("QDRANT", "CREATE_INDEX", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					dimension,
+					metric
+				}
+			}, error);
+		}
+	}
+	transformFilter(filter) {
+		return new QdrantFilterTranslator().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, using }) {
+		if (!queryVector) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "QUERY", "MISSING_VECTOR"),
+			text: "queryVector is required for Qdrant queries. Metadata-only queries are not supported by this vector store.",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		const translatedFilter = this.transformFilter(filter) ?? {};
+		try {
+			return (await this.client.query(indexName, {
+				query: queryVector,
+				limit: topK,
+				filter: translatedFilter,
+				with_payload: true,
+				with_vector: includeVector,
+				...using ? { using } : {}
+			})).points.map((match) => {
+				let vector = [];
+				if (includeVector && match.vector != null) {
+					if (Array.isArray(match.vector)) vector = match.vector;
+					else if (typeof match.vector === "object" && match.vector !== null) {
+						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 {
+					id: match.id,
+					score: match.score || 0,
+					metadata: match.payload,
+					...includeVector && { vector }
+				};
+			});
+		} catch (error) {
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "QUERY", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					topK,
+					...using && { using }
+				}
+			}, error);
+		}
+	}
+	async listIndexes() {
+		try {
+			return (await this.client.getCollections()).collections.map((collection) => collection.name) || [];
+		} catch (error) {
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "LIST_INDEXES", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY
+			}, error);
+		}
+	}
+	/**
+	* Retrieves statistics about a vector index.
+	*
+	* @param {string} indexName - The name of the index to describe
+	* @returns A promise that resolves to the index statistics including dimension, count and metric
+	*/
+	async describeIndex({ indexName }) {
+		try {
+			const { config, points_count } = await this.client.getCollection(indexName);
+			const distance = config.params.vectors?.distance;
+			return {
+				dimension: config.params.vectors?.size,
+				count: points_count || 0,
+				metric: Object.keys(DISTANCE_MAPPING).find((key) => DISTANCE_MAPPING[key] === distance)
+			};
+		} catch (error) {
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "DESCRIBE_INDEX", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	async deleteIndex({ indexName }) {
+		try {
+			await this.client.deleteCollection(indexName);
+		} catch (error) {
+			const errorMessage = error?.message || error?.toString() || "";
+			if (error?.status === 404 || errorMessage.toLowerCase().includes("not found") || errorMessage.toLowerCase().includes("not exist")) {
+				this.logger.info(`Collection ${indexName} does not exist, treating as already deleted`);
+				return;
+			}
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "DELETE_INDEX", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: { indexName }
+			}, error);
+		}
+	}
+	/**
+	* Updates a vector by its ID or multiple vectors matching a filter.
+	* @param indexName - The name of the index containing the vector(s).
+	* @param id - The ID of the vector to update (mutually exclusive with filter).
+	* @param filter - Filter to match multiple vectors to update (mutually exclusive with id).
+	* @param update - An object containing the vector and/or metadata to update.
+	* @param update.vector - An optional array of numbers representing the new vector.
+	* @param update.metadata - An optional record containing the new metadata.
+	* @returns A promise that resolves when the update is complete.
+	* @throws Will throw an error if no updates are provided or if the update operation fails.
+	*/
+	async updateVector({ indexName, id, filter, update }) {
+		if (id && filter) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "MUTUALLY_EXCLUSIVE"),
+			text: "Cannot specify both id and filter - they are mutually exclusive",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (!id && !filter) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "NO_TARGET"),
+			text: "Either id or filter must be provided",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (!update.vector && !update.metadata) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "NO_PAYLOAD"),
+			text: "No updates provided",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: {
+				indexName,
+				...id && { id }
+			}
+		});
+		if (filter && Object.keys(filter).length === 0) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "EMPTY_FILTER"),
+			text: "Filter cannot be an empty filter object",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		try {
+			if (id) {
+				const pointId = this.parsePointId(id);
+				if (update.metadata && !update.vector) {
+					await this.client.setPayload(indexName, {
+						payload: update.metadata,
+						points: [pointId]
+					});
+					return;
+				}
+				if (update.vector && !update.metadata) {
+					await this.client.updateVectors(indexName, { points: [{
+						id: pointId,
+						vector: update.vector
+					}] });
+					return;
+				}
+				if (update.vector && update.metadata) {
+					const point = {
+						id: pointId,
+						vector: update.vector,
+						payload: update.metadata
+					};
+					await this.client.upsert(indexName, { points: [point] });
+					return;
+				}
+			} else if (filter) {
+				const translatedFilter = this.transformFilter(filter);
+				const matchingPoints = [];
+				let offset = void 0;
+				do {
+					const scrollResult = await this.client.scroll(indexName, {
+						filter: translatedFilter,
+						limit: 100,
+						offset,
+						with_payload: false,
+						with_vector: update.vector ? false : true
+					});
+					matchingPoints.push(...scrollResult.points.map((point) => ({
+						id: point.id,
+						vector: Array.isArray(point.vector) ? point.vector : void 0
+					})));
+					const nextOffset = scrollResult.next_page_offset;
+					offset = typeof nextOffset === "string" || typeof nextOffset === "number" ? nextOffset : void 0;
+				} while (offset !== void 0);
+				if (matchingPoints.length === 0) return;
+				const pointIds = matchingPoints.map((p) => p.id);
+				if (update.metadata && !update.vector) {
+					await this.client.setPayload(indexName, {
+						payload: update.metadata,
+						points: pointIds
+					});
+					return;
+				}
+				if (update.vector) {
+					const points = matchingPoints.map((p) => ({
+						id: p.id,
+						vector: update.vector,
+						payload: update.metadata || {}
+					}));
+					for (let i = 0; i < points.length; i += BATCH_SIZE) {
+						const batch = points.slice(i, i + BATCH_SIZE);
+						await this.client.upsert(indexName, {
+							points: batch,
+							wait: true
+						});
+					}
+					return;
+				}
+			}
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "UPDATE_VECTOR", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...id && { id },
+					...filter && { filter: JSON.stringify(filter) }
+				}
+			}, error);
+		}
+	}
+	/**
+	* Deletes a vector by its ID.
+	* @param indexName - The name of the index containing the vector.
+	* @param id - The ID of the vector to delete.
+	* @returns A promise that resolves when the deletion is complete.
+	* @throws Will throw an error if the deletion operation fails.
+	*/
+	async deleteVector({ indexName, id }) {
+		try {
+			const pointId = this.parsePointId(id);
+			await this.client.delete(indexName, { points: [pointId] });
+		} catch (error) {
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "DELETE_VECTOR", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...id && { id }
+				}
+			}, error);
+		}
+	}
+	/**
+	* Parses and converts a string ID to the appropriate type (string or number) for Qdrant point operations.
+	*
+	* Qdrant supports both numeric and string IDs. This helper method ensures IDs are in the correct format
+	* before sending them to the Qdrant client API.
+	*
+	* @param id - The ID string to parse
+	* @returns The parsed ID as either a number (if string contains only digits) or the original string
+	*
+	* @example
+	* // Numeric ID strings are converted to numbers
+	* parsePointId("123") => 123
+	* parsePointId("42") => 42
+	* parsePointId("0") => 0
+	*
+	* // String IDs containing any non-digit characters remain as strings
+	* parsePointId("doc-123") => "doc-123"
+	* parsePointId("user_42") => "user_42"
+	* parsePointId("abc123") => "abc123"
+	* parsePointId("123abc") => "123abc"
+	* parsePointId("") => ""
+	* parsePointId("uuid-5678-xyz") => "uuid-5678-xyz"
+	*
+	* @remarks
+	* - This conversion is important because Qdrant treats numeric and string IDs differently
+	* - Only positive integers are converted to numbers (negative numbers with minus signs remain strings)
+	* - The method uses base-10 parsing, so leading zeros will be dropped in numeric conversions
+	* - reference: https://qdrant.tech/documentation/concepts/points/?q=qdrant+point+id#point-ids
+	*/
+	parsePointId(id) {
+		if (/^\d+$/.test(id)) return parseInt(id, 10);
+		return id;
+	}
+	/**
+	* Deletes multiple vectors by IDs or filter.
+	* @param indexName - The name of the index containing the vectors.
+	* @param ids - Array of vector IDs to delete (mutually exclusive with filter).
+	* @param filter - Filter to match vectors to delete (mutually exclusive with ids).
+	* @returns A promise that resolves when the deletion is complete.
+	* @throws Will throw an error if both ids and filter are provided, or if neither is provided.
+	*/
+	async deleteVectors({ indexName, filter, ids }) {
+		if (ids && filter) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "MUTUALLY_EXCLUSIVE"),
+			text: "Cannot specify both ids and filter - they are mutually exclusive",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (!ids && !filter) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "NO_TARGET"),
+			text: "Either filter or ids must be provided",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (ids && ids.length === 0) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "EMPTY_IDS"),
+			text: "Cannot delete with empty ids array",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		if (filter && Object.keys(filter).length === 0) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "EMPTY_FILTER"),
+			text: "Cannot delete with empty filter object",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: { indexName }
+		});
+		try {
+			if (ids) {
+				const pointIds = ids.map((id) => this.parsePointId(id));
+				try {
+					await this.client.delete(indexName, {
+						points: pointIds,
+						wait: true
+					});
+				} catch (error) {
+					if ((error?.message || error?.toString() || "").toLowerCase().includes("bad request")) return;
+					throw error;
+				}
+			} else if (filter) {
+				const translatedFilter = this.transformFilter(filter) ?? {};
+				await this.client.delete(indexName, {
+					filter: translatedFilter,
+					wait: true
+				});
+			}
+		} catch (error) {
+			if (error instanceof MastraError) throw error;
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "DELETE_VECTORS", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					...filter && { filter: JSON.stringify(filter) },
+					...ids && { idsCount: ids.length }
+				}
+			}, error);
+		}
+	}
+	/**
+	* Creates a payload index on a Qdrant collection to enable efficient filtering on metadata fields.
+	*
+	* This is required for Qdrant Cloud and any Qdrant instance with `strict_mode_config = true`,
+	* where metadata (payload) fields must be explicitly indexed before they can be used for filtering.
+	*
+	* @param params - The parameters for creating the payload index.
+	* @param params.indexName - The name of the collection (index) to create the payload index on.
+	* @param params.fieldName - The name of the payload field to index.
+	* @param params.fieldSchema - The schema type for the field (e.g., 'keyword', 'integer', 'text').
+	* @param params.wait - Whether to wait for the operation to complete. Defaults to true.
+	* @returns A promise that resolves when the index is created (idempotent if index already exists).
+	* @throws Will throw a MastraError if arguments are invalid or if the operation fails.
+	*
+	* @example
+	* ```ts
+	* // Create a keyword index for filtering by source
+	* await qdrant.createPayloadIndex({
+	*   indexName: 'my-collection',
+	*   fieldName: 'source',
+	*   fieldSchema: 'keyword',
+	* });
+	*
+	* // Create an integer index for numeric filtering
+	* await qdrant.createPayloadIndex({
+	*   indexName: 'my-collection',
+	*   fieldName: 'price',
+	*   fieldSchema: 'integer',
+	* });
+	* ```
+	*
+	* @see https://qdrant.tech/documentation/concepts/indexing/#payload-index
+	*/
+	async createPayloadIndex({ indexName, fieldName, fieldSchema, wait = true }) {
+		const validSchemas = [
+			"keyword",
+			"integer",
+			"float",
+			"geo",
+			"text",
+			"bool",
+			"datetime",
+			"uuid"
+		];
+		if (!indexName || typeof indexName !== "string" || indexName.trim() === "") throw new MastraError({
+			id: createVectorErrorId("QDRANT", "CREATE_PAYLOAD_INDEX", "INVALID_ARGS"),
+			text: "indexName must be a non-empty string",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: {
+				indexName,
+				fieldName,
+				fieldSchema
+			}
+		});
+		if (!fieldName || typeof fieldName !== "string" || fieldName.trim() === "") throw new MastraError({
+			id: createVectorErrorId("QDRANT", "CREATE_PAYLOAD_INDEX", "INVALID_ARGS"),
+			text: "fieldName must be a non-empty string",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: {
+				indexName,
+				fieldName,
+				fieldSchema
+			}
+		});
+		if (!validSchemas.includes(fieldSchema)) throw new MastraError({
+			id: createVectorErrorId("QDRANT", "CREATE_PAYLOAD_INDEX", "INVALID_ARGS"),
+			text: `fieldSchema must be one of: ${validSchemas.join(", ")}`,
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: {
+				indexName,
+				fieldName,
+				fieldSchema
+			}
+		});
+		try {
+			await this.client.createPayloadIndex(indexName, {
+				field_name: fieldName,
+				field_schema: fieldSchema,
+				wait
+			});
+		} catch (error) {
+			const message = error?.message || error?.toString() || "";
+			if (error?.status === 409 || message.toLowerCase().includes("exists")) {
+				this.logger.info(`Payload index for field "${fieldName}" already exists on collection "${indexName}"`);
+				return;
+			}
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "CREATE_PAYLOAD_INDEX", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					fieldName,
+					fieldSchema
+				}
+			}, error);
+		}
+	}
+	/**
+	* Deletes a payload index from a Qdrant collection.
+	*
+	* @param params - The parameters for deleting the payload index.
+	* @param params.indexName - The name of the collection (index) to delete the payload index from.
+	* @param params.fieldName - The name of the payload field index to delete.
+	* @param params.wait - Whether to wait for the operation to complete. Defaults to true.
+	* @returns A promise that resolves when the index is deleted (idempotent if index doesn't exist).
+	* @throws Will throw a MastraError if the operation fails.
+	*
+	* @example
+	* ```ts
+	* await qdrant.deletePayloadIndex({
+	*   indexName: 'my-collection',
+	*   fieldName: 'source',
+	* });
+	* ```
+	*/
+	async deletePayloadIndex({ indexName, fieldName, wait = true }) {
+		if (!indexName || typeof indexName !== "string" || indexName.trim() === "") throw new MastraError({
+			id: createVectorErrorId("QDRANT", "DELETE_PAYLOAD_INDEX", "INVALID_ARGS"),
+			text: "indexName must be a non-empty string",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: {
+				indexName,
+				fieldName
+			}
+		});
+		if (!fieldName || typeof fieldName !== "string" || fieldName.trim() === "") throw new MastraError({
+			id: createVectorErrorId("QDRANT", "DELETE_PAYLOAD_INDEX", "INVALID_ARGS"),
+			text: "fieldName must be a non-empty string",
+			domain: ErrorDomain.STORAGE,
+			category: ErrorCategory.USER,
+			details: {
+				indexName,
+				fieldName
+			}
+		});
+		try {
+			await this.client.deletePayloadIndex(indexName, fieldName, { wait });
+		} catch (error) {
+			const message = error?.message || error?.toString() || "";
+			if (error?.status === 404 || message.toLowerCase().includes("not found") || message.toLowerCase().includes("not exist")) {
+				this.logger.info(`Payload index for field "${fieldName}" does not exist on collection "${indexName}"`);
+				return;
+			}
+			throw new MastraError({
+				id: createVectorErrorId("QDRANT", "DELETE_PAYLOAD_INDEX", "FAILED"),
+				domain: ErrorDomain.STORAGE,
+				category: ErrorCategory.THIRD_PARTY,
+				details: {
+					indexName,
+					fieldName
+				}
+			}, error);
+		}
+	}
 };
-
-// src/vector/prompt.ts
-var QDRANT_PROMPT = `When querying Qdrant, you can ONLY use the operators listed below. Any other operators will be rejected.
+//#endregion
+//#region src/vector/prompt.ts
+/**
+* Vector store specific prompt that details supported operators and examples.
+* This prompt helps users construct valid filters for Qdrant Vector.
+*/
+const QDRANT_PROMPT = `When querying Qdrant, you can ONLY use the operators listed below. Any other operators will be rejected.
 Important: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.
 If a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.
 
@@ -1133,7 +1008,7 @@ Example Complex Query:
     { "$not": { "status": "discontinued" } }
   ]
 }`;
-
+//#endregion
 export { QDRANT_PROMPT, QdrantVector };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map