langchain 0.0.202 → 0.0.204-rc.0

package/dist/util/math.d.ts

@@ -1,40 +1 @@
-type VectorFunction = (xVector: number[], yVector: number[]) => number;
-/**
- * Apply a row-wise function between two matrices with the same number of columns.
- *
- * @param {number[][]} X - The first matrix.
- * @param {number[][]} Y - The second matrix.
- * @param {VectorFunction} func - The function to apply.
- *
- * @throws {Error} If the number of columns in X and Y are not the same.
- *
- * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.
- */
-export declare function matrixFunc(X: number[][], Y: number[][], func: VectorFunction): number[][];
-export declare function normalize(M: number[][], similarity?: boolean): number[][];
-/**
- * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
- *
- * @param {number[][]} X - The first matrix.
- * @param {number[][]} Y - The second matrix.
- *
- * @throws {Error} If the number of columns in X and Y are not the same.
- *
- * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
- */
-export declare function cosineSimilarity(X: number[][], Y: number[][]): number[][];
-export declare function innerProduct(X: number[][], Y: number[][]): number[][];
-export declare function euclideanDistance(X: number[][], Y: number[][]): number[][];
-/**
- * This function implements the Maximal Marginal Relevance algorithm
- * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
- *
- * @param {number[]|number[][]} queryEmbedding - The query embedding.
- * @param {number[][]} embeddingList - The list of embeddings to select from.
- * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.
- * @param {number} [k=4] - The maximum number of embeddings to select.
- *
- * @returns {number[]} The indexes of the selected embeddings in the embeddingList.
- */
-export declare function maximalMarginalRelevance(queryEmbedding: number[] | number[][], embeddingList: number[][], lambda?: number, k?: number): number[];
-export {};
+export * from "@langchain/core/utils/math";

package/dist/util/math.js

@@ -1,116 +1 @@
-import { similarity as ml_distance_similarity, distance as ml_distance, } from "ml-distance";
-/**
- * Apply a row-wise function between two matrices with the same number of columns.
- *
- * @param {number[][]} X - The first matrix.
- * @param {number[][]} Y - The second matrix.
- * @param {VectorFunction} func - The function to apply.
- *
- * @throws {Error} If the number of columns in X and Y are not the same.
- *
- * @returns {number[][] | [[]]} A matrix where each row represents the result of applying the function between the corresponding rows of X and Y.
- */
-export function matrixFunc(X, Y, func) {
-    if (X.length === 0 ||
-        X[0].length === 0 ||
-        Y.length === 0 ||
-        Y[0].length === 0) {
-        return [[]];
-    }
-    if (X[0].length !== Y[0].length) {
-        throw new Error(`Number of columns in X and Y must be the same. X has shape ${[
-            X.length,
-            X[0].length,
-        ]} and Y has shape ${[Y.length, Y[0].length]}.`);
-    }
-    return X.map((xVector) => Y.map((yVector) => func(xVector, yVector)).map((similarity) => Number.isNaN(similarity) ? 0 : similarity));
-}
-export function normalize(M, similarity = false) {
-    const max = matrixMaxVal(M);
-    return M.map((row) => row.map((val) => (similarity ? 1 - val / max : val / max)));
-}
-/**
- * This function calculates the row-wise cosine similarity between two matrices with the same number of columns.
- *
- * @param {number[][]} X - The first matrix.
- * @param {number[][]} Y - The second matrix.
- *
- * @throws {Error} If the number of columns in X and Y are not the same.
- *
- * @returns {number[][] | [[]]} A matrix where each row represents the cosine similarity values between the corresponding rows of X and Y.
- */
-export function cosineSimilarity(X, Y) {
-    return matrixFunc(X, Y, ml_distance_similarity.cosine);
-}
-export function innerProduct(X, Y) {
-    return matrixFunc(X, Y, ml_distance.innerProduct);
-}
-export function euclideanDistance(X, Y) {
-    return matrixFunc(X, Y, ml_distance.euclidean);
-}
-/**
- * This function implements the Maximal Marginal Relevance algorithm
- * to select a set of embeddings that maximizes the diversity and relevance to a query embedding.
- *
- * @param {number[]|number[][]} queryEmbedding - The query embedding.
- * @param {number[][]} embeddingList - The list of embeddings to select from.
- * @param {number} [lambda=0.5] - The trade-off parameter between relevance and diversity.
- * @param {number} [k=4] - The maximum number of embeddings to select.
- *
- * @returns {number[]} The indexes of the selected embeddings in the embeddingList.
- */
-export function maximalMarginalRelevance(queryEmbedding, embeddingList, lambda = 0.5, k = 4) {
-    if (Math.min(k, embeddingList.length) <= 0) {
-        return [];
-    }
-    const queryEmbeddingExpanded = (Array.isArray(queryEmbedding[0]) ? queryEmbedding : [queryEmbedding]);
-    const similarityToQuery = cosineSimilarity(queryEmbeddingExpanded, embeddingList)[0];
-    const mostSimilarEmbeddingIndex = argMax(similarityToQuery).maxIndex;
-    const selectedEmbeddings = [embeddingList[mostSimilarEmbeddingIndex]];
-    const selectedEmbeddingsIndexes = [mostSimilarEmbeddingIndex];
-    while (selectedEmbeddingsIndexes.length < Math.min(k, embeddingList.length)) {
-        let bestScore = -Infinity;
-        let bestIndex = -1;
-        const similarityToSelected = cosineSimilarity(embeddingList, selectedEmbeddings);
-        similarityToQuery.forEach((queryScore, queryScoreIndex) => {
-            if (selectedEmbeddingsIndexes.includes(queryScoreIndex)) {
-                return;
-            }
-            const maxSimilarityToSelected = Math.max(...similarityToSelected[queryScoreIndex]);
-            const score = lambda * queryScore - (1 - lambda) * maxSimilarityToSelected;
-            if (score > bestScore) {
-                bestScore = score;
-                bestIndex = queryScoreIndex;
-            }
-        });
-        selectedEmbeddings.push(embeddingList[bestIndex]);
-        selectedEmbeddingsIndexes.push(bestIndex);
-    }
-    return selectedEmbeddingsIndexes;
-}
-/**
- * Finds the index of the maximum value in the given array.
- * @param {number[]} array - The input array.
- *
- * @returns {number} The index of the maximum value in the array. If the array is empty, returns -1.
- */
-function argMax(array) {
-    if (array.length === 0) {
-        return {
-            maxIndex: -1,
-            maxValue: NaN,
-        };
-    }
-    let maxValue = array[0];
-    let maxIndex = 0;
-    for (let i = 1; i < array.length; i += 1) {
-        if (array[i] > maxValue) {
-            maxIndex = i;
-            maxValue = array[i];
-        }
-    }
-    return { maxIndex, maxValue };
-}
-function matrixMaxVal(arrays) {
-    return arrays.reduce((acc, array) => Math.max(acc, argMax(array).maxValue), 0);
-}
+export * from "@langchain/core/utils/math";

package/dist/util/openapi.d.ts

@@ -7,7 +7,7 @@ export declare class OpenAPISpec {
     getParametersStrict(): Record<string, OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject>;
     getSchemasStrict(): Record<string, OpenAPIV3_1.SchemaObject>;
     getRequestBodiesStrict(): Record<string, OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.RequestBodyObject>;
-    getPathStrict(path: string): Omit<OpenAPIV3.PathItemObject<{}>, "parameters" | "servers"> & {
+    getPathStrict(path: string): Omit<OpenAPIV3.PathItemObject<{}>, "servers" | "parameters"> & {
         servers?: OpenAPIV3_1.ServerObject[] | undefined;
         parameters?: (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[] | undefined;
     } & {
@@ -59,7 +59,7 @@ export declare class OpenAPISpec {
         deprecated?: boolean | undefined;
         security?: OpenAPIV3.SecurityRequirementObject[] | undefined;
         servers?: OpenAPIV3.ServerObject[] | undefined;
-    }, "callbacks" | "parameters" | "servers" | "responses" | "requestBody"> & {
+    }, "callbacks" | "servers" | "parameters" | "responses" | "requestBody"> & {
         parameters?: (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[] | undefined;
         requestBody?: OpenAPIV3_1.ReferenceObject | OpenAPIV3_1.RequestBodyObject | undefined;
         responses?: OpenAPIV3_1.ResponsesObject | undefined;

package/dist/vectorstores/analyticdb.cjs

@@ -10,338 +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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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.AnalyticDBVectorStore = void 0;
-const uuid = __importStar(require("uuid"));
-const pg_1 = __importDefault(require("pg"));
-const pg_copy_streams_1 = require("pg-copy-streams");
-const promises_1 = require("node:stream/promises");
-const node_stream_1 = require("node:stream");
-const base_js_1 = require("./base.cjs");
-const document_js_1 = require("../document.cjs");
-const _LANGCHAIN_DEFAULT_COLLECTION_NAME = "langchain_document";
-/**
- * Class that provides methods for creating and managing a collection of
- * documents in an AnalyticDB, adding documents or vectors to the
- * collection, performing similarity search on vectors, and creating an
- * instance of `AnalyticDBVectorStore` from texts or documents.
- */
-class AnalyticDBVectorStore extends base_js_1.VectorStore {
-    _vectorstoreType() {
-        return "analyticdb";
-    }
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        Object.defineProperty(this, "pool", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "embeddingDimension", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "collectionName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "preDeleteCollection", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "isCreateCollection", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        this.pool = new pg_1.default.Pool({
-            host: args.connectionOptions.host,
-            port: args.connectionOptions.port,
-            database: args.connectionOptions.database,
-            user: args.connectionOptions.user,
-            password: args.connectionOptions.password,
-        });
-        this.embeddingDimension = args.embeddingDimension;
-        this.collectionName =
-            args.collectionName || _LANGCHAIN_DEFAULT_COLLECTION_NAME;
-        this.preDeleteCollection = args.preDeleteCollection || false;
-    }
-    /**
-     * Closes all the clients in the pool and terminates the pool.
-     * @returns Promise that resolves when all clients are closed and the pool is terminated.
-     */
-    async end() {
-        return this.pool.end();
-    }
-    /**
-     * Creates a new table in the database if it does not already exist. The
-     * table is created with columns for id, embedding, document, and
-     * metadata. An index is also created on the embedding column if it does
-     * not already exist.
-     * @returns Promise that resolves when the table and index are created.
-     */
-    async createTableIfNotExists() {
-        if (!this.embeddingDimension) {
-            this.embeddingDimension = (await this.embeddings.embedQuery("test")).length;
-        }
-        const client = await this.pool.connect();
-        try {
-            await client.query("BEGIN");
-            // Create the table if it doesn't exist
-            await client.query(`
-        CREATE TABLE IF NOT EXISTS ${this.collectionName} (
-          id TEXT PRIMARY KEY DEFAULT NULL,
-          embedding REAL[],
-          document TEXT,
-          metadata JSON
-        );
-      `);
-            // Check if the index exists
-            const indexName = `${this.collectionName}_embedding_idx`;
-            const indexQuery = `
-        SELECT 1
-        FROM pg_indexes
-        WHERE indexname = '${indexName}';
-      `;
-            const result = await client.query(indexQuery);
-            // Create the index if it doesn't exist
-            if (result.rowCount === 0) {
-                const indexStatement = `
-          CREATE INDEX ${indexName}
-          ON ${this.collectionName} USING ann(embedding)
-          WITH (
-            "dim" = ${this.embeddingDimension},
-            "hnsw_m" = 100
-          );
-        `;
-                await client.query(indexStatement);
-            }
-            await client.query("COMMIT");
-        }
-        catch (err) {
-            await client.query("ROLLBACK");
-            throw err;
-        }
-        finally {
-            client.release();
-        }
-    }
-    /**
-     * Deletes the collection from the database if it exists.
-     * @returns Promise that resolves when the collection is deleted.
-     */
-    async deleteCollection() {
-        const dropStatement = `DROP TABLE IF EXISTS ${this.collectionName};`;
-        await this.pool.query(dropStatement);
-    }
-    /**
-     * Creates a new collection in the database. If `preDeleteCollection` is
-     * true, any existing collection with the same name is deleted before the
-     * new collection is created.
-     * @returns Promise that resolves when the collection is created.
-     */
-    async createCollection() {
-        if (this.preDeleteCollection) {
-            await this.deleteCollection();
-        }
-        await this.createTableIfNotExists();
-        this.isCreateCollection = true;
-    }
-    /**
-     * Adds an array of documents to the collection. The documents are first
-     * converted to vectors using the `embedDocuments` method of the
-     * `embeddings` instance.
-     * @param documents Array of Document instances to be added to the collection.
-     * @returns Promise that resolves when the documents are added.
-     */
-    async addDocuments(documents) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
-    }
-    /**
-     * Adds an array of vectors and corresponding documents to the collection.
-     * The vectors and documents are batch inserted into the database.
-     * @param vectors Array of vectors to be added to the collection.
-     * @param documents Array of Document instances corresponding to the vectors.
-     * @returns Promise that resolves when the vectors and documents are added.
-     */
-    async addVectors(vectors, documents) {
-        if (vectors.length === 0) {
-            return;
-        }
-        if (vectors.length !== documents.length) {
-            throw new Error(`Vectors and documents must have the same length`);
-        }
-        if (!this.embeddingDimension) {
-            this.embeddingDimension = (await this.embeddings.embedQuery("test")).length;
-        }
-        if (vectors[0].length !== this.embeddingDimension) {
-            throw new Error(`Vectors must have the same length as the number of dimensions (${this.embeddingDimension})`);
-        }
-        if (!this.isCreateCollection) {
-            await this.createCollection();
-        }
-        const client = await this.pool.connect();
-        try {
-            const chunkSize = 500;
-            const chunksTableData = [];
-            for (let i = 0; i < documents.length; i += 1) {
-                chunksTableData.push({
-                    id: uuid.v4(),
-                    embedding: vectors[i],
-                    document: documents[i].pageContent,
-                    metadata: documents[i].metadata,
-                });
-                // Execute the batch insert when the batch size is reached
-                if (chunksTableData.length === chunkSize) {
-                    const rs = new node_stream_1.Readable();
-                    let currentIndex = 0;
-                    rs._read = function () {
-                        if (currentIndex === chunkSize) {
-                            rs.push(null);
-                        }
-                        else {
-                            const data = chunksTableData[currentIndex];
-                            rs.push(`${data.id}\t{${data.embedding.join(",")}}\t${data.document}\t${JSON.stringify(data.metadata)}\n`);
-                            currentIndex += 1;
-                        }
-                    };
-                    const ws = client.query((0, pg_copy_streams_1.from)(`COPY ${this.collectionName}(id, embedding, document, metadata) FROM STDIN`));
-                    await (0, promises_1.pipeline)(rs, ws);
-                    // Clear the chunksTableData list for the next batch
-                    chunksTableData.length = 0;
-                }
-            }
-            // Insert any remaining records that didn't make up a full batch
-            if (chunksTableData.length > 0) {
-                const rs = new node_stream_1.Readable();
-                let currentIndex = 0;
-                rs._read = function () {
-                    if (currentIndex === chunksTableData.length) {
-                        rs.push(null);
-                    }
-                    else {
-                        const data = chunksTableData[currentIndex];
-                        rs.push(`${data.id}\t{${data.embedding.join(",")}}\t${data.document}\t${JSON.stringify(data.metadata)}\n`);
-                        currentIndex += 1;
-                    }
-                };
-                const ws = client.query((0, pg_copy_streams_1.from)(`COPY ${this.collectionName}(id, embedding, document, metadata) FROM STDIN`));
-                await (0, promises_1.pipeline)(rs, ws);
-            }
-        }
-        finally {
-            client.release();
-        }
-    }
-    /**
-     * Performs a similarity search on the vectors in the collection. The
-     * search is performed using the given query vector and returns the top k
-     * most similar vectors along with their corresponding documents and
-     * similarity scores.
-     * @param query Query vector for the similarity search.
-     * @param k Number of top similar vectors to return.
-     * @param filter Optional. Filter to apply on the metadata of the documents.
-     * @returns Promise that resolves to an array of tuples, each containing a Document instance and its similarity score.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
-        if (!this.isCreateCollection) {
-            await this.createCollection();
-        }
-        let filterCondition = "";
-        const filterEntries = filter ? Object.entries(filter) : [];
-        if (filterEntries.length > 0) {
-            const conditions = filterEntries.map((_, index) => `metadata->>$${2 * index + 3} = $${2 * index + 4}`);
-            filterCondition = `WHERE ${conditions.join(" AND ")}`;
-        }
-        const sqlQuery = `
-      SELECT *, l2_distance(embedding, $1::real[]) AS distance
-      FROM ${this.collectionName}
-      ${filterCondition}
-      ORDER BY embedding <-> $1
-      LIMIT $2;
-    `;
-        // Execute the query and fetch the results
-        const { rows } = await this.pool.query(sqlQuery, [
-            query,
-            k,
-            ...filterEntries.flatMap(([key, value]) => [key, value]),
-        ]);
-        const result = rows.map((row) => [
-            new document_js_1.Document({ pageContent: row.document, metadata: row.metadata }),
-            row.distance,
-        ]);
-        return result;
-    }
-    /**
-     * Creates an instance of `AnalyticDBVectorStore` from an array of texts
-     * and corresponding metadata. The texts are first converted to Document
-     * instances before being added to the collection.
-     * @param texts Array of texts to be added to the collection.
-     * @param metadatas Array or object of metadata corresponding to the texts.
-     * @param embeddings Embeddings instance used to convert the texts to vectors.
-     * @param dbConfig Configuration for the AnalyticDB.
-     * @returns Promise that resolves to an instance of `AnalyticDBVectorStore`.
-     */
-    static async fromTexts(texts, metadatas, embeddings, dbConfig) {
-        const docs = [];
-        for (let i = 0; i < texts.length; i += 1) {
-            const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;
-            const newDoc = new document_js_1.Document({
-                pageContent: texts[i],
-                metadata,
-            });
-            docs.push(newDoc);
-        }
-        return AnalyticDBVectorStore.fromDocuments(docs, embeddings, dbConfig);
-    }
-    /**
-     * Creates an instance of `AnalyticDBVectorStore` from an array of
-     * Document instances. The documents are added to the collection.
-     * @param docs Array of Document instances to be added to the collection.
-     * @param embeddings Embeddings instance used to convert the documents to vectors.
-     * @param dbConfig Configuration for the AnalyticDB.
-     * @returns Promise that resolves to an instance of `AnalyticDBVectorStore`.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        await instance.addDocuments(docs);
-        return instance;
-    }
-    /**
-     * Creates an instance of `AnalyticDBVectorStore` from an existing index
-     * in the database. A new collection is created in the database.
-     * @param embeddings Embeddings instance used to convert the documents to vectors.
-     * @param dbConfig Configuration for the AnalyticDB.
-     * @returns Promise that resolves to an instance of `AnalyticDBVectorStore`.
-     */
-    static async fromExistingIndex(embeddings, dbConfig) {
-        const instance = new this(embeddings, dbConfig);
-        await instance.createCollection();
-        return instance;
-    }
-}
-exports.AnalyticDBVectorStore = AnalyticDBVectorStore;
+__exportStar(require("@langchain/community/vectorstores/analyticdb"), exports);

package/dist/vectorstores/analyticdb.d.ts

@@ -1,110 +1 @@
-import { PoolConfig } from "pg";
-import { VectorStore } from "./base.js";
-import { Embeddings } from "../embeddings/base.js";
-import { Document } from "../document.js";
-/**
- * Interface defining the arguments required to create an instance of
- * `AnalyticDBVectorStore`.
- */
-export interface AnalyticDBArgs {
-    connectionOptions: PoolConfig;
-    embeddingDimension?: number;
-    collectionName?: string;
-    preDeleteCollection?: boolean;
-}
-/**
- * Class that provides methods for creating and managing a collection of
- * documents in an AnalyticDB, adding documents or vectors to the
- * collection, performing similarity search on vectors, and creating an
- * instance of `AnalyticDBVectorStore` from texts or documents.
- */
-export declare class AnalyticDBVectorStore extends VectorStore {
-    FilterType: Record<string, any>;
-    private pool;
-    private embeddingDimension?;
-    private collectionName;
-    private preDeleteCollection;
-    private isCreateCollection;
-    _vectorstoreType(): string;
-    constructor(embeddings: Embeddings, args: AnalyticDBArgs);
-    /**
-     * Closes all the clients in the pool and terminates the pool.
-     * @returns Promise that resolves when all clients are closed and the pool is terminated.
-     */
-    end(): Promise<void>;
-    /**
-     * Creates a new table in the database if it does not already exist. The
-     * table is created with columns for id, embedding, document, and
-     * metadata. An index is also created on the embedding column if it does
-     * not already exist.
-     * @returns Promise that resolves when the table and index are created.
-     */
-    createTableIfNotExists(): Promise<void>;
-    /**
-     * Deletes the collection from the database if it exists.
-     * @returns Promise that resolves when the collection is deleted.
-     */
-    deleteCollection(): Promise<void>;
-    /**
-     * Creates a new collection in the database. If `preDeleteCollection` is
-     * true, any existing collection with the same name is deleted before the
-     * new collection is created.
-     * @returns Promise that resolves when the collection is created.
-     */
-    createCollection(): Promise<void>;
-    /**
-     * Adds an array of documents to the collection. The documents are first
-     * converted to vectors using the `embedDocuments` method of the
-     * `embeddings` instance.
-     * @param documents Array of Document instances to be added to the collection.
-     * @returns Promise that resolves when the documents are added.
-     */
-    addDocuments(documents: Document[]): Promise<void>;
-    /**
-     * Adds an array of vectors and corresponding documents to the collection.
-     * The vectors and documents are batch inserted into the database.
-     * @param vectors Array of vectors to be added to the collection.
-     * @param documents Array of Document instances corresponding to the vectors.
-     * @returns Promise that resolves when the vectors and documents are added.
-     */
-    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
-    /**
-     * Performs a similarity search on the vectors in the collection. The
-     * search is performed using the given query vector and returns the top k
-     * most similar vectors along with their corresponding documents and
-     * similarity scores.
-     * @param query Query vector for the similarity search.
-     * @param k Number of top similar vectors to return.
-     * @param filter Optional. Filter to apply on the metadata of the documents.
-     * @returns Promise that resolves to an array of tuples, each containing a Document instance and its similarity score.
-     */
-    similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
-    /**
-     * Creates an instance of `AnalyticDBVectorStore` from an array of texts
-     * and corresponding metadata. The texts are first converted to Document
-     * instances before being added to the collection.
-     * @param texts Array of texts to be added to the collection.
-     * @param metadatas Array or object of metadata corresponding to the texts.
-     * @param embeddings Embeddings instance used to convert the texts to vectors.
-     * @param dbConfig Configuration for the AnalyticDB.
-     * @returns Promise that resolves to an instance of `AnalyticDBVectorStore`.
-     */
-    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: AnalyticDBArgs): Promise<AnalyticDBVectorStore>;
-    /**
-     * Creates an instance of `AnalyticDBVectorStore` from an array of
-     * Document instances. The documents are added to the collection.
-     * @param docs Array of Document instances to be added to the collection.
-     * @param embeddings Embeddings instance used to convert the documents to vectors.
-     * @param dbConfig Configuration for the AnalyticDB.
-     * @returns Promise that resolves to an instance of `AnalyticDBVectorStore`.
-     */
-    static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: AnalyticDBArgs): Promise<AnalyticDBVectorStore>;
-    /**
-     * Creates an instance of `AnalyticDBVectorStore` from an existing index
-     * in the database. A new collection is created in the database.
-     * @param embeddings Embeddings instance used to convert the documents to vectors.
-     * @param dbConfig Configuration for the AnalyticDB.
-     * @returns Promise that resolves to an instance of `AnalyticDBVectorStore`.
-     */
-    static fromExistingIndex(embeddings: Embeddings, dbConfig: AnalyticDBArgs): Promise<AnalyticDBVectorStore>;
-}
+export * from "@langchain/community/vectorstores/analyticdb";