@mastra/chroma 0.0.0-vnext-inngest-20250508122351 → 0.0.0-vnext-20251104230439

package/src/vector/index.ts

@@ -1,231 +0,0 @@
-import { MastraVector } from '@mastra/core/vector';
-import type {
-  QueryResult,
-  IndexStats,
-  CreateIndexParams,
-  UpsertVectorParams,
-  QueryVectorParams,
-  ParamsToArgs,
-  QueryVectorArgs,
-  UpsertVectorArgs,
-} from '@mastra/core/vector';
-
-import type { VectorFilter } from '@mastra/core/vector/filter';
-import { ChromaClient } from 'chromadb';
-import type { UpdateRecordsParams, Collection } from 'chromadb';
-import { ChromaFilterTranslator } from './filter';
-
-interface ChromaUpsertVectorParams extends UpsertVectorParams {
-  documents?: string[];
-}
-
-type ChromaUpsertArgs = [...UpsertVectorArgs, string[]?];
-
-interface ChromaQueryVectorParams extends QueryVectorParams {
-  documentFilter?: VectorFilter;
-}
-
-type ChromaQueryArgs = [...QueryVectorArgs, VectorFilter?];
-
-export class ChromaVector extends MastraVector {
-  private client: ChromaClient;
-  private collections: Map<string, any>;
-
-  constructor({
-    path,
-    auth,
-  }: {
-    path: string;
-    auth?: {
-      provider: string;
-      credentials: string;
-    };
-  }) {
-    super();
-    this.client = new ChromaClient({
-      path,
-      auth,
-    });
-    this.collections = new Map();
-  }
-
-  async getCollection(indexName: string, throwIfNotExists: boolean = true) {
-    try {
-      const collection = await this.client.getCollection({ name: indexName, embeddingFunction: undefined as any });
-      this.collections.set(indexName, collection);
-    } catch {
-      if (throwIfNotExists) {
-        throw new Error(`Index ${indexName} does not exist`);
-      }
-      return null;
-    }
-    return this.collections.get(indexName);
-  }
-
-  private validateVectorDimensions(vectors: number[][], dimension: number): void {
-    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: ParamsToArgs<ChromaUpsertVectorParams> | ChromaUpsertArgs): Promise<string[]> {
-    const params = this.normalizeArgs<ChromaUpsertVectorParams, ChromaUpsertArgs>('upsert', args, ['documents']);
-
-    const { indexName, vectors, metadata, ids, documents } = params;
-
-    const collection = await this.getCollection(indexName);
-
-    // Get index stats to check dimension
-    const stats = await this.describeIndex(indexName);
-
-    // Validate vector dimensions
-    this.validateVectorDimensions(vectors, stats.dimension);
-
-    // Generate IDs if not provided
-    const generatedIds = ids || vectors.map(() => crypto.randomUUID());
-
-    // Ensure metadata exists for each vector
-    const normalizedMetadata = metadata || vectors.map(() => ({}));
-
-    await collection.upsert({
-      ids: generatedIds,
-      embeddings: vectors,
-      metadatas: normalizedMetadata,
-      documents: documents,
-    });
-
-    return generatedIds;
-  }
-
-  private HnswSpaceMap = {
-    cosine: 'cosine',
-    euclidean: 'l2',
-    dotproduct: 'ip',
-    l2: 'euclidean',
-    ip: 'dotproduct',
-  };
-
-  async createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void> {
-    const params = this.normalizeArgs<CreateIndexParams>('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`);
-    }
-    try {
-      await this.client.createCollection({
-        name: indexName,
-        metadata: {
-          dimension,
-          'hnsw:space': hnswSpace,
-        },
-      });
-    } catch (error: any) {
-      // Check for 'already exists' error
-      const message = error?.message || error?.toString();
-      if (message && message.toLowerCase().includes('already exists')) {
-        // Fetch collection info and check dimension
-        await this.validateExistingIndex(indexName, dimension, metric);
-        return;
-      }
-      throw error;
-    }
-  }
-
-  transformFilter(filter?: VectorFilter) {
-    const translator = new ChromaFilterTranslator();
-    return translator.translate(filter);
-  }
-  async query(...args: ParamsToArgs<ChromaQueryVectorParams> | ChromaQueryArgs): Promise<QueryResult[]> {
-    const params = this.normalizeArgs<ChromaQueryVectorParams, ChromaQueryArgs>('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,
-    });
-
-    // Transform ChromaDB results to QueryResult format
-    return (results.ids[0] || []).map((id: string, index: number) => ({
-      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(): Promise<string[]> {
-    const collections = await this.client.listCollections();
-    return collections.map(collection => collection);
-  }
-
-  async describeIndex(indexName: string): Promise<IndexStats> {
-    const collection = await this.getCollection(indexName);
-    const count = await collection.count();
-    const metadata = collection.metadata;
-
-    const hnswSpace = metadata?.['hnsw:space'] as 'cosine' | 'l2' | 'ip';
-
-    return {
-      dimension: metadata?.dimension || 0,
-      count,
-      metric: this.HnswSpaceMap[hnswSpace] as 'cosine' | 'euclidean' | 'dotproduct',
-    };
-  }
-
-  async deleteIndex(indexName: string): Promise<void> {
-    await this.client.deleteCollection({ name: indexName });
-    this.collections.delete(indexName);
-  }
-
-  async updateIndexById(
-    indexName: string,
-    id: string,
-    update: { vector?: number[]; metadata?: Record<string, any> },
-  ): Promise<void> {
-    if (!update.vector && !update.metadata) {
-      throw new Error('No updates provided');
-    }
-
-    const collection: Collection = await this.getCollection(indexName, true);
-
-    const updateOptions: UpdateRecordsParams = { ids: [id] };
-
-    if (update?.vector) {
-      updateOptions.embeddings = [update.vector];
-    }
-
-    if (update?.metadata) {
-      updateOptions.metadatas = [update.metadata];
-    }
-
-    return await collection.update(updateOptions);
-  }
-
-  async deleteIndexById(indexName: string, id: string): Promise<void> {
-    try {
-      const collection: Collection = await this.getCollection(indexName, true);
-      await collection.delete({ ids: [id] });
-    } catch (error: any) {
-      throw new Error(`Failed to delete index by id: ${id} for index name: ${indexName}: ${error.message}`);
-    }
-  }
-}

package/src/vector/prompt.ts

@@ -1,72 +0,0 @@
-/**
- * Vector store specific prompt that details supported operators and examples.
- * This prompt helps users construct valid filters for Chroma Vector.
- */
-export const 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 }
-    ]}
-  ]
-}`;

package/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.test.ts"]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['src/**/*.test.ts'],
-  },
-});