@mastra/qdrant 0.1.6-alpha.1 → 0.1.6-alpha.4

package/.turbo/turbo-build.log

@@ -1,18 +1,23 @@
 
-> @mastra/qdrant@0.1.6-alpha.1 build /home/runner/work/mastra/mastra/stores/qdrant
-> tsup src/index.ts --format esm --experimental-dts --clean --treeshake
+> @mastra/qdrant@0.1.6-alpha.4 build /home/runner/work/mastra/mastra/stores/qdrant
+> tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.3.6
 TSC Build start
-TSC ⚡️ Build success in 8031ms
+TSC ⚡️ Build success in 7774ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.7.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/qdrant/dist/_tsup-dts-rollup.d.ts
-DTS ⚡️ Build success in 5790ms
+Analysis will use the bundled TypeScript version 5.7.3
+Writing package typings: /home/runner/work/mastra/mastra/stores/qdrant/dist/_tsup-dts-rollup.d.cts
+DTS ⚡️ Build success in 9281ms
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js 10.31 KB
-ESM ⚡️ Build success in 433ms
+CJS Build start
+ESM dist/index.js 10.58 KB
+ESM ⚡️ Build success in 672ms
+CJS dist/index.cjs 10.62 KB
+CJS ⚡️ Build success in 678ms

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @mastra/qdrant
 
+## 0.1.6-alpha.4
+
+### Patch Changes
+
+- Updated dependencies [dabecf4]
+  - @mastra/core@0.4.3-alpha.4
+
+## 0.1.6-alpha.3
+
+### Patch Changes
+
+- 0fd78ac: Update vector store functions to use object params
+- fd14a3f: Updating filter location from @mastra/core/filter to @mastra/core/vector/filter
+- 4d4e1e1: Updated vector tests and pinecone
+- bb4f447: Add support for commonjs
+- Updated dependencies [0fd78ac]
+- Updated dependencies [0d25b75]
+- Updated dependencies [fd14a3f]
+- Updated dependencies [3f369a2]
+- Updated dependencies [4d4e1e1]
+- Updated dependencies [bb4f447]
+  - @mastra/core@0.4.3-alpha.3
+
+## 0.1.6-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [2512a93]
+- Updated dependencies [e62de74]
+  - @mastra/core@0.4.3-alpha.2
+
 ## 0.1.6-alpha.1
 
 ### Patch Changes

package/README.md

@@ -20,21 +20,21 @@ const vectorStore = new QdrantVector(
 );
 
 // Create a new collection
-await vectorStore.createIndex('my-collection', 1536, 'cosine');
+await vectorStore.createIndex({ indexName: 'my-collection', dimension: 1536, metric: 'cosine' });
 
 // Add vectors
 const vectors = [[0.1, 0.2, ...], [0.3, 0.4, ...]];
 const metadata = [{ text: 'doc1' }, { text: 'doc2' }];
-const ids = await vectorStore.upsert('my-collection', vectors, metadata);
+const ids = await vectorStore.upsert({ indexName: 'my-collection', vectors, metadata });
 
 // Query vectors
-const results = await vectorStore.query(
-  'my-collection',
-  [0.1, 0.2, ...],
-  10, // topK
-  { text: { $eq: 'doc1' } }, // optional filter
-  false // includeVector
-);
+const results = await vectorStore.query({
+  indexName: 'my-collection',
+  queryVector: [0.1, 0.2, ...],
+  topK: 10, // topK
+  filter: { text: { $eq: 'doc1' } }, // optional filter
+  includeVector: false // includeVector
+});
 ```
 
 ## Configuration
@@ -69,9 +69,9 @@ The following distance metrics are supported:
 
 ## Methods
 
-- `createIndex(indexName, dimension, metric?)`: Create a new collection
-- `upsert(indexName, vectors, metadata?, ids?)`: Add or update vectors
-- `query(indexName, queryVector, topK?, filter?, includeVector?)`: Search for similar vectors
+- `createIndex({ indexName, dimension, metric? })`: Create a new collection
+- `upsert({ indexName, vectors, metadata?, ids? })`: Add or update vectors
+- `query({ indexName, queryVector, topK?, filter?, includeVector? })`: Search for similar vectors
 - `listIndexes()`: List all collections
 - `describeIndex(indexName)`: Get collection statistics
 - `deleteIndex(indexName)`: Delete a collection

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,62 @@
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { CreateIndexParams } from '@mastra/core/vector';
+import type { IndexStats } from '@mastra/core/vector';
+import type { LogicalOperator } from '@mastra/core/vector/filter';
+import { MastraVector } from '@mastra/core/vector';
+import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { ParamsToArgs } from '@mastra/core/vector';
+import type { QueryResult } from '@mastra/core/vector';
+import type { QueryVectorParams } from '@mastra/core/vector';
+import type { UpsertVectorParams } from '@mastra/core/vector';
+import type { VectorFilter } from '@mastra/core/vector/filter';
+
+/**
+ * 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
+ */
+export declare class QdrantFilterTranslator extends BaseFilterTranslator {
+    protected isLogicalOperator(key: string): key is LogicalOperator;
+    protected getSupportedOperators(): OperatorSupport;
+    translate(filter?: VectorFilter): VectorFilter;
+    private createCondition;
+    private translateNode;
+    private buildFinalConditions;
+    private handleLogicalOperators;
+    private handleFieldConditions;
+    private translateCustomOperator;
+    private getQdrantLogicalOp;
+    private translateOperatorValue;
+    private translateGeoFilter;
+    private normalizeDatetimeRange;
+}
+
+declare class QdrantVector extends MastraVector {
+    private client;
+    constructor(url: string, apiKey?: string, https?: boolean);
+    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<IndexStats>;
+    deleteIndex(indexName: string): Promise<void>;
+}
+export { QdrantVector }
+export { QdrantVector as QdrantVector_alias_1 }
+
+export { }

package/dist/_tsup-dts-rollup.d.ts

@@ -1,10 +1,14 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
-import type { Filter } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { CreateIndexParams } from '@mastra/core/vector';
 import type { IndexStats } from '@mastra/core/vector';
-import type { LogicalOperator } from '@mastra/core/filter';
+import type { LogicalOperator } from '@mastra/core/vector/filter';
 import { MastraVector } from '@mastra/core/vector';
-import type { OperatorSupport } from '@mastra/core/filter';
+import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { ParamsToArgs } from '@mastra/core/vector';
 import type { QueryResult } from '@mastra/core/vector';
+import type { QueryVectorParams } from '@mastra/core/vector';
+import type { UpsertVectorParams } from '@mastra/core/vector';
+import type { VectorFilter } from '@mastra/core/vector/filter';
 
 /**
  * Translates MongoDB-style filters to Qdrant compatible filters.
@@ -28,7 +32,7 @@ import type { QueryResult } from '@mastra/core/vector';
 export declare class QdrantFilterTranslator extends BaseFilterTranslator {
     protected isLogicalOperator(key: string): key is LogicalOperator;
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: Filter): Filter | undefined;
+    translate(filter?: VectorFilter): VectorFilter;
     private createCondition;
     private translateNode;
     private buildFinalConditions;
@@ -44,10 +48,10 @@ export declare class QdrantFilterTranslator extends BaseFilterTranslator {
 declare class QdrantVector extends MastraVector {
     private client;
     constructor(url: string, apiKey?: string, https?: boolean);
-    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
-    createIndex(indexName: string, dimension: number, metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
-    transformFilter(filter?: Filter): Filter | undefined;
-    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean): Promise<QueryResult[]>;
+    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
     describeIndex(indexName: string): Promise<IndexStats>;
     deleteIndex(indexName: string): Promise<void>;

package/dist/index.cjs

@@ -0,0 +1,342 @@
+'use strict';
+
+var vector = require('@mastra/core/vector');
+var jsClientRest = require('@qdrant/js-client-rest');
+var filter = require('@mastra/core/vector/filter');
+
+// src/vector/index.ts
+var QdrantFilterTranslator = class extends filter.BaseFilterTranslator {
+  isLogicalOperator(key) {
+    return super.isLogicalOperator(key) || key === "$hasId" || key === "$hasVector";
+  }
+  getSupportedOperators() {
+    return {
+      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+      logical: ["$and", "$or", "$not"],
+      array: ["$in", "$nin"],
+      regex: ["$regex"],
+      custom: ["$count", "$geo", "$nested", "$datetime", "$null", "$empty", "$hasId", "$hasVector"]
+    };
+  }
+  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) && 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);
+    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) {
+    const firstKey = entries[0]?.[0];
+    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.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":
+        return { value: normalizedValue };
+      case "$ne":
+        return { except: [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 { except: 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 }
+        };
+      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"
+};
+var QdrantVector = class extends vector.MastraVector {
+  client;
+  constructor(url, apiKey, https) {
+    super();
+    const baseClient = new jsClientRest.QdrantClient({
+      url,
+      apiKey,
+      https
+    });
+    const telemetry = this.__getTelemetry();
+    this.client = telemetry?.traceClass(baseClient, {
+      spanNamePrefix: "qdrant-vector",
+      attributes: {
+        "vector.type": "qdrant"
+      }
+    }) ?? baseClient;
+  }
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args);
+    const { indexName, vectors, metadata, ids } = params;
+    const pointIds = ids || vectors.map(() => crypto.randomUUID());
+    const records = vectors.map((vector, i) => ({
+      id: pointIds[i],
+      vector,
+      payload: metadata?.[i] || {}
+    }));
+    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
+      });
+    }
+    return pointIds;
+  }
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+      throw new Error("Dimension must be a positive integer");
+    }
+    await this.client.createCollection(indexName, {
+      vectors: {
+        // @ts-expect-error
+        size: dimension,
+        // @ts-expect-error
+        distance: DISTANCE_MAPPING[metric]
+      }
+    });
+  }
+  transformFilter(filter) {
+    const translator = new QdrantFilterTranslator();
+    return translator.translate(filter);
+  }
+  async query(...args) {
+    const params = this.normalizeArgs("query", args);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
+    const translatedFilter = this.transformFilter(filter) ?? {};
+    const results = (await this.client.query(indexName, {
+      query: queryVector,
+      limit: topK,
+      filter: translatedFilter,
+      with_payload: true,
+      with_vector: includeVector
+    })).points;
+    return results.map((match) => {
+      let vector = [];
+      if (includeVector) {
+        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");
+        }
+      }
+      return {
+        id: match.id,
+        score: match.score || 0,
+        metadata: match.payload,
+        ...includeVector && { vector }
+      };
+    });
+  }
+  async listIndexes() {
+    const response = await this.client.getCollections();
+    return response.collections.map((collection) => collection.name) || [];
+  }
+  async describeIndex(indexName) {
+    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,
+      // @ts-expect-error
+      metric: Object.keys(DISTANCE_MAPPING).find((key) => DISTANCE_MAPPING[key] === distance)
+    };
+  }
+  async deleteIndex(indexName) {
+    await this.client.deleteCollection(indexName);
+  }
+};
+
+exports.QdrantVector = QdrantVector;

package/dist/index.d.cts

@@ -0,0 +1 @@
+export { QdrantVector } from './_tsup-dts-rollup.cjs';

package/dist/index.js

@@ -1,6 +1,6 @@
 import { MastraVector } from '@mastra/core/vector';
 import { QdrantClient } from '@qdrant/js-client-rest';
-import { BaseFilterTranslator } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/vector/index.ts
 var QdrantFilterTranslator = class extends BaseFilterTranslator {
@@ -252,7 +252,9 @@ var QdrantVector = class extends MastraVector {
       }
     }) ?? baseClient;
   }
-  async upsert(indexName, vectors, metadata, ids) {
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args);
+    const { indexName, vectors, metadata, ids } = params;
     const pointIds = ids || vectors.map(() => crypto.randomUUID());
     const records = vectors.map((vector, i) => ({
       id: pointIds[i],
@@ -269,7 +271,9 @@ var QdrantVector = class extends MastraVector {
     }
     return pointIds;
   }
-  async createIndex(indexName, dimension, metric = "cosine") {
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
     if (!Number.isInteger(dimension) || dimension <= 0) {
       throw new Error("Dimension must be a positive integer");
     }
@@ -286,8 +290,10 @@ var QdrantVector = class extends MastraVector {
     const translator = new QdrantFilterTranslator();
     return translator.translate(filter);
   }
-  async query(indexName, queryVector, topK = 10, filter, includeVector = false) {
-    const translatedFilter = this.transformFilter(filter);
+  async query(...args) {
+    const params = this.normalizeArgs("query", args);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
+    const translatedFilter = this.transformFilter(filter) ?? {};
     const results = (await this.client.query(indexName, {
       query: queryVector,
       limit: topK,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/qdrant",
-  "version": "0.1.6-alpha.1",
+  "version": "0.1.6-alpha.4",
   "description": "Qdrant vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -10,13 +10,17 @@
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       }
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
     "@qdrant/js-client-rest": "^1.12.0",
-    "@mastra/core": "^0.4.3-alpha.1"
+    "@mastra/core": "^0.4.3-alpha.4"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",
@@ -28,7 +32,7 @@
     "@internal/lint": "0.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --experimental-dts --clean --treeshake",
+    "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake",
     "build:watch": "pnpm build --watch",
     "test": "vitest run",
     "lint": "eslint ."

package/src/vector/filter.ts

@@ -1,5 +1,5 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
-import type { FieldCondition, Filter, LogicalOperator, OperatorSupport } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { FieldCondition, VectorFilter, LogicalOperator, OperatorSupport } from '@mastra/core/vector/filter';
 
 /**
  * Translates MongoDB-style filters to Qdrant compatible filters.
@@ -35,9 +35,9 @@ export class QdrantFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: Filter): Filter | undefined {
+  translate(filter?: VectorFilter): VectorFilter {
     if (this.isEmpty(filter)) return filter;
-    this.validateFilter(filter as Filter);
+    this.validateFilter(filter);
     return this.translateNode(filter);
   }
 
@@ -46,7 +46,7 @@ export class QdrantFilterTranslator extends BaseFilterTranslator {
     return fieldKey ? { key: fieldKey, ...condition } : condition;
   }
 
-  private translateNode(node: Filter | FieldCondition, isNested: boolean = false, fieldKey?: string): any {
+  private translateNode(node: VectorFilter | FieldCondition, isNested: boolean = false, fieldKey?: string): any {
     if (!this.isEmpty(node) && typeof node === 'object' && 'must' in node) {
       return node;
     }

package/src/vector/index.test.ts

@@ -1,6 +1,6 @@
 // To setup a Qdrant server, run:
 // docker run -p 6333:6333 qdrant/qdrant
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, afterEach, vi, beforeEach } from 'vitest';
 
 import { QdrantVector } from './index';
 
@@ -13,7 +13,7 @@ describe('QdrantVector', () => {
   describe('Index Operations', () => {
     beforeAll(async () => {
       qdrant = new QdrantVector('http://localhost:6333/');
-      await qdrant.createIndex(testCollectionName, dimension);
+      await qdrant.createIndex({ indexName: testCollectionName, dimension });
     });
 
     afterAll(async () => {
@@ -36,7 +36,7 @@ describe('QdrantVector', () => {
   describe('Vector Operations', () => {
     beforeAll(async () => {
       qdrant = new QdrantVector('http://localhost:6333/');
-      await qdrant.createIndex(testCollectionName, dimension);
+      await qdrant.createIndex({ indexName: testCollectionName, dimension });
     });
 
     afterAll(async () => {
@@ -52,13 +52,13 @@ describe('QdrantVector', () => {
     let vectorIds: string[];
 
     it('should upsert vectors with metadata', async () => {
-      vectorIds = await qdrant.upsert(testCollectionName, testVectors, testMetadata);
+      vectorIds = await qdrant.upsert({ indexName: testCollectionName, vectors: testVectors, metadata: testMetadata });
       expect(vectorIds).toHaveLength(3);
     }, 50000);
 
     it('should query vectors and return nearest neighbors', async () => {
       const queryVector = [1.0, 0.1, 0.1];
-      const results = await qdrant.query(testCollectionName, queryVector, 3);
+      const results = await qdrant.query({ indexName: testCollectionName, queryVector, topK: 3 });
 
       expect(results).toHaveLength(3);
       expect(results?.[0]?.score).toBeGreaterThan(0);
@@ -67,7 +67,7 @@ describe('QdrantVector', () => {
 
     it('should query vectors and return vector in results', async () => {
       const queryVector = [1.0, 0.1, 0.1];
-      const results = await qdrant.query(testCollectionName, queryVector, 3, undefined, true);
+      const results = await qdrant.query({ indexName: testCollectionName, queryVector, topK: 3, includeVector: true });
 
       expect(results).toHaveLength(3);
       expect(results?.[0]?.vector).toBeDefined();
@@ -80,7 +80,7 @@ describe('QdrantVector', () => {
         label: 'y-axis',
       };
 
-      const results = await qdrant.query(testCollectionName, queryVector, 1, filter);
+      const results = await qdrant.query({ indexName: testCollectionName, queryVector, topK: 1, filter });
 
       expect(results).toHaveLength(1);
       expect(results?.[0]?.metadata?.label).toBe('y-axis');
@@ -184,8 +184,8 @@ describe('QdrantVector', () => {
 
     beforeAll(async () => {
       qdrant = new QdrantVector('http://localhost:6333/');
-      await qdrant.createIndex(testCollectionName, dimension);
-      await qdrant.upsert(testCollectionName, filterTestVectors, filterTestMetadata);
+      await qdrant.createIndex({ indexName: testCollectionName, dimension });
+      await qdrant.upsert({ indexName: testCollectionName, vectors: filterTestVectors, metadata: filterTestMetadata });
     });
 
     afterAll(async () => {
@@ -195,21 +195,21 @@ describe('QdrantVector', () => {
     describe('Basic Operators', () => {
       it('should filter by exact value match', async () => {
         const filter = { name: 'item1' };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(1);
         expect(results[0]?.metadata?.name).toBe('item1');
       });
 
       it('should filter using comparison operators', async () => {
         const filter = { price: { $gt: 100, $lt: 600 } };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(1);
         expect(results[0]?.metadata?.price).toBe(500);
       });
 
       it('should filter using array operators', async () => {
         const filter = { tags: { $in: ['premium', 'bestseller'] } };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(2);
         const tags = results.flatMap(r => r.metadata?.tags || []);
         expect(tags).toContain('bestseller');
@@ -218,7 +218,7 @@ describe('QdrantVector', () => {
 
       it('should handle null values', async () => {
         const filter = { price: null };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(1);
         expect(results[0]?.metadata?.price).toBeNull();
       });
@@ -227,7 +227,7 @@ describe('QdrantVector', () => {
         const filter = {
           tags: [],
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         const resultsWithMetadata = results.filter(r => Object.keys(r?.metadata || {}).length > 0);
         expect(resultsWithMetadata).toHaveLength(1);
         expect(resultsWithMetadata[0]?.metadata?.tags).toHaveLength(0);
@@ -239,7 +239,7 @@ describe('QdrantVector', () => {
         const filter = {
           $and: [{ tags: { $in: ['electronics'] } }, { price: { $gt: 700 } }],
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(1);
         expect(results[0]?.metadata?.price).toBeGreaterThan(700);
         expect(results[0]?.metadata?.tags).toContain('electronics');
@@ -249,7 +249,7 @@ describe('QdrantVector', () => {
         const filter = {
           $or: [{ price: { $gt: 900 } }, { tags: { $in: ['bestseller'] } }],
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(2);
         results.forEach(result => {
           expect(result.metadata?.price > 900 || result.metadata?.tags?.includes('bestseller')).toBe(true);
@@ -260,7 +260,7 @@ describe('QdrantVector', () => {
         const filter = {
           $not: { tags: { $in: ['electronics'] } },
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         const resultsWithMetadata = results.filter(r => Object.keys(r?.metadata || {}).length > 0);
         expect(resultsWithMetadata).toHaveLength(2);
         resultsWithMetadata.forEach(result => {
@@ -277,7 +277,7 @@ describe('QdrantVector', () => {
             },
           ],
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(2);
         results.forEach(result => {
           expect(result.metadata?.details?.weight).toBeLessThan(2.0);
@@ -287,7 +287,7 @@ describe('QdrantVector', () => {
 
       it('should handle empty logical operators', async () => {
         const filter = { $and: [] };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results.length).toBeGreaterThan(0);
       });
     });
@@ -295,7 +295,7 @@ describe('QdrantVector', () => {
     describe('Custom Operators', () => {
       it('should filter using $count operator', async () => {
         const filter = { 'stock.locations': { $count: { $gt: 1 } } };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(2);
         results.forEach(result => {
           expect(result.metadata?.stock?.locations?.length).toBeGreaterThan(1);
@@ -312,7 +312,7 @@ describe('QdrantVector', () => {
             },
           },
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(1);
         expect(results[0]?.metadata?.location?.lat).toBe(52.5);
         expect(results[0]?.metadata?.location?.lon).toBe(13.4);
@@ -328,7 +328,7 @@ describe('QdrantVector', () => {
             },
           },
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(1);
         expect(results[0]?.metadata?.location?.lat).toBe(52.5);
         expect(results[0]?.metadata?.location?.lon).toBe(13.4);
@@ -351,7 +351,7 @@ describe('QdrantVector', () => {
             },
           },
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(1);
         expect(results[0]?.metadata?.location?.lat).toBe(52.5);
         expect(results[0]?.metadata?.location?.lon).toBe(13.4);
@@ -359,11 +359,11 @@ describe('QdrantVector', () => {
 
       it('should filter using $hasId operator', async () => {
         // First get some IDs from a regular query
-        const allResults = await qdrant.query(testCollectionName, [1, 0, 0], 2);
+        const allResults = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], topK: 2 });
         const targetIds = allResults.map(r => r.id);
 
         const filter = { $hasId: targetIds };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(2);
         results.forEach(result => {
           expect(targetIds).toContain(result.id);
@@ -372,7 +372,7 @@ describe('QdrantVector', () => {
 
       it('should filter using $hasVector operator', async () => {
         const filter = { $hasVector: '' };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results.length).toBeGreaterThan(0);
       });
 
@@ -385,7 +385,7 @@ describe('QdrantVector', () => {
         const metadata = {
           created_at: now.toISOString(),
         };
-        await qdrant.upsert(testCollectionName, [vector], [metadata]);
+        await qdrant.upsert({ indexName: testCollectionName, vectors: [vector], metadata: [metadata] });
 
         const filter = {
           created_at: {
@@ -397,7 +397,7 @@ describe('QdrantVector', () => {
             },
           },
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
           expect(new Date(result.metadata?.created_at).getTime()).toBeGreaterThan(now.getTime() - 1000);
@@ -408,39 +408,41 @@ describe('QdrantVector', () => {
 
     describe('Special Cases', () => {
       it('handles regex patterns in queries', async () => {
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, {
-          name: { $regex: 'item' },
+        const results = await qdrant.query({
+          indexName: testCollectionName,
+          queryVector: [1, 0, 0],
+          filter: { name: { $regex: 'item' } },
         });
         expect(results.length).toBe(4);
       });
 
       it('handles array operators in queries', async () => {
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, {
-          tags: { $in: ['electronics', 'books'] },
+        const results = await qdrant.query({
+          indexName: testCollectionName,
+          queryVector: [1, 0, 0],
+          filter: { tags: { $in: ['electronics', 'books'] } },
         });
         expect(results.length).toBe(3);
       });
 
       it('handles nested array queries', async () => {
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, {
-          'stock.locations[]': {
-            $nested: {
-              warehouse: 'A',
-              count: { $gt: 20 },
-            },
-          },
+        const results = await qdrant.query({
+          indexName: testCollectionName,
+          queryVector: [1, 0, 0],
+          filter: { 'stock.locations[]': { $nested: { warehouse: 'A', count: { $gt: 20 } } } },
         });
         expect(results.length).toBe(2);
       });
 
       it('handles collection-wide operators', async () => {
         // First get some actual IDs from our collection
-        const searchResults = await qdrant.query(testCollectionName, [1, 0, 0], 2);
+        const searchResults = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], topK: 2 });
         const ids = searchResults.map(r => r.id);
 
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, {
-          $hasId: ids,
-          $hasVector: '', // Use the default vector name
+        const results = await qdrant.query({
+          indexName: testCollectionName,
+          queryVector: [1, 0, 0],
+          filter: { $hasId: ids, $hasVector: '' },
         });
         expect(results.length).toBe(2);
       });
@@ -449,7 +451,7 @@ describe('QdrantVector', () => {
           'details.color': 'red',
           'stock.quantity': { $gt: 0 },
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(1);
         expect(results[0]?.metadata?.details?.color).toBe('red');
         expect(results[0]?.metadata?.stock?.quantity).toBeGreaterThan(0);
@@ -459,7 +461,7 @@ describe('QdrantVector', () => {
         const filter = {
           price: { $gt: 20, $lt: 30 },
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(1);
         expect(results[0]?.metadata?.price).toBe(25);
       });
@@ -474,7 +476,7 @@ describe('QdrantVector', () => {
             { $not: { tags: { $in: ['basic'] } } },
           ],
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(2);
         results.forEach(result => {
           expect(result.metadata?.details?.weight).toBeLessThan(3.0);
@@ -487,7 +489,7 @@ describe('QdrantVector', () => {
         const filter = {
           'stock.locations[].warehouse': { $in: ['A'] },
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(2);
         results.forEach(result => {
           expect(result.metadata?.stock?.locations?.some((loc: any) => loc.warehouse === 'A')).toBe(true);
@@ -498,7 +500,7 @@ describe('QdrantVector', () => {
         const filter = {
           $and: [{ 'stock.locations[].warehouse': { $in: ['A'] } }, { 'stock.locations[].count': { $gt: 20 } }],
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results).toHaveLength(2);
         results.forEach(result => {
           const locations = result.metadata?.stock?.locations || [];
@@ -517,7 +519,7 @@ describe('QdrantVector', () => {
             updated: new Date(now.getTime() + 1000).toISOString(),
           },
         };
-        await qdrant.upsert(testCollectionName, [vector], [metadata]);
+        await qdrant.upsert({ indexName: testCollectionName, vectors: [vector], metadata: [metadata] });
 
         const filter = {
           $and: [
@@ -533,7 +535,7 @@ describe('QdrantVector', () => {
             },
           ],
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results.length).toBeGreaterThan(0);
       });
 
@@ -557,7 +559,7 @@ describe('QdrantVector', () => {
             },
           ],
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         expect(results.length).toBeGreaterThan(0);
         results.forEach(result => {
           const metadata = result.metadata || {};
@@ -580,7 +582,7 @@ describe('QdrantVector', () => {
               $or: [{ 'details.weight': { $lt: 2.0 } }, { 'stock.quantity': { $gt: 0 } }],
             })),
         };
-        const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, filter);
+        const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter });
         const duration = Date.now() - start;
         expect(duration).toBeLessThan(1000); // Should complete within 1 second
         expect(results.length).toBeGreaterThan(0);
@@ -590,7 +592,7 @@ describe('QdrantVector', () => {
         const filters = [{ price: { $gt: 500 } }, { tags: { $in: ['electronics'] } }, { 'stock.quantity': { $gt: 0 } }];
         const start = Date.now();
         const results = await Promise.all(
-          filters.map(filter => qdrant.query(testCollectionName, [1, 0, 0], 10, filter)),
+          filters.map(filter => qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter })),
         );
         const duration = Date.now() - start;
         expect(duration).toBeLessThan(3000); // Should complete within 3 seconds
@@ -603,12 +605,12 @@ describe('QdrantVector', () => {
   describe('Error Handling', () => {
     it('should handle non-existent index query gracefully', async () => {
       const nonExistentIndex = 'non-existent-index';
-      await expect(qdrant.query(nonExistentIndex, [1, 0, 0])).rejects.toThrow();
+      await expect(qdrant.query({ indexName: nonExistentIndex, queryVector: [1, 0, 0] })).rejects.toThrow();
     }, 50000);
 
     it('should handle incorrect dimension vectors', async () => {
       const wrongDimVector = [[1, 0]]; // 2D vector for 3D index
-      await expect(qdrant.upsert(testCollectionName, wrongDimVector)).rejects.toThrow();
+      await expect(qdrant.upsert({ indexName: testCollectionName, vectors: wrongDimVector })).rejects.toThrow();
     }, 50000);
   });
 
@@ -649,30 +651,30 @@ describe('QdrantVector', () => {
 
     beforeAll(async () => {
       qdrant = new QdrantVector('http://localhost:6333/');
-      await qdrant.createIndex(testCollectionName, dimension);
-      await qdrant.upsert(testCollectionName, filterTestVectors, filterTestMetadata);
+      await qdrant.createIndex({ indexName: testCollectionName, dimension });
+      await qdrant.upsert({ indexName: testCollectionName, vectors: filterTestVectors, metadata: filterTestMetadata });
     });
 
     afterAll(async () => {
       await qdrant.deleteIndex(testCollectionName);
     }, 50000);
     it('should handle undefined filter', async () => {
-      const results1 = await qdrant.query(testCollectionName, [1, 0, 0], 10, undefined);
-      const results2 = await qdrant.query(testCollectionName, [1, 0, 0], 10);
+      const results1 = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter: undefined });
+      const results2 = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0] });
       expect(results1).toEqual(results2);
       expect(results1.length).toBeGreaterThan(0);
     });
 
     it('should handle empty object filter', async () => {
-      const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, {});
-      const results2 = await qdrant.query(testCollectionName, [1, 0, 0], 10);
+      const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter: {} });
+      const results2 = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0] });
       expect(results).toEqual(results2);
       expect(results.length).toBeGreaterThan(0);
     });
 
     it('should handle null filter', async () => {
-      const results = await qdrant.query(testCollectionName, [1, 0, 0], 10, null as any);
-      const results2 = await qdrant.query(testCollectionName, [1, 0, 0], 10);
+      const results = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0], filter: null });
+      const results2 = await qdrant.query({ indexName: testCollectionName, queryVector: [1, 0, 0] });
       expect(results).toEqual(results2);
       expect(results.length).toBeGreaterThan(0);
     });
@@ -681,7 +683,7 @@ describe('QdrantVector', () => {
   describe('Performance Tests', () => {
     beforeAll(async () => {
       qdrant = new QdrantVector('http://localhost:6333/');
-      await qdrant.createIndex(testCollectionName, dimension);
+      await qdrant.createIndex({ indexName: testCollectionName, dimension });
     });
 
     afterAll(async () => {
@@ -700,7 +702,7 @@ describe('QdrantVector', () => {
       const metadata = vectors.map((_, i) => ({ id: i }));
 
       const start = Date.now();
-      const ids = await qdrant.upsert(testCollectionName, vectors, metadata);
+      const ids = await qdrant.upsert({ indexName: testCollectionName, vectors, metadata });
       const duration = Date.now() - start;
 
       expect(ids).toHaveLength(batchSize);
@@ -714,7 +716,7 @@ describe('QdrantVector', () => {
       const start = Date.now();
       const promises = Array(numQueries)
         .fill(null)
-        .map(() => qdrant.query(testCollectionName, queryVector));
+        .map(() => qdrant.query({ indexName: testCollectionName, queryVector }));
 
       const results = await Promise.all(promises);
       const duration = Date.now() - start;
@@ -723,4 +725,101 @@ describe('QdrantVector', () => {
       console.log(`${numQueries} concurrent queries took ${duration}ms`);
     }, 50000);
   });
+  describe('Deprecation Warnings', () => {
+    const indexName = 'testdeprecationwarnings';
+
+    const indexName2 = 'testdeprecationwarnings2';
+
+    let warnSpy;
+
+    beforeAll(async () => {
+      await qdrant.createIndex({ indexName: indexName, dimension: 3 });
+    });
+
+    afterAll(async () => {
+      await qdrant.deleteIndex(indexName);
+      await qdrant.deleteIndex(indexName2);
+    });
+
+    beforeEach(async () => {
+      warnSpy = vi.spyOn(qdrant['logger'], 'warn');
+    });
+
+    afterEach(async () => {
+      warnSpy.mockRestore();
+      await qdrant.deleteIndex(indexName2);
+    });
+
+    it('should show deprecation warning when using individual args for createIndex', async () => {
+      await qdrant.createIndex(indexName2, 3, 'cosine');
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Deprecation Warning: Passing individual arguments to createIndex() is deprecated'),
+      );
+    });
+
+    it('should show deprecation warning when using individual args for upsert', async () => {
+      await qdrant.upsert(indexName, [[1, 2, 3]], [{ test: 'data' }]);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Deprecation Warning: Passing individual arguments to upsert() is deprecated'),
+      );
+    });
+
+    it('should show deprecation warning when using individual args for query', async () => {
+      await qdrant.query(indexName, [1, 2, 3], 5);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Deprecation Warning: Passing individual arguments to query() is deprecated'),
+      );
+    });
+
+    it('should not show deprecation warning when using object param for query', async () => {
+      await qdrant.query({
+        indexName,
+        queryVector: [1, 2, 3],
+        topK: 5,
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not show deprecation warning when using object param for createIndex', async () => {
+      await qdrant.createIndex({
+        indexName: indexName2,
+        dimension: 3,
+        metric: 'cosine',
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not show deprecation warning when using object param for upsert', async () => {
+      await qdrant.upsert({
+        indexName,
+        vectors: [[1, 2, 3]],
+        metadata: [{ test: 'data' }],
+      });
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('should maintain backward compatibility with individual args', async () => {
+      // Query
+      const queryResults = await qdrant.query(indexName, [1, 2, 3], 5);
+      expect(Array.isArray(queryResults)).toBe(true);
+
+      // CreateIndex
+      await expect(qdrant.createIndex(indexName2, 3, 'cosine')).resolves.not.toThrow();
+
+      // Upsert
+      const upsertResults = await qdrant.upsert({
+        indexName,
+        vectors: [[1, 2, 3]],
+        metadata: [{ test: 'data' }],
+      });
+      expect(Array.isArray(upsertResults)).toBe(true);
+      expect(upsertResults).toHaveLength(1);
+    });
+  });
 });

package/src/vector/index.ts

@@ -1,6 +1,13 @@
-import type { Filter } from '@mastra/core/filter';
 import { MastraVector } from '@mastra/core/vector';
-import type { QueryResult, IndexStats } from '@mastra/core/vector';
+import type {
+  QueryResult,
+  IndexStats,
+  CreateIndexParams,
+  UpsertVectorParams,
+  QueryVectorParams,
+  ParamsToArgs,
+} from '@mastra/core/vector';
+import type { VectorFilter } from '@mastra/core/vector/filter';
 import { QdrantClient } from '@qdrant/js-client-rest';
 import type { Schemas } from '@qdrant/js-client-rest';
 
@@ -35,12 +42,11 @@ export class QdrantVector extends MastraVector {
       }) ?? baseClient;
   }
 
-  async upsert(
-    indexName: string,
-    vectors: number[][],
-    metadata?: Record<string, any>[],
-    ids?: string[],
-  ): Promise<string[]> {
+  async upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]> {
+    const params = this.normalizeArgs<UpsertVectorParams>('upsert', args);
+
+    const { indexName, vectors, metadata, ids } = params;
+
     const pointIds = ids || vectors.map(() => crypto.randomUUID());
 
     const records = vectors.map((vector, i) => ({
@@ -61,11 +67,11 @@ export class QdrantVector extends MastraVector {
     return pointIds;
   }
 
-  async createIndex(
-    indexName: string,
-    dimension: number,
-    metric: 'cosine' | 'euclidean' | 'dotproduct' = 'cosine',
-  ): Promise<void> {
+  async createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void> {
+    const params = this.normalizeArgs<CreateIndexParams>('createIndex', args);
+
+    const { indexName, dimension, metric = 'cosine' } = params;
+
     if (!Number.isInteger(dimension) || dimension <= 0) {
       throw new Error('Dimension must be a positive integer');
     }
@@ -79,19 +85,17 @@ export class QdrantVector extends MastraVector {
     });
   }
 
-  transformFilter(filter?: Filter) {
+  transformFilter(filter?: VectorFilter) {
     const translator = new QdrantFilterTranslator();
     return translator.translate(filter);
   }
 
-  async query(
-    indexName: string,
-    queryVector: number[],
-    topK: number = 10,
-    filter?: Filter,
-    includeVector: boolean = false,
-  ): Promise<QueryResult[]> {
-    const translatedFilter = this.transformFilter(filter);
+  async query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]> {
+    const params = this.normalizeArgs<QueryVectorParams>('query', args);
+
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
+
+    const translatedFilter = this.transformFilter(filter) ?? {};
 
     const results = (
       await this.client.query(indexName, {