@mastra/qdrant 0.10.3 → 0.10.4-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/qdrant@0.10.3-alpha.0 build /home/runner/work/mastra/mastra/stores/qdrant
+> @mastra/qdrant@0.10.4-alpha.0 build /home/runner/work/mastra/mastra/stores/qdrant
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 7578ms
+TSC ⚡️ Build success in 7453ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/qdrant/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/qdrant/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 10357ms
+DTS ⚡️ Build success in 9897ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 18.24 KB
-ESM ⚡️ Build success in 687ms
-CJS dist/index.cjs 18.30 KB
-CJS ⚡️ Build success in 691ms
+CJS dist/index.cjs 21.22 KB
+CJS ⚡️ Build success in 959ms
+ESM dist/index.js 20.99 KB
+ESM ⚡️ Build success in 962ms

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @mastra/qdrant
 
+## 0.10.4-alpha.0
+
+### Patch Changes
+
+- 0e17048: Throw mastra errors in storage packages
+- Updated dependencies [d1baedb]
+- Updated dependencies [4d21bf2]
+- Updated dependencies [2097952]
+- Updated dependencies [4fb0cc2]
+- Updated dependencies [d2a7a31]
+- Updated dependencies [0e17048]
+  - @mastra/core@0.10.7-alpha.1
+
 ## 0.10.3
 
 ### Patch Changes

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var error = require('@mastra/core/error');
 var vector = require('@mastra/core/vector');
 var jsClientRest = require('@qdrant/js-client-rest');
 var filter = require('@mastra/core/vector/filter');
@@ -267,22 +268,46 @@ var QdrantVector = class extends vector.MastraVector {
       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
-      });
+    try {
+      for (let i = 0; i < records.length; i += BATCH_SIZE) {
+        const batch = records.slice(i, i + BATCH_SIZE);
+        await this.client.upsert(indexName, {
+          // @ts-expect-error
+          points: batch,
+          wait: true
+        });
+      }
+      return pointIds;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_UPSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, vectorCount: vectors.length }
+        },
+        error$1
+      );
     }
-    return pointIds;
   }
   async createIndex({ indexName, dimension, metric = "cosine" }) {
-    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`);
+    try {
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+      if (!DISTANCE_MAPPING[metric]) {
+        throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
+      }
+    } catch (validationError) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_CREATE_INDEX_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName, dimension, metric }
+        },
+        validationError
+      );
     }
     try {
       await this.client.createCollection(indexName, {
@@ -291,12 +316,21 @@ var QdrantVector = class extends vector.MastraVector {
           distance: DISTANCE_MAPPING[metric]
         }
       });
-    } catch (error) {
-      const message = error?.message || error?.toString();
-      if (error?.status === 409 || typeof message === "string" && message.toLowerCase().includes("exists")) {
+    } catch (error$1) {
+      const message = error$1?.message || error$1?.toString();
+      if (error$1?.status === 409 || typeof message === "string" && message.toLowerCase().includes("exists")) {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_CREATE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, dimension, metric }
+        },
+        error$1
+      );
     }
   }
   transformFilter(filter) {
@@ -311,33 +345,56 @@ var QdrantVector = class extends vector.MastraVector {
     includeVector = false
   }) {
     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");
+    try {
+      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 }
-      };
-    });
+        return {
+          id: match.id,
+          score: match.score || 0,
+          metadata: match.payload,
+          ...includeVector && { vector }
+        };
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_QUERY_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, topK }
+        },
+        error$1
+      );
+    }
   }
   async listIndexes() {
-    const response = await this.client.getCollections();
-    return response.collections.map((collection) => collection.name) || [];
+    try {
+      const response = await this.client.getCollections();
+      return response.collections.map((collection) => collection.name) || [];
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_LIST_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -346,17 +403,41 @@ var QdrantVector = class extends vector.MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   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)
-    };
+    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,
+        // @ts-expect-error
+        metric: Object.keys(DISTANCE_MAPPING).find((key) => DISTANCE_MAPPING[key] === distance)
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
   }
   async deleteIndex({ indexName }) {
-    await this.client.deleteCollection(indexName);
+    try {
+      await this.client.deleteCollection(indexName);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_DELETE_INDEX_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error$1
+      );
+    }
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
@@ -369,8 +450,20 @@ var QdrantVector = class extends vector.MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }) {
-    if (!update.vector && !update.metadata) {
-      throw new Error("No updates provided");
+    try {
+      if (!update.vector && !update.metadata) {
+        throw new Error("No updates provided");
+      }
+    } catch (validationError) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { indexName, id }
+        },
+        validationError
+      );
     }
     const pointId = this.parsePointId(id);
     try {
@@ -400,9 +493,16 @@ var QdrantVector = class extends vector.MastraVector {
         });
         return;
       }
-    } catch (error) {
-      console.error(`Failed to update vector by id: ${id} for index name: ${indexName}:`, error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error$1
+      );
     }
   }
   /**
@@ -418,8 +518,16 @@ var QdrantVector = class extends vector.MastraVector {
       await this.client.delete(indexName, {
         points: [pointId]
       });
-    } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_DELETE_VECTOR_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error$1
+      );
     }
   }
   /**

package/dist/index.js

@@ -1,3 +1,4 @@
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import { QdrantClient } from '@qdrant/js-client-rest';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
@@ -265,22 +266,46 @@ var QdrantVector = class extends MastraVector {
       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
-      });
+    try {
+      for (let i = 0; i < records.length; i += BATCH_SIZE) {
+        const batch = records.slice(i, i + BATCH_SIZE);
+        await this.client.upsert(indexName, {
+          // @ts-expect-error
+          points: batch,
+          wait: true
+        });
+      }
+      return pointIds;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_UPSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, vectorCount: vectors.length }
+        },
+        error
+      );
     }
-    return pointIds;
   }
   async createIndex({ indexName, dimension, metric = "cosine" }) {
-    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`);
+    try {
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error("Dimension must be a positive integer");
+      }
+      if (!DISTANCE_MAPPING[metric]) {
+        throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
+      }
+    } catch (validationError) {
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_CREATE_INDEX_INVALID_ARGS",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName, dimension, metric }
+        },
+        validationError
+      );
     }
     try {
       await this.client.createCollection(indexName, {
@@ -295,6 +320,15 @@ var QdrantVector = class extends MastraVector {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_CREATE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, dimension, metric }
+        },
+        error
+      );
     }
   }
   transformFilter(filter) {
@@ -309,33 +343,56 @@ var QdrantVector = class extends MastraVector {
     includeVector = false
   }) {
     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");
+    try {
+      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 }
-      };
-    });
+        return {
+          id: match.id,
+          score: match.score || 0,
+          metadata: match.payload,
+          ...includeVector && { vector }
+        };
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_QUERY_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, topK }
+        },
+        error
+      );
+    }
   }
   async listIndexes() {
-    const response = await this.client.getCollections();
-    return response.collections.map((collection) => collection.name) || [];
+    try {
+      const response = await this.client.getCollections();
+      return response.collections.map((collection) => collection.name) || [];
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_LIST_INDEXES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
   }
   /**
    * Retrieves statistics about a vector index.
@@ -344,17 +401,41 @@ var QdrantVector = class extends MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   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)
-    };
+    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,
+        // @ts-expect-error
+        metric: Object.keys(DISTANCE_MAPPING).find((key) => DISTANCE_MAPPING[key] === distance)
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_DESCRIBE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   async deleteIndex({ indexName }) {
-    await this.client.deleteCollection(indexName);
+    try {
+      await this.client.deleteCollection(indexName);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_DELETE_INDEX_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName }
+        },
+        error
+      );
+    }
   }
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
@@ -367,8 +448,20 @@ var QdrantVector = class extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }) {
-    if (!update.vector && !update.metadata) {
-      throw new Error("No updates provided");
+    try {
+      if (!update.vector && !update.metadata) {
+        throw new Error("No updates provided");
+      }
+    } catch (validationError) {
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_UPDATE_VECTOR_INVALID_ARGS",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName, id }
+        },
+        validationError
+      );
     }
     const pointId = this.parsePointId(id);
     try {
@@ -399,8 +492,15 @@ var QdrantVector = class extends MastraVector {
         return;
       }
     } catch (error) {
-      console.error(`Failed to update vector by id: ${id} for index name: ${indexName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_UPDATE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
   /**
@@ -417,7 +517,15 @@ var QdrantVector = class extends MastraVector {
         points: [pointId]
       });
     } catch (error) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new MastraError(
+        {
+          id: "STORAGE_QDRANT_VECTOR_DELETE_VECTOR_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id }
+        },
+        error
+      );
     }
   }
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/qdrant",
-  "version": "0.10.3",
+  "version": "0.10.4-alpha.0",
   "description": "Qdrant vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -30,7 +30,7 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
     "@internal/lint": "0.0.13",
-    "@mastra/core": "0.10.6"
+    "@mastra/core": "0.10.7-alpha.1"
   },
   "peerDependencies": {
     "@mastra/core": ">=0.10.4-0 <0.11.0"

package/src/vector/index.ts

@@ -1,3 +1,4 @@
+import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 import type {
   QueryResult,
@@ -58,25 +59,50 @@ export class QdrantVector extends MastraVector {
       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,
-      });
-    }
+    try {
+      for (let i = 0; i < records.length; i += BATCH_SIZE) {
+        const batch = records.slice(i, i + BATCH_SIZE);
+        await this.client.upsert(indexName, {
+          // @ts-expect-error
+          points: batch,
+          wait: true,
+        });
+      }
 
-    return pointIds;
+      return pointIds;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_UPSERT_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, vectorCount: vectors.length },
+        },
+        error,
+      );
+    }
   }
 
   async createIndex({ indexName, dimension, metric = 'cosine' }: CreateIndexParams): Promise<void> {
-    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`);
+    try {
+      if (!Number.isInteger(dimension) || dimension <= 0) {
+        throw new Error('Dimension must be a positive integer');
+      }
+      if (!DISTANCE_MAPPING[metric]) {
+        throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
+      }
+    } catch (validationError) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_CREATE_INDEX_INVALID_ARGS',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName, dimension, metric },
+        },
+        validationError,
+      );
     }
+
     try {
       await this.client.createCollection(indexName, {
         vectors: {
@@ -92,6 +118,16 @@ export class QdrantVector extends MastraVector {
         await this.validateExistingIndex(indexName, dimension, metric);
         return;
       }
+
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_CREATE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, dimension, metric },
+        },
+        error,
+      );
     }
   }
 
@@ -109,40 +145,63 @@ export class QdrantVector extends MastraVector {
   }: QueryVectorParams): Promise<QueryResult[]> {
     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;
+    try {
+      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: number[] = [];
-      if (includeVector) {
-        if (Array.isArray(match.vector)) {
-          // If it's already an array of numbers
-          vector = match.vector as number[];
-        } else if (typeof match.vector === 'object' && match.vector !== null) {
-          // If it's an object with vector data
-          vector = Object.values(match.vector).filter(v => typeof v === 'number');
+      return results.map(match => {
+        let vector: number[] = [];
+        if (includeVector) {
+          if (Array.isArray(match.vector)) {
+            // If it's already an array of numbers
+            vector = match.vector as number[];
+          } else if (typeof match.vector === 'object' && match.vector !== null) {
+            // If it's an object with vector data
+            vector = Object.values(match.vector).filter(v => typeof v === 'number');
+          }
         }
-      }
 
-      return {
-        id: match.id as string,
-        score: match.score || 0,
-        metadata: match.payload as Record<string, any>,
-        ...(includeVector && { vector }),
-      };
-    });
+        return {
+          id: match.id as string,
+          score: match.score || 0,
+          metadata: match.payload as Record<string, any>,
+          ...(includeVector && { vector }),
+        };
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_QUERY_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, topK },
+        },
+        error,
+      );
+    }
   }
 
   async listIndexes(): Promise<string[]> {
-    const response = await this.client.getCollections();
-    return response.collections.map(collection => collection.name) || [];
+    try {
+      const response = await this.client.getCollections();
+      return response.collections.map(collection => collection.name) || [];
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_LIST_INDEXES_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -152,19 +211,43 @@ export class QdrantVector extends MastraVector {
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
   async describeIndex({ indexName }: DescribeIndexParams): Promise<IndexStats> {
-    const { config, points_count } = await this.client.getCollection(indexName);
+    try {
+      const { config, points_count } = await this.client.getCollection(indexName);
 
-    const distance = config.params.vectors?.distance as Schemas['Distance'];
-    return {
-      dimension: config.params.vectors?.size as number,
-      count: points_count || 0,
-      // @ts-expect-error
-      metric: Object.keys(DISTANCE_MAPPING).find(key => DISTANCE_MAPPING[key] === distance),
-    };
+      const distance = config.params.vectors?.distance as Schemas['Distance'];
+      return {
+        dimension: config.params.vectors?.size as number,
+        count: points_count || 0,
+        // @ts-expect-error
+        metric: Object.keys(DISTANCE_MAPPING).find(key => DISTANCE_MAPPING[key] === distance),
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_DESCRIBE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
+    }
   }
 
   async deleteIndex({ indexName }: DeleteIndexParams): Promise<void> {
-    await this.client.deleteCollection(indexName);
+    try {
+      await this.client.deleteCollection(indexName);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_DELETE_INDEX_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName },
+        },
+        error,
+      );
+    }
   }
 
   /**
@@ -178,8 +261,20 @@ export class QdrantVector extends MastraVector {
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
   async updateVector({ indexName, id, update }: UpdateVectorParams): Promise<void> {
-    if (!update.vector && !update.metadata) {
-      throw new Error('No updates provided');
+    try {
+      if (!update.vector && !update.metadata) {
+        throw new Error('No updates provided');
+      }
+    } catch (validationError) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_UPDATE_VECTOR_INVALID_ARGS',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { indexName, id },
+        },
+        validationError,
+      );
     }
 
     const pointId = this.parsePointId(id);
@@ -219,8 +314,15 @@ export class QdrantVector extends MastraVector {
         return;
       }
     } catch (error) {
-      console.error(`Failed to update vector by id: ${id} for index name: ${indexName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_UPDATE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id },
+        },
+        error,
+      );
     }
   }
 
@@ -240,8 +342,16 @@ export class QdrantVector extends MastraVector {
       await this.client.delete(indexName, {
         points: [pointId],
       });
-    } catch (error: any) {
-      throw new Error(`Failed to delete vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: 'STORAGE_QDRANT_VECTOR_DELETE_VECTOR_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { indexName, id },
+        },
+        error,
+      );
     }
   }