@mastra/chroma 0.0.0-vector-query-sources-20250516172905 → 0.0.0-vector-query-tool-provider-options-20250828222356

package/dist/vector/index.d.ts

@@ -0,0 +1,70 @@
+import { MastraVector } from '@mastra/core/vector';
+import type { QueryResult, IndexStats, CreateIndexParams, UpsertVectorParams, QueryVectorParams, DescribeIndexParams, DeleteIndexParams, DeleteVectorParams, UpdateVectorParams } from '@mastra/core/vector';
+import type { ChromaClientArgs, Where, WhereDocument, Collection, Metadata } from 'chromadb';
+import type { ChromaVectorFilter } from './filter.js';
+interface ChromaUpsertVectorParams extends UpsertVectorParams {
+    documents?: string[];
+}
+interface ChromaQueryVectorParams extends QueryVectorParams<ChromaVectorFilter> {
+    documentFilter?: WhereDocument | null;
+}
+interface ChromaGetRecordsParams {
+    indexName: string;
+    ids?: string[];
+    filter?: ChromaVectorFilter;
+    documentFilter?: WhereDocument | null;
+    includeVector?: boolean;
+    limit?: number;
+    offset?: number;
+}
+type ChromaVectorArgs = ChromaClientArgs & {
+    apiKey?: string;
+};
+export declare class ChromaVector extends MastraVector<ChromaVectorFilter> {
+    private client;
+    private collections;
+    constructor(chromaClientArgs?: ChromaVectorArgs);
+    getCollection({ indexName, forceUpdate }: {
+        indexName: string;
+        forceUpdate?: boolean;
+    }): Promise<Collection>;
+    private validateVectorDimensions;
+    upsert({ indexName, vectors, metadata, ids, documents }: ChromaUpsertVectorParams): Promise<string[]>;
+    createIndex({ indexName, dimension, metric }: CreateIndexParams): Promise<void>;
+    transformFilter(filter?: ChromaVectorFilter): Where | undefined;
+    query<T extends Metadata = Metadata>({ indexName, queryVector, topK, filter, includeVector, documentFilter, }: ChromaQueryVectorParams): Promise<QueryResult[]>;
+    get<T extends Metadata = Metadata>({ indexName, ids, filter, includeVector, documentFilter, offset, limit, }: ChromaGetRecordsParams): Promise<{
+        id: string;
+        document: string | null | undefined;
+        embedding: number[] | undefined;
+        metadata: T | null | undefined;
+        uri: string | null | undefined;
+    }[]>;
+    listIndexes(): Promise<string[]>;
+    /**
+     * Retrieves statistics about a vector index.
+     *
+     * @param {string} indexName - The name of the index to describe
+     * @returns A promise that resolves to the index statistics including dimension, count and metric
+     */
+    describeIndex({ indexName }: DescribeIndexParams): Promise<IndexStats>;
+    deleteIndex({ indexName }: DeleteIndexParams): Promise<void>;
+    forkIndex({ indexName, newIndexName }: {
+        indexName: string;
+        newIndexName: string;
+    }): Promise<void>;
+    /**
+     * Updates a vector by its ID with the provided vector and/or metadata.
+     * @param indexName - The name of the index containing the vector.
+     * @param id - The ID of the vector to update.
+     * @param update - An object containing the vector and/or metadata to update.
+     * @param update.vector - An optional array of numbers representing the new vector.
+     * @param update.metadata - An optional record containing the new metadata.
+     * @returns A promise that resolves when the update is complete.
+     * @throws Will throw an error if no updates are provided or if the update operation fails.
+     */
+    updateVector({ indexName, id, update }: UpdateVectorParams): Promise<void>;
+    deleteVector({ indexName, id }: DeleteVectorParams): Promise<void>;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/vector/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vector/index.ts"],"names":[],"mappings":"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"}

package/dist/vector/prompt.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Vector store specific prompt that details supported operators and examples.
+ * This prompt helps users construct valid filters for Chroma Vector.
+ */
+export declare const CHROMA_PROMPT = "When querying Chroma, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf 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.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n\nLogical Operators:\n- $and: Logical AND\n  Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n\nRestrictions:\n- Regex patterns are not supported\n- Element operators are not supported\n- Only $and and $or logical operators are supported\n- Nested fields are supported using dot notation\n- Multiple conditions on the same field are supported with both implicit and explicit $and\n- Empty arrays in $in/$nin will return no results\n- If multiple top-level fields exist, they're wrapped in $and\n- Only logical operators ($and, $or) can be used at the top level\n- All other operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n  Invalid: { \"$in\": [...] }\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- Logical operators ($and, $or):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\n\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"$or\": [\n      { \"inStock\": true },\n      { \"preorder\": true }\n    ]}\n  ]\n}";
+//# sourceMappingURL=prompt.d.ts.map

package/dist/vector/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/vector/prompt.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,aAAa,q8FAmExB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/chroma",
-  "version": "0.0.0-vector-query-sources-20250516172905",
+  "version": "0.0.0-vector-query-tool-provider-options-20250828222356",
   "description": "Chroma vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -12,7 +12,7 @@
         "default": "./dist/index.js"
       },
       "require": {
-        "types": "./dist/index.d.cts",
+        "types": "./dist/index.d.ts",
         "default": "./dist/index.cjs"
       }
     },
@@ -20,21 +20,26 @@
   },
   "license": "MIT",
   "dependencies": {
-    "chromadb": "^2.2.0",
-    "@mastra/core": "0.0.0-vector-query-sources-20250516172905"
+    "chromadb": "^3.0.11"
   },
   "devDependencies": {
-    "@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-vector-query-sources-20250516172905"
+    "@microsoft/api-extractor": "^7.52.8",
+    "@types/node": "^20.19.0",
+    "eslint": "^9.30.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.4",
+    "@internal/lint": "0.0.0-vector-query-tool-provider-options-20250828222356",
+    "@internal/storage-test-utils": "0.0.30",
+    "@internal/types-builder": "0.0.0-vector-query-tool-provider-options-20250828222356",
+    "@mastra/core": "0.0.0-vector-query-tool-provider-options-20250828222356"
+  },
+  "peerDependencies": {
+    "@mastra/core": "0.0.0-vector-query-tool-provider-options-20250828222356"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",
-    "build:watch": "pnpm build --watch",
+    "build": "tsup --silent --config tsup.config.ts",
+    "build:watch": "tsup --watch --silent --config tsup.config.ts",
     "test": "vitest run",
     "lint": "eslint ."
   }

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 
+import type { ChromaVectorFilter } from './filter';
 import { ChromaFilterTranslator } from './filter';
 
 describe('ChromaFilterTranslator', () => {
@@ -13,17 +14,17 @@ describe('ChromaFilterTranslator', () => {
   describe('basic operations', () => {
     it('handles empty filters', () => {
       expect(translator.translate({})).toEqual({});
-      expect(translator.translate(null as any)).toEqual(null);
-      expect(translator.translate(undefined as any)).toEqual(undefined);
+      expect(translator.translate(null)).toEqual(null);
+      expect(translator.translate(undefined)).toEqual(undefined);
     });
 
     it('retains implicit equality', () => {
-      const filter = { field: 'value' };
+      const filter: ChromaVectorFilter = { field: 'value' };
       expect(translator.translate(filter)).toEqual({ field: 'value' });
     });
 
     it('converts multiple top-level fields to $and', () => {
-      const filter = {
+      const filter: ChromaVectorFilter = {
         field1: 'value1',
         field2: 'value2',
       };
@@ -33,7 +34,7 @@ describe('ChromaFilterTranslator', () => {
     });
 
     it('handles multiple operators on same field', () => {
-      const filter = {
+      const filter: ChromaVectorFilter = {
         price: { $gt: 100, $lt: 200 },
         quantity: { $gte: 10, $lte: 20 },
       };
@@ -49,7 +50,7 @@ describe('ChromaFilterTranslator', () => {
 
     it('normalizes date values', () => {
       const date = new Date('2024-01-01');
-      const filter = { timestamp: { $gt: date } };
+      const filter: ChromaVectorFilter = { timestamp: { $gt: date } };
       expect(translator.translate(filter)).toEqual({ timestamp: { $gt: date.toISOString() } });
     });
   });
@@ -57,7 +58,7 @@ describe('ChromaFilterTranslator', () => {
   // Array Operations
   describe('array operations', () => {
     it('handles arrays as $in operator', () => {
-      const filter = { tags: ['tag1', 'tag2'] };
+      const filter: ChromaVectorFilter = { tags: ['tag1', 'tag2'] };
       expect(translator.translate(filter)).toEqual({ tags: { $in: ['tag1', 'tag2'] } });
     });
 
@@ -68,10 +69,14 @@ describe('ChromaFilterTranslator', () => {
 
     it('handles arrays as direct values', () => {
       // Direct array value should be converted to $in
-      expect(translator.translate({ field: ['value1', 'value2'] })).toEqual({ field: { $in: ['value1', 'value2'] } });
+      const filter: ChromaVectorFilter = { field: ['value1', 'value2'] };
+      expect(translator.translate(filter)).toEqual({
+        field: { $in: ['value1', 'value2'] },
+      });
 
       // Empty direct array
-      expect(translator.translate({ field: [] })).toEqual({ field: { $in: [] } });
+      const filter2 = { field: [] };
+      expect(translator.translate(filter2)).toEqual({ field: { $in: [] } });
     });
 
     describe('$in operator variations', () => {
@@ -99,7 +104,7 @@ describe('ChromaFilterTranslator', () => {
   // Logical Operators
   describe('logical operators', () => {
     it('handles logical operators', () => {
-      const filter = {
+      const filter: ChromaVectorFilter = {
         $or: [{ status: { $eq: 'active' } }, { age: { $gt: 25 } }],
       };
       expect(translator.translate(filter)).toEqual({
@@ -108,7 +113,7 @@ describe('ChromaFilterTranslator', () => {
     });
 
     it('handles nested logical operators', () => {
-      const filter = {
+      const filter: ChromaVectorFilter = {
         $and: [
           { status: { $eq: 'active' } },
           {
@@ -142,7 +147,7 @@ describe('ChromaFilterTranslator', () => {
     });
 
     it('handles complex nested conditions', () => {
-      const filter = {
+      const filter: ChromaVectorFilter = {
         $or: [
           { age: { $gt: 25 } },
           {
@@ -176,7 +181,7 @@ describe('ChromaFilterTranslator', () => {
     });
 
     it('preserves empty objects as exact match conditions', () => {
-      const filter = {
+      const filter: ChromaVectorFilter = {
         metadata: {},
         'user.profile': {},
       };
@@ -187,7 +192,7 @@ describe('ChromaFilterTranslator', () => {
     });
 
     it('handles empty objects in logical operators', () => {
-      const filter = {
+      const filter: ChromaVectorFilter = {
         $or: [{}, { status: 'active' }],
       };
 
@@ -211,7 +216,7 @@ describe('ChromaFilterTranslator', () => {
     });
 
     it('handles empty objects in comparison operators', () => {
-      const filter = {
+      const filter: ChromaVectorFilter = {
         metadata: { $eq: {} },
       };
 
@@ -221,7 +226,7 @@ describe('ChromaFilterTranslator', () => {
     });
 
     it('handles empty objects in array operators', () => {
-      const filter = {
+      const filter: ChromaVectorFilter = {
         tags: { $in: [{}] },
       };
 
@@ -335,7 +340,7 @@ describe('ChromaFilterTranslator', () => {
       });
 
       it('throws error for unsupported logical operators', () => {
-        const invalidFilters = [
+        const invalidFilters: any = [
           {
             $not: { field: 'value' },
           },
@@ -350,6 +355,7 @@ describe('ChromaFilterTranslator', () => {
           },
         ];
 
+        // @ts-expect-error
         invalidFilters.forEach(filter => {
           expect(() => translator.translate(filter)).toThrow(/Unsupported operator/);
         });
@@ -374,7 +380,7 @@ describe('ChromaFilterTranslator', () => {
     });
 
     it('throws error for unsupported operators', () => {
-      const unsupportedFilters = [
+      const unsupportedFilters: any = [
         { field: { $regex: 'pattern' } },
         { field: { $contains: 'value' } },
         { field: { $exists: true } },
@@ -385,6 +391,7 @@ describe('ChromaFilterTranslator', () => {
         { field: { $all: [{ $eq: 'value' }] } },
       ];
 
+      // @ts-expect-error
       unsupportedFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Unsupported operator/);
       });
@@ -395,8 +402,9 @@ describe('ChromaFilterTranslator', () => {
       expect(() => translator.translate(filter)).toThrow();
     });
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
+      const invalidFilters: any = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
 
+      // @ts-expect-error
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);
       });

package/src/vector/filter.ts

@@ -1,12 +1,32 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type { FieldCondition, VectorFilter, OperatorSupport, QueryOperator } from '@mastra/core/vector/filter';
+import type {
+  VectorFilter,
+  OperatorSupport,
+  QueryOperator,
+  OperatorValueMap,
+  LogicalOperatorValueMap,
+  BlacklistedRootOperators,
+} from '@mastra/core/vector/filter';
+
+type ChromaOperatorValueMap = Omit<OperatorValueMap, '$exists' | '$elemMatch' | '$regex' | '$options'>;
+
+type ChromaLogicalOperatorValueMap = Omit<LogicalOperatorValueMap, '$nor' | '$not'>;
+
+type ChromaBlacklisted = BlacklistedRootOperators | '$nor' | '$not';
+
+export type ChromaVectorFilter = VectorFilter<
+  keyof ChromaOperatorValueMap,
+  ChromaOperatorValueMap,
+  ChromaLogicalOperatorValueMap,
+  ChromaBlacklisted
+>;
 
 /**
  * Translator for Chroma filter queries.
  * Maintains MongoDB-compatible syntax while ensuring proper validation
  * and normalization of values.
  */
-export class ChromaFilterTranslator extends BaseFilterTranslator {
+export class ChromaFilterTranslator extends BaseFilterTranslator<ChromaVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -18,17 +38,17 @@ export class ChromaFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): VectorFilter {
+  translate(filter?: ChromaVectorFilter): ChromaVectorFilter {
     if (this.isEmpty(filter)) return filter;
     this.validateFilter(filter);
 
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition, currentPath: string = ''): any {
+  private translateNode(node: ChromaVectorFilter, currentPath: string = ''): any {
     // Handle primitive values and arrays
     if (this.isRegex(node)) {
-      throw new Error('Regex is not supported in Chroma');
+      throw new Error('Regex is supported in Chroma via the `documentFilter` argument');
     }
     if (this.isPrimitive(node)) return this.normalizeComparisonValue(node);
     if (Array.isArray(node)) return { $in: this.normalizeArrayValues(node) };
@@ -39,6 +59,9 @@ export class ChromaFilterTranslator extends BaseFilterTranslator {
     if (entries.length === 1 && firstEntry && this.isOperator(firstEntry[0])) {
       const [operator, value] = firstEntry;
       const translated = this.translateOperator(operator, value);
+      if (this.isLogicalOperator(operator) && Array.isArray(translated) && translated.length === 1) {
+        return translated[0];
+      }
       return this.isLogicalOperator(operator) ? { [operator]: translated } : translated;
     }