@mastra/vectorize 0.1.6-alpha.0 → 0.1.6-alpha.3

package/.turbo/turbo-build.log

@@ -1,18 +1,23 @@
 
-> @mastra/vectorize@0.1.6-alpha.0 build /home/runner/work/mastra/mastra/stores/vectorize
-> tsup src/index.ts --format esm --experimental-dts --clean --treeshake
+> @mastra/vectorize@0.1.6-alpha.3 build /home/runner/work/mastra/mastra/stores/vectorize
+> 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 12685ms
+TSC ⚡️ Build success in 12974ms
 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/vectorize/dist/_tsup-dts-rollup.d.ts
-DTS ⚡️ Build success in 9765ms
+Analysis will use the bundled TypeScript version 5.7.3
+Writing package typings: /home/runner/work/mastra/mastra/stores/vectorize/dist/_tsup-dts-rollup.d.cts
+DTS ⚡️ Build success in 17317ms
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js 5.26 KB
+CJS Build start
+CJS dist/index.cjs 5.68 KB
+CJS ⚡️ Build success in 465ms
+ESM dist/index.js 5.48 KB
 ESM ⚡️ Build success in 465ms

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @mastra/vectorize
 
+## 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
+- c4fdac3: Updated tests for upstash and astra
+- 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
+
+- Updated dependencies [0d185b1]
+- Updated dependencies [ed55f1d]
+- Updated dependencies [8d13b14]
+- Updated dependencies [3ee4831]
+- Updated dependencies [108793c]
+- Updated dependencies [5f28f44]
+  - @mastra/core@0.4.3-alpha.1
+
 ## 0.1.6-alpha.0
 
 ### Patch Changes

package/README.md

@@ -14,7 +14,33 @@ npm install @mastra/vectorize
 import { VectorizeStore } from '@mastra/vectorize';
 
 const vectorStore = new VectorizeStore({
-  // configuration options
+  apiKey: process.env.VECTORIZE_API_KEY,
+  projectId: process.env.VECTORIZE_PROJECT_ID
+});
+
+// Create a new index
+await vectorStore.createIndex({
+  indexName: 'my-index',
+  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({
+  indexName: 'my-index',
+  vectors,
+  metadata
+});
+
+// Query vectors
+const results = await vectorStore.query({
+  indexName: 'my-index',
+  queryVector: [0.1, 0.2, ...],
+  topK: 10,
+  filter: { text: { $eq: 'doc1' } },
+  includeVector: false
 });
 ```
 
@@ -34,6 +60,15 @@ The Vectorize vector store requires the following configuration:
 - Scalable architecture
 - Real-time updates and queries
 
+## Methods
+
+- `createIndex({ indexName, dimension, metric? })`: Create a new index
+- `upsert({ indexName, vectors, metadata?, ids? })`: Add or update vectors
+- `query({ indexName, queryVector, topK?, filter?, includeVector? })`: Search for similar vectors
+- `listIndexes()`: List all indexes
+- `describeIndex(indexName)`: Get index statistics
+- `deleteIndex(indexName)`: Delete an index
+
 ## Related Links
 
 - [Vectorize Documentation](https://www.vectorize.com/docs)

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

@@ -0,0 +1,43 @@
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import Cloudflare from 'cloudflare';
+import type { CreateIndexParams } from '@mastra/core/vector';
+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';
+
+declare class CloudflareVector extends MastraVector {
+    client: Cloudflare;
+    accountId: string;
+    constructor({ accountId, apiToken }: {
+        accountId: string;
+        apiToken: string;
+    });
+    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    query(...args: ParamsToArgs<QueryVectorParams>): 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?: VectorFilter): VectorFilter;
+    private translateNode;
+}
+
+export { }

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

@@ -1,9 +1,13 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 import Cloudflare from 'cloudflare';
-import { Filter } from '@mastra/core/filter';
+import type { CreateIndexParams } from '@mastra/core/vector';
 import { MastraVector } from '@mastra/core/vector';
-import { OperatorSupport } from '@mastra/core/filter';
-import { QueryResult } 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';
 
 declare class CloudflareVector extends MastraVector {
     client: Cloudflare;
@@ -12,10 +16,10 @@ declare class CloudflareVector extends MastraVector {
         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[]>;
+    upsert(...args: ParamsToArgs<UpsertVectorParams>): Promise<string[]>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    query(...args: ParamsToArgs<QueryVectorParams>): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
     describeIndex(indexName: string): Promise<{
         dimension: number;
@@ -32,7 +36,7 @@ export { CloudflareVector as CloudflareVector_alias_1 }
 
 export declare class VectorizeFilterTranslator extends BaseFilterTranslator {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: Filter): Filter | undefined;
+    translate(filter?: VectorFilter): VectorFilter;
     private translateNode;
 }
 

package/dist/index.cjs

@@ -0,0 +1,184 @@
+'use strict';
+
+var vector = require('@mastra/core/vector');
+var Cloudflare = require('cloudflare');
+var filter = require('@mastra/core/vector/filter');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Cloudflare__default = /*#__PURE__*/_interopDefault(Cloudflare);
+
+// src/vector/index.ts
+var VectorizeFilterTranslator = class extends filter.BaseFilterTranslator {
+  getSupportedOperators() {
+    return {
+      ...filter.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 vector.MastraVector {
+  client;
+  accountId;
+  constructor({ accountId, apiToken }) {
+    super();
+    this.accountId = accountId;
+    this.client = new Cloudflare__default.default({
+      apiKey: apiToken
+    });
+  }
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args);
+    const { indexName, vectors, metadata, ids } = params;
+    const generatedIds = ids || vectors.map(() => crypto.randomUUID());
+    const ndjson = vectors.map(
+      (vector, index) => JSON.stringify({
+        id: generatedIds[index],
+        values: vector,
+        metadata: metadata?.[index]
+      })
+    ).join("\n");
+    await this.client.vectorize.indexes.upsert(
+      indexName,
+      {
+        account_id: this.accountId,
+        body: ndjson
+      },
+      {
+        __binaryRequest: true
+      }
+    );
+    return generatedIds;
+  }
+  transformFilter(filter) {
+    const translator = new VectorizeFilterTranslator();
+    return translator.translate(filter);
+  }
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
+    await this.client.vectorize.indexes.create({
+      account_id: this.accountId,
+      config: {
+        dimensions: dimension,
+        metric: metric === "dotproduct" ? "dot-product" : metric
+      },
+      name: indexName
+    });
+  }
+  async query(...args) {
+    const params = this.normalizeArgs("query", args);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
+    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 ?? [];
+  }
+};
+
+exports.CloudflareVector = CloudflareVector;

package/dist/index.d.cts

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

package/dist/index.js

@@ -1,6 +1,6 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
 import { MastraVector } from '@mastra/core/vector';
 import Cloudflare from 'cloudflare';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/vector/index.ts
 var VectorizeFilterTranslator = class extends BaseFilterTranslator {
@@ -68,7 +68,9 @@ var CloudflareVector = class extends MastraVector {
       apiKey: apiToken
     });
   }
-  async upsert(indexName, vectors, metadata, ids) {
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args);
+    const { indexName, vectors, metadata, ids } = params;
     const generatedIds = ids || vectors.map(() => crypto.randomUUID());
     const ndjson = vectors.map(
       (vector, index) => JSON.stringify({
@@ -91,10 +93,11 @@ var CloudflareVector = class extends MastraVector {
   }
   transformFilter(filter) {
     const translator = new VectorizeFilterTranslator();
-    const translatedFilter = translator.translate(filter);
-    return translatedFilter;
+    return translator.translate(filter);
   }
-  async createIndex(indexName, dimension, metric = "cosine") {
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
     await this.client.vectorize.indexes.create({
       account_id: this.accountId,
       config: {
@@ -104,8 +107,10 @@ var CloudflareVector = class extends MastraVector {
       name: indexName
     });
   }
-  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 response = await this.client.vectorize.indexes.query(indexName, {
       account_id: this.accountId,
       vector: queryVector,

package/eslint.config.js

@@ -0,0 +1,6 @@
+import { createConfig } from '@internal/lint/eslint';
+
+const config = await createConfig();
+
+/** @type {import("eslint").Linter.Config[]} */
+export default [...config];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/vectorize",
-  "version": "0.1.6-alpha.0",
+  "version": "0.1.6-alpha.3",
   "description": "Cloudflare Vectorize store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -10,24 +10,31 @@
       "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": {
     "cloudflare": "^4.0.0",
-    "@mastra/core": "^0.4.3-alpha.0"
+    "@mastra/core": "^0.4.3-alpha.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",
     "@types/node": "^22.13.1",
     "tsup": "^8.0.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.5"
+    "vitest": "^3.0.5",
+    "eslint": "^9.20.1",
+    "@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"
+    "test": "vitest run",
+    "lint": "eslint ."
   }
 }

package/src/vector/filter.ts

@@ -1,4 +1,5 @@
-import { BaseFilterTranslator, type Filter, type FieldCondition, type OperatorSupport } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { VectorFilter, FieldCondition, OperatorSupport } from '@mastra/core/vector/filter';
 
 export class VectorizeFilterTranslator extends BaseFilterTranslator {
   protected override getSupportedOperators(): OperatorSupport {
@@ -12,13 +13,13 @@ export class VectorizeFilterTranslator 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);
   }
 
-  private translateNode(node: Filter | FieldCondition, currentPath: string = ''): any {
+  private translateNode(node: VectorFilter | FieldCondition, currentPath: string = ''): any {
     if (this.isRegex(node)) {
       throw new Error('Regex is not supported in Vectorize');
     }