@mastra/vectorize 0.1.0-alpha.29

package/src/vector/index.ts

@@ -0,0 +1,150 @@
+import { Filter } from '@mastra/core/filter';
+import { MastraVector, QueryResult } from '@mastra/core/vector';
+import Cloudflare from 'cloudflare';
+
+import { VectorizeFilterTranslator } from './filter';
+
+export class CloudflareVector extends MastraVector {
+  client: Cloudflare;
+  accountId: string;
+
+  constructor({ accountId, apiToken }: { accountId: string; apiToken: string }) {
+    super();
+    this.accountId = accountId;
+
+    this.client = new Cloudflare({
+      apiKey: apiToken,
+    });
+  }
+
+  async upsert(
+    indexName: string,
+    vectors: number[][],
+    metadata?: Record<string, any>[],
+    ids?: string[],
+  ): Promise<string[]> {
+    const generatedIds = ids || vectors.map(() => crypto.randomUUID());
+
+    // Create NDJSON string - each line is a JSON object
+    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 as any,
+    });
+
+    return generatedIds;
+  }
+
+  transformFilter(filter?: Filter) {
+    const translator = new VectorizeFilterTranslator();
+    const translatedFilter = translator.translate(filter);
+    return translatedFilter;
+  }
+
+  async createIndex(
+    indexName: string,
+    dimension: number,
+    metric: 'cosine' | 'euclidean' | 'dotproduct' = 'cosine',
+  ): Promise<void> {
+    await this.client.vectorize.indexes.create({
+      account_id: this.accountId,
+      config: {
+        dimensions: dimension,
+        metric: metric === 'dotproduct' ? 'dot-product' : metric,
+      },
+      name: indexName,
+    });
+  }
+
+  async query(
+    indexName: string,
+    queryVector: number[],
+    topK: number = 10,
+    filter?: Filter,
+    includeVector: boolean = false,
+  ): Promise<QueryResult[]> {
+    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: any) => {
+        return {
+          id: match.id,
+          metadata: match.metadata,
+          score: match.score,
+          vector: match.values,
+        };
+      }) || []
+    );
+  }
+
+  async listIndexes(): Promise<string[]> {
+    const res = await this.client.vectorize.indexes.list({
+      account_id: this.accountId,
+    });
+
+    return res?.result?.map(index => index.name!) || [];
+  }
+
+  async describeIndex(indexName: string) {
+    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 as 'cosine' | 'euclidean' | 'dotproduct',
+    };
+  }
+
+  async deleteIndex(indexName: string): Promise<void> {
+    await this.client.vectorize.indexes.delete(indexName, {
+      account_id: this.accountId,
+    });
+  }
+
+  async createMetadataIndex(indexName: string, propertyName: string, indexType: 'string' | 'number' | 'boolean') {
+    await this.client.vectorize.indexes.metadataIndex.create(indexName, {
+      account_id: this.accountId,
+      propertyName,
+      indexType,
+    });
+  }
+
+  async deleteMetadataIndex(indexName: string, propertyName: string) {
+    await this.client.vectorize.indexes.metadataIndex.delete(indexName, {
+      account_id: this.accountId,
+      propertyName,
+    });
+  }
+
+  async listMetadataIndexes(indexName: string) {
+    const res = await this.client.vectorize.indexes.metadataIndex.list(indexName, {
+      account_id: this.accountId,
+    });
+
+    return res?.metadataIndexes ?? [];
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+    coverage: {
+      reporter: ['text', 'json', 'html'],
+    },
+  },
+});