@mastra/vectorize 0.1.0-alpha.37 → 0.1.0-alpha.38

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @mastra/vectorize
 
+## 0.1.0-alpha.38
+
+### Patch Changes
+
+- Updated dependencies [a9345f9]
+  - @mastra/core@0.2.0-alpha.102
+
 ## 0.1.0-alpha.37
 
 ### Patch Changes

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

@@ -0,0 +1,39 @@
+import { BaseFilterTranslator } from '@mastra/core/filter';
+import Cloudflare from 'cloudflare';
+import { Filter } from '@mastra/core/filter';
+import { MastraVector } from '@mastra/core/vector';
+import { OperatorSupport } from '@mastra/core/filter';
+import { QueryResult } from '@mastra/core/vector';
+
+declare class CloudflareVector extends MastraVector {
+    client: Cloudflare;
+    accountId: string;
+    constructor({ accountId, apiToken }: {
+        accountId: string;
+        apiToken: string;
+    });
+    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
+    transformFilter(filter?: Filter): Filter | undefined;
+    createIndex(indexName: string, dimension: number, metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
+    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean): Promise<QueryResult[]>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<{
+        dimension: number;
+        count: number;
+        metric: "cosine" | "euclidean" | "dotproduct";
+    }>;
+    deleteIndex(indexName: string): Promise<void>;
+    createMetadataIndex(indexName: string, propertyName: string, indexType: 'string' | 'number' | 'boolean'): Promise<void>;
+    deleteMetadataIndex(indexName: string, propertyName: string): Promise<void>;
+    listMetadataIndexes(indexName: string): Promise<Cloudflare.Vectorize.Indexes.MetadataIndex.MetadataIndexListResponse.MetadataIndex[]>;
+}
+export { CloudflareVector }
+export { CloudflareVector as CloudflareVector_alias_1 }
+
+export declare class VectorizeFilterTranslator extends BaseFilterTranslator {
+    protected getSupportedOperators(): OperatorSupport;
+    translate(filter?: Filter): Filter | undefined;
+    private translateNode;
+}
+
+export { }

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,165 @@
+import { BaseFilterTranslator } from '@mastra/core/filter';
+import { MastraVector } from '@mastra/core/vector';
+import Cloudflare from 'cloudflare';
+
+// src/vector/index.ts
+var VectorizeFilterTranslator = class extends BaseFilterTranslator {
+  getSupportedOperators() {
+    return {
+      ...BaseFilterTranslator.DEFAULT_OPERATORS,
+      logical: [],
+      array: ["$in", "$nin"],
+      element: [],
+      regex: [],
+      custom: []
+    };
+  }
+  translate(filter) {
+    if (this.isEmpty(filter)) return filter;
+    this.validateFilter(filter);
+    return this.translateNode(filter);
+  }
+  translateNode(node, currentPath = "") {
+    if (this.isRegex(node)) {
+      throw new Error("Regex is not supported in Vectorize");
+    }
+    if (this.isPrimitive(node)) return { $eq: this.normalizeComparisonValue(node) };
+    if (Array.isArray(node)) return { $in: this.normalizeArrayValues(node) };
+    const entries = Object.entries(node);
+    const firstEntry = entries[0];
+    if (entries.length === 1 && firstEntry && this.isOperator(firstEntry[0])) {
+      const [operator, value] = firstEntry;
+      return { [operator]: this.normalizeComparisonValue(value) };
+    }
+    const result = {};
+    for (const [key, value] of entries) {
+      const newPath = currentPath ? `${currentPath}.${key}` : key;
+      if (this.isOperator(key)) {
+        result[key] = this.normalizeComparisonValue(value);
+        continue;
+      }
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        if (Object.keys(value).length === 0) {
+          result[newPath] = this.translateNode(value);
+          continue;
+        }
+        const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
+        if (hasOperators) {
+          result[newPath] = this.translateNode(value);
+        } else {
+          Object.assign(result, this.translateNode(value, newPath));
+        }
+      } else {
+        result[newPath] = this.translateNode(value);
+      }
+    }
+    return result;
+  }
+};
+
+// src/vector/index.ts
+var CloudflareVector = class extends MastraVector {
+  client;
+  accountId;
+  constructor({ accountId, apiToken }) {
+    super();
+    this.accountId = accountId;
+    this.client = new Cloudflare({
+      apiKey: apiToken
+    });
+  }
+  async upsert(indexName, vectors, metadata, ids) {
+    const generatedIds = ids || vectors.map(() => crypto.randomUUID());
+    const ndjson = vectors.map((vector, index) => ({
+      id: generatedIds[index],
+      values: vector,
+      metadata: metadata?.[index]
+    })).map((record) => JSON.stringify(record)).join("\n");
+    await this.client.vectorize.indexes.upsert(indexName, {
+      account_id: this.accountId,
+      body: ndjson
+    });
+    return generatedIds;
+  }
+  transformFilter(filter) {
+    const translator = new VectorizeFilterTranslator();
+    const translatedFilter = translator.translate(filter);
+    return translatedFilter;
+  }
+  async createIndex(indexName, dimension, metric = "cosine") {
+    await this.client.vectorize.indexes.create({
+      account_id: this.accountId,
+      config: {
+        dimensions: dimension,
+        metric: metric === "dotproduct" ? "dot-product" : metric
+      },
+      name: indexName
+    });
+  }
+  async query(indexName, queryVector, topK = 10, filter, includeVector = false) {
+    const translatedFilter = this.transformFilter(filter);
+    const response = await this.client.vectorize.indexes.query(indexName, {
+      account_id: this.accountId,
+      vector: queryVector,
+      returnValues: includeVector,
+      returnMetadata: "all",
+      topK,
+      filter: translatedFilter
+    });
+    return response?.matches?.map((match) => {
+      return {
+        id: match.id,
+        metadata: match.metadata,
+        score: match.score,
+        vector: match.values
+      };
+    }) || [];
+  }
+  async listIndexes() {
+    const res = await this.client.vectorize.indexes.list({
+      account_id: this.accountId
+    });
+    return res?.result?.map((index) => index.name) || [];
+  }
+  async describeIndex(indexName) {
+    const index = await this.client.vectorize.indexes.get(indexName, {
+      account_id: this.accountId
+    });
+    const described = await this.client.vectorize.indexes.info(indexName, {
+      account_id: this.accountId
+    });
+    return {
+      dimension: described?.dimensions,
+      // Since vector_count is not available in the response,
+      // we might need a separate API call to get the count if needed
+      count: described?.vectorCount || 0,
+      metric: index?.config?.metric
+    };
+  }
+  async deleteIndex(indexName) {
+    await this.client.vectorize.indexes.delete(indexName, {
+      account_id: this.accountId
+    });
+  }
+  async createMetadataIndex(indexName, propertyName, indexType) {
+    await this.client.vectorize.indexes.metadataIndex.create(indexName, {
+      account_id: this.accountId,
+      propertyName,
+      indexType
+    });
+  }
+  async deleteMetadataIndex(indexName, propertyName) {
+    await this.client.vectorize.indexes.metadataIndex.delete(indexName, {
+      account_id: this.accountId,
+      propertyName
+    });
+  }
+  async listMetadataIndexes(indexName) {
+    const res = await this.client.vectorize.indexes.metadataIndex.list(indexName, {
+      account_id: this.accountId
+    });
+    return res?.metadataIndexes ?? [];
+  }
+};
+
+export { CloudflareVector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/vectorize",
-  "version": "0.1.0-alpha.37",
+  "version": "0.1.0-alpha.38",
   "description": "Cloudflare Vectorize store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,7 @@
   },
   "dependencies": {
     "cloudflare": "^4.0.0",
-    "@mastra/core": "^0.2.0-alpha.101"
+    "@mastra/core": "^0.2.0-alpha.102"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",