@mastra/chroma 0.1.0-alpha.34 → 0.1.0-alpha.36

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @mastra/chroma
 
+## 0.1.0-alpha.36
+
+### Patch Changes
+
+- 4f1d1a1: Enforce types ann cleanup package.json
+- Updated dependencies [66a03ec]
+- Updated dependencies [4f1d1a1]
+  - @mastra/core@0.2.0-alpha.101
+
+## 0.1.0-alpha.35
+
+### Patch Changes
+
+- Updated dependencies [9d1796d]
+  - @mastra/core@0.2.0-alpha.100
+
 ## 0.1.0-alpha.34
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/chroma",
-  "version": "0.1.0-alpha.34",
+  "version": "0.1.0-alpha.36",
   "description": "Chroma vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -16,16 +16,16 @@
   },
   "dependencies": {
     "chromadb": "^1.9.4",
-    "@mastra/core": "^0.2.0-alpha.99"
+    "@mastra/core": "^0.2.0-alpha.101"
   },
   "devDependencies": {
-    "@tsconfig/recommended": "^1.0.7",
-    "@types/node": "^22.9.0",
+    "@microsoft/api-extractor": "^7.49.2",
+    "@types/node": "^22.13.1",
     "tsup": "^8.0.1",
     "vitest": "^3.0.4"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean --treeshake",
+    "build": "tsup src/index.ts --format esm --experimental-dts --clean --treeshake",
     "build:watch": "pnpm build --watch",
     "test": "vitest run"
   }

package/src/vector/filter.ts

@@ -1,4 +1,10 @@
-import { BaseFilterTranslator, FieldCondition, Filter, OperatorSupport, QueryOperator } from '@mastra/core/filter';
+import {
+  BaseFilterTranslator,
+  type FieldCondition,
+  type Filter,
+  type OperatorSupport,
+  type QueryOperator,
+} from '@mastra/core/filter';
 
 /**
  * Translator for Chroma filter queries.

package/src/vector/index.ts

@@ -1,5 +1,5 @@
-import { Filter } from '@mastra/core/filter';
-import { MastraVector, QueryResult, IndexStats } from '@mastra/core/vector';
+import { type Filter } from '@mastra/core/filter';
+import { MastraVector, type QueryResult, type IndexStats } from '@mastra/core/vector';
 import { ChromaClient } from 'chromadb';
 
 import { ChromaFilterTranslator } from './filter';

package/tsconfig.json

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

package/dist/index.d.ts

@@ -1,25 +0,0 @@
-import { Filter } from '@mastra/core/filter';
-import { MastraVector, QueryResult, IndexStats } from '@mastra/core/vector';
-
-declare class ChromaVector extends MastraVector {
-    private client;
-    private collections;
-    constructor({ path, auth, }: {
-        path: string;
-        auth?: {
-            provider: string;
-            credentials: string;
-        };
-    });
-    private getCollection;
-    private validateVectorDimensions;
-    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
-    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): Promise<QueryResult[]>;
-    listIndexes(): Promise<string[]>;
-    describeIndex(indexName: string): Promise<IndexStats>;
-    deleteIndex(indexName: string): Promise<void>;
-}
-
-export { ChromaVector };

package/dist/index.js

@@ -1,190 +0,0 @@
-import { MastraVector } from '@mastra/core/vector';
-import { ChromaClient } from 'chromadb';
-import { BaseFilterTranslator } from '@mastra/core/filter';
-
-// src/vector/index.ts
-var ChromaFilterTranslator = class extends BaseFilterTranslator {
-  getSupportedOperators() {
-    return {
-      ...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 MastraVector {
-  constructor({
-    path,
-    auth
-  }) {
-    super();
-    this.client = new 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 (error) {
-      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(indexName, vectors, metadata, ids) {
-    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
-    });
-    return generatedIds;
-  }
-  async createIndex(indexName, dimension, metric = "cosine") {
-    if (!Number.isInteger(dimension) || dimension <= 0) {
-      throw new Error("Dimension must be a positive integer");
-    }
-    await this.client.createCollection({
-      name: indexName,
-      metadata: {
-        dimension,
-        metric
-      }
-    });
-  }
-  transformFilter(filter) {
-    const chromaFilter = new ChromaFilterTranslator();
-    const translatedFilter = chromaFilter.translate(filter);
-    return translatedFilter;
-  }
-  async query(indexName, queryVector, topK = 10, filter, includeVector = false) {
-    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,
-      include: includeVector ? [...defaultInclude, "embeddings"] : defaultInclude
-    });
-    return (results.ids[0] || []).map((id, index) => ({
-      id,
-      score: results.distances?.[0]?.[index] || 0,
-      metadata: results.metadatas?.[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;
-    return {
-      dimension: metadata?.dimension || 0,
-      count,
-      metric: metadata?.metric
-    };
-  }
-  async deleteIndex(indexName) {
-    await this.client.deleteCollection({ name: indexName });
-    this.collections.delete(indexName);
-  }
-};
-
-export { ChromaVector };