langchain 0.0.202 → 0.0.204-rc.0

package/dist/vectorstores/convex.js

@@ -1,173 +1 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-import { makeFunctionReference, } from "convex/server";
-import { Document } from "../document.js";
-import { VectorStore } from "./base.js";
-/**
- * Class that is a wrapper around Convex storage and vector search. It is used
- * to insert embeddings in Convex documents with a vector search index,
- * and perform a vector search on them.
- *
- * ConvexVectorStore does NOT implement maxMarginalRelevanceSearch.
- */
-export class ConvexVectorStore extends VectorStore {
-    _vectorstoreType() {
-        return "convex";
-    }
-    constructor(embeddings, config) {
-        super(embeddings, config);
-        Object.defineProperty(this, "ctx", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "table", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "index", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "textField", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "embeddingField", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "metadataField", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "insert", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "get", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.ctx = config.ctx;
-        this.table = config.table ?? "documents";
-        this.index = config.index ?? "byEmbedding";
-        this.textField = config.textField ?? "text";
-        this.embeddingField =
-            config.embeddingField ?? "embedding";
-        this.metadataField =
-            config.metadataField ?? "metadata";
-        this.insert =
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            config.insert ?? makeFunctionReference("langchain/db:insert");
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.get = config.get ?? makeFunctionReference("langchain/db:get");
-    }
-    /**
-     * Add vectors and their corresponding documents to the Convex table.
-     * @param vectors Vectors to be added.
-     * @param documents Corresponding documents to be added.
-     * @returns Promise that resolves when the vectors and documents have been added.
-     */
-    async addVectors(vectors, documents) {
-        const convexDocuments = vectors.map((embedding, idx) => ({
-            [this.textField]: documents[idx].pageContent,
-            [this.embeddingField]: embedding,
-            [this.metadataField]: documents[idx].metadata,
-        }));
-        // TODO: Remove chunking when Convex handles the concurrent requests correctly
-        const PAGE_SIZE = 16;
-        for (let i = 0; i < convexDocuments.length; i += PAGE_SIZE) {
-            await Promise.all(convexDocuments.slice(i, i + PAGE_SIZE).map((document) => this.ctx.runMutation(this.insert, {
-                table: this.table,
-                document,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            })));
-        }
-    }
-    /**
-     * Add documents to the Convex table. It first converts
-     * the documents to vectors using the embeddings and then calls the
-     * addVectors method.
-     * @param documents Documents to be added.
-     * @returns Promise that resolves when the documents have been added.
-     */
-    async addDocuments(documents) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
-    }
-    /**
-     * Similarity search on the vectors stored in the
-     * Convex table. It returns a list of documents and their
-     * corresponding similarity scores.
-     * @param query Query vector for the similarity search.
-     * @param k Number of nearest neighbors to return.
-     * @param filter Optional filter to be applied.
-     * @returns Promise that resolves to a list of documents and their corresponding similarity scores.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        const idsAndScores = await this.ctx.vectorSearch(this.table, this.index, {
-            vector: query,
-            limit: k,
-            filter: filter?.filter,
-        });
-        const documents = await Promise.all(idsAndScores.map(({ _id }) => 
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.ctx.runQuery(this.get, { id: _id })));
-        return documents.map(({ [this.textField]: text, [this.embeddingField]: embedding, [this.metadataField]: metadata, }, idx) => [
-            new Document({
-                pageContent: text,
-                metadata: {
-                    ...metadata,
-                    ...(filter?.includeEmbeddings ? { embedding } : null),
-                },
-            }),
-            idsAndScores[idx]._score,
-        ]);
-    }
-    /**
-     * Static method to create an instance of ConvexVectorStore from a
-     * list of texts. It first converts the texts to vectors and then adds
-     * them to the Convex table.
-     * @param texts List of texts to be converted to vectors.
-     * @param metadatas Metadata for the texts.
-     * @param embeddings Embeddings to be used for conversion.
-     * @param dbConfig Database configuration for Convex.
-     * @returns Promise that resolves to a new instance of ConvexVectorStore.
-     */
-    static async fromTexts(texts, metadatas, embeddings, dbConfig) {
-        const docs = texts.map((text, i) => new Document({
-            pageContent: text,
-            metadata: Array.isArray(metadatas) ? metadatas[i] : metadatas,
-        }));
-        return ConvexVectorStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Static method to create an instance of ConvexVectorStore from a
-     * list of documents. It first converts the documents to vectors and then
-     * adds them to the Convex table.
-     * @param docs List of documents to be converted to vectors.
-     * @param embeddings Embeddings to be used for conversion.
-     * @param dbConfig Database configuration for Convex.
-     * @returns Promise that resolves to a new instance of ConvexVectorStore.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-}
+export * from "@langchain/community/vectorstores/convex";

package/dist/vectorstores/elasticsearch.cjs

@@ -10,292 +10,8 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElasticVectorSearch = void 0;
-const uuid = __importStar(require("uuid"));
-const document_js_1 = require("../document.cjs");
-const base_js_1 = require("./base.cjs");
-/**
- * Class for interacting with an Elasticsearch database. It extends the
- * VectorStore base class and provides methods for adding documents and
- * vectors to the Elasticsearch database, performing similarity searches,
- * deleting documents, and more.
- */
-class ElasticVectorSearch extends base_js_1.VectorStore {
-    _vectorstoreType() {
-        return "elasticsearch";
-    }
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        Object.defineProperty(this, "client", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "indexName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "engine", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "similarity", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "efConstruction", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "m", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "candidates", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.engine = args.vectorSearchOptions?.engine ?? "hnsw";
-        this.similarity = args.vectorSearchOptions?.similarity ?? "l2_norm";
-        this.m = args.vectorSearchOptions?.m ?? 16;
-        this.efConstruction = args.vectorSearchOptions?.efConstruction ?? 100;
-        this.candidates = args.vectorSearchOptions?.candidates ?? 200;
-        this.client = args.client.child({
-            headers: { "user-agent": "langchain-js-vs/0.0.1" },
-        });
-        this.indexName = args.indexName ?? "documents";
-    }
-    /**
-     * Method to add documents to the Elasticsearch database. It first
-     * converts the documents to vectors using the embeddings, then adds the
-     * vectors to the database.
-     * @param documents The documents to add to the database.
-     * @param options Optional parameter that can contain the IDs for the documents.
-     * @returns A promise that resolves with the IDs of the added documents.
-     */
-    async addDocuments(documents, options) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
-    }
-    /**
-     * Method to add vectors to the Elasticsearch database. It ensures the
-     * index exists, then adds the vectors and their corresponding documents
-     * to the database.
-     * @param vectors The vectors to add to the database.
-     * @param documents The documents corresponding to the vectors.
-     * @param options Optional parameter that can contain the IDs for the documents.
-     * @returns A promise that resolves with the IDs of the added documents.
-     */
-    async addVectors(vectors, documents, options) {
-        await this.ensureIndexExists(vectors[0].length, this.engine, this.similarity, this.efConstruction, this.m);
-        const documentIds = options?.ids ?? Array.from({ length: vectors.length }, () => uuid.v4());
-        const operations = vectors.flatMap((embedding, idx) => [
-            {
-                index: {
-                    _id: documentIds[idx],
-                    _index: this.indexName,
-                },
-            },
-            {
-                embedding,
-                metadata: documents[idx].metadata,
-                text: documents[idx].pageContent,
-            },
-        ]);
-        await this.client.bulk({ refresh: true, operations });
-        return documentIds;
-    }
-    /**
-     * Method to perform a similarity search in the Elasticsearch database
-     * using a vector. It returns the k most similar documents along with
-     * their similarity scores.
-     * @param query The query vector.
-     * @param k The number of most similar documents to return.
-     * @param filter Optional filter to apply to the search.
-     * @returns A promise that resolves with an array of tuples, where each tuple contains a Document and its similarity score.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        const result = await this.client.search({
-            index: this.indexName,
-            size: k,
-            knn: {
-                field: "embedding",
-                query_vector: query,
-                filter: this.buildMetadataTerms(filter),
-                k,
-                num_candidates: this.candidates,
-            },
-        });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return result.hits.hits.map((hit) => [
-            new document_js_1.Document({
-                pageContent: hit._source.text,
-                metadata: hit._source.metadata,
-            }),
-            hit._score,
-        ]);
-    }
-    /**
-     * Method to delete documents from the Elasticsearch database.
-     * @param params Object containing the IDs of the documents to delete.
-     * @returns A promise that resolves when the deletion is complete.
-     */
-    async delete(params) {
-        const operations = params.ids.map((id) => ({
-            delete: {
-                _id: id,
-                _index: this.indexName,
-            },
-        }));
-        await this.client.bulk({ refresh: true, operations });
-    }
-    /**
-     * Static method to create an ElasticVectorSearch instance from texts. It
-     * creates Document instances from the texts and their corresponding
-     * metadata, then calls the fromDocuments method to create the
-     * ElasticVectorSearch instance.
-     * @param texts The texts to create the ElasticVectorSearch instance from.
-     * @param metadatas The metadata corresponding to the texts.
-     * @param embeddings The embeddings to use for the documents.
-     * @param args The arguments to create the Elasticsearch client.
-     * @returns A promise that resolves with the created ElasticVectorSearch instance.
-     */
-    static fromTexts(texts, metadatas, embeddings, args) {
-        const documents = texts.map((text, idx) => {
-            const metadata = Array.isArray(metadatas) ? metadatas[idx] : metadatas;
-            return new document_js_1.Document({ pageContent: text, metadata });
-        });
-        return ElasticVectorSearch.fromDocuments(documents, embeddings, args);
-    }
-    /**
-     * Static method to create an ElasticVectorSearch instance from Document
-     * instances. It adds the documents to the Elasticsearch database, then
-     * returns the ElasticVectorSearch instance.
-     * @param docs The Document instances to create the ElasticVectorSearch instance from.
-     * @param embeddings The embeddings to use for the documents.
-     * @param dbConfig The configuration for the Elasticsearch database.
-     * @returns A promise that resolves with the created ElasticVectorSearch instance.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const store = new ElasticVectorSearch(embeddings, dbConfig);
-        await store.addDocuments(docs).then(() => store);
-        return store;
-    }
-    /**
-     * Static method to create an ElasticVectorSearch instance from an
-     * existing index in the Elasticsearch database. It checks if the index
-     * exists, then returns the ElasticVectorSearch instance if it does.
-     * @param embeddings The embeddings to use for the documents.
-     * @param dbConfig The configuration for the Elasticsearch database.
-     * @returns A promise that resolves with the created ElasticVectorSearch instance if the index exists, otherwise it throws an error.
-     */
-    static async fromExistingIndex(embeddings, dbConfig) {
-        const store = new ElasticVectorSearch(embeddings, dbConfig);
-        const exists = await store.doesIndexExist();
-        if (exists) {
-            return store;
-        }
-        throw new Error(`The index ${store.indexName} does not exist.`);
-    }
-    async ensureIndexExists(dimension, engine = "hnsw", similarity = "l2_norm", efConstruction = 100, m = 16) {
-        const request = {
-            index: this.indexName,
-            mappings: {
-                dynamic_templates: [
-                    {
-                        // map all metadata properties to be keyword
-                        "metadata.*": {
-                            match_mapping_type: "*",
-                            mapping: { type: "keyword" },
-                        },
-                    },
-                ],
-                properties: {
-                    text: { type: "text" },
-                    metadata: { type: "object" },
-                    embedding: {
-                        type: "dense_vector",
-                        dims: dimension,
-                        index: true,
-                        similarity,
-                        index_options: {
-                            type: engine,
-                            m,
-                            ef_construction: efConstruction,
-                        },
-                    },
-                },
-            },
-        };
-        const indexExists = await this.doesIndexExist();
-        if (indexExists)
-            return;
-        await this.client.indices.create(request);
-    }
-    buildMetadataTerms(filter
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) {
-        if (filter == null)
-            return [];
-        const result = [];
-        const filters = Array.isArray(filter)
-            ? filter
-            : Object.entries(filter).map(([key, value]) => ({
-                operator: "term",
-                field: key,
-                value,
-            }));
-        for (const condition of filters) {
-            result.push({
-                [condition.operator]: {
-                    [`metadata.${condition.field}`]: condition.value,
-                },
-            });
-        }
-        return result;
-    }
-    /**
-     * Method to check if an index exists in the Elasticsearch database.
-     * @returns A promise that resolves with a boolean indicating whether the index exists.
-     */
-    async doesIndexExist() {
-        return await this.client.indices.exists({ index: this.indexName });
-    }
-    /**
-     * Method to delete an index from the Elasticsearch database if it exists.
-     * @returns A promise that resolves when the deletion is complete.
-     */
-    async deleteIfExists() {
-        const indexExists = await this.doesIndexExist();
-        if (!indexExists)
-            return;
-        await this.client.indices.delete({ index: this.indexName });
-    }
-}
-exports.ElasticVectorSearch = ElasticVectorSearch;
+__exportStar(require("@langchain/community/vectorstores/elasticsearch"), exports);

package/dist/vectorstores/elasticsearch.d.ts

@@ -1,143 +1 @@
-import { Client } from "@elastic/elasticsearch";
-import { Embeddings } from "../embeddings/base.js";
-import { Document } from "../document.js";
-import { VectorStore } from "./base.js";
-/**
- * Type representing the k-nearest neighbors (k-NN) engine used in
- * Elasticsearch.
- */
-type ElasticKnnEngine = "hnsw";
-/**
- * Type representing the similarity measure used in Elasticsearch.
- */
-type ElasticSimilarity = "l2_norm" | "dot_product" | "cosine";
-/**
- * Interface defining the options for vector search in Elasticsearch.
- */
-interface VectorSearchOptions {
-    readonly engine?: ElasticKnnEngine;
-    readonly similarity?: ElasticSimilarity;
-    readonly m?: number;
-    readonly efConstruction?: number;
-    readonly candidates?: number;
-}
-/**
- * Interface defining the arguments required to create an Elasticsearch
- * client.
- */
-export interface ElasticClientArgs {
-    readonly client: Client;
-    readonly indexName?: string;
-    readonly vectorSearchOptions?: VectorSearchOptions;
-}
-/**
- * Type representing a filter object in Elasticsearch.
- */
-type ElasticFilter = object | {
-    field: string;
-    operator: string;
-    value: any;
-}[];
-/**
- * Class for interacting with an Elasticsearch database. It extends the
- * VectorStore base class and provides methods for adding documents and
- * vectors to the Elasticsearch database, performing similarity searches,
- * deleting documents, and more.
- */
-export declare class ElasticVectorSearch extends VectorStore {
-    FilterType: ElasticFilter;
-    private readonly client;
-    private readonly indexName;
-    private readonly engine;
-    private readonly similarity;
-    private readonly efConstruction;
-    private readonly m;
-    private readonly candidates;
-    _vectorstoreType(): string;
-    constructor(embeddings: Embeddings, args: ElasticClientArgs);
-    /**
-     * Method to add documents to the Elasticsearch database. It first
-     * converts the documents to vectors using the embeddings, then adds the
-     * vectors to the database.
-     * @param documents The documents to add to the database.
-     * @param options Optional parameter that can contain the IDs for the documents.
-     * @returns A promise that resolves with the IDs of the added documents.
-     */
-    addDocuments(documents: Document[], options?: {
-        ids?: string[];
-    }): Promise<string[]>;
-    /**
-     * Method to add vectors to the Elasticsearch database. It ensures the
-     * index exists, then adds the vectors and their corresponding documents
-     * to the database.
-     * @param vectors The vectors to add to the database.
-     * @param documents The documents corresponding to the vectors.
-     * @param options Optional parameter that can contain the IDs for the documents.
-     * @returns A promise that resolves with the IDs of the added documents.
-     */
-    addVectors(vectors: number[][], documents: Document[], options?: {
-        ids?: string[];
-    }): Promise<string[]>;
-    /**
-     * Method to perform a similarity search in the Elasticsearch database
-     * using a vector. It returns the k most similar documents along with
-     * their similarity scores.
-     * @param query The query vector.
-     * @param k The number of most similar documents to return.
-     * @param filter Optional filter to apply to the search.
-     * @returns A promise that resolves with an array of tuples, where each tuple contains a Document and its similarity score.
-     */
-    similaritySearchVectorWithScore(query: number[], k: number, filter?: ElasticFilter): Promise<[Document, number][]>;
-    /**
-     * Method to delete documents from the Elasticsearch database.
-     * @param params Object containing the IDs of the documents to delete.
-     * @returns A promise that resolves when the deletion is complete.
-     */
-    delete(params: {
-        ids: string[];
-    }): Promise<void>;
-    /**
-     * Static method to create an ElasticVectorSearch instance from texts. It
-     * creates Document instances from the texts and their corresponding
-     * metadata, then calls the fromDocuments method to create the
-     * ElasticVectorSearch instance.
-     * @param texts The texts to create the ElasticVectorSearch instance from.
-     * @param metadatas The metadata corresponding to the texts.
-     * @param embeddings The embeddings to use for the documents.
-     * @param args The arguments to create the Elasticsearch client.
-     * @returns A promise that resolves with the created ElasticVectorSearch instance.
-     */
-    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, args: ElasticClientArgs): Promise<ElasticVectorSearch>;
-    /**
-     * Static method to create an ElasticVectorSearch instance from Document
-     * instances. It adds the documents to the Elasticsearch database, then
-     * returns the ElasticVectorSearch instance.
-     * @param docs The Document instances to create the ElasticVectorSearch instance from.
-     * @param embeddings The embeddings to use for the documents.
-     * @param dbConfig The configuration for the Elasticsearch database.
-     * @returns A promise that resolves with the created ElasticVectorSearch instance.
-     */
-    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: ElasticClientArgs): Promise<ElasticVectorSearch>;
-    /**
-     * Static method to create an ElasticVectorSearch instance from an
-     * existing index in the Elasticsearch database. It checks if the index
-     * exists, then returns the ElasticVectorSearch instance if it does.
-     * @param embeddings The embeddings to use for the documents.
-     * @param dbConfig The configuration for the Elasticsearch database.
-     * @returns A promise that resolves with the created ElasticVectorSearch instance if the index exists, otherwise it throws an error.
-     */
-    static fromExistingIndex(embeddings: Embeddings, dbConfig: ElasticClientArgs): Promise<ElasticVectorSearch>;
-    private ensureIndexExists;
-    private buildMetadataTerms;
-    /**
-     * Method to check if an index exists in the Elasticsearch database.
-     * @returns A promise that resolves with a boolean indicating whether the index exists.
-     */
-    doesIndexExist(): Promise<boolean>;
-    /**
-     * Method to delete an index from the Elasticsearch database if it exists.
-     * @returns A promise that resolves when the deletion is complete.
-     */
-    deleteIfExists(): Promise<void>;
-}
-export {};
+export * from "@langchain/community/vectorstores/elasticsearch";