@mastra/chroma 0.0.0-storage-20250225005900 → 0.0.0-vnext-inngest-20250506121901

package/dist/index.js

@@ -1,6 +1,6 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
 import { MastraVector } from '@mastra/core/vector';
 import { ChromaClient } from 'chromadb';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/vector/index.ts
 var ChromaFilterTranslator = class extends BaseFilterTranslator {
@@ -105,7 +105,7 @@ var ChromaVector = class extends MastraVector {
     try {
       const collection = await this.client.getCollection({ name: indexName, embeddingFunction: void 0 });
       this.collections.set(indexName, collection);
-    } catch (error) {
+    } catch {
       if (throwIfNotExists) {
         throw new Error(`Index ${indexName} does not exist`);
       }
@@ -122,7 +122,9 @@ var ChromaVector = class extends MastraVector {
       }
     }
   }
-  async upsert(indexName, vectors, metadata, ids) {
+  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);
@@ -131,28 +133,43 @@ var ChromaVector = class extends MastraVector {
     await collection.upsert({
       ids: generatedIds,
       embeddings: vectors,
-      metadatas: normalizedMetadata
+      metadatas: normalizedMetadata,
+      documents
     });
     return generatedIds;
   }
-  async createIndex(indexName, dimension, metric = "cosine") {
+  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,
-        metric
+        "hnsw:space": this.HnswSpaceMap[metric]
       }
     });
   }
   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) {
+  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);
@@ -160,12 +177,14 @@ var ChromaVector = class extends MastraVector {
       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] || [] }
     }));
   }
@@ -177,16 +196,109 @@ var ChromaVector = class extends MastraVector {
     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: metadata?.metric
+      metric: this.HnswSpaceMap[hnswSpace]
     };
   }
   async deleteIndex(indexName) {
     await this.client.deleteCollection({ name: indexName });
     this.collections.delete(indexName);
   }
+  async updateIndexById(indexName, id, update) {
+    if (!update.vector && !update.metadata) {
+      throw new Error("No updates provided");
+    }
+    const collection = await this.getCollection(indexName, true);
+    const updateOptions = { ids: [id] };
+    if (update?.vector) {
+      updateOptions.embeddings = [update.vector];
+    }
+    if (update?.metadata) {
+      updateOptions.metadatas = [update.metadata];
+    }
+    return await collection.update(updateOptions);
+  }
+  async deleteIndexById(indexName, id) {
+    try {
+      const collection = await this.getCollection(indexName, true);
+      await collection.delete({ ids: [id] });
+    } catch (error) {
+      throw new Error(`Failed to delete index by id: ${id} for index name: ${indexName}: ${error.message}`);
+    }
+  }
 };
 
-export { ChromaVector };
+// src/vector/prompt.ts
+var CHROMA_PROMPT = `When querying Chroma, you can ONLY use the operators listed below. Any other operators will be rejected.
+Important: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.
+If a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.
+
+Basic Comparison Operators:
+- $eq: Exact match (default when using field: value)
+  Example: { "category": "electronics" }
+- $ne: Not equal
+  Example: { "category": { "$ne": "electronics" } }
+- $gt: Greater than
+  Example: { "price": { "$gt": 100 } }
+- $gte: Greater than or equal
+  Example: { "price": { "$gte": 100 } }
+- $lt: Less than
+  Example: { "price": { "$lt": 100 } }
+- $lte: Less than or equal
+  Example: { "price": { "$lte": 100 } }
+
+Array Operators:
+- $in: Match any value in array
+  Example: { "category": { "$in": ["electronics", "books"] } }
+- $nin: Does not match any value in array
+  Example: { "category": { "$nin": ["electronics", "books"] } }
+
+Logical Operators:
+- $and: Logical AND
+  Example: { "$and": [{ "price": { "$gt": 100 } }, { "category": "electronics" }] }
+- $or: Logical OR
+  Example: { "$or": [{ "price": { "$lt": 50 } }, { "category": "books" }] }
+
+Restrictions:
+- Regex patterns are not supported
+- Element operators are not supported
+- Only $and and $or logical operators are supported
+- Nested fields are supported using dot notation
+- Multiple conditions on the same field are supported with both implicit and explicit $and
+- Empty arrays in $in/$nin will return no results
+- If multiple top-level fields exist, they're wrapped in $and
+- Only logical operators ($and, $or) can be used at the top level
+- All other operators must be used within a field condition
+  Valid: { "field": { "$gt": 100 } }
+  Valid: { "$and": [...] }
+  Invalid: { "$gt": 100 }
+  Invalid: { "$in": [...] }
+- Logical operators must contain field conditions, not direct operators
+  Valid: { "$and": [{ "field": { "$gt": 100 } }] }
+  Invalid: { "$and": [{ "$gt": 100 }] }
+- Logical operators ($and, $or):
+  - Can only be used at top level or nested within other logical operators
+  - Can not be used on a field level, or be nested inside a field
+  - Can not be used inside an operator
+  - Valid: { "$and": [{ "field": { "$gt": 100 } }] }
+  - Valid: { "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }
+  - Invalid: { "field": { "$and": [{ "$gt": 100 }] } }
+  - Invalid: { "field": { "$or": [{ "$gt": 100 }] } }
+  - Invalid: { "field": { "$gt": { "$and": [{...}] } } }
+
+Example Complex Query:
+{
+  "$and": [
+    { "category": { "$in": ["electronics", "computers"] } },
+    { "price": { "$gte": 100, "$lte": 1000 } },
+    { "$or": [
+      { "inStock": true },
+      { "preorder": true }
+    ]}
+  ]
+}`;
+
+export { CHROMA_PROMPT, ChromaVector };

package/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  chroma:
+    image: chromadb/chroma
+    ports:
+      - 8000:8000
+volumes:
+  pgdata:

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/chroma",
-  "version": "0.0.0-storage-20250225005900",
+  "version": "0.0.0-vnext-inngest-20250506121901",
   "description": "Chroma vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -10,24 +10,32 @@
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       }
     },
     "./package.json": "./package.json"
   },
+  "license": "MIT",
   "dependencies": {
-    "chromadb": "^1.9.4",
-    "@mastra/core": "^0.0.0-storage-20250225005900"
+    "chromadb": "^2.2.0",
+    "@mastra/core": "0.0.0-vnext-inngest-20250506121901"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.49.2",
-    "@types/node": "^22.13.1",
-    "tsup": "^8.0.1",
-    "typescript": "^5.7.3",
-    "vitest": "^3.0.4"
+    "@microsoft/api-extractor": "^7.52.5",
+    "@types/node": "^20.17.27",
+    "eslint": "^9.23.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2",
+    "vitest": "^3.1.2",
+    "@internal/lint": "0.0.0-vnext-inngest-20250506121901"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --experimental-dts --clean --treeshake",
+    "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
     "build:watch": "pnpm build --watch",
-    "test": "vitest run"
+    "test": "vitest run",
+    "lint": "eslint ."
   }
 }

package/src/index.ts

@@ -1 +1,2 @@
 export * from './vector/index';
+export { CHROMA_PROMPT } from './vector/prompt';

package/src/vector/filter.ts

@@ -1,10 +1,5 @@
-import {
-  BaseFilterTranslator,
-  type FieldCondition,
-  type Filter,
-  type OperatorSupport,
-  type 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.
@@ -23,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');