langchain 0.0.131 → 0.0.132

package/dist/vectorstores/mongodb_atlas.d.ts

@@ -2,17 +2,34 @@ import type { Collection, Document as MongoDBDocument } from "mongodb";
 import { MaxMarginalRelevanceSearchOptions, VectorStore } from "./base.js";
 import { Embeddings } from "../embeddings/base.js";
 import { Document } from "../document.js";
+/**
+ * Type that defines the arguments required to initialize the
+ * MongoDBAtlasVectorSearch class. It includes the MongoDB collection,
+ * index name, text key, and embedding key.
+ */
 export type MongoDBAtlasVectorSearchLibArgs = {
     readonly collection: Collection<MongoDBDocument>;
     readonly indexName?: string;
     readonly textKey?: string;
     readonly embeddingKey?: string;
 };
+/**
+ * Type that defines the filter used in the
+ * similaritySearchVectorWithScore and maxMarginalRelevanceSearch methods.
+ * It includes pre-filter, post-filter pipeline, and a flag to include
+ * embeddings.
+ */
 type MongoDBAtlasFilter = {
     preFilter?: MongoDBDocument;
     postFilterPipeline?: MongoDBDocument[];
     includeEmbeddings?: boolean;
 } & MongoDBDocument;
+/**
+ * Class that is a wrapper around MongoDB Atlas Vector Search. It is used
+ * to store embeddings in MongoDB documents, create a vector search index,
+ * and perform K-Nearest Neighbors (KNN) search with an approximate
+ * nearest neighbor algorithm.
+ */
 export declare class MongoDBAtlasVectorSearch extends VectorStore {
     FilterType: MongoDBAtlasFilter;
     private readonly collection;
@@ -21,8 +38,31 @@ export declare class MongoDBAtlasVectorSearch extends VectorStore {
     private readonly embeddingKey;
     _vectorstoreType(): string;
     constructor(embeddings: Embeddings, args: MongoDBAtlasVectorSearchLibArgs);
+    /**
+     * Method to add vectors and their corresponding documents to the MongoDB
+     * collection.
+     * @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.
+     */
     addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    /**
+     * Method to add documents to the MongoDB collection. 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.
+     */
     addDocuments(documents: Document[]): Promise<void>;
+    /**
+     * Method that performs a similarity search on the vectors stored in the
+     * MongoDB collection. 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.
+     */
     similaritySearchVectorWithScore(query: number[], k: number, filter?: MongoDBAtlasFilter): Promise<[Document, number][]>;
     /**
      * Return documents selected using the maximal marginal relevance.
@@ -40,7 +80,26 @@ export declare class MongoDBAtlasVectorSearch extends VectorStore {
      * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
      */
     maxMarginalRelevanceSearch(query: string, options: MaxMarginalRelevanceSearchOptions<this["FilterType"]>): Promise<Document[]>;
+    /**
+     * Static method to create an instance of MongoDBAtlasVectorSearch from a
+     * list of texts. It first converts the texts to vectors and then adds
+     * them to the MongoDB collection.
+     * @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 MongoDB Atlas.
+     * @returns Promise that resolves to a new instance of MongoDBAtlasVectorSearch.
+     */
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: MongoDBAtlasVectorSearchLibArgs): Promise<MongoDBAtlasVectorSearch>;
+    /**
+     * Static method to create an instance of MongoDBAtlasVectorSearch from a
+     * list of documents. It first converts the documents to vectors and then
+     * adds them to the MongoDB collection.
+     * @param docs List of documents to be converted to vectors.
+     * @param embeddings Embeddings to be used for conversion.
+     * @param dbConfig Database configuration for MongoDB Atlas.
+     * @returns Promise that resolves to a new instance of MongoDBAtlasVectorSearch.
+     */
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: MongoDBAtlasVectorSearchLibArgs): Promise<MongoDBAtlasVectorSearch>;
 }
 export {};

package/dist/vectorstores/mongodb_atlas.js

@@ -1,6 +1,12 @@
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
 import { maximalMarginalRelevance } from "../util/math.js";
+/**
+ * Class that is a wrapper around MongoDB Atlas Vector Search. It is used
+ * to store embeddings in MongoDB documents, create a vector search index,
+ * and perform K-Nearest Neighbors (KNN) search with an approximate
+ * nearest neighbor algorithm.
+ */
 export class MongoDBAtlasVectorSearch extends VectorStore {
     _vectorstoreType() {
         return "mongodb_atlas";
@@ -36,6 +42,13 @@ export class MongoDBAtlasVectorSearch extends VectorStore {
         this.textKey = args.textKey ?? "text";
         this.embeddingKey = args.embeddingKey ?? "embedding";
     }
+    /**
+     * Method to add vectors and their corresponding documents to the MongoDB
+     * collection.
+     * @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 docs = vectors.map((embedding, idx) => ({
             [this.textKey]: documents[idx].pageContent,
@@ -44,10 +57,26 @@ export class MongoDBAtlasVectorSearch extends VectorStore {
         }));
         await this.collection.insertMany(docs);
     }
+    /**
+     * Method to add documents to the MongoDB collection. 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);
     }
+    /**
+     * Method that performs a similarity search on the vectors stored in the
+     * MongoDB collection. 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 knnBeta = {
             vector: query,
@@ -138,6 +167,16 @@ export class MongoDBAtlasVectorSearch extends VectorStore {
             return doc;
         });
     }
+    /**
+     * Static method to create an instance of MongoDBAtlasVectorSearch from a
+     * list of texts. It first converts the texts to vectors and then adds
+     * them to the MongoDB collection.
+     * @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 MongoDB Atlas.
+     * @returns Promise that resolves to a new instance of MongoDBAtlasVectorSearch.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -150,6 +189,15 @@ export class MongoDBAtlasVectorSearch extends VectorStore {
         }
         return MongoDBAtlasVectorSearch.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Static method to create an instance of MongoDBAtlasVectorSearch from a
+     * list of documents. It first converts the documents to vectors and then
+     * adds them to the MongoDB collection.
+     * @param docs List of documents to be converted to vectors.
+     * @param embeddings Embeddings to be used for conversion.
+     * @param dbConfig Database configuration for MongoDB Atlas.
+     * @returns Promise that resolves to a new instance of MongoDBAtlasVectorSearch.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.addDocuments(docs);

package/dist/vectorstores/myscale.cjs

@@ -28,6 +28,12 @@ const uuid = __importStar(require("uuid"));
 const client_1 = require("@clickhouse/client");
 const base_js_1 = require("./base.cjs");
 const document_js_1 = require("../document.cjs");
+/**
+ * Class for interacting with the MyScale database. It extends the
+ * VectorStore class and provides methods for adding vectors and
+ * documents, searching for similar vectors, and creating instances from
+ * texts or documents.
+ */
 class MyScaleStore extends base_js_1.VectorStore {
     _vectorstoreType() {
         return "myscale";
@@ -100,6 +106,12 @@ class MyScaleStore extends base_js_1.VectorStore {
             session_id: uuid.v4(),
         });
     }
+    /**
+     * Method to add vectors to the MyScale database.
+     * @param vectors The vectors to add.
+     * @param documents The documents associated with the vectors.
+     * @returns Promise that resolves when the vectors have been added.
+     */
     async addVectors(vectors, documents) {
         if (vectors.length === 0) {
             return;
@@ -110,9 +122,21 @@ class MyScaleStore extends base_js_1.VectorStore {
         const queryStr = this.buildInsertQuery(vectors, documents);
         await this.client.exec({ query: queryStr });
     }
+    /**
+     * Method to add documents to the MyScale database.
+     * @param documents The documents to add.
+     * @returns Promise that resolves when the documents have been added.
+     */
     async addDocuments(documents) {
         return this.addVectors(await this.embeddings.embedDocuments(documents.map((d) => d.pageContent)), documents);
     }
+    /**
+     * Method to search for vectors that are similar to a given query vector.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @param filter Optional filter for the search results.
+     * @returns Promise that resolves with an array of tuples, each containing a Document and a score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         if (!this.isInitialized) {
             await this.initialize(query.length);
@@ -126,6 +150,14 @@ class MyScaleStore extends base_js_1.VectorStore {
         ]);
         return result;
     }
+    /**
+     * Static method to create an instance of MyScaleStore from texts.
+     * @param texts The texts to use.
+     * @param metadatas The metadata associated with the texts.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the MyScaleStore.
+     * @returns Promise that resolves with a new instance of MyScaleStore.
+     */
     static async fromTexts(texts, metadatas, embeddings, args) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -138,16 +170,35 @@ class MyScaleStore extends base_js_1.VectorStore {
         }
         return MyScaleStore.fromDocuments(docs, embeddings, args);
     }
+    /**
+     * Static method to create an instance of MyScaleStore from documents.
+     * @param docs The documents to use.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the MyScaleStore.
+     * @returns Promise that resolves with a new instance of MyScaleStore.
+     */
     static async fromDocuments(docs, embeddings, args) {
         const instance = new this(embeddings, args);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Static method to create an instance of MyScaleStore from an existing
+     * index.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the MyScaleStore.
+     * @returns Promise that resolves with a new instance of MyScaleStore.
+     */
     static async fromExistingIndex(embeddings, args) {
         const instance = new this(embeddings, args);
         await instance.initialize();
         return instance;
     }
+    /**
+     * Method to initialize the MyScale database.
+     * @param dimension Optional dimension of the vectors.
+     * @returns Promise that resolves when the database has been initialized.
+     */
     async initialize(dimension) {
         const dim = dimension ?? (await this.embeddings.embedQuery("test")).length;
         let indexParamStr = "";
@@ -171,6 +222,13 @@ class MyScaleStore extends base_js_1.VectorStore {
         await this.client.exec({ query });
         this.isInitialized = true;
     }
+    /**
+     * Method to build an SQL query for inserting vectors and documents into
+     * the MyScale database.
+     * @param vectors The vectors to insert.
+     * @param documents The documents to insert.
+     * @returns The SQL query string.
+     */
     buildInsertQuery(vectors, documents) {
         const columnsStr = Object.values(this.columnMap).join(", ");
         const data = [];
@@ -196,6 +254,14 @@ class MyScaleStore extends base_js_1.VectorStore {
     escapeString(str) {
         return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
     }
+    /**
+     * Method to build an SQL query for searching for similar vectors in the
+     * MyScale database.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @param filter Optional filter for the search results.
+     * @returns The SQL query string.
+     */
     buildSearchQuery(query, k, filter) {
         const order = this.metric === "ip" ? "DESC" : "ASC";
         const whereStr = filter ? `PREWHERE ${filter.whereStr}` : "";

package/dist/vectorstores/myscale.d.ts

@@ -1,6 +1,11 @@
 import { Embeddings } from "../embeddings/base.js";
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
+/**
+ * Arguments for the MyScaleStore class, which include the host, port,
+ * protocol, username, password, index type, index parameters, column map,
+ * database, table, and metric.
+ */
 export interface MyScaleLibArgs {
     host: string;
     port: string | number;
@@ -14,16 +19,31 @@ export interface MyScaleLibArgs {
     table?: string;
     metric?: metric;
 }
+/**
+ * Mapping of columns in the MyScale database.
+ */
 export interface ColumnMap {
     id: string;
     text: string;
     vector: string;
     metadata: string;
 }
+/**
+ * Type of metric used in the MyScale database.
+ */
 export type metric = "ip" | "cosine" | "l2";
+/**
+ * Type for filtering search results in the MyScale database.
+ */
 export interface MyScaleFilter {
     whereStr: string;
 }
+/**
+ * Class for interacting with the MyScale database. It extends the
+ * VectorStore class and provides methods for adding vectors and
+ * documents, searching for similar vectors, and creating instances from
+ * texts or documents.
+ */
 export declare class MyScaleStore extends VectorStore {
     FilterType: MyScaleFilter;
     private client;
@@ -36,14 +56,74 @@ export declare class MyScaleStore extends VectorStore {
     private isInitialized;
     _vectorstoreType(): string;
     constructor(embeddings: Embeddings, args: MyScaleLibArgs);
+    /**
+     * Method to add vectors to the MyScale database.
+     * @param vectors The vectors to add.
+     * @param documents The documents associated with the vectors.
+     * @returns Promise that resolves when the vectors have been added.
+     */
     addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    /**
+     * Method to add documents to the MyScale database.
+     * @param documents The documents to add.
+     * @returns Promise that resolves when the documents have been added.
+     */
     addDocuments(documents: Document[]): Promise<void>;
+    /**
+     * Method to search for vectors that are similar to a given query vector.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @param filter Optional filter for the search results.
+     * @returns Promise that resolves with an array of tuples, each containing a Document and a score.
+     */
     similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
+    /**
+     * Static method to create an instance of MyScaleStore from texts.
+     * @param texts The texts to use.
+     * @param metadatas The metadata associated with the texts.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the MyScaleStore.
+     * @returns Promise that resolves with a new instance of MyScaleStore.
+     */
     static fromTexts(texts: string[], metadatas: object | object[], embeddings: Embeddings, args: MyScaleLibArgs): Promise<MyScaleStore>;
+    /**
+     * Static method to create an instance of MyScaleStore from documents.
+     * @param docs The documents to use.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the MyScaleStore.
+     * @returns Promise that resolves with a new instance of MyScaleStore.
+     */
     static fromDocuments(docs: Document[], embeddings: Embeddings, args: MyScaleLibArgs): Promise<MyScaleStore>;
+    /**
+     * Static method to create an instance of MyScaleStore from an existing
+     * index.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the MyScaleStore.
+     * @returns Promise that resolves with a new instance of MyScaleStore.
+     */
     static fromExistingIndex(embeddings: Embeddings, args: MyScaleLibArgs): Promise<MyScaleStore>;
+    /**
+     * Method to initialize the MyScale database.
+     * @param dimension Optional dimension of the vectors.
+     * @returns Promise that resolves when the database has been initialized.
+     */
     private initialize;
+    /**
+     * Method to build an SQL query for inserting vectors and documents into
+     * the MyScale database.
+     * @param vectors The vectors to insert.
+     * @param documents The documents to insert.
+     * @returns The SQL query string.
+     */
     private buildInsertQuery;
     private escapeString;
+    /**
+     * Method to build an SQL query for searching for similar vectors in the
+     * MyScale database.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @param filter Optional filter for the search results.
+     * @returns The SQL query string.
+     */
     private buildSearchQuery;
 }

package/dist/vectorstores/myscale.js

@@ -2,6 +2,12 @@ import * as uuid from "uuid";
 import { createClient } from "@clickhouse/client";
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
+/**
+ * Class for interacting with the MyScale database. It extends the
+ * VectorStore class and provides methods for adding vectors and
+ * documents, searching for similar vectors, and creating instances from
+ * texts or documents.
+ */
 export class MyScaleStore extends VectorStore {
     _vectorstoreType() {
         return "myscale";
@@ -74,6 +80,12 @@ export class MyScaleStore extends VectorStore {
             session_id: uuid.v4(),
         });
     }
+    /**
+     * Method to add vectors to the MyScale database.
+     * @param vectors The vectors to add.
+     * @param documents The documents associated with the vectors.
+     * @returns Promise that resolves when the vectors have been added.
+     */
     async addVectors(vectors, documents) {
         if (vectors.length === 0) {
             return;
@@ -84,9 +96,21 @@ export class MyScaleStore extends VectorStore {
         const queryStr = this.buildInsertQuery(vectors, documents);
         await this.client.exec({ query: queryStr });
     }
+    /**
+     * Method to add documents to the MyScale database.
+     * @param documents The documents to add.
+     * @returns Promise that resolves when the documents have been added.
+     */
     async addDocuments(documents) {
         return this.addVectors(await this.embeddings.embedDocuments(documents.map((d) => d.pageContent)), documents);
     }
+    /**
+     * Method to search for vectors that are similar to a given query vector.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @param filter Optional filter for the search results.
+     * @returns Promise that resolves with an array of tuples, each containing a Document and a score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         if (!this.isInitialized) {
             await this.initialize(query.length);
@@ -100,6 +124,14 @@ export class MyScaleStore extends VectorStore {
         ]);
         return result;
     }
+    /**
+     * Static method to create an instance of MyScaleStore from texts.
+     * @param texts The texts to use.
+     * @param metadatas The metadata associated with the texts.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the MyScaleStore.
+     * @returns Promise that resolves with a new instance of MyScaleStore.
+     */
     static async fromTexts(texts, metadatas, embeddings, args) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -112,16 +144,35 @@ export class MyScaleStore extends VectorStore {
         }
         return MyScaleStore.fromDocuments(docs, embeddings, args);
     }
+    /**
+     * Static method to create an instance of MyScaleStore from documents.
+     * @param docs The documents to use.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the MyScaleStore.
+     * @returns Promise that resolves with a new instance of MyScaleStore.
+     */
     static async fromDocuments(docs, embeddings, args) {
         const instance = new this(embeddings, args);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Static method to create an instance of MyScaleStore from an existing
+     * index.
+     * @param embeddings The embeddings to use.
+     * @param args The arguments for the MyScaleStore.
+     * @returns Promise that resolves with a new instance of MyScaleStore.
+     */
     static async fromExistingIndex(embeddings, args) {
         const instance = new this(embeddings, args);
         await instance.initialize();
         return instance;
     }
+    /**
+     * Method to initialize the MyScale database.
+     * @param dimension Optional dimension of the vectors.
+     * @returns Promise that resolves when the database has been initialized.
+     */
     async initialize(dimension) {
         const dim = dimension ?? (await this.embeddings.embedQuery("test")).length;
         let indexParamStr = "";
@@ -145,6 +196,13 @@ export class MyScaleStore extends VectorStore {
         await this.client.exec({ query });
         this.isInitialized = true;
     }
+    /**
+     * Method to build an SQL query for inserting vectors and documents into
+     * the MyScale database.
+     * @param vectors The vectors to insert.
+     * @param documents The documents to insert.
+     * @returns The SQL query string.
+     */
     buildInsertQuery(vectors, documents) {
         const columnsStr = Object.values(this.columnMap).join(", ");
         const data = [];
@@ -170,6 +228,14 @@ export class MyScaleStore extends VectorStore {
     escapeString(str) {
         return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
     }
+    /**
+     * Method to build an SQL query for searching for similar vectors in the
+     * MyScale database.
+     * @param query The query vector.
+     * @param k The number of similar vectors to return.
+     * @param filter Optional filter for the search results.
+     * @returns The SQL query string.
+     */
     buildSearchQuery(query, k, filter) {
         const order = this.metric === "ip" ? "DESC" : "ASC";
         const whereStr = filter ? `PREWHERE ${filter.whereStr}` : "";

package/dist/vectorstores/opensearch.cjs

@@ -28,6 +28,12 @@ const opensearch_1 = require("@opensearch-project/opensearch");
 const uuid = __importStar(require("uuid"));
 const document_js_1 = require("../document.cjs");
 const base_js_1 = require("./base.cjs");
+/**
+ * Class that provides a wrapper around the OpenSearch service for vector
+ * search. It provides methods for adding documents and vectors to the
+ * OpenSearch index, searching for similar vectors, and managing the
+ * OpenSearch index.
+ */
 class OpenSearchVectorStore extends base_js_1.VectorStore {
     _vectorstoreType() {
         return "opensearch";
@@ -84,10 +90,24 @@ class OpenSearchVectorStore extends base_js_1.VectorStore {
         this.client = args.client;
         this.indexName = args.indexName ?? "documents";
     }
+    /**
+     * Method to add documents to the OpenSearch index. It first converts the
+     * documents to vectors using the embeddings, then adds the vectors to the
+     * index.
+     * @param documents The documents to be added to the OpenSearch index.
+     * @returns Promise resolving to void.
+     */
     async addDocuments(documents) {
         const texts = documents.map(({ pageContent }) => pageContent);
         return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
     }
+    /**
+     * Method to add vectors to the OpenSearch index. It ensures the index
+     * exists, then adds the vectors and associated documents to the index.
+     * @param vectors The vectors to be added to the OpenSearch index.
+     * @param documents The documents associated with the vectors.
+     * @returns Promise resolving to void.
+     */
     async addVectors(vectors, documents) {
         await this.ensureIndexExists(vectors[0].length, this.engine, this.spaceType, this.efSearch, this.efConstruction, this.m);
         const operations = vectors.flatMap((embedding, idx) => [
@@ -106,6 +126,14 @@ class OpenSearchVectorStore extends base_js_1.VectorStore {
         await this.client.bulk({ body: operations });
         await this.client.indices.refresh({ index: this.indexName });
     }
+    /**
+     * Method to perform a similarity search on the OpenSearch index using a
+     * query vector. It returns the k most similar documents and their scores.
+     * @param query The query vector.
+     * @param k The number of similar documents to return.
+     * @param filter Optional filter for the OpenSearch query.
+     * @returns Promise resolving to an array of tuples, each containing a Document and its score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         const search = {
             index: this.indexName,
@@ -135,6 +163,15 @@ class OpenSearchVectorStore extends base_js_1.VectorStore {
             hit._score,
         ]);
     }
+    /**
+     * Static method to create a new OpenSearchVectorStore from an array of
+     * texts, their metadata, embeddings, and OpenSearch client arguments.
+     * @param texts The texts to be converted into documents and added to the OpenSearch index.
+     * @param metadatas The metadata associated with the texts. Can be an array of objects or a single object.
+     * @param embeddings The embeddings used to convert the texts into vectors.
+     * @param args The OpenSearch client arguments.
+     * @returns Promise resolving to a new instance of OpenSearchVectorStore.
+     */
     static fromTexts(texts, metadatas, embeddings, args) {
         const documents = texts.map((text, idx) => {
             const metadata = Array.isArray(metadatas) ? metadatas[idx] : metadatas;
@@ -142,11 +179,26 @@ class OpenSearchVectorStore extends base_js_1.VectorStore {
         });
         return OpenSearchVectorStore.fromDocuments(documents, embeddings, args);
     }
+    /**
+     * Static method to create a new OpenSearchVectorStore from an array of
+     * Documents, embeddings, and OpenSearch client arguments.
+     * @param docs The documents to be added to the OpenSearch index.
+     * @param embeddings The embeddings used to convert the documents into vectors.
+     * @param dbConfig The OpenSearch client arguments.
+     * @returns Promise resolving to a new instance of OpenSearchVectorStore.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const store = new OpenSearchVectorStore(embeddings, dbConfig);
         await store.addDocuments(docs).then(() => store);
         return store;
     }
+    /**
+     * Static method to create a new OpenSearchVectorStore from an existing
+     * OpenSearch index, embeddings, and OpenSearch client arguments.
+     * @param embeddings The embeddings used to convert the documents into vectors.
+     * @param dbConfig The OpenSearch client arguments.
+     * @returns Promise resolving to a new instance of OpenSearchVectorStore.
+     */
     static async fromExistingIndex(embeddings, dbConfig) {
         const store = new OpenSearchVectorStore(embeddings, dbConfig);
         await store.client.cat.indices({ index: store.indexName });
@@ -202,6 +254,10 @@ class OpenSearchVectorStore extends base_js_1.VectorStore {
         }
         return result;
     }
+    /**
+     * Method to check if the OpenSearch index exists.
+     * @returns Promise resolving to a boolean indicating whether the index exists.
+     */
     async doesIndexExist() {
         try {
             await this.client.cat.indices({ index: this.indexName });
@@ -215,6 +271,10 @@ class OpenSearchVectorStore extends base_js_1.VectorStore {
             throw err;
         }
     }
+    /**
+     * Method to delete the OpenSearch index if it exists.
+     * @returns Promise resolving to void.
+     */
     async deleteIfExists() {
         const indexExists = await this.doesIndexExist();
         if (!indexExists)