@mastra/qdrant 0.1.0-alpha.28

package/dist/index.js

@@ -0,0 +1,333 @@
+import { MastraVector } from '@mastra/core/vector';
+import { QdrantClient } from '@qdrant/js-client-rest';
+import { BaseFilterTranslator } from '@mastra/core/filter';
+
+// src/vector/index.ts
+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"],
+      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 MastraVector {
+  constructor(url, apiKey, https) {
+    super();
+    const baseClient = new QdrantClient({
+      url,
+      apiKey,
+      https
+    });
+    const telemetry = this.__getTelemetry();
+    this.client = telemetry?.traceClass(baseClient, {
+      spanNamePrefix: "qdrant-vector",
+      attributes: {
+        "vector.type": "qdrant"
+      }
+    }) ?? baseClient;
+  }
+  async upsert(indexName, vectors, metadata, ids) {
+    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(indexName, dimension, metric = "cosine") {
+    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(indexName, queryVector, topK = 10, filter, 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");
+        }
+      }
+      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);
+  }
+};
+
+export { QdrantVector };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@mastra/qdrant",
+  "version": "0.1.0-alpha.28",
+  "description": "Qdrant vector store provider for Mastra",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@qdrant/js-client-rest": "^1.12.0",
+    "@mastra/core": "^0.2.0-alpha.93"
+  },
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.7",
+    "@types/node": "^22.9.0",
+    "tsup": "^8.0.1",
+    "vitest": "^3.0.4"
+  },
+  "scripts": {
+    "build": "tsup-node src/index.ts --format esm --dts --clean --treeshake",
+    "dev": "tsup-node src/index.ts --format esm --dts --clean --treeshake --watch",
+    "test": "vitest run"
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './vector';