@juspay/neurolink 11.13.0 → 11.13.2

package/dist/lib/rag/retrieval/vectorQueryTool.js

@@ -1,325 +0,0 @@
-/**
- * Vector Query Tool
- *
- * Provides semantic search capabilities for RAG pipelines.
- * Integrates with vector stores and supports metadata filtering and reranking.
- */
-import { randomUUID } from "crypto";
-import { z } from "zod";
-import { ProviderFactory } from "../../factories/providerFactory.js";
-import { withSpan } from "../../telemetry/withSpan.js";
-import { tracers } from "../../telemetry/tracers.js";
-import { logger } from "../../utils/logger.js";
-import { rerank } from "../reranker/reranker.js";
-/**
- * Creates a vector query tool for semantic search
- * Follows NeuroLink's factory pattern
- *
- * @param config - Tool configuration
- * @param vectorStore - Vector store instance or resolver function
- * @returns Tool object with execute method
- */
-export function createVectorQueryTool(config, vectorStore) {
-    const { id = `vector-query-${randomUUID().slice(0, 8)}`, description = "Access the knowledge base to find information needed to answer user questions", indexName, embeddingModel, enableFilter = false, includeVectors = false, includeSources = true, topK = 10, reranker: rerankerConfig, providerOptions, } = config;
-    return {
-        name: id,
-        description,
-        parameters: z.object({
-            query: z
-                .string()
-                .describe("The search query to find relevant information"),
-            ...(enableFilter
-                ? {
-                    filter: z
-                        .record(z.string(), z.unknown())
-                        .optional()
-                        .describe("Metadata filters to narrow down results"),
-                }
-                : {}),
-            topK: z
-                .number()
-                .optional()
-                .describe(`Number of results to return (default: ${topK})`),
-        }),
-        /**
-         * Execute the vector query
-         * @param params - Query parameters
-         * @param context - Optional request context
-         * @returns Query results with relevant context
-         */
-        execute: async (params, context) => {
-            return withSpan({
-                name: "neurolink.rag.vectorQuery",
-                tracer: tracers.rag,
-                attributes: {
-                    "rag.vector.index": indexName,
-                    "rag.vector.top_k": params.topK ?? topK,
-                    "rag.vector.query_length": params.query.length,
-                },
-            }, async (span) => {
-                const startTime = Date.now();
-                try {
-                    // Resolve vector store if it's a function
-                    const store = typeof vectorStore === "function"
-                        ? vectorStore(context || {})
-                        : vectorStore;
-                    // Generate query embedding
-                    const embeddingProvider = await ProviderFactory.createProvider(embeddingModel.provider, embeddingModel.modelName);
-                    // Check if provider has embed method
-                    if (typeof embeddingProvider.embed !== "function") {
-                        throw new Error(`Provider ${embeddingModel.provider} does not support embeddings`);
-                    }
-                    const queryEmbedding = await embeddingProvider.embed(params.query);
-                    // Query the vector store
-                    let results = await store.query({
-                        indexName,
-                        queryVector: queryEmbedding,
-                        topK: params.topK || topK,
-                        filter: params.filter,
-                        includeVectors,
-                        ...providerOptions,
-                    });
-                    let reranked = false;
-                    // Apply reranking if configured
-                    if (rerankerConfig && results.length > 0) {
-                        const rerankerModel = await ProviderFactory.createProvider(typeof rerankerConfig.model === "object"
-                            ? rerankerConfig.model.provider
-                            : rerankerConfig.model, typeof rerankerConfig.model === "object"
-                            ? rerankerConfig.model.modelName
-                            : rerankerConfig.model);
-                        const rerankedResults = await rerank(results, params.query, rerankerModel, {
-                            weights: rerankerConfig.weights,
-                            topK: rerankerConfig.topK,
-                            queryEmbedding,
-                        });
-                        results = rerankedResults.map((r) => r.result);
-                        reranked = true;
-                    }
-                    // Format results
-                    const relevantContext = results
-                        .map((r, i) => `[${i + 1}] ${r.metadata?.text || r.text || ""}`)
-                        .join("\n\n");
-                    const queryTime = Date.now() - startTime;
-                    logger.info("[VectorQueryTool] Query completed", {
-                        query: params.query.slice(0, 50),
-                        resultsCount: results.length,
-                        queryTime,
-                        reranked,
-                        filtered: !!params.filter,
-                    });
-                    span.setAttribute("rag.vector.result_count", results.length);
-                    span.setAttribute("rag.vector.reranked", reranked);
-                    return {
-                        relevantContext,
-                        sources: includeSources ? results : [],
-                        totalResults: results.length,
-                        metadata: {
-                            queryTime,
-                            reranked,
-                            filtered: !!params.filter,
-                        },
-                    };
-                }
-                catch (error) {
-                    logger.error("[VectorQueryTool] Query failed", {
-                        query: params.query.slice(0, 50),
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    throw error;
-                }
-            }); // end withSpan
-        },
-    };
-}
-/**
- * In-memory vector store implementation for testing and development
- */
-export class InMemoryVectorStore {
-    vectors = new Map();
-    /**
-     * Add vectors to an index
-     */
-    async upsert(indexName, items) {
-        let index = this.vectors.get(indexName);
-        if (!index) {
-            index = new Map();
-            this.vectors.set(indexName, index);
-        }
-        for (const item of items) {
-            index.set(item.id, {
-                vector: item.vector,
-                metadata: item.metadata || {},
-            });
-        }
-    }
-    /**
-     * Query vectors by similarity
-     */
-    async query(params) {
-        const { indexName, queryVector, topK = 10, filter, includeVectors = false, } = params;
-        const index = this.vectors.get(indexName);
-        if (!index) {
-            return [];
-        }
-        // Calculate similarities
-        const results = [];
-        for (const [id, data] of index) {
-            // Apply filter if provided
-            if (filter && !this.matchesFilter(data.metadata, filter)) {
-                continue;
-            }
-            const score = this.cosineSimilarity(queryVector, data.vector);
-            results.push({
-                id,
-                score,
-                metadata: data.metadata,
-                ...(includeVectors ? { vector: data.vector } : {}),
-            });
-        }
-        // Sort by score descending and take top K
-        results.sort((a, b) => b.score - a.score);
-        return results.slice(0, topK).map((r) => ({
-            id: r.id,
-            score: r.score,
-            text: r.metadata.text,
-            metadata: r.metadata,
-            ...(includeVectors ? { vector: r.vector } : {}),
-        }));
-    }
-    /**
-     * Delete vectors from an index
-     */
-    async delete(indexName, ids) {
-        const index = this.vectors.get(indexName);
-        if (!index) {
-            return;
-        }
-        for (const id of ids) {
-            index.delete(id);
-        }
-    }
-    /**
-     * Check if metadata matches filter
-     */
-    matchesFilter(metadata, filter) {
-        for (const [key, value] of Object.entries(filter)) {
-            if (key.startsWith("$")) {
-                // Logical operators
-                switch (key) {
-                    case "$and":
-                        if (!value.every((f) => this.matchesFilter(metadata, f))) {
-                            return false;
-                        }
-                        break;
-                    case "$or":
-                        if (!value.some((f) => this.matchesFilter(metadata, f))) {
-                            return false;
-                        }
-                        break;
-                    case "$not":
-                        if (this.matchesFilter(metadata, value)) {
-                            return false;
-                        }
-                        break;
-                }
-            }
-            else {
-                // Field comparison
-                const fieldValue = metadata[key];
-                if (typeof value === "object" && value !== null) {
-                    // Comparison operators
-                    const ops = value;
-                    if ("$eq" in ops && fieldValue !== ops.$eq) {
-                        return false;
-                    }
-                    if ("$ne" in ops && fieldValue === ops.$ne) {
-                        return false;
-                    }
-                    if ("$gt" in ops &&
-                        (typeof fieldValue !== "number" ||
-                            fieldValue <= ops.$gt)) {
-                        return false;
-                    }
-                    if ("$gte" in ops &&
-                        (typeof fieldValue !== "number" ||
-                            fieldValue < ops.$gte)) {
-                        return false;
-                    }
-                    if ("$lt" in ops &&
-                        (typeof fieldValue !== "number" ||
-                            fieldValue >= ops.$lt)) {
-                        return false;
-                    }
-                    if ("$lte" in ops &&
-                        (typeof fieldValue !== "number" ||
-                            fieldValue > ops.$lte)) {
-                        return false;
-                    }
-                    if ("$in" in ops && !ops.$in.includes(fieldValue)) {
-                        return false;
-                    }
-                    if ("$nin" in ops && ops.$nin.includes(fieldValue)) {
-                        return false;
-                    }
-                    if ("$exists" in ops &&
-                        (ops.$exists ? fieldValue === undefined : fieldValue !== undefined)) {
-                        return false;
-                    }
-                    if ("$contains" in ops &&
-                        (typeof fieldValue !== "string" ||
-                            !fieldValue.includes(ops.$contains))) {
-                        return false;
-                    }
-                    if ("$regex" in ops) {
-                        const pattern = ops.$regex;
-                        let regexMatches = false;
-                        // Guard against ReDoS: reject excessively long patterns and limit
-                        // the tested string length to prevent pathological backtracking.
-                        if (pattern.length <= 200) {
-                            try {
-                                const re = new RegExp(pattern);
-                                const testValue = typeof fieldValue === "string"
-                                    ? fieldValue.slice(0, 10_000)
-                                    : "";
-                                regexMatches = re.test(testValue);
-                            }
-                            catch {
-                                // Invalid regex pattern — treat as non-match
-                                regexMatches = false;
-                            }
-                        }
-                        if (!regexMatches) {
-                            return false;
-                        }
-                    }
-                }
-                else {
-                    // Direct equality
-                    if (fieldValue !== value) {
-                        return false;
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    /**
-     * Calculate cosine similarity between two vectors
-     */
-    cosineSimilarity(a, b) {
-        if (a.length !== b.length) {
-            return 0;
-        }
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            dotProduct += a[i] * b[i];
-            normA += a[i] * a[i];
-            normB += b[i] * b[i];
-        }
-        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-        return denominator === 0 ? 0 : dotProduct / denominator;
-    }
-}
-//# sourceMappingURL=vectorQueryTool.js.map

package/dist/lib/rag/stores/chroma.d.ts

@@ -1,90 +0,0 @@
-/**
- * Chroma vector store adapter
- *
- * Implements the `VectorStore` contract (see `src/lib/types/rag.ts`) against
- * a Chroma collection. This module has zero runtime dependency on the
- * `chromadb` package: callers construct their own `ChromaClient` (or any
- * compatible object) and inject it here. The structural interfaces below
- * mirror the subset of the `chromadb` API this adapter relies on
- * (`getOrCreateCollection`, `collection.upsert/query/delete`).
- *
- * ## Distance -> similarity scoring
- *
- * Chroma returns *distances*, not similarities, and the meaning of that
- * distance depends entirely on the collection's configured `hnsw:space`
- * (this adapter does not — and cannot — set that; it is chosen when the
- * collection is created on the Chroma side). `distanceMetric` tells this
- * adapter which space the collection uses so it can invert the distance
- * into a `score` consistent with `InMemoryVectorStore` (higher = more
- * similar):
- *
- * - `"cosine"` (default): Chroma returns `distance = 1 - cosineSimilarity`,
- *   so `score = 1 - distance` reproduces `InMemoryVectorStore`'s cosine
- *   score exactly.
- * - `"ip"`: Chroma returns `distance = 1 - dot(a, b)`, so
- *   `score = 1 - distance` yields the raw dot product — only equal to
- *   cosine similarity if both vectors are unit-normalized.
- * - `"l2"`: Chroma returns squared Euclidean distance, range
- *   `[0, Infinity)`, which has no exact inverse into a cosine-similarity
- *   scale. It is converted via `score = 1 / (1 + distance)`, a
- *   monotonically decreasing-in-distance map into `(0, 1]`. This preserves
- *   result ordering but is NOT numerically comparable to cosine scores.
- *
- * Passing a `distanceMetric` that does not match the collection's actual
- * `hnsw:space` will silently produce meaningless scores (Chroma has no way
- * to report its configured space back to the client), so callers must keep
- * the two in sync.
- *
- * ## Metadata round-tripping
- *
- * Chroma metadata values must be strings, numbers, or booleans. Values that
- * are `undefined` are dropped (Chroma rejects `undefined`); any other
- * non-primitive value (object, array, `null`) is `JSON.stringify`-ed on
- * write. This is lossy: such values come back as JSON-encoded strings on
- * read, not their original type. Store only primitive metadata values if
- * you need exact round-tripping.
- *
- * ## indexName -> collection mapping
- *
- * `indexName` is used verbatim as the Chroma collection name (1:1,
- * lazily created via `getOrCreateCollection` and cached for the lifetime of
- * this adapter instance).
- */
-import type { ChromaClientLike, ChromaVectorStoreOptions, ChromaWhere, MetadataFilter, VectorQueryResult, VectorStore } from "../../types/index.js";
-/**
- * Translates a `MetadataFilter` into a Chroma `where` clause.
- *
- * Throws a clear error for any operator Chroma's metadata `where` clause
- * cannot express ($not, $nor, $exists, $contains, $regex, $size) rather than
- * silently dropping the constraint and mis-filtering results.
- */
-export declare function translateMetadataFilter(filter: MetadataFilter): ChromaWhere;
-export declare class ChromaVectorStore implements VectorStore {
-    private readonly client;
-    private readonly collections;
-    private readonly distanceMetric;
-    constructor(client: ChromaClientLike, options?: ChromaVectorStoreOptions);
-    private getCollection;
-    /**
-     * Add or update vectors in an index (Chroma collection).
-     */
-    upsert(indexName: string, items: Array<{
-        id: string;
-        vector: number[];
-        metadata?: Record<string, unknown>;
-    }>): Promise<void>;
-    /**
-     * Query vectors by similarity.
-     */
-    query(params: {
-        indexName: string;
-        queryVector: number[];
-        topK?: number;
-        filter?: MetadataFilter;
-        includeVectors?: boolean;
-    }): Promise<VectorQueryResult[]>;
-    /**
-     * Delete vectors from an index (Chroma collection) by id.
-     */
-    delete(indexName: string, ids: string[]): Promise<void>;
-}

package/dist/lib/rag/stores/chroma.js

@@ -1,281 +0,0 @@
-/**
- * Chroma vector store adapter
- *
- * Implements the `VectorStore` contract (see `src/lib/types/rag.ts`) against
- * a Chroma collection. This module has zero runtime dependency on the
- * `chromadb` package: callers construct their own `ChromaClient` (or any
- * compatible object) and inject it here. The structural interfaces below
- * mirror the subset of the `chromadb` API this adapter relies on
- * (`getOrCreateCollection`, `collection.upsert/query/delete`).
- *
- * ## Distance -> similarity scoring
- *
- * Chroma returns *distances*, not similarities, and the meaning of that
- * distance depends entirely on the collection's configured `hnsw:space`
- * (this adapter does not — and cannot — set that; it is chosen when the
- * collection is created on the Chroma side). `distanceMetric` tells this
- * adapter which space the collection uses so it can invert the distance
- * into a `score` consistent with `InMemoryVectorStore` (higher = more
- * similar):
- *
- * - `"cosine"` (default): Chroma returns `distance = 1 - cosineSimilarity`,
- *   so `score = 1 - distance` reproduces `InMemoryVectorStore`'s cosine
- *   score exactly.
- * - `"ip"`: Chroma returns `distance = 1 - dot(a, b)`, so
- *   `score = 1 - distance` yields the raw dot product — only equal to
- *   cosine similarity if both vectors are unit-normalized.
- * - `"l2"`: Chroma returns squared Euclidean distance, range
- *   `[0, Infinity)`, which has no exact inverse into a cosine-similarity
- *   scale. It is converted via `score = 1 / (1 + distance)`, a
- *   monotonically decreasing-in-distance map into `(0, 1]`. This preserves
- *   result ordering but is NOT numerically comparable to cosine scores.
- *
- * Passing a `distanceMetric` that does not match the collection's actual
- * `hnsw:space` will silently produce meaningless scores (Chroma has no way
- * to report its configured space back to the client), so callers must keep
- * the two in sync.
- *
- * ## Metadata round-tripping
- *
- * Chroma metadata values must be strings, numbers, or booleans. Values that
- * are `undefined` are dropped (Chroma rejects `undefined`); any other
- * non-primitive value (object, array, `null`) is `JSON.stringify`-ed on
- * write. This is lossy: such values come back as JSON-encoded strings on
- * read, not their original type. Store only primitive metadata values if
- * you need exact round-tripping.
- *
- * ## indexName -> collection mapping
- *
- * `indexName` is used verbatim as the Chroma collection name (1:1,
- * lazily created via `getOrCreateCollection` and cached for the lifetime of
- * this adapter instance).
- */
-// Structural Chroma client/collection types (`ChromaClientLike`,
-// `ChromaCollectionLike`, `ChromaUpsertParams`, etc.) live in
-// `src/lib/types/vectorStoreChroma.ts` per this repo's canonical-type-
-// location rule (see CLAUDE.md Critical Rules 2 & 12) and are imported from
-// the types barrel above. This file only re-exports runtime values
-// (`ChromaVectorStore`, `translateMetadataFilter`) — consumers who need the
-// structural types should import them from `@juspay/neurolink` (root) or
-// the types barrel directly, per Critical Rule 13.
-// ---------------------------------------------------------------------------
-// MetadataFilter -> Chroma `where` translation
-// ---------------------------------------------------------------------------
-const CHROMA_SUPPORTED_FIELD_OPS = new Set([
-    "$eq",
-    "$ne",
-    "$gt",
-    "$gte",
-    "$lt",
-    "$lte",
-    "$in",
-    "$nin",
-]);
-const CHROMA_UNSUPPORTED_FIELD_OP_REASONS = {
-    $exists: 'Chroma metadata filtering has no existence check on the "where" clause.',
-    $contains: 'Chroma metadata filtering has no substring-match operator on the "where" clause (Chroma\'s substring matching only applies to document text via "where_document", not metadata field values).',
-    $regex: 'Chroma metadata filtering has no regular-expression operator on the "where" clause.',
-    $size: 'Chroma metadata filtering has no array-length operator on the "where" clause.',
-};
-function unsupportedFieldOpError(opKey, field) {
-    const reason = CHROMA_UNSUPPORTED_FIELD_OP_REASONS[opKey] ??
-        `Chroma metadata filtering does not support the "${opKey}" operator on the "where" clause.`;
-    return new Error(`Unsupported operator "${opKey}" (field "${field}"): ${reason}`);
-}
-/**
- * Translates a field-level filter value (either a direct-equality primitive
- * or an operator bag) into a Chroma `where` clause fragment for that field.
- *
- * Returns `undefined` when the filter value carries no enforceable
- * constraint (an array, or an operator bag with no recognized keys) — this
- * mirrors `InMemoryVectorStore.matchesFilter`, which treats any non-null
- * object value as an "operator bag" and silently applies none of its checks
- * when no recognized `$`-key is present, i.e. the field matches
- * unconditionally. Omitting the field from the Chroma `where` clause
- * reproduces that same "always matches" behavior.
- */
-function translateFieldFilter(field, value) {
-    if (Array.isArray(value)) {
-        return undefined;
-    }
-    if (value === null || typeof value !== "object") {
-        return { [field]: { $eq: value } };
-    }
-    const ops = value;
-    const opKeys = Object.keys(ops);
-    if (opKeys.length === 0) {
-        return undefined;
-    }
-    const chromaOps = {};
-    for (const opKey of opKeys) {
-        if (!CHROMA_SUPPORTED_FIELD_OPS.has(opKey)) {
-            throw unsupportedFieldOpError(opKey, field);
-        }
-        chromaOps[opKey] = ops[opKey];
-    }
-    return { [field]: chromaOps };
-}
-function translateLogicalOperator(key, value) {
-    switch (key) {
-        case "$and":
-            return {
-                $and: value.map(translateMetadataFilter),
-            };
-        case "$or":
-            return {
-                $or: value.map(translateMetadataFilter),
-            };
-        case "$not":
-            throw new Error('Chroma metadata filtering has no negation operator on the "where" clause; "$not" cannot be translated. Rewrite the filter using $ne/$nin instead.');
-        case "$nor":
-            throw new Error('"$nor" is declared on MetadataFilter but is not implemented by InMemoryVectorStore either, and Chroma has no negation operator on the "where" clause. Rewrite using $and of $ne/$nin clauses.');
-        default:
-            throw new Error(`Unknown logical operator "${key}" in MetadataFilter.`);
-    }
-}
-/**
- * Translates a `MetadataFilter` into a Chroma `where` clause.
- *
- * Throws a clear error for any operator Chroma's metadata `where` clause
- * cannot express ($not, $nor, $exists, $contains, $regex, $size) rather than
- * silently dropping the constraint and mis-filtering results.
- */
-export function translateMetadataFilter(filter) {
-    const clauses = [];
-    for (const [key, value] of Object.entries(filter)) {
-        const clause = key.startsWith("$")
-            ? translateLogicalOperator(key, value)
-            : translateFieldFilter(key, value);
-        if (clause !== undefined) {
-            clauses.push(clause);
-        }
-    }
-    if (clauses.length === 0) {
-        return {};
-    }
-    if (clauses.length === 1) {
-        return clauses[0];
-    }
-    // Chroma requires a single top-level operator; combine multiple field/
-    // logical clauses with an explicit $and (mirrors matchesFilter ANDing
-    // every top-level entry).
-    return { $and: clauses };
-}
-// ---------------------------------------------------------------------------
-// Metadata <-> Chroma metadata conversion
-// ---------------------------------------------------------------------------
-function toChromaMetadataValue(value) {
-    if (typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean") {
-        return value;
-    }
-    // Chroma metadata values must be string | number | boolean. Non-primitive
-    // values (object, array, null) are JSON-stringified — lossy on read back,
-    // see module doc comment.
-    return JSON.stringify(value);
-}
-function toChromaMetadata(metadata) {
-    const result = {};
-    for (const [key, value] of Object.entries(metadata)) {
-        if (value === undefined) {
-            // Chroma rejects `undefined` metadata values outright.
-            continue;
-        }
-        result[key] = toChromaMetadataValue(value);
-    }
-    return result;
-}
-function distanceToScore(distance, metric) {
-    switch (metric) {
-        case "cosine":
-        case "ip":
-            return 1 - distance;
-        case "l2":
-            return 1 / (1 + distance);
-        default: {
-            const exhaustive = metric;
-            throw new Error(`Unknown Chroma distance metric: ${String(exhaustive)}`);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// ChromaVectorStore
-// ---------------------------------------------------------------------------
-export class ChromaVectorStore {
-    client;
-    collections = new Map();
-    distanceMetric;
-    constructor(client, options = {}) {
-        this.client = client;
-        this.distanceMetric = options.distanceMetric ?? "cosine";
-    }
-    getCollection(indexName) {
-        let collection = this.collections.get(indexName);
-        if (!collection) {
-            collection = this.client.getOrCreateCollection({ name: indexName });
-            this.collections.set(indexName, collection);
-        }
-        return collection;
-    }
-    /**
-     * Add or update vectors in an index (Chroma collection).
-     */
-    async upsert(indexName, items) {
-        if (items.length === 0) {
-            return;
-        }
-        const collection = await this.getCollection(indexName);
-        await collection.upsert({
-            ids: items.map((item) => item.id),
-            embeddings: items.map((item) => item.vector),
-            metadatas: items.map((item) => toChromaMetadata(item.metadata ?? {})),
-        });
-    }
-    /**
-     * Query vectors by similarity.
-     */
-    async query(params) {
-        const { indexName, queryVector, topK = 10, filter, includeVectors = false, } = params;
-        const collection = await this.getCollection(indexName);
-        const include = ["metadatas", "distances"];
-        if (includeVectors) {
-            include.push("embeddings");
-        }
-        const response = await collection.query({
-            queryEmbeddings: [queryVector],
-            nResults: topK,
-            ...(filter ? { where: translateMetadataFilter(filter) } : {}),
-            include,
-        });
-        const ids = response.ids[0] ?? [];
-        const metadatasRow = response.metadatas?.[0] ?? [];
-        const distancesRow = response.distances?.[0] ?? [];
-        const embeddingsRow = response.embeddings?.[0] ?? [];
-        return ids.map((id, i) => {
-            const metadata = (metadatasRow[i] ?? {});
-            const distance = distancesRow[i];
-            const score = distance === null || distance === undefined
-                ? undefined
-                : distanceToScore(distance, this.distanceMetric);
-            return {
-                id,
-                score,
-                text: metadata.text,
-                metadata,
-                ...(includeVectors ? { vector: embeddingsRow[i] ?? [] } : {}),
-            };
-        });
-    }
-    /**
-     * Delete vectors from an index (Chroma collection) by id.
-     */
-    async delete(indexName, ids) {
-        if (ids.length === 0) {
-            return;
-        }
-        const collection = await this.getCollection(indexName);
-        await collection.delete({ ids });
-    }
-}
-//# sourceMappingURL=chroma.js.map