langchain 0.0.131 → 0.0.132

package/dist/vectorstores/supabase.d.ts

@@ -6,6 +6,9 @@ import { Document } from "../document.js";
 export type SupabaseMetadata = Record<string, any>;
 export type SupabaseFilter = PostgrestFilterBuilder<any, any, any>;
 export type SupabaseFilterRPCCall = (rpcCall: SupabaseFilter) => SupabaseFilter;
+/**
+ * Interface for the arguments required to initialize a Supabase library.
+ */
 export interface SupabaseLibArgs {
     client: SupabaseClient;
     tableName?: string;
@@ -13,6 +16,10 @@ export interface SupabaseLibArgs {
     filter?: SupabaseMetadata | SupabaseFilterRPCCall;
     upsertBatchSize?: number;
 }
+/**
+ * Class for interacting with a Supabase database to store and manage
+ * vectors.
+ */
 export declare class SupabaseVectorStore extends VectorStore {
     FilterType: SupabaseMetadata | SupabaseFilterRPCCall;
     client: SupabaseClient;
@@ -22,17 +29,63 @@ export declare class SupabaseVectorStore extends VectorStore {
     upsertBatchSize: number;
     _vectorstoreType(): string;
     constructor(embeddings: Embeddings, args: SupabaseLibArgs);
+    /**
+     * Adds documents to the vector store.
+     * @param documents The documents to add.
+     * @param options Optional parameters for adding the documents.
+     * @returns A promise that resolves when the documents have been added.
+     */
     addDocuments(documents: Document[], options?: {
         ids?: string[] | number[];
     }): Promise<string[]>;
+    /**
+     * Adds vectors to the vector store.
+     * @param vectors The vectors to add.
+     * @param documents The documents associated with the vectors.
+     * @param options Optional parameters for adding the vectors.
+     * @returns A promise that resolves with the IDs of the added vectors when the vectors have been added.
+     */
     addVectors(vectors: number[][], documents: Document[], options?: {
         ids?: string[] | number[];
     }): Promise<string[]>;
+    /**
+     * Deletes vectors from the vector store.
+     * @param params The parameters for deleting vectors.
+     * @returns A promise that resolves when the vectors have been deleted.
+     */
     delete(params: {
         ids: string[];
     }): Promise<void>;
+    /**
+     * Performs a similarity search on the vector store.
+     * @param query The query vector.
+     * @param k The number of results to return.
+     * @param filter Optional filter to apply to the search.
+     * @returns A promise that resolves with the search results when the search is complete.
+     */
     similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
+    /**
+     * Creates a new SupabaseVectorStore instance from an array of texts.
+     * @param texts The texts to create documents from.
+     * @param metadatas The metadata for the documents.
+     * @param embeddings The embeddings to use.
+     * @param dbConfig The configuration for the Supabase database.
+     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
+     */
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: SupabaseLibArgs): Promise<SupabaseVectorStore>;
+    /**
+     * Creates a new SupabaseVectorStore instance from an array of documents.
+     * @param docs The documents to create the instance from.
+     * @param embeddings The embeddings to use.
+     * @param dbConfig The configuration for the Supabase database.
+     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
+     */
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: SupabaseLibArgs): Promise<SupabaseVectorStore>;
+    /**
+     * Creates a new SupabaseVectorStore instance from an existing index.
+     * @param embeddings The embeddings to use.
+     * @param dbConfig The configuration for the Supabase database.
+     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
+     */
     static fromExistingIndex(embeddings: Embeddings, dbConfig: SupabaseLibArgs): Promise<SupabaseVectorStore>;
 }

package/dist/vectorstores/supabase.js

@@ -1,5 +1,9 @@
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
+/**
+ * Class for interacting with a Supabase database to store and manage
+ * vectors.
+ */
 export class SupabaseVectorStore extends VectorStore {
     _vectorstoreType() {
         return "supabase";
@@ -42,10 +46,23 @@ export class SupabaseVectorStore extends VectorStore {
         this.filter = args.filter;
         this.upsertBatchSize = args.upsertBatchSize ?? this.upsertBatchSize;
     }
+    /**
+     * Adds documents to the vector store.
+     * @param documents The documents to add.
+     * @param options Optional parameters for adding the documents.
+     * @returns A promise that resolves when the documents have been added.
+     */
     async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
         return this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
+    /**
+     * Adds vectors to the vector store.
+     * @param vectors The vectors to add.
+     * @param documents The documents associated with the vectors.
+     * @param options Optional parameters for adding the vectors.
+     * @returns A promise that resolves with the IDs of the added vectors when the vectors have been added.
+     */
     async addVectors(vectors, documents, options) {
         const rows = vectors.map((embedding, idx) => ({
             content: documents[idx].pageContent,
@@ -72,12 +89,24 @@ export class SupabaseVectorStore extends VectorStore {
         }
         return returnedIds;
     }
+    /**
+     * Deletes vectors from the vector store.
+     * @param params The parameters for deleting vectors.
+     * @returns A promise that resolves when the vectors have been deleted.
+     */
     async delete(params) {
         const { ids } = params;
         for (const id of ids) {
             await this.client.from(this.tableName).delete().eq("id", id);
         }
     }
+    /**
+     * Performs a similarity search on the vector store.
+     * @param query The query vector.
+     * @param k The number of results to return.
+     * @param filter Optional filter to apply to the search.
+     * @returns A promise that resolves with the search results when the search is complete.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         if (filter && this.filter) {
             throw new Error("cannot provide both `filter` and `this.filter`");
@@ -112,6 +141,14 @@ export class SupabaseVectorStore extends VectorStore {
         ]);
         return result;
     }
+    /**
+     * Creates a new SupabaseVectorStore instance from an array of texts.
+     * @param texts The texts to create documents from.
+     * @param metadatas The metadata for the documents.
+     * @param embeddings The embeddings to use.
+     * @param dbConfig The configuration for the Supabase database.
+     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -124,11 +161,24 @@ export class SupabaseVectorStore extends VectorStore {
         }
         return SupabaseVectorStore.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Creates a new SupabaseVectorStore instance from an array of documents.
+     * @param docs The documents to create the instance from.
+     * @param embeddings The embeddings to use.
+     * @param dbConfig The configuration for the Supabase database.
+     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Creates a new SupabaseVectorStore instance from an existing index.
+     * @param embeddings The embeddings to use.
+     * @param dbConfig The configuration for the Supabase database.
+     * @returns A promise that resolves with a new SupabaseVectorStore instance when the instance has been created.
+     */
     static async fromExistingIndex(embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         return instance;

package/dist/vectorstores/tigris.cjs

@@ -27,6 +27,10 @@ exports.TigrisVectorStore = void 0;
 const uuid = __importStar(require("uuid"));
 const base_js_1 = require("./base.cjs");
 const document_js_1 = require("../document.cjs");
+/**
+ * Class for managing and operating vector search applications with
+ * Tigris, an open-source Serverless NoSQL Database and Search Platform.
+ */
 class TigrisVectorStore extends base_js_1.VectorStore {
     _vectorstoreType() {
         return "tigris";
@@ -42,10 +46,23 @@ class TigrisVectorStore extends base_js_1.VectorStore {
         this.embeddings = embeddings;
         this.index = args.index;
     }
+    /**
+     * Method to add an array of documents to the Tigris database.
+     * @param documents An array of Document instances to be added to the Tigris database.
+     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
+     * @returns A Promise that resolves when the documents have been added to the Tigris database.
+     */
     async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
         await this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
+    /**
+     * Method to add vectors to the Tigris database.
+     * @param vectors An array of vectors to be added to the Tigris database.
+     * @param documents An array of Document instances corresponding to the vectors.
+     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
+     * @returns A Promise that resolves when the vectors have been added to the Tigris database.
+     */
     async addVectors(vectors, documents, options) {
         if (vectors.length === 0) {
             return;
@@ -64,6 +81,14 @@ class TigrisVectorStore extends base_js_1.VectorStore {
             })),
         });
     }
+    /**
+     * Method to perform a similarity search in the Tigris database and return
+     * the k most similar vectors along with their similarity scores.
+     * @param query The query vector.
+     * @param k The number of most similar vectors to return.
+     * @param filter Optional filter object to apply during the search.
+     * @returns A Promise that resolves to an array of tuples, each containing a Document and its similarity score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         const result = await this.index?.similaritySearchVectorWithScore({
             query,
@@ -81,6 +106,15 @@ class TigrisVectorStore extends base_js_1.VectorStore {
             score,
         ]);
     }
+    /**
+     * Static method to create a new instance of TigrisVectorStore from an
+     * array of texts.
+     * @param texts An array of texts to be converted into Document instances and added to the Tigris database.
+     * @param metadatas Either an array of metadata objects or a single metadata object to be associated with the texts.
+     * @param embeddings An instance of Embeddings to be used for embedding the texts.
+     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
+     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -93,11 +127,26 @@ class TigrisVectorStore extends base_js_1.VectorStore {
         }
         return TigrisVectorStore.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Static method to create a new instance of TigrisVectorStore from an
+     * array of Document instances.
+     * @param docs An array of Document instances to be added to the Tigris database.
+     * @param embeddings An instance of Embeddings to be used for embedding the documents.
+     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
+     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Static method to create a new instance of TigrisVectorStore from an
+     * existing index.
+     * @param embeddings An instance of Embeddings to be used for embedding the documents.
+     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
+     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
+     */
     static async fromExistingIndex(embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         return instance;

package/dist/vectorstores/tigris.d.ts

@@ -2,21 +2,74 @@ import type { VectorDocumentStore as VectorDocumentStoreT } from "@tigrisdata/ve
 import { Embeddings } from "../embeddings/base.js";
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
+/**
+ * Type definition for the arguments required to initialize a
+ * TigrisVectorStore instance.
+ */
 export type TigrisLibArgs = {
     index: VectorDocumentStoreT;
 };
+/**
+ * Class for managing and operating vector search applications with
+ * Tigris, an open-source Serverless NoSQL Database and Search Platform.
+ */
 export declare class TigrisVectorStore extends VectorStore {
     index?: VectorDocumentStoreT;
     _vectorstoreType(): string;
     constructor(embeddings: Embeddings, args: TigrisLibArgs);
+    /**
+     * Method to add an array of documents to the Tigris database.
+     * @param documents An array of Document instances to be added to the Tigris database.
+     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
+     * @returns A Promise that resolves when the documents have been added to the Tigris database.
+     */
     addDocuments(documents: Document[], options?: {
         ids?: string[];
     } | string[]): Promise<void>;
+    /**
+     * Method to add vectors to the Tigris database.
+     * @param vectors An array of vectors to be added to the Tigris database.
+     * @param documents An array of Document instances corresponding to the vectors.
+     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
+     * @returns A Promise that resolves when the vectors have been added to the Tigris database.
+     */
     addVectors(vectors: number[][], documents: Document[], options?: {
         ids?: string[];
     } | string[]): Promise<void>;
+    /**
+     * Method to perform a similarity search in the Tigris database and return
+     * the k most similar vectors along with their similarity scores.
+     * @param query The query vector.
+     * @param k The number of most similar vectors to return.
+     * @param filter Optional filter object to apply during the search.
+     * @returns A Promise that resolves to an array of tuples, each containing a Document and its similarity score.
+     */
     similaritySearchVectorWithScore(query: number[], k: number, filter?: object): Promise<[Document<Record<string, any>>, number][]>;
+    /**
+     * Static method to create a new instance of TigrisVectorStore from an
+     * array of texts.
+     * @param texts An array of texts to be converted into Document instances and added to the Tigris database.
+     * @param metadatas Either an array of metadata objects or a single metadata object to be associated with the texts.
+     * @param embeddings An instance of Embeddings to be used for embedding the texts.
+     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
+     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
+     */
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: TigrisLibArgs): Promise<TigrisVectorStore>;
+    /**
+     * Static method to create a new instance of TigrisVectorStore from an
+     * array of Document instances.
+     * @param docs An array of Document instances to be added to the Tigris database.
+     * @param embeddings An instance of Embeddings to be used for embedding the documents.
+     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
+     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
+     */
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: TigrisLibArgs): Promise<TigrisVectorStore>;
+    /**
+     * Static method to create a new instance of TigrisVectorStore from an
+     * existing index.
+     * @param embeddings An instance of Embeddings to be used for embedding the documents.
+     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
+     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
+     */
     static fromExistingIndex(embeddings: Embeddings, dbConfig: TigrisLibArgs): Promise<TigrisVectorStore>;
 }

package/dist/vectorstores/tigris.js

@@ -1,6 +1,10 @@
 import * as uuid from "uuid";
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
+/**
+ * Class for managing and operating vector search applications with
+ * Tigris, an open-source Serverless NoSQL Database and Search Platform.
+ */
 export class TigrisVectorStore extends VectorStore {
     _vectorstoreType() {
         return "tigris";
@@ -16,10 +20,23 @@ export class TigrisVectorStore extends VectorStore {
         this.embeddings = embeddings;
         this.index = args.index;
     }
+    /**
+     * Method to add an array of documents to the Tigris database.
+     * @param documents An array of Document instances to be added to the Tigris database.
+     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
+     * @returns A Promise that resolves when the documents have been added to the Tigris database.
+     */
     async addDocuments(documents, options) {
         const texts = documents.map(({ pageContent }) => pageContent);
         await this.addVectors(await this.embeddings.embedDocuments(texts), documents, options);
     }
+    /**
+     * Method to add vectors to the Tigris database.
+     * @param vectors An array of vectors to be added to the Tigris database.
+     * @param documents An array of Document instances corresponding to the vectors.
+     * @param options Optional parameter that can either be an array of string IDs or an object with a property 'ids' that is an array of string IDs.
+     * @returns A Promise that resolves when the vectors have been added to the Tigris database.
+     */
     async addVectors(vectors, documents, options) {
         if (vectors.length === 0) {
             return;
@@ -38,6 +55,14 @@ export class TigrisVectorStore extends VectorStore {
             })),
         });
     }
+    /**
+     * Method to perform a similarity search in the Tigris database and return
+     * the k most similar vectors along with their similarity scores.
+     * @param query The query vector.
+     * @param k The number of most similar vectors to return.
+     * @param filter Optional filter object to apply during the search.
+     * @returns A Promise that resolves to an array of tuples, each containing a Document and its similarity score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         const result = await this.index?.similaritySearchVectorWithScore({
             query,
@@ -55,6 +80,15 @@ export class TigrisVectorStore extends VectorStore {
             score,
         ]);
     }
+    /**
+     * Static method to create a new instance of TigrisVectorStore from an
+     * array of texts.
+     * @param texts An array of texts to be converted into Document instances and added to the Tigris database.
+     * @param metadatas Either an array of metadata objects or a single metadata object to be associated with the texts.
+     * @param embeddings An instance of Embeddings to be used for embedding the texts.
+     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
+     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -67,11 +101,26 @@ export class TigrisVectorStore extends VectorStore {
         }
         return TigrisVectorStore.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Static method to create a new instance of TigrisVectorStore from an
+     * array of Document instances.
+     * @param docs An array of Document instances to be added to the Tigris database.
+     * @param embeddings An instance of Embeddings to be used for embedding the documents.
+     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
+     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Static method to create a new instance of TigrisVectorStore from an
+     * existing index.
+     * @param embeddings An instance of Embeddings to be used for embedding the documents.
+     * @param dbConfig An instance of TigrisLibArgs to be used for configuring the Tigris database.
+     * @returns A Promise that resolves to a new instance of TigrisVectorStore.
+     */
     static async fromExistingIndex(embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         return instance;

package/dist/vectorstores/typeorm.cjs

@@ -5,6 +5,10 @@ const typeorm_1 = require("typeorm");
 const base_js_1 = require("./base.cjs");
 const document_js_1 = require("../document.cjs");
 const env_js_1 = require("../util/env.cjs");
+/**
+ * Class that extends the `Document` base class and adds an `embedding`
+ * property. It represents a document in the vector store.
+ */
 class TypeORMVectorStoreDocument extends document_js_1.Document {
     constructor() {
         super(...arguments);
@@ -24,6 +28,12 @@ class TypeORMVectorStoreDocument extends document_js_1.Document {
 }
 exports.TypeORMVectorStoreDocument = TypeORMVectorStoreDocument;
 const defaultDocumentTableName = "documents";
+/**
+ * Class that provides an interface to a Postgres vector database. It
+ * extends the `VectorStore` base class and implements methods for adding
+ * documents and vectors, performing similarity searches, and ensuring the
+ * existence of a table in the database.
+ */
 class TypeORMVectorStore extends base_js_1.VectorStore {
     _vectorstoreType() {
         return "typeorm";
@@ -92,6 +102,14 @@ class TypeORMVectorStore extends base_js_1.VectorStore {
                 fields.verbose ??
                 false;
     }
+    /**
+     * Static method to create a new `TypeORMVectorStore` instance from a
+     * `DataSource`. It initializes the `DataSource` if it is not already
+     * initialized.
+     * @param embeddings Embeddings instance.
+     * @param fields `TypeORMVectorStoreArgs` instance.
+     * @returns A new instance of `TypeORMVectorStore`.
+     */
     static async fromDataSource(embeddings, fields) {
         const postgresqlVectorStore = new TypeORMVectorStore(embeddings, fields);
         if (!postgresqlVectorStore.appDataSource.isInitialized) {
@@ -99,6 +117,13 @@ class TypeORMVectorStore extends base_js_1.VectorStore {
         }
         return postgresqlVectorStore;
     }
+    /**
+     * Method to add documents to the vector store. It ensures the existence
+     * of the table in the database, converts the documents into vectors, and
+     * adds them to the store.
+     * @param documents Array of `Document` instances.
+     * @returns Promise that resolves when the documents have been added.
+     */
     async addDocuments(documents) {
         const texts = documents.map(({ pageContent }) => pageContent);
         // This will create the table if it does not exist. We can call it every time as it doesn't
@@ -106,6 +131,13 @@ class TypeORMVectorStore extends base_js_1.VectorStore {
         await this.ensureTableInDatabase();
         return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
     }
+    /**
+     * Method to add vectors to the vector store. It converts the vectors into
+     * rows and inserts them into the database.
+     * @param vectors Array of vectors.
+     * @param documents Array of `Document` instances.
+     * @returns Promise that resolves when the vectors have been added.
+     */
     async addVectors(vectors, documents) {
         const rows = vectors.map((embedding, idx) => {
             const embeddingString = `[${embedding.join(",")}]`;
@@ -129,6 +161,15 @@ class TypeORMVectorStore extends base_js_1.VectorStore {
             }
         }
     }
+    /**
+     * Method to perform a similarity search in the vector store. It returns
+     * the `k` most similar documents to the query vector, along with their
+     * similarity scores.
+     * @param query Query vector.
+     * @param k Number of most similar documents to return.
+     * @param filter Optional filter to apply to the search.
+     * @returns Promise that resolves with an array of tuples, each containing a `TypeORMVectorStoreDocument` and its similarity score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         const embeddingString = `[${query.join(",")}]`;
         const _filter = filter ?? "{}";
@@ -153,6 +194,11 @@ class TypeORMVectorStore extends base_js_1.VectorStore {
         }
         return results;
     }
+    /**
+     * Method to ensure the existence of the table in the database. It creates
+     * the table if it does not already exist.
+     * @returns Promise that resolves when the table has been ensured.
+     */
     async ensureTableInDatabase() {
         await this.appDataSource.query("CREATE EXTENSION IF NOT EXISTS vector;");
         await this.appDataSource.query('CREATE EXTENSION IF NOT EXISTS "uuid-ossp";');
@@ -165,6 +211,16 @@ class TypeORMVectorStore extends base_js_1.VectorStore {
       );
     `);
     }
+    /**
+     * Static method to create a new `TypeORMVectorStore` instance from an
+     * array of texts and their metadata. It converts the texts into
+     * `Document` instances and adds them to the store.
+     * @param texts Array of texts.
+     * @param metadatas Array of metadata objects or a single metadata object.
+     * @param embeddings Embeddings instance.
+     * @param dbConfig `TypeORMVectorStoreArgs` instance.
+     * @returns Promise that resolves with a new instance of `TypeORMVectorStore`.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -177,11 +233,26 @@ class TypeORMVectorStore extends base_js_1.VectorStore {
         }
         return TypeORMVectorStore.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Static method to create a new `TypeORMVectorStore` instance from an
+     * array of `Document` instances. It adds the documents to the store.
+     * @param docs Array of `Document` instances.
+     * @param embeddings Embeddings instance.
+     * @param dbConfig `TypeORMVectorStoreArgs` instance.
+     * @returns Promise that resolves with a new instance of `TypeORMVectorStore`.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = await TypeORMVectorStore.fromDataSource(embeddings, dbConfig);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Static method to create a new `TypeORMVectorStore` instance from an
+     * existing index.
+     * @param embeddings Embeddings instance.
+     * @param dbConfig `TypeORMVectorStoreArgs` instance.
+     * @returns Promise that resolves with a new instance of `TypeORMVectorStore`.
+     */
     static async fromExistingIndex(embeddings, dbConfig) {
         const instance = await TypeORMVectorStore.fromDataSource(embeddings, dbConfig);
         return instance;