@mastra/chroma 0.1.6-alpha.1 → 0.1.6-alpha.4

package/.turbo/turbo-build.log

@@ -1,18 +1,23 @@
 
-> @mastra/chroma@0.1.6-alpha.1 build /home/runner/work/mastra/mastra/stores/chroma
-> tsup src/index.ts --format esm --experimental-dts --clean --treeshake
+> @mastra/chroma@0.1.6-alpha.4 build /home/runner/work/mastra/mastra/stores/chroma
+> 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 6980ms
+TSC ⚡️ Build success in 6393ms
 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/chroma/dist/_tsup-dts-rollup.d.ts
-DTS ⚡️ Build success in 6006ms
+Analysis will use the bundled TypeScript version 5.7.3
+Writing package typings: /home/runner/work/mastra/mastra/stores/chroma/dist/_tsup-dts-rollup.d.cts
+DTS ⚡️ Build success in 8226ms
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js 7.03 KB
-ESM ⚡️ Build success in 410ms
+CJS Build start
+ESM dist/index.js 7.28 KB
+ESM ⚡️ Build success in 637ms
+CJS dist/index.cjs 7.31 KB
+CJS ⚡️ Build success in 637ms

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @mastra/chroma
 
+## 0.1.6-alpha.4
+
+### Patch Changes
+
+- Updated dependencies [dabecf4]
+  - @mastra/core@0.4.3-alpha.4
+
+## 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
+- 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

package/README.md

@@ -22,29 +22,28 @@ const vectorStore = new ChromaVector({
 });
 
 // Create a new collection
-await vectorStore.createIndex('my-collection', 1536, 'cosine');
+await vectorStore.createIndex({ indexName: 'my-collection', dimension: 1536, metric: 'cosine' });
 
 // Add vectors with documents
 const vectors = [[0.1, 0.2, ...], [0.3, 0.4, ...]];
 const metadata = [{ text: 'doc1' }, { text: 'doc2' }];
 const documents = ['full text 1', 'full text 2'];
-const ids = await vectorStore.upsert(
-  'my-collection',
+const ids = await vectorStore.upsert({
+  indexName: 'my-collection',
   vectors,
   metadata,
-  undefined, // auto-generate IDs
-  documents  // store original text
-);
+  documents, // store original text
+});
 
 // Query vectors with document filtering
-const results = await vectorStore.query(
-  'my-collection',
-  [0.1, 0.2, ...],
-  10, // topK
-  { text: { $eq: 'doc1' } }, // metadata filter
-  false, // includeVector
-  { $contains: 'specific text' } // document content filter
-);
+const results = await vectorStore.query({
+  indexName: 'my-collection',
+  queryVector: [0.1, 0.2, ...],
+  topK: 10, // topK
+  filter: { text: { $eq: 'doc1' } }, // metadata filter
+  includeVector: false, // includeVector
+  documentFilter: { $contains: 'specific text' } // document content filter
+});
 ```
 
 ## Configuration
@@ -74,9 +73,9 @@ Optional:
 
 ## Methods
 
-- `createIndex(indexName, dimension, metric?)`: Create a new collection
-- `upsert(indexName, vectors, metadata?, ids?, documents?)`: Add or update vectors with optional document storage
-- `query(indexName, queryVector, topK?, filter?, includeVector?, documentFilter?)`: Search for similar vectors with optional document filtering
+- `createIndex({ indexName, dimension, metric? })`: Create a new collection
+- `upsert({ indexName, vectors, metadata?, ids?, documents? })`: Add or update vectors with optional document storage
+- `query({ indexName, queryVector, topK?, filter?, includeVector?, documentFilter? })`: Search for similar vectors with optional document filtering
 - `listIndexes()`: List all collections
 - `describeIndex(indexName)`: Get collection statistics
 - `deleteIndex(indexName)`: Delete a collection

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

@@ -0,0 +1,56 @@
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { CreateIndexParams } from '@mastra/core/vector';
+import type { IndexStats } 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';
+
+/**
+ * Translator for Chroma filter queries.
+ * Maintains MongoDB-compatible syntax while ensuring proper validation
+ * and normalization of values.
+ */
+export declare class ChromaFilterTranslator extends BaseFilterTranslator {
+    protected getSupportedOperators(): OperatorSupport;
+    translate(filter?: VectorFilter): VectorFilter;
+    private translateNode;
+    private translateOperator;
+}
+
+declare interface ChromaQueryVectorParams extends QueryVectorParams {
+    documentFilter?: VectorFilter;
+}
+
+declare interface ChromaUpsertVectorParams extends UpsertVectorParams {
+    documents?: string[];
+}
+
+declare class ChromaVector extends MastraVector {
+    private client;
+    private collections;
+    constructor({ path, auth, }: {
+        path: string;
+        auth?: {
+            provider: string;
+            credentials: string;
+        };
+    });
+    getCollection(indexName: string, throwIfNotExists?: boolean): Promise<any>;
+    private validateVectorDimensions;
+    upsert(...args: ParamsToArgs<ChromaUpsertVectorParams>): Promise<string[]>;
+    private HnswSpaceMap;
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    query(...args: ParamsToArgs<ChromaQueryVectorParams>): Promise<QueryResult[]>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<IndexStats>;
+    deleteIndex(indexName: string): Promise<void>;
+}
+export { ChromaVector }
+export { ChromaVector as ChromaVector_alias_1 }
+
+export { }

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

@@ -1,9 +1,13 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
-import type { Filter } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { CreateIndexParams } from '@mastra/core/vector';
 import type { IndexStats } from '@mastra/core/vector';
 import { MastraVector } from '@mastra/core/vector';
-import type { OperatorSupport } from '@mastra/core/filter';
+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';
 
 /**
  * Translator for Chroma filter queries.
@@ -12,11 +16,19 @@ import type { QueryResult } from '@mastra/core/vector';
  */
 export declare class ChromaFilterTranslator extends BaseFilterTranslator {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: Filter): Filter | undefined;
+    translate(filter?: VectorFilter): VectorFilter;
     private translateNode;
     private translateOperator;
 }
 
+declare interface ChromaQueryVectorParams extends QueryVectorParams {
+    documentFilter?: VectorFilter;
+}
+
+declare interface ChromaUpsertVectorParams extends UpsertVectorParams {
+    documents?: string[];
+}
+
 declare class ChromaVector extends MastraVector {
     private client;
     private collections;
@@ -29,11 +41,11 @@ declare class ChromaVector extends MastraVector {
     });
     getCollection(indexName: string, throwIfNotExists?: boolean): Promise<any>;
     private validateVectorDimensions;
-    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[], documents?: string[]): Promise<string[]>;
+    upsert(...args: ParamsToArgs<ChromaUpsertVectorParams>): Promise<string[]>;
     private HnswSpaceMap;
-    createIndex(indexName: string, dimension: number, metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
-    transformFilter(filter?: Filter): Filter | undefined;
-    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean, documentFilter?: Filter): Promise<QueryResult[]>;
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    query(...args: ParamsToArgs<ChromaQueryVectorParams>): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
     describeIndex(indexName: string): Promise<IndexStats>;
     deleteIndex(indexName: string): Promise<void>;
@@ -41,11 +53,4 @@ declare class ChromaVector extends MastraVector {
 export { ChromaVector }
 export { ChromaVector as ChromaVector_alias_1 }
 
-declare interface DocumentMetadata {
-    content?: string;
-    metadata?: Record<string, any>;
-}
-export { DocumentMetadata }
-export { DocumentMetadata as DocumentMetadata_alias_1 }
-
 export { }

package/dist/index.cjs

@@ -0,0 +1,214 @@
+'use strict';
+
+var vector = require('@mastra/core/vector');
+var chromadb = require('chromadb');
+var filter = require('@mastra/core/vector/filter');
+
+// src/vector/index.ts
+var ChromaFilterTranslator = class extends filter.BaseFilterTranslator {
+  getSupportedOperators() {
+    return {
+      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+      logical: ["$and", "$or"],
+      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 Chroma");
+    }
+    if (this.isPrimitive(node)) return 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;
+      const translated = this.translateOperator(operator, value);
+      return this.isLogicalOperator(operator) ? { [operator]: translated } : translated;
+    }
+    const result = {};
+    const multiOperatorConditions = [];
+    for (const [key, value] of entries) {
+      const newPath = currentPath ? `${currentPath}.${key}` : key;
+      if (this.isOperator(key)) {
+        result[key] = this.translateOperator(key, value);
+        continue;
+      }
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const valueEntries = Object.entries(value);
+        if (valueEntries.every(([op]) => this.isOperator(op)) && valueEntries.length > 1) {
+          valueEntries.forEach(([op, opValue]) => {
+            multiOperatorConditions.push({
+              [newPath]: { [op]: this.normalizeComparisonValue(opValue) }
+            });
+          });
+          continue;
+        }
+        if (Object.keys(value).length === 0) {
+          result[newPath] = this.translateNode(value);
+        } else {
+          const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
+          if (hasOperators) {
+            const normalizedValue = {};
+            for (const [op, opValue] of Object.entries(value)) {
+              normalizedValue[op] = this.isOperator(op) ? this.translateOperator(op, opValue) : opValue;
+            }
+            result[newPath] = normalizedValue;
+          } else {
+            Object.assign(result, this.translateNode(value, newPath));
+          }
+        }
+      } else {
+        result[newPath] = this.translateNode(value);
+      }
+    }
+    if (multiOperatorConditions.length > 0) {
+      return { $and: multiOperatorConditions };
+    }
+    if (Object.keys(result).length > 1 && !currentPath) {
+      return {
+        $and: Object.entries(result).map(([key, value]) => ({ [key]: value }))
+      };
+    }
+    return result;
+  }
+  translateOperator(operator, value) {
+    if (this.isLogicalOperator(operator)) {
+      return Array.isArray(value) ? value.map((item) => this.translateNode(item)) : this.translateNode(value);
+    }
+    return this.normalizeComparisonValue(value);
+  }
+};
+
+// src/vector/index.ts
+var ChromaVector = class extends vector.MastraVector {
+  client;
+  collections;
+  constructor({
+    path,
+    auth
+  }) {
+    super();
+    this.client = new chromadb.ChromaClient({
+      path,
+      auth
+    });
+    this.collections = /* @__PURE__ */ new Map();
+  }
+  async getCollection(indexName, throwIfNotExists = true) {
+    try {
+      const collection = await this.client.getCollection({ name: indexName, embeddingFunction: void 0 });
+      this.collections.set(indexName, collection);
+    } catch {
+      if (throwIfNotExists) {
+        throw new Error(`Index ${indexName} does not exist`);
+      }
+      return null;
+    }
+    return this.collections.get(indexName);
+  }
+  validateVectorDimensions(vectors, dimension) {
+    for (let i = 0; i < vectors.length; i++) {
+      if (vectors?.[i]?.length !== dimension) {
+        throw new Error(
+          `Vector at index ${i} has invalid dimension ${vectors?.[i]?.length}. Expected ${dimension} dimensions.`
+        );
+      }
+    }
+  }
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args, ["documents"]);
+    const { indexName, vectors, metadata, ids, documents } = params;
+    const collection = await this.getCollection(indexName);
+    const stats = await this.describeIndex(indexName);
+    this.validateVectorDimensions(vectors, stats.dimension);
+    const generatedIds = ids || vectors.map(() => crypto.randomUUID());
+    const normalizedMetadata = metadata || vectors.map(() => ({}));
+    await collection.upsert({
+      ids: generatedIds,
+      embeddings: vectors,
+      metadatas: normalizedMetadata,
+      documents
+    });
+    return generatedIds;
+  }
+  HnswSpaceMap = {
+    cosine: "cosine",
+    euclidean: "l2",
+    dotproduct: "ip",
+    l2: "euclidean",
+    ip: "dotproduct"
+  };
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+      throw new Error("Dimension must be a positive integer");
+    }
+    const hnswSpace = this.HnswSpaceMap[metric];
+    if (!["cosine", "l2", "ip"].includes(hnswSpace)) {
+      throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
+    }
+    await this.client.createCollection({
+      name: indexName,
+      metadata: {
+        dimension,
+        "hnsw:space": this.HnswSpaceMap[metric]
+      }
+    });
+  }
+  transformFilter(filter) {
+    const translator = new ChromaFilterTranslator();
+    return translator.translate(filter);
+  }
+  async query(...args) {
+    const params = this.normalizeArgs("query", args, ["documentFilter"]);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false, documentFilter } = params;
+    const collection = await this.getCollection(indexName, true);
+    const defaultInclude = ["documents", "metadatas", "distances"];
+    const translatedFilter = this.transformFilter(filter);
+    const results = await collection.query({
+      queryEmbeddings: [queryVector],
+      nResults: topK,
+      where: translatedFilter,
+      whereDocument: documentFilter,
+      include: includeVector ? [...defaultInclude, "embeddings"] : defaultInclude
+    });
+    return (results.ids[0] || []).map((id, index) => ({
+      id,
+      score: results.distances?.[0]?.[index] || 0,
+      metadata: results.metadatas?.[0]?.[index] || {},
+      document: results.documents?.[0]?.[index],
+      ...includeVector && { vector: results.embeddings?.[0]?.[index] || [] }
+    }));
+  }
+  async listIndexes() {
+    const collections = await this.client.listCollections();
+    return collections.map((collection) => collection);
+  }
+  async describeIndex(indexName) {
+    const collection = await this.getCollection(indexName);
+    const count = await collection.count();
+    const metadata = collection.metadata;
+    const hnswSpace = metadata?.["hnsw:space"];
+    return {
+      dimension: metadata?.dimension || 0,
+      count,
+      metric: this.HnswSpaceMap[hnswSpace]
+    };
+  }
+  async deleteIndex(indexName) {
+    await this.client.deleteCollection({ name: indexName });
+    this.collections.delete(indexName);
+  }
+};
+
+exports.ChromaVector = ChromaVector;

package/dist/index.d.cts

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

package/dist/index.d.ts

@@ -1,2 +1 @@
-export { DocumentMetadata } from './_tsup-dts-rollup.js';
 export { ChromaVector } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 import { MastraVector } from '@mastra/core/vector';
 import { ChromaClient } from 'chromadb';
-import { BaseFilterTranslator } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/vector/index.ts
 var ChromaFilterTranslator = class extends BaseFilterTranslator {
@@ -122,7 +122,9 @@ var ChromaVector = class extends MastraVector {
       }
     }
   }
-  async upsert(indexName, vectors, metadata, ids, documents) {
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args, ["documents"]);
+    const { indexName, vectors, metadata, ids, documents } = params;
     const collection = await this.getCollection(indexName);
     const stats = await this.describeIndex(indexName);
     this.validateVectorDimensions(vectors, stats.dimension);
@@ -143,7 +145,9 @@ var ChromaVector = class extends MastraVector {
     l2: "euclidean",
     ip: "dotproduct"
   };
-  async createIndex(indexName, dimension, metric = "cosine") {
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
     if (!Number.isInteger(dimension) || dimension <= 0) {
       throw new Error("Dimension must be a positive integer");
     }
@@ -160,11 +164,12 @@ var ChromaVector = class extends MastraVector {
     });
   }
   transformFilter(filter) {
-    const chromaFilter = new ChromaFilterTranslator();
-    const translatedFilter = chromaFilter.translate(filter);
-    return translatedFilter;
+    const translator = new ChromaFilterTranslator();
+    return translator.translate(filter);
   }
-  async query(indexName, queryVector, topK = 10, filter, includeVector = false, documentFilter) {
+  async query(...args) {
+    const params = this.normalizeArgs("query", args, ["documentFilter"]);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false, documentFilter } = params;
     const collection = await this.getCollection(indexName, true);
     const defaultInclude = ["documents", "metadatas", "distances"];
     const translatedFilter = this.transformFilter(filter);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/chroma",
-  "version": "0.1.6-alpha.1",
+  "version": "0.1.6-alpha.4",
   "description": "Chroma vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -10,13 +10,17 @@
       "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": {
     "chromadb": "^1.9.4",
-    "@mastra/core": "^0.4.3-alpha.1"
+    "@mastra/core": "^0.4.3-alpha.4"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",
@@ -28,7 +32,7 @@
     "@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",
     "lint": "eslint ."

package/src/vector/filter.ts

@@ -1,5 +1,5 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
-import type { FieldCondition, Filter, OperatorSupport, QueryOperator } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { FieldCondition, VectorFilter, OperatorSupport, QueryOperator } from '@mastra/core/vector/filter';
 
 /**
  * Translator for Chroma filter queries.
@@ -18,14 +18,14 @@ export class ChromaFilterTranslator 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 {
     // Handle primitive values and arrays
     if (this.isRegex(node)) {
       throw new Error('Regex is not supported in Chroma');