langchain 0.0.145 → 0.0.147

package/dist/util/async_caller.js

@@ -12,6 +12,32 @@ const STATUS_NO_RETRY = [
     408,
     409, // Conflict
 ];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const defaultFailedAttemptHandler = (error) => {
+    if (error.message.startsWith("Cancel") ||
+        error.message.startsWith("TimeoutError") ||
+        error.name === "TimeoutError" ||
+        error.message.startsWith("AbortError") ||
+        error.name === "AbortError") {
+        throw error;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (error?.code === "ECONNABORTED") {
+        throw error;
+    }
+    const status = 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error?.response?.status ?? error?.status;
+    if (status && STATUS_NO_RETRY.includes(+status)) {
+        throw error;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (error?.error?.code === "insufficient_quota") {
+        const err = new Error(error?.message);
+        err.name = "InsufficientQuotaError";
+        throw err;
+    }
+};
 /**
  * A class that can be used to make async calls with concurrency and retry logic.
  *
@@ -39,6 +65,12 @@ export class AsyncCaller {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "onFailedAttempt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "queue", {
             enumerable: true,
             configurable: true,
@@ -47,6 +79,8 @@ export class AsyncCaller {
         });
         this.maxConcurrency = params.maxConcurrency ?? Infinity;
         this.maxRetries = params.maxRetries ?? 6;
+        this.onFailedAttempt =
+            params.onFailedAttempt ?? defaultFailedAttemptHandler;
         const PQueue = "default" in PQueueMod ? PQueueMod.default : PQueueMod;
         this.queue = new PQueue({ concurrency: this.maxConcurrency });
     }
@@ -61,31 +95,7 @@ export class AsyncCaller {
                 throw new Error(error);
             }
         }), {
-            onFailedAttempt(error) {
-                if (error.message.startsWith("Cancel") ||
-                    error.message.startsWith("TimeoutError") ||
-                    error.name === "TimeoutError" ||
-                    error.message.startsWith("AbortError") ||
-                    error.name === "AbortError") {
-                    throw error;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                if (error?.code === "ECONNABORTED") {
-                    throw error;
-                }
-                const status = 
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                error?.response?.status ?? error?.status;
-                if (status && STATUS_NO_RETRY.includes(+status)) {
-                    throw error;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                if (error?.error?.code === "insufficient_quota") {
-                    const err = new Error(error?.message);
-                    err.name = "InsufficientQuotaError";
-                    throw err;
-                }
-            },
+            onFailedAttempt: this.onFailedAttempt,
             retries: this.maxRetries,
             randomize: true,
             // If needed we can change some of the defaults here,

package/dist/vectorstores/pinecone.cjs

@@ -31,6 +31,8 @@ const uuid = __importStar(require("uuid"));
 const flat_1 = __importDefault(require("flat"));
 const base_js_1 = require("./base.cjs");
 const document_js_1 = require("../document.cjs");
+const chunk_js_1 = require("../util/chunk.cjs");
+const async_caller_js_1 = require("../util/async_caller.cjs");
 /**
  * Class that extends the VectorStore class and provides methods to
  * interact with the Pinecone vector database.
@@ -65,11 +67,19 @@ class PineconeStore extends base_js_1.VectorStore {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.embeddings = embeddings;
-        this.namespace = args.namespace;
-        this.pineconeIndex = args.pineconeIndex;
-        this.textKey = args.textKey ?? "text";
-        this.filter = args.filter;
+        const { namespace, pineconeIndex, textKey, filter, ...asyncCallerArgs } = args;
+        this.namespace = namespace;
+        this.pineconeIndex = pineconeIndex;
+        this.textKey = textKey ?? "text";
+        this.filter = filter;
+        this.caller = new async_caller_js_1.AsyncCaller(asyncCallerArgs);
     }
     /**
      * Method that adds documents to the Pinecone database.
@@ -126,16 +136,15 @@ class PineconeStore extends base_js_1.VectorStore {
             };
         });
         // Pinecone recommends a limit of 100 vectors per upsert request
-        const chunkSize = 50;
-        for (let i = 0; i < pineconeVectors.length; i += chunkSize) {
-            const chunk = pineconeVectors.slice(i, i + chunkSize);
-            await this.pineconeIndex.upsert({
-                upsertRequest: {
-                    vectors: chunk,
-                    namespace: this.namespace,
-                },
-            });
-        }
+        const chunkSize = 100;
+        const chunkedVectors = (0, chunk_js_1.chunkArray)(pineconeVectors, chunkSize);
+        const batchRequests = chunkedVectors.map((chunk) => this.caller.call(async () => this.pineconeIndex.upsert({
+            upsertRequest: {
+                vectors: chunk,
+                namespace: this.namespace,
+            },
+        })));
+        await Promise.all(batchRequests);
         return documentIds;
     }
     /**
@@ -154,14 +163,13 @@ class PineconeStore extends base_js_1.VectorStore {
         }
         else if (ids) {
             const batchSize = 1000;
-            for (let i = 0; i < ids.length; i += batchSize) {
-                const batchIds = ids.slice(i, i + batchSize);
-                await this.pineconeIndex.delete1({
-                    ids: batchIds,
-                    namespace,
-                    ...rest,
-                });
-            }
+            const batchedIds = (0, chunk_js_1.chunkArray)(ids, batchSize);
+            const batchRequests = batchedIds.map((batchIds) => this.caller.call(async () => this.pineconeIndex.delete1({
+                ids: batchIds,
+                namespace,
+                ...rest,
+            })));
+            await Promise.all(batchRequests);
         }
         else {
             throw new Error("Either ids or delete_all must be provided.");

package/dist/vectorstores/pinecone.d.ts

@@ -1,9 +1,10 @@
 import { VectorStore } from "./base.js";
 import { Embeddings } from "../embeddings/base.js";
 import { Document } from "../document.js";
+import { AsyncCaller, type AsyncCallerParams } from "../util/async_caller.js";
 type PineconeMetadata = Record<string, any>;
 type VectorOperationsApi = ReturnType<import("@pinecone-database/pinecone").PineconeClient["Index"]>;
-export interface PineconeLibArgs {
+export interface PineconeLibArgs extends AsyncCallerParams {
     pineconeIndex: VectorOperationsApi;
     textKey?: string;
     namespace?: string;
@@ -28,6 +29,7 @@ export declare class PineconeStore extends VectorStore {
     namespace?: string;
     pineconeIndex: VectorOperationsApi;
     filter?: PineconeMetadata;
+    caller: AsyncCaller;
     _vectorstoreType(): string;
     constructor(embeddings: Embeddings, args: PineconeLibArgs);
     /**

package/dist/vectorstores/pinecone.js

@@ -2,6 +2,8 @@ import * as uuid from "uuid";
 import flatten from "flat";
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
+import { chunkArray } from "../util/chunk.js";
+import { AsyncCaller } from "../util/async_caller.js";
 /**
  * Class that extends the VectorStore class and provides methods to
  * interact with the Pinecone vector database.
@@ -36,11 +38,19 @@ export class PineconeStore extends VectorStore {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "caller", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.embeddings = embeddings;
-        this.namespace = args.namespace;
-        this.pineconeIndex = args.pineconeIndex;
-        this.textKey = args.textKey ?? "text";
-        this.filter = args.filter;
+        const { namespace, pineconeIndex, textKey, filter, ...asyncCallerArgs } = args;
+        this.namespace = namespace;
+        this.pineconeIndex = pineconeIndex;
+        this.textKey = textKey ?? "text";
+        this.filter = filter;
+        this.caller = new AsyncCaller(asyncCallerArgs);
     }
     /**
      * Method that adds documents to the Pinecone database.
@@ -97,16 +107,15 @@ export class PineconeStore extends VectorStore {
             };
         });
         // Pinecone recommends a limit of 100 vectors per upsert request
-        const chunkSize = 50;
-        for (let i = 0; i < pineconeVectors.length; i += chunkSize) {
-            const chunk = pineconeVectors.slice(i, i + chunkSize);
-            await this.pineconeIndex.upsert({
-                upsertRequest: {
-                    vectors: chunk,
-                    namespace: this.namespace,
-                },
-            });
-        }
+        const chunkSize = 100;
+        const chunkedVectors = chunkArray(pineconeVectors, chunkSize);
+        const batchRequests = chunkedVectors.map((chunk) => this.caller.call(async () => this.pineconeIndex.upsert({
+            upsertRequest: {
+                vectors: chunk,
+                namespace: this.namespace,
+            },
+        })));
+        await Promise.all(batchRequests);
         return documentIds;
     }
     /**
@@ -125,14 +134,13 @@ export class PineconeStore extends VectorStore {
         }
         else if (ids) {
             const batchSize = 1000;
-            for (let i = 0; i < ids.length; i += batchSize) {
-                const batchIds = ids.slice(i, i + batchSize);
-                await this.pineconeIndex.delete1({
-                    ids: batchIds,
-                    namespace,
-                    ...rest,
-                });
-            }
+            const batchedIds = chunkArray(ids, batchSize);
+            const batchRequests = batchedIds.map((batchIds) => this.caller.call(async () => this.pineconeIndex.delete1({
+                ids: batchIds,
+                namespace,
+                ...rest,
+            })));
+            await Promise.all(batchRequests);
         }
         else {
             throw new Error("Either ids or delete_all must be provided.");

package/dist/vectorstores/vectara.cjs

@@ -185,42 +185,39 @@ class VectaraStore extends base_js_1.VectorStore {
      * pre-processing and chunking internally in an optimal manner. This method is a wrapper
      * to utilize that API within LangChain.
      *
-     * @param filePaths An array of Blob objects representing the files to be uploaded to Vectara.
+     * @param files An array of VectaraFile objects representing the files and their respective file names to be uploaded to Vectara.
      * @param metadata Optional. An array of metadata objects corresponding to each file in the `filePaths` array.
      * @returns A Promise that resolves to the number of successfully uploaded files.
      */
-    async addFiles(filePaths, metadatas = undefined) {
+    async addFiles(files, metadatas = undefined) {
         if (this.corpusId.length > 1)
             throw new Error("addFiles does not support multiple corpus ids");
         let numDocs = 0;
-        for (const [index, fileBlob] of filePaths.entries()) {
+        for (const [index, file] of files.entries()) {
             const md = metadatas ? metadatas[index] : {};
             const data = new FormData();
-            data.append("file", fileBlob, `file_${index}`);
+            data.append("file", file.blob, file.fileName);
             data.append("doc-metadata", JSON.stringify(md));
-            try {
-                const response = await fetch(`https://api.vectara.io/v1/upload?c=${this.customerId}&o=${this.corpusId[0]}`, {
-                    method: "POST",
-                    headers: {
-                        "x-api-key": this.apiKey,
-                    },
-                    body: data,
-                });
-                const result = await response.json();
-                const { status } = response;
-                if (status !== 200 && status !== 409) {
-                    throw new Error(`Vectara API returned status code ${status}: ${result}`);
-                }
-                else {
-                    numDocs += 1;
-                }
+            const response = await fetch(`https://api.vectara.io/v1/upload?c=${this.customerId}&o=${this.corpusId[0]}`, {
+                method: "POST",
+                headers: {
+                    "x-api-key": this.apiKey,
+                },
+                body: data,
+            });
+            const { status } = response;
+            if (status === 409) {
+                throw new Error(`File at index ${index} already exists in Vectara`);
+            }
+            else if (status !== 200) {
+                throw new Error(`Vectara API returned status code ${status}`);
             }
-            catch (err) {
-                console.error(`Failed to upload file at index ${index}:`, err);
+            else {
+                numDocs += 1;
             }
         }
         if (this.verbose) {
-            console.log(`Uploaded ${filePaths.length} files to Vectara`);
+            console.log(`Uploaded ${files.length} files to Vectara`);
         }
         return numDocs;
     }

package/dist/vectorstores/vectara.d.ts

@@ -21,6 +21,13 @@ interface VectaraCallHeader {
         "customer-id": string;
     };
 }
+/**
+ * Interface for the file objects to be uploaded to Vectara.
+ */
+export interface VectaraFile {
+    blob: Blob;
+    fileName: string;
+}
 /**
  * Interface for the filter options used in Vectara API calls.
  */
@@ -80,11 +87,11 @@ export declare class VectaraStore extends VectorStore {
      * pre-processing and chunking internally in an optimal manner. This method is a wrapper
      * to utilize that API within LangChain.
      *
-     * @param filePaths An array of Blob objects representing the files to be uploaded to Vectara.
+     * @param files An array of VectaraFile objects representing the files and their respective file names to be uploaded to Vectara.
      * @param metadata Optional. An array of metadata objects corresponding to each file in the `filePaths` array.
      * @returns A Promise that resolves to the number of successfully uploaded files.
      */
-    addFiles(filePaths: Blob[], metadatas?: Record<string, unknown> | undefined): Promise<number>;
+    addFiles(files: VectaraFile[], metadatas?: Record<string, unknown> | undefined): Promise<number>;
     /**
      * Performs a similarity search and returns documents along with their
      * scores.

package/dist/vectorstores/vectara.js

@@ -182,42 +182,39 @@ export class VectaraStore extends VectorStore {
      * pre-processing and chunking internally in an optimal manner. This method is a wrapper
      * to utilize that API within LangChain.
      *
-     * @param filePaths An array of Blob objects representing the files to be uploaded to Vectara.
+     * @param files An array of VectaraFile objects representing the files and their respective file names to be uploaded to Vectara.
      * @param metadata Optional. An array of metadata objects corresponding to each file in the `filePaths` array.
      * @returns A Promise that resolves to the number of successfully uploaded files.
      */
-    async addFiles(filePaths, metadatas = undefined) {
+    async addFiles(files, metadatas = undefined) {
         if (this.corpusId.length > 1)
             throw new Error("addFiles does not support multiple corpus ids");
         let numDocs = 0;
-        for (const [index, fileBlob] of filePaths.entries()) {
+        for (const [index, file] of files.entries()) {
             const md = metadatas ? metadatas[index] : {};
             const data = new FormData();
-            data.append("file", fileBlob, `file_${index}`);
+            data.append("file", file.blob, file.fileName);
             data.append("doc-metadata", JSON.stringify(md));
-            try {
-                const response = await fetch(`https://api.vectara.io/v1/upload?c=${this.customerId}&o=${this.corpusId[0]}`, {
-                    method: "POST",
-                    headers: {
-                        "x-api-key": this.apiKey,
-                    },
-                    body: data,
-                });
-                const result = await response.json();
-                const { status } = response;
-                if (status !== 200 && status !== 409) {
-                    throw new Error(`Vectara API returned status code ${status}: ${result}`);
-                }
-                else {
-                    numDocs += 1;
-                }
+            const response = await fetch(`https://api.vectara.io/v1/upload?c=${this.customerId}&o=${this.corpusId[0]}`, {
+                method: "POST",
+                headers: {
+                    "x-api-key": this.apiKey,
+                },
+                body: data,
+            });
+            const { status } = response;
+            if (status === 409) {
+                throw new Error(`File at index ${index} already exists in Vectara`);
+            }
+            else if (status !== 200) {
+                throw new Error(`Vectara API returned status code ${status}`);
             }
-            catch (err) {
-                console.error(`Failed to upload file at index ${index}:`, err);
+            else {
+                numDocs += 1;
             }
         }
         if (this.verbose) {
-            console.log(`Uploaded ${filePaths.length} files to Vectara`);
+            console.log(`Uploaded ${files.length} files to Vectara`);
         }
         return numDocs;
     }

package/dist/vectorstores/voy.cjs

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoyVectorStore = void 0;
+const base_js_1 = require("./base.cjs");
+const document_js_1 = require("../document.cjs");
+/**
+ * Class that extends `VectorStore`. It allows to perform similarity search using
+ * Voi similarity search engine. The class requires passing Voy Client as an input parameter.
+ */
+class VoyVectorStore extends base_js_1.VectorStore {
+    _vectorstoreType() {
+        return "voi";
+    }
+    constructor(client, embeddings) {
+        super(embeddings, {});
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "numDimensions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "docstore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.client = client;
+        this.embeddings = embeddings;
+    }
+    /**
+     * Adds documents to the Voy database. The documents are embedded using embeddings provided while instantiating the class.
+     * @param documents An array of `Document` instances associated with the vectors.
+     */
+    async addDocuments(documents) {
+        const texts = documents.map(({ pageContent }) => pageContent);
+        if (documents.length === 0) {
+            return;
+        }
+        const firstVector = (await this.embeddings.embedDocuments(texts.slice(0, 1)))[0];
+        if (this.numDimensions === null) {
+            this.numDimensions = firstVector.length;
+        }
+        else if (this.numDimensions !== firstVector.length) {
+            throw new Error(`Vectors must have the same length as the number of dimensions (${this.numDimensions})`);
+        }
+        const restResults = await this.embeddings.embedDocuments(texts.slice(1));
+        await this.addVectors([firstVector, ...restResults], documents);
+    }
+    /**
+     * Adds vectors to the Voy database. The vectors are associated with
+     * the provided documents.
+     * @param vectors An array of vectors to be added to the database.
+     * @param documents An array of `Document` instances associated with the vectors.
+     */
+    async addVectors(vectors, documents) {
+        if (vectors.length === 0) {
+            return;
+        }
+        if (this.numDimensions === null) {
+            this.numDimensions = vectors[0].length;
+        }
+        if (vectors.length !== documents.length) {
+            throw new Error(`Vectors and metadata must have the same length`);
+        }
+        if (!vectors.every((v) => v.length === this.numDimensions)) {
+            throw new Error(`Vectors must have the same length as the number of dimensions (${this.numDimensions})`);
+        }
+        vectors.forEach((item, idx) => {
+            const doc = documents[idx];
+            this.docstore.push({ embeddings: item, document: doc });
+        });
+        const embeddings = this.docstore.map((item, idx) => ({
+            id: String(idx),
+            embeddings: item.embeddings,
+            title: "",
+            url: "",
+        }));
+        this.client.index({ embeddings });
+    }
+    /**
+     * Searches for vectors in the Voy database that are similar to the
+     * provided query vector.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @returns A promise that resolves with an array of tuples, each containing a `Document` instance and a similarity score.
+     */
+    async similaritySearchVectorWithScore(query, k) {
+        if (this.numDimensions === null) {
+            throw new Error("There aren't any elements in the index yet.");
+        }
+        if (query.length !== this.numDimensions) {
+            throw new Error(`Query vector must have the same length as the number of dimensions (${this.numDimensions})`);
+        }
+        const itemsToQuery = Math.min(this.docstore.length, k);
+        if (itemsToQuery > this.docstore.length) {
+            console.warn(`k (${k}) is greater than the number of elements in the index (${this.docstore.length}), setting k to ${itemsToQuery}`);
+        }
+        const results = this.client.search(new Float32Array(query), itemsToQuery);
+        return results.neighbors.map(({ id }, idx) => [this.docstore[parseInt(id, 10)].document, idx]);
+    }
+    /**
+     * Method to delete data from the Voy index. It can delete data based
+     * on specific IDs or a filter.
+     * @param params Object that includes either an array of IDs or a filter for the data to be deleted.
+     * @returns Promise that resolves when the deletion is complete.
+     */
+    async delete(params) {
+        if (params.deleteAll === true) {
+            await this.client.clear();
+        }
+        else {
+            throw new Error(`You must provide a "deleteAll" parameter.`);
+        }
+    }
+    /**
+     * Creates a new `VoyVectorStore` instance from an array of text strings. The text
+     * strings are converted to `Document` instances and added to the Voy
+     * database.
+     * @param texts An array of text strings.
+     * @param metadatas An array of metadata objects or a single metadata object. If an array is provided, it must have the same length as the `texts` array.
+     * @param embeddings An `Embeddings` instance used to generate embeddings for the documents.
+     * @param client An instance of Voy client to use in the underlying operations.
+     * @returns A promise that resolves with a new `VoyVectorStore` instance.
+     */
+    static async fromTexts(texts, metadatas, embeddings, client) {
+        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 VoyVectorStore.fromDocuments(docs, embeddings, client);
+    }
+    /**
+     * Creates a new `VoyVectorStore` instance from an array of `Document` instances.
+     * The documents are added to the Voy database.
+     * @param docs An array of `Document` instances.
+     * @param embeddings An `Embeddings` instance used to generate embeddings for the documents.
+     * @param client An instance of Voy client to use in the underlying operations.
+     * @returns A promise that resolves with a new `VoyVectorStore` instance.
+     */
+    static async fromDocuments(docs, embeddings, client) {
+        const instance = new VoyVectorStore(client, embeddings);
+        await instance.addDocuments(docs);
+        return instance;
+    }
+}
+exports.VoyVectorStore = VoyVectorStore;

package/dist/vectorstores/voy.d.ts

@@ -0,0 +1,73 @@
+import type { Voy as VoyOriginClient } from "voy-search";
+import { Embeddings } from "../embeddings/base.js";
+import { VectorStore } from "./base.js";
+import { Document } from "../document.js";
+export type VoyClient = Omit<VoyOriginClient, "remove" | "size" | "serialize" | "free">;
+/**
+ * Internal interface for storing documents mappings.
+ */
+interface InternalDoc {
+    embeddings: number[];
+    document: Document;
+}
+/**
+ * Class that extends `VectorStore`. It allows to perform similarity search using
+ * Voi similarity search engine. The class requires passing Voy Client as an input parameter.
+ */
+export declare class VoyVectorStore extends VectorStore {
+    client: VoyClient;
+    numDimensions: number | null;
+    docstore: InternalDoc[];
+    _vectorstoreType(): string;
+    constructor(client: VoyClient, embeddings: Embeddings);
+    /**
+     * Adds documents to the Voy database. The documents are embedded using embeddings provided while instantiating the class.
+     * @param documents An array of `Document` instances associated with the vectors.
+     */
+    addDocuments(documents: Document[]): Promise<void>;
+    /**
+     * Adds vectors to the Voy database. The vectors are associated with
+     * the provided documents.
+     * @param vectors An array of vectors to be added to the database.
+     * @param documents An array of `Document` instances associated with the vectors.
+     */
+    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    /**
+     * Searches for vectors in the Voy database that are similar to the
+     * provided query vector.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @returns A promise that resolves with an array of tuples, each containing a `Document` instance and a similarity score.
+     */
+    similaritySearchVectorWithScore(query: number[], k: number): Promise<[Document<Record<string, any>>, number][]>;
+    /**
+     * Method to delete data from the Voy index. It can delete data based
+     * on specific IDs or a filter.
+     * @param params Object that includes either an array of IDs or a filter for the data to be deleted.
+     * @returns Promise that resolves when the deletion is complete.
+     */
+    delete(params: {
+        deleteAll?: boolean;
+    }): Promise<void>;
+    /**
+     * Creates a new `VoyVectorStore` instance from an array of text strings. The text
+     * strings are converted to `Document` instances and added to the Voy
+     * database.
+     * @param texts An array of text strings.
+     * @param metadatas An array of metadata objects or a single metadata object. If an array is provided, it must have the same length as the `texts` array.
+     * @param embeddings An `Embeddings` instance used to generate embeddings for the documents.
+     * @param client An instance of Voy client to use in the underlying operations.
+     * @returns A promise that resolves with a new `VoyVectorStore` instance.
+     */
+    static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, client: VoyClient): Promise<VoyVectorStore>;
+    /**
+     * Creates a new `VoyVectorStore` instance from an array of `Document` instances.
+     * The documents are added to the Voy database.
+     * @param docs An array of `Document` instances.
+     * @param embeddings An `Embeddings` instance used to generate embeddings for the documents.
+     * @param client An instance of Voy client to use in the underlying operations.
+     * @returns A promise that resolves with a new `VoyVectorStore` instance.
+     */
+    static fromDocuments(docs: Document[], embeddings: Embeddings, client: VoyClient): Promise<VoyVectorStore>;
+}
+export {};