@nodetool-ai/base-nodes 0.7.0-rc.23 → 0.8.2

package/dist/nodes/vector.js

@@ -1,1121 +0,0 @@
-/**
- * Vector database nodes for NodeTool (sqlite-vec backed).
- * Provides collection management, indexing, and querying operations.
- */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { BaseNode, prop } from "@nodetool-ai/node-sdk";
-import { getVecStore, getCollection, OllamaEmbeddingFunction } from "@nodetool-ai/vectorstore";
-// ---------------------------------------------------------------------------
-// Client helpers
-// ---------------------------------------------------------------------------
-async function getOllamaEmbedding(model, text) {
-    const ef = new OllamaEmbeddingFunction(model);
-    const result = await ef.generate([text]);
-    return result[0];
-}
-// ---------------------------------------------------------------------------
-// 1. CollectionNode
-// ---------------------------------------------------------------------------
-export class CollectionNode extends BaseNode {
-    static nodeType = "vector.Collection";
-    static title = "Collection";
-    static description = "Get or create a named vector database collection for storing embeddings.\n    vector, embedding, collection, RAG, get, create";
-    static metadataOutputTypes = {
-        output: "collection"
-    };
-    async process() {
-        const name = String(this.name ?? this.name ?? "");
-        const embeddingModel = (this.embedding_model ??
-            this.embedding_model ?? { repo_id: "" });
-        if (!name.trim()) {
-            throw new Error("Collection name cannot be empty");
-        }
-        const store = await getVecStore();
-        await store.getOrCreateCollection({
-            name,
-            metadata: { embedding_model: embeddingModel.repo_id ?? "" }
-        });
-        return { output: { name } };
-    }
-}
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Name",
-        description: "The name of the collection to create"
-    })
-], CollectionNode.prototype, "name", void 0);
-__decorate([
-    prop({
-        type: "llama_model",
-        default: {
-            type: "llama_model",
-            name: "",
-            repo_id: "",
-            modified_at: "",
-            size: 0,
-            digest: "",
-            details: {}
-        },
-        title: "Embedding Model",
-        description: "Model to use for embedding, search for nomic-embed-text and download it"
-    })
-], CollectionNode.prototype, "embedding_model", void 0);
-// ---------------------------------------------------------------------------
-// 2. CountNode
-// ---------------------------------------------------------------------------
-export class CountNode extends BaseNode {
-    static nodeType = "vector.Count";
-    static title = "Count";
-    static description = "Count the number of documents in a collection.\n    vector, embedding, collection, RAG";
-    static metadataOutputTypes = {
-        output: "int"
-    };
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const collection = await getCollection(name);
-        const count = await collection.count();
-        return { output: count };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to count"
-    })
-], CountNode.prototype, "collection", void 0);
-// ---------------------------------------------------------------------------
-// 3. GetDocumentsNode
-// ---------------------------------------------------------------------------
-export class GetDocumentsNode extends BaseNode {
-    static nodeType = "vector.GetDocuments";
-    static title = "Get Documents";
-    static description = "Get documents from a collection.\n    vector, embedding, collection, RAG, retrieve";
-    static metadataOutputTypes = {
-        output: "list[str]"
-    };
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const ids = (this.ids ?? this.ids ?? []);
-        const limit = Number(this.limit ?? this.limit ?? 100);
-        const offset = Number(this.offset ?? this.offset ?? 0);
-        const collection = await getCollection(name);
-        // When ids is empty, pass empty array (returns nothing) to match Python behavior.
-        // Passing undefined would return all docs, which differs from Python's empty-list semantics.
-        const result = await collection.get({
-            ids: ids.length > 0 ? ids : [],
-            limit,
-            offset
-        });
-        return { output: result.documents };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to get"
-    })
-], GetDocumentsNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "list[str]",
-        default: [],
-        title: "Ids",
-        description: "The ids of the documents to get"
-    })
-], GetDocumentsNode.prototype, "ids", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 100,
-        title: "Limit",
-        description: "The limit of the documents to get"
-    })
-], GetDocumentsNode.prototype, "limit", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 0,
-        title: "Offset",
-        description: "The offset of the documents to get"
-    })
-], GetDocumentsNode.prototype, "offset", void 0);
-// ---------------------------------------------------------------------------
-// 4. PeekNode
-// ---------------------------------------------------------------------------
-export class PeekNode extends BaseNode {
-    static nodeType = "vector.Peek";
-    static title = "Peek";
-    static description = "Peek at the documents in a collection.\n    vector, embedding, collection, RAG, preview";
-    static metadataOutputTypes = {
-        output: "list[str]"
-    };
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const limit = Number(this.limit ?? this.limit ?? 100);
-        const collection = await getCollection(name);
-        const result = await collection.peek({ limit });
-        return { output: result.documents };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to peek"
-    })
-], PeekNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 100,
-        title: "Limit",
-        description: "The limit of the documents to peek"
-    })
-], PeekNode.prototype, "limit", void 0);
-// ---------------------------------------------------------------------------
-// 5. IndexImageNode
-// ---------------------------------------------------------------------------
-export class IndexImageNode extends BaseNode {
-    static nodeType = "vector.IndexImage";
-    static title = "Index Image";
-    static description = "Index a list of image assets or files.\n    vector, embedding, collection, RAG, index, image, batch";
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const image = (this.image ?? this.image ?? {});
-        const indexId = String(this.index_id ?? this.index_id ?? "");
-        const metadataRaw = (this.metadata ?? this.metadata ?? {});
-        const doUpsert = Boolean(this.upsert ?? this.upsert ?? false);
-        // Resolve document ID: prefer explicit index_id, then document_id field on image ref
-        const resolvedId = indexId.trim() ||
-            String(image.document_id ?? "").trim();
-        if (!resolvedId) {
-            throw new Error("document_id cannot be empty for image. Provide index_id or ensure image has a document_id.");
-        }
-        // Obtain image URI — TS environment does not have PIL; pass uri as document
-        const uri = String(image.uri ?? image.asset_id ?? "");
-        if (!uri) {
-            throw new Error("Image reference must have a uri or asset_id");
-        }
-        // Flatten metadata to Record<string, string | number | boolean>
-        const metadata = {};
-        for (const [k, v] of Object.entries(metadataRaw)) {
-            if (typeof v === "string" ||
-                typeof v === "number" ||
-                typeof v === "boolean") {
-                metadata[k] = v;
-            }
-            else {
-                metadata[k] = String(v);
-            }
-        }
-        const collection = await getCollection(name);
-        if (doUpsert) {
-            await collection.upsert({
-                ids: [resolvedId],
-                uris: [uri],
-                metadatas: [metadata]
-            });
-        }
-        else {
-            await collection.add({
-                ids: [resolvedId],
-                uris: [uri],
-                metadatas: [metadata]
-            });
-        }
-        return { output: null };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to index"
-    })
-], IndexImageNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "image",
-        default: [],
-        title: "Image",
-        description: "List of image assets to index"
-    })
-], IndexImageNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Index Id",
-        description: "The ID to associate with the image, defaults to the URI of the image"
-    })
-], IndexImageNode.prototype, "index_id", void 0);
-__decorate([
-    prop({
-        type: "dict",
-        default: {},
-        title: "Metadata",
-        description: "The metadata to associate with the image"
-    })
-], IndexImageNode.prototype, "metadata", void 0);
-__decorate([
-    prop({
-        type: "bool",
-        default: false,
-        title: "Upsert",
-        description: "Whether to upsert the images"
-    })
-], IndexImageNode.prototype, "upsert", void 0);
-// ---------------------------------------------------------------------------
-// 6. IndexEmbeddingNode
-// ---------------------------------------------------------------------------
-export class IndexEmbeddingNode extends BaseNode {
-    static nodeType = "vector.IndexEmbedding";
-    static title = "Index Embedding";
-    static description = "Index a single embedding vector into a collection with optional metadata. Creates a searchable entry that can be queried for similarity matching.\n    vector, index, embedding, storage, RAG";
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const embeddingRaw = this.embedding ?? this.embedding;
-        const indexId = this.index_id ?? this.index_id ?? "";
-        const metadataRaw = this.metadata ?? this.metadata ?? {};
-        // embeddingRaw may be a flat number[] (single embedding) or number[][] (batch)
-        // or an NPArray-like object with a `data` field
-        let embeddings;
-        if (Array.isArray(embeddingRaw)) {
-            if (embeddingRaw.length === 0)
-                throw new Error("The embedding cannot be empty");
-            if (typeof embeddingRaw[0] === "number") {
-                // single 1-D array
-                embeddings = [embeddingRaw];
-            }
-            else {
-                embeddings = embeddingRaw;
-            }
-        }
-        else if (embeddingRaw && typeof embeddingRaw === "object") {
-            // NPArray-like
-            const obj = embeddingRaw;
-            const data = obj.data ?? obj.array ?? obj.embedding;
-            if (Array.isArray(data)) {
-                if (typeof data[0] === "number") {
-                    embeddings = [data];
-                }
-                else {
-                    embeddings = data;
-                }
-            }
-            else {
-                throw new Error("Cannot extract embedding data from provided object");
-            }
-        }
-        else {
-            throw new Error("The embedding cannot be empty");
-        }
-        if (Array.isArray(indexId)) {
-            // Batch mode
-            if (indexId.length === 0)
-                throw new Error("The IDs list cannot be empty");
-            if (indexId.length !== embeddings.length) {
-                throw new Error(`Number of IDs (${indexId.length}) must match number of embeddings (${embeddings.length})`);
-            }
-            let metadatas;
-            if (Array.isArray(metadataRaw)) {
-                if (metadataRaw.length !== indexId.length) {
-                    throw new Error(`Number of IDs (${indexId.length}) must match number of metadatas (${metadataRaw.length})`);
-                }
-                metadatas = metadataRaw.map(flattenMetadata);
-            }
-            else {
-                const flat = flattenMetadata(metadataRaw);
-                metadatas = Array(indexId.length).fill(flat);
-            }
-            const collection = await getCollection(name);
-            await collection.add({
-                ids: indexId,
-                embeddings,
-                metadatas
-            });
-        }
-        else {
-            // Single mode
-            const idStr = String(indexId);
-            if (!idStr.trim())
-                throw new Error("The ID cannot be empty");
-            const flat = flattenMetadata((Array.isArray(metadataRaw) ? metadataRaw[0] : metadataRaw));
-            const collection = await getCollection(name);
-            await collection.add({
-                ids: [idStr],
-                embeddings: [embeddings[0]],
-                metadatas: [flat]
-            });
-        }
-        return { output: null };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to index"
-    })
-], IndexEmbeddingNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "list",
-        default: {
-            type: "list",
-            value: null,
-            dtype: "<i8",
-            shape: [1]
-        },
-        title: "Embedding",
-        description: "The embedding to index"
-    })
-], IndexEmbeddingNode.prototype, "embedding", void 0);
-__decorate([
-    prop({
-        type: "union[str, list[str]]",
-        default: "",
-        title: "Index Id",
-        description: "The ID to associate with the embedding"
-    })
-], IndexEmbeddingNode.prototype, "index_id", void 0);
-__decorate([
-    prop({
-        type: "union[dict, list[dict]]",
-        default: {},
-        title: "Metadata",
-        description: "The metadata to associate with the embedding"
-    })
-], IndexEmbeddingNode.prototype, "metadata", void 0);
-function flattenMetadata(obj) {
-    const result = {};
-    for (const [k, v] of Object.entries(obj ?? {})) {
-        if (typeof v === "string" ||
-            typeof v === "number" ||
-            typeof v === "boolean") {
-            result[k] = v;
-        }
-        else if (v !== null && v !== undefined) {
-            result[k] = String(v);
-        }
-    }
-    return result;
-}
-// ---------------------------------------------------------------------------
-// 7. IndexTextChunkNode
-// ---------------------------------------------------------------------------
-export class IndexTextChunkNode extends BaseNode {
-    static nodeType = "vector.IndexTextChunk";
-    static title = "Index Text Chunk";
-    static description = "Index a single text chunk.\n    vector, embedding, collection, RAG, index, text, chunk";
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const documentId = String(this.document_id ?? this.document_id ?? "");
-        if (!documentId.trim())
-            throw new Error("The document ID cannot be empty");
-        const text = String(this.text ?? this.text ?? "");
-        const metadataRaw = (this.metadata ?? this.metadata ?? {});
-        const collection = await getCollection(name);
-        await collection.add({
-            ids: [documentId],
-            documents: [text],
-            metadatas: [flattenMetadata(metadataRaw)]
-        });
-        return { output: null };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to index"
-    })
-], IndexTextChunkNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Document Id",
-        description: "The document ID to associate with the text chunk"
-    })
-], IndexTextChunkNode.prototype, "document_id", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Text",
-        description: "The text to index"
-    })
-], IndexTextChunkNode.prototype, "text", void 0);
-__decorate([
-    prop({
-        type: "dict",
-        default: {},
-        title: "Metadata",
-        description: "The metadata to associate with the text chunk"
-    })
-], IndexTextChunkNode.prototype, "metadata", void 0);
-export class IndexAggregatedTextNode extends BaseNode {
-    static nodeType = "vector.IndexAggregatedText";
-    static title = "Index Aggregated Text";
-    static description = "Index multiple text chunks at once with aggregated embeddings from Ollama.\n    vector, embedding, collection, RAG, index, text, chunk, batch, ollama";
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const document = String(this.document ?? this.document ?? "");
-        const documentId = String(this.document_id ?? this.document_id ?? "");
-        const metadataRaw = (this.metadata ?? this.metadata ?? {});
-        const textChunksRaw = (this.text_chunks ?? this.text_chunks ?? []);
-        const aggregation = String(this.aggregation ?? this.aggregation ?? "mean");
-        if (!documentId.trim())
-            throw new Error("The document ID cannot be empty");
-        if (!document.trim())
-            throw new Error("The document cannot be empty");
-        if (textChunksRaw.length === 0)
-            throw new Error("The text chunks cannot be empty");
-        // Retrieve the collection to get the embedding model name
-        const collection = await getCollection(name);
-        const model = collection.metadata
-            ?.embedding_model;
-        if (!model)
-            throw new Error("The collection does not have an embedding_model in its metadata");
-        // Extract plain text from each chunk
-        const texts = textChunksRaw.map((chunk) => typeof chunk === "string" ? chunk : chunk.text);
-        // Compute embeddings via Ollama
-        const embeddings = [];
-        for (const text of texts) {
-            const embedding = await getOllamaEmbedding(model, text);
-            embeddings.push(embedding);
-        }
-        // Aggregate embeddings
-        const dim = embeddings[0].length;
-        const aggregated = new Array(dim).fill(0);
-        if (aggregation === "mean" || aggregation === "sum") {
-            for (const emb of embeddings) {
-                for (let i = 0; i < dim; i++) {
-                    aggregated[i] += emb[i];
-                }
-            }
-            if (aggregation === "mean") {
-                for (let i = 0; i < dim; i++) {
-                    aggregated[i] /= embeddings.length;
-                }
-            }
-        }
-        else if (aggregation === "max") {
-            for (let i = 0; i < dim; i++) {
-                aggregated[i] = embeddings[0][i];
-            }
-            for (let j = 1; j < embeddings.length; j++) {
-                for (let i = 0; i < dim; i++) {
-                    aggregated[i] = Math.max(aggregated[i], embeddings[j][i]);
-                }
-            }
-        }
-        else if (aggregation === "min") {
-            for (let i = 0; i < dim; i++) {
-                aggregated[i] = embeddings[0][i];
-            }
-            for (let j = 1; j < embeddings.length; j++) {
-                for (let i = 0; i < dim; i++) {
-                    aggregated[i] = Math.min(aggregated[i], embeddings[j][i]);
-                }
-            }
-        }
-        else {
-            throw new Error(`Invalid aggregation method: ${aggregation}`);
-        }
-        const flat = flattenMetadata(metadataRaw);
-        await collection.add({
-            ids: [documentId],
-            documents: [document],
-            embeddings: [aggregated],
-            metadatas: Object.keys(flat).length > 0 ? [flat] : undefined
-        });
-        return { output: null };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to index"
-    })
-], IndexAggregatedTextNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Document",
-        description: "The document to index"
-    })
-], IndexAggregatedTextNode.prototype, "document", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Document Id",
-        description: "The document ID to associate with the text"
-    })
-], IndexAggregatedTextNode.prototype, "document_id", void 0);
-__decorate([
-    prop({
-        type: "dict",
-        default: {},
-        title: "Metadata",
-        description: "The metadata to associate with the text"
-    })
-], IndexAggregatedTextNode.prototype, "metadata", void 0);
-__decorate([
-    prop({
-        type: "list[union[text_chunk, str]]",
-        default: [],
-        title: "Text Chunks",
-        description: "List of text chunks to index"
-    })
-], IndexAggregatedTextNode.prototype, "text_chunks", void 0);
-__decorate([
-    prop({
-        type: "enum",
-        default: "mean",
-        title: "Aggregation",
-        description: "The aggregation method to use for the embeddings.",
-        values: ["mean", "max", "min", "sum"]
-    })
-], IndexAggregatedTextNode.prototype, "aggregation", void 0);
-// ---------------------------------------------------------------------------
-// 9. IndexStringNode
-// ---------------------------------------------------------------------------
-export class IndexStringNode extends BaseNode {
-    static nodeType = "vector.IndexString";
-    static title = "Index String";
-    static description = "Index a string with a Document ID to a collection.\n    vector, embedding, collection, RAG, index, text, string";
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const documentId = String(this.document_id ?? this.document_id ?? "");
-        if (!documentId.trim())
-            throw new Error("The document ID cannot be empty");
-        const text = String(this.text ?? this.text ?? "");
-        const collection = await getCollection(name);
-        await collection.add({
-            ids: [documentId],
-            documents: [text]
-        });
-        return { output: null };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to index"
-    })
-], IndexStringNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Text",
-        description: "Text content to index"
-    })
-], IndexStringNode.prototype, "text", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Document Id",
-        description: "Document ID to associate with the text content"
-    })
-], IndexStringNode.prototype, "document_id", void 0);
-__decorate([
-    prop({
-        type: "dict",
-        default: {},
-        title: "Metadata",
-        description: "The metadata to associate with the text"
-    })
-], IndexStringNode.prototype, "metadata", void 0);
-// ---------------------------------------------------------------------------
-// 10. QueryImageNode
-// ---------------------------------------------------------------------------
-export class QueryImageNode extends BaseNode {
-    static nodeType = "vector.QueryImage";
-    static title = "Query Image";
-    static description = "Query the index for similar images.\n    vector, RAG, query, image, search, similarity";
-    static metadataOutputTypes = {
-        ids: "list[str]",
-        documents: "list[str]",
-        metadatas: "list[dict]",
-        distances: "list[float]"
-    };
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const image = (this.image ?? this.image ?? {});
-        const uri = String(image.uri ?? image.asset_id ?? "");
-        if (!uri)
-            throw new Error("Image is not connected (no uri or asset_id)");
-        const nResults = Number(this.n_results ?? this.n_results ?? 1);
-        const collection = await getCollection(name);
-        const result = await collection.query({
-            queryURIs: [uri],
-            nResults,
-            include: ["documents", "metadatas", "distances"]
-        });
-        if (!result.ids)
-            throw new Error("Ids are not returned");
-        if (!result.documents)
-            throw new Error("Documents are not returned");
-        if (!result.metadatas)
-            throw new Error("Metadatas are not returned");
-        if (!result.distances)
-            throw new Error("Distances are not returned");
-        // Sort by ID (matching Python behavior)
-        const combined = result.ids[0].map((id, idx) => ({
-            id: String(id),
-            document: result.documents[0][idx] ?? "",
-            metadata: (result.metadatas[0][idx] ?? {}),
-            distance: result.distances[0][idx] ?? 0
-        }));
-        combined.sort((a, b) => a.id.localeCompare(b.id));
-        return {
-            output: {
-                ids: combined.map((r) => r.id),
-                documents: combined.map((r) => r.document),
-                metadatas: combined.map((r) => r.metadata),
-                distances: combined.map((r) => r.distance)
-            }
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to query"
-    })
-], QueryImageNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "image",
-        default: {
-            type: "image",
-            uri: "",
-            asset_id: null,
-            data: null,
-            metadata: null
-        },
-        title: "Image",
-        description: "The image to query"
-    })
-], QueryImageNode.prototype, "image", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 1,
-        title: "N Results",
-        description: "The number of results to return"
-    })
-], QueryImageNode.prototype, "n_results", void 0);
-// ---------------------------------------------------------------------------
-// 11. QueryTextNode
-// ---------------------------------------------------------------------------
-export class QueryTextNode extends BaseNode {
-    static nodeType = "vector.QueryText";
-    static title = "Query Text";
-    static description = "Query the index for similar text.\n    vector, RAG, query, text, search, similarity";
-    static metadataOutputTypes = {
-        ids: "list[str]",
-        documents: "list[str]",
-        metadatas: "list[dict]",
-        distances: "list[float]"
-    };
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const text = String(this.text ?? this.text ?? "");
-        const nResults = Number(this.n_results ?? this.n_results ?? 1);
-        const collection = await getCollection(name);
-        const result = await collection.query({
-            queryTexts: [text],
-            nResults,
-            include: ["documents", "metadatas", "distances"]
-        });
-        if (!result.ids)
-            throw new Error("Ids are not returned");
-        if (!result.documents)
-            throw new Error("Documents are not returned");
-        if (!result.metadatas)
-            throw new Error("Metadatas are not returned");
-        if (!result.distances)
-            throw new Error("Distances are not returned");
-        // Sort by ID (matching Python behavior)
-        const combined = result.ids[0].map((id, idx) => ({
-            id: String(id),
-            document: result.documents[0][idx] ?? "",
-            metadata: (result.metadatas[0][idx] ?? {}),
-            distance: result.distances[0][idx] ?? 0
-        }));
-        combined.sort((a, b) => a.id.localeCompare(b.id));
-        return {
-            output: {
-                ids: combined.map((r) => r.id),
-                documents: combined.map((r) => r.document),
-                metadatas: combined.map((r) => r.metadata),
-                distances: combined.map((r) => r.distance)
-            }
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to query"
-    })
-], QueryTextNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Text",
-        description: "The text to query"
-    })
-], QueryTextNode.prototype, "text", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 1,
-        title: "N Results",
-        description: "The number of results to return"
-    })
-], QueryTextNode.prototype, "n_results", void 0);
-// ---------------------------------------------------------------------------
-// 12. RemoveOverlapNode
-// ---------------------------------------------------------------------------
-export class RemoveOverlapNode extends BaseNode {
-    static nodeType = "vector.RemoveOverlap";
-    static title = "Remove Overlap";
-    static description = "Removes overlapping words between consecutive strings in a list. Splits text into words and matches word sequences for more accurate overlap detection.\n    vector, RAG, query, text, processing, overlap, deduplication";
-    static metadataOutputTypes = {
-        documents: "list[str]"
-    };
-    _splitIntoWords(text) {
-        return text.split(/\s+/).filter((w) => w.length > 0);
-    }
-    _findWordOverlap(words1, words2, minOverlap) {
-        if (words1.length < minOverlap || words2.length < minOverlap)
-            return 0;
-        const maxCheck = Math.min(words1.length, words2.length);
-        for (let overlapSize = maxCheck; overlapSize >= minOverlap; overlapSize--) {
-            const tail = words1.slice(words1.length - overlapSize);
-            const head = words2.slice(0, overlapSize);
-            if (tail.every((w, i) => w === head[i])) {
-                return overlapSize;
-            }
-        }
-        return 0;
-    }
-    async process() {
-        const documents = (this.documents ?? this.documents ?? []);
-        const minOverlapWords = Number(this.min_overlap_words ?? this.min_overlap_words ?? 2);
-        if (documents.length === 0) {
-            return { documents: [] };
-        }
-        const result = [documents[0]];
-        for (let i = 1; i < documents.length; i++) {
-            const prevWords = this._splitIntoWords(result[result.length - 1]);
-            const currWords = this._splitIntoWords(documents[i]);
-            const overlapWordCount = this._findWordOverlap(prevWords, currWords, minOverlapWords);
-            if (overlapWordCount > 0) {
-                const newText = currWords.slice(overlapWordCount).join(" ");
-                if (newText) {
-                    result.push(newText);
-                }
-            }
-            else {
-                result.push(documents[i]);
-            }
-        }
-        return { documents: result };
-    }
-}
-__decorate([
-    prop({
-        type: "list[str]",
-        default: [],
-        title: "Documents",
-        description: "List of strings to process for overlap removal"
-    })
-], RemoveOverlapNode.prototype, "documents", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 2,
-        title: "Min Overlap Words",
-        description: "Minimum number of words that must overlap to be considered"
-    })
-], RemoveOverlapNode.prototype, "min_overlap_words", void 0);
-// ---------------------------------------------------------------------------
-// 13. HybridSearchNode
-// ---------------------------------------------------------------------------
-export class HybridSearchNode extends BaseNode {
-    static nodeType = "vector.HybridSearch";
-    static title = "Hybrid Search";
-    static description = "Hybrid search combining semantic and keyword-based search for better retrieval. Uses reciprocal rank fusion to combine results from both methods.\n    vector, RAG, query, semantic, text, similarity";
-    static metadataOutputTypes = {
-        ids: "list[str]",
-        documents: "list[str]",
-        metadatas: "list[dict]",
-        distances: "list[float]",
-        scores: "list[float]"
-    };
-    _getKeywordQuery(text, minKeywordLength) {
-        const pattern = /[ ,.!?\-_=|]+/;
-        const queryTokens = text
-            .toLowerCase()
-            .split(pattern)
-            .map((t) => t.trim())
-            .filter((t) => t.length >= minKeywordLength);
-        if (queryTokens.length === 0)
-            return null;
-        if (queryTokens.length > 1) {
-            return { $or: queryTokens.map((token) => ({ $contains: token })) };
-        }
-        return { $contains: queryTokens[0] };
-    }
-    async process() {
-        const collectionInput = (this.collection ??
-            this.collection ?? { name: "" });
-        const name = collectionInput.name ?? "";
-        if (!name.trim())
-            throw new Error("Collection name cannot be empty");
-        const text = String(this.text ?? this.text ?? "");
-        if (!text.trim())
-            throw new Error("Search text cannot be empty");
-        const nResults = Number(this.n_results ?? this.n_results ?? 5);
-        const kConstant = Number(this.k_constant ?? this.k_constant ?? 60.0);
-        const minKeywordLength = Number(this.min_keyword_length ?? this.min_keyword_length ?? 3);
-        const collection = await getCollection(name);
-        // Semantic search
-        const semanticResult = await collection.query({
-            queryTexts: [text],
-            nResults: nResults * 2,
-            include: ["documents", "metadatas", "distances"]
-        });
-        // Keyword search
-        const keywordQuery = this._getKeywordQuery(text, minKeywordLength);
-        let keywordResult = semanticResult;
-        if (keywordQuery) {
-            keywordResult = await collection.query({
-                queryTexts: [text],
-                nResults: nResults * 2,
-                whereDocument: keywordQuery,
-                include: ["documents", "metadatas", "distances"]
-            });
-        }
-        // Validate
-        for (const res of [semanticResult, keywordResult]) {
-            if (!res.ids)
-                throw new Error("Ids are not returned");
-            if (!res.documents)
-                throw new Error("Documents are not returned");
-            if (!res.metadatas)
-                throw new Error("Metadatas are not returned");
-            if (!res.distances)
-                throw new Error("Distances are not returned");
-        }
-        // Reciprocal rank fusion
-        const combinedScores = new Map();
-        const processResults = (ids, docs, metas, distances) => {
-            ids.forEach((id, rank) => {
-                const strId = String(id);
-                const score = 1 / (rank + kConstant);
-                if (combinedScores.has(strId)) {
-                    combinedScores.get(strId).score += score;
-                }
-                else {
-                    combinedScores.set(strId, {
-                        doc: docs[rank] ?? "",
-                        meta: (metas[rank] ?? {}),
-                        distance: distances[rank] ?? 0,
-                        score
-                    });
-                }
-            });
-        };
-        processResults(semanticResult.ids[0].map(String), semanticResult.documents[0], semanticResult.metadatas[0], semanticResult.distances[0]);
-        processResults(keywordResult.ids[0].map(String), keywordResult.documents[0], keywordResult.metadatas[0], keywordResult.distances[0]);
-        // Sort by combined score descending
-        const sorted = [...combinedScores.entries()]
-            .sort((a, b) => b[1].score - a[1].score)
-            .slice(0, nResults);
-        const resultIds = [];
-        const resultDocs = [];
-        const resultMetas = [];
-        const resultDistances = [];
-        const resultScores = [];
-        for (const [id, data] of sorted) {
-            resultIds.push(id);
-            resultDocs.push(data.doc);
-            resultMetas.push(data.meta);
-            resultDistances.push(data.distance);
-            resultScores.push(data.score);
-        }
-        return {
-            ids: resultIds,
-            documents: resultDocs,
-            metadatas: resultMetas,
-            distances: resultDistances,
-            scores: resultScores
-        };
-    }
-}
-__decorate([
-    prop({
-        type: "collection",
-        default: {
-            type: "collection",
-            name: ""
-        },
-        title: "Collection",
-        description: "The collection to query"
-    })
-], HybridSearchNode.prototype, "collection", void 0);
-__decorate([
-    prop({
-        type: "str",
-        default: "",
-        title: "Text",
-        description: "The text to query"
-    })
-], HybridSearchNode.prototype, "text", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 5,
-        title: "N Results",
-        description: "The number of final results to return"
-    })
-], HybridSearchNode.prototype, "n_results", void 0);
-__decorate([
-    prop({
-        type: "float",
-        default: 60,
-        title: "K Constant",
-        description: "Constant for reciprocal rank fusion (default: 60.0)"
-    })
-], HybridSearchNode.prototype, "k_constant", void 0);
-__decorate([
-    prop({
-        type: "int",
-        default: 3,
-        title: "Min Keyword Length",
-        description: "Minimum length for keyword tokens"
-    })
-], HybridSearchNode.prototype, "min_keyword_length", void 0);
-// ---------------------------------------------------------------------------
-// Export
-// ---------------------------------------------------------------------------
-export const VECTOR_NODES = [
-    CollectionNode,
-    CountNode,
-    GetDocumentsNode,
-    PeekNode,
-    IndexImageNode,
-    IndexEmbeddingNode,
-    IndexTextChunkNode,
-    IndexAggregatedTextNode,
-    IndexStringNode,
-    QueryImageNode,
-    QueryTextNode,
-    RemoveOverlapNode,
-    HybridSearchNode
-];
-//# sourceMappingURL=vector.js.map