langchain 0.0.131 → 0.0.132

package/dist/vectorstores/milvus.d.ts

@@ -1,7 +1,10 @@
-import { MilvusClient } from "@zilliz/milvus2-sdk-node";
+import { MilvusClient, ClientConfig } from "@zilliz/milvus2-sdk-node";
 import { Embeddings } from "../embeddings/base.js";
 import { VectorStore } from "./base.js";
 import { Document } from "../document.js";
+/**
+ * Interface for the arguments required by the Milvus class constructor.
+ */
 export interface MilvusLibArgs {
     collectionName?: string;
     primaryField?: string;
@@ -12,8 +15,17 @@ export interface MilvusLibArgs {
     username?: string;
     password?: string;
     textFieldMaxLength?: number;
+    clientConfig?: ClientConfig;
+    autoId?: boolean;
 }
+/**
+ * Type representing the type of index used in the Milvus database.
+ */
 type IndexType = "IVF_FLAT" | "IVF_SQ8" | "IVF_PQ" | "HNSW" | "RHNSW_FLAT" | "RHNSW_SQ" | "RHNSW_PQ" | "IVF_HNSW" | "ANNOY";
+/**
+ * Interface for the parameters required to create an index in the Milvus
+ * database.
+ */
 interface IndexParam {
     params: {
         nprobe?: number;
@@ -21,6 +33,10 @@ interface IndexParam {
         search_k?: number;
     };
 }
+/**
+ * Class for interacting with a Milvus database. Extends the VectorStore
+ * class.
+ */
 export declare class Milvus extends VectorStore {
     get lc_secrets(): {
         [key: string]: string;
@@ -44,15 +60,78 @@ export declare class Milvus extends VectorStore {
     indexSearchParams: string;
     _vectorstoreType(): string;
     constructor(embeddings: Embeddings, args: MilvusLibArgs);
+    /**
+     * Adds documents to the Milvus database.
+     * @param documents Array of Document instances to be added to the database.
+     * @returns Promise resolving to void.
+     */
     addDocuments(documents: Document[]): Promise<void>;
+    /**
+     * Adds vectors to the Milvus database.
+     * @param vectors Array of vectors to be added to the database.
+     * @param documents Array of Document instances associated with the vectors.
+     * @returns Promise resolving to void.
+     */
     addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    /**
+     * Searches for vectors in the Milvus database that are similar to a given
+     * vector.
+     * @param query Vector to compare with the vectors in the database.
+     * @param k Number of similar vectors to return.
+     * @param filter Optional filter to apply to the search.
+     * @returns Promise resolving to an array of tuples, each containing a Document instance and a similarity score.
+     */
     similaritySearchVectorWithScore(query: number[], k: number, filter?: string): Promise<[Document, number][]>;
+    /**
+     * Ensures that a collection exists in the Milvus database.
+     * @param vectors Optional array of vectors to be used if a new collection needs to be created.
+     * @param documents Optional array of Document instances to be used if a new collection needs to be created.
+     * @returns Promise resolving to void.
+     */
     ensureCollection(vectors?: number[][], documents?: Document[]): Promise<void>;
+    /**
+     * Creates a collection in the Milvus database.
+     * @param vectors Array of vectors to be added to the new collection.
+     * @param documents Array of Document instances to be added to the new collection.
+     * @returns Promise resolving to void.
+     */
     createCollection(vectors: number[][], documents: Document[]): Promise<void>;
+    /**
+     * Retrieves the fields of a collection in the Milvus database.
+     * @returns Promise resolving to void.
+     */
     grabCollectionFields(): Promise<void>;
+    /**
+     * Creates a Milvus instance from a set of texts and their associated
+     * metadata.
+     * @param texts Array of texts to be added to the database.
+     * @param metadatas Array of metadata objects associated with the texts.
+     * @param embeddings Embeddings instance used to generate vector embeddings for the texts.
+     * @param dbConfig Optional configuration for the Milvus database.
+     * @returns Promise resolving to a new Milvus instance.
+     */
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig?: MilvusLibArgs): Promise<Milvus>;
+    /**
+     * Creates a Milvus instance from a set of Document instances.
+     * @param docs Array of Document instances to be added to the database.
+     * @param embeddings Embeddings instance used to generate vector embeddings for the documents.
+     * @param dbConfig Optional configuration for the Milvus database.
+     * @returns Promise resolving to a new Milvus instance.
+     */
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig?: MilvusLibArgs): Promise<Milvus>;
+    /**
+     * Creates a Milvus instance from an existing collection in the Milvus
+     * database.
+     * @param embeddings Embeddings instance used to generate vector embeddings for the documents in the collection.
+     * @param dbConfig Configuration for the Milvus database.
+     * @returns Promise resolving to a new Milvus instance.
+     */
     static fromExistingCollection(embeddings: Embeddings, dbConfig: MilvusLibArgs): Promise<Milvus>;
+    /**
+     * Deletes data from the Milvus database.
+     * @param params Object containing a filter to apply to the deletion.
+     * @returns Promise resolving to void.
+     */
     delete(params: {
         filter: string;
     }): Promise<void>;

package/dist/vectorstores/milvus.js

@@ -7,6 +7,10 @@ const MILVUS_PRIMARY_FIELD_NAME = "langchain_primaryid";
 const MILVUS_VECTOR_FIELD_NAME = "langchain_vector";
 const MILVUS_TEXT_FIELD_NAME = "langchain_text";
 const MILVUS_COLLECTION_NAME_PREFIX = "langchain_col";
+/**
+ * Class for interacting with a Milvus database. Extends the VectorStore
+ * class.
+ */
 export class Milvus extends VectorStore {
     get lc_secrets() {
         return {
@@ -109,21 +113,41 @@ export class Milvus extends VectorStore {
         this.embeddings = embeddings;
         this.collectionName = args.collectionName ?? genCollectionName();
         this.textField = args.textField ?? MILVUS_TEXT_FIELD_NAME;
-        this.autoId = true;
+        this.autoId = args.autoId ?? true;
         this.primaryField = args.primaryField ?? MILVUS_PRIMARY_FIELD_NAME;
         this.vectorField = args.vectorField ?? MILVUS_VECTOR_FIELD_NAME;
         this.textFieldMaxLength = args.textFieldMaxLength ?? 0;
         this.fields = [];
         const url = args.url ?? getEnvironmentVariable("MILVUS_URL");
-        if (!url) {
+        const { address = "", username = "", password = "", ssl, } = args.clientConfig || {};
+        // combine args clientConfig and env variables
+        const clientConfig = {
+            ...(args.clientConfig || {}),
+            address: url || address,
+            username: args.username || username,
+            password: args.password || password,
+            ssl: args.ssl || ssl,
+        };
+        if (!clientConfig.address) {
             throw new Error("Milvus URL address is not provided.");
         }
-        this.client = new MilvusClient(url, args.ssl, args.username, args.password);
+        this.client = new MilvusClient(clientConfig);
     }
+    /**
+     * Adds documents to the Milvus database.
+     * @param documents Array of Document instances to be added to the database.
+     * @returns Promise resolving to void.
+     */
     async addDocuments(documents) {
         const texts = documents.map(({ pageContent }) => pageContent);
         await this.addVectors(await this.embeddings.embedDocuments(texts), documents);
     }
+    /**
+     * Adds vectors to the Milvus database.
+     * @param vectors Array of vectors to be added to the database.
+     * @param documents Array of Document instances associated with the vectors.
+     * @returns Promise resolving to void.
+     */
     async addVectors(vectors, documents) {
         if (vectors.length === 0) {
             return;
@@ -178,6 +202,14 @@ export class Milvus extends VectorStore {
         }
         await this.client.flushSync({ collection_names: [this.collectionName] });
     }
+    /**
+     * Searches for vectors in the Milvus database that are similar to a given
+     * vector.
+     * @param query Vector to compare with the vectors in the database.
+     * @param k Number of similar vectors to return.
+     * @param filter Optional filter to apply to the search.
+     * @returns Promise resolving to an array of tuples, each containing a Document instance and a similarity score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         const hasColResp = await this.client.hasCollection({
             collection_name: this.collectionName,
@@ -240,6 +272,12 @@ export class Milvus extends VectorStore {
         // console.log("Search result: " + JSON.stringify(results, null, 2));
         return results;
     }
+    /**
+     * Ensures that a collection exists in the Milvus database.
+     * @param vectors Optional array of vectors to be used if a new collection needs to be created.
+     * @param documents Optional array of Document instances to be used if a new collection needs to be created.
+     * @returns Promise resolving to void.
+     */
     async ensureCollection(vectors, documents) {
         const hasColResp = await this.client.hasCollection({
             collection_name: this.collectionName,
@@ -257,9 +295,15 @@ export class Milvus extends VectorStore {
             await this.grabCollectionFields();
         }
     }
+    /**
+     * Creates a collection in the Milvus database.
+     * @param vectors Array of vectors to be added to the new collection.
+     * @param documents Array of Document instances to be added to the new collection.
+     * @returns Promise resolving to void.
+     */
     async createCollection(vectors, documents) {
         const fieldList = [];
-        fieldList.push(...createFieldTypeForMetadata(documents));
+        fieldList.push(...createFieldTypeForMetadata(documents, this.primaryField));
         fieldList.push({
             name: this.primaryField,
             description: "Primary key",
@@ -302,6 +346,10 @@ export class Milvus extends VectorStore {
             extra_params: this.indexCreateParams,
         });
     }
+    /**
+     * Retrieves the fields of a collection in the Milvus database.
+     * @returns Promise resolving to void.
+     */
     async grabCollectionFields() {
         if (!this.collectionName) {
             throw new Error("Need collection name to grab collection fields");
@@ -326,7 +374,7 @@ export class Milvus extends VectorStore {
             if (field.is_primary_key) {
                 this.primaryField = field.name;
             }
-            const dtype = DataTypeMap[field.data_type.toLowerCase()];
+            const dtype = DataTypeMap[field.data_type];
             if (dtype === DataType.FloatVector || dtype === DataType.BinaryVector) {
                 this.vectorField = field.name;
             }
@@ -335,6 +383,15 @@ export class Milvus extends VectorStore {
             }
         });
     }
+    /**
+     * Creates a Milvus instance from a set of texts and their associated
+     * metadata.
+     * @param texts Array of texts to be added to the database.
+     * @param metadatas Array of metadata objects associated with the texts.
+     * @param embeddings Embeddings instance used to generate vector embeddings for the texts.
+     * @param dbConfig Optional configuration for the Milvus database.
+     * @returns Promise resolving to a new Milvus instance.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -347,6 +404,13 @@ export class Milvus extends VectorStore {
         }
         return Milvus.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Creates a Milvus instance from a set of Document instances.
+     * @param docs Array of Document instances to be added to the database.
+     * @param embeddings Embeddings instance used to generate vector embeddings for the documents.
+     * @param dbConfig Optional configuration for the Milvus database.
+     * @returns Promise resolving to a new Milvus instance.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const args = {
             collectionName: dbConfig?.collectionName || genCollectionName(),
@@ -357,16 +421,30 @@ export class Milvus extends VectorStore {
             textField: dbConfig?.textField,
             primaryField: dbConfig?.primaryField,
             vectorField: dbConfig?.vectorField,
+            clientConfig: dbConfig?.clientConfig,
+            autoId: dbConfig?.autoId,
         };
         const instance = new this(embeddings, args);
         await instance.addDocuments(docs);
         return instance;
     }
+    /**
+     * Creates a Milvus instance from an existing collection in the Milvus
+     * database.
+     * @param embeddings Embeddings instance used to generate vector embeddings for the documents in the collection.
+     * @param dbConfig Configuration for the Milvus database.
+     * @returns Promise resolving to a new Milvus instance.
+     */
     static async fromExistingCollection(embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.ensureCollection();
         return instance;
     }
+    /**
+     * Deletes data from the Milvus database.
+     * @param params Object containing a filter to apply to the deletion.
+     * @returns Promise resolving to void.
+     */
     async delete(params) {
         const hasColResp = await this.client.hasCollection({
             collection_name: this.collectionName,
@@ -387,7 +465,7 @@ export class Milvus extends VectorStore {
         }
     }
 }
-function createFieldTypeForMetadata(documents) {
+function createFieldTypeForMetadata(documents, primaryFieldName) {
     const sampleMetadata = documents[0].metadata;
     let textFieldMaxLength = 0;
     let jsonFieldMaxLength = 0;
@@ -415,7 +493,13 @@ function createFieldTypeForMetadata(documents) {
     const fields = [];
     for (const [key, value] of Object.entries(sampleMetadata)) {
         const type = typeof value;
-        if (type === "string") {
+        if (key === primaryFieldName) {
+            /**
+             * skip primary field
+             * because we will create primary field in createCollection
+             *  */
+        }
+        else if (type === "string") {
             fields.push({
                 name: key,
                 description: `Metadata String field`,

package/dist/vectorstores/mongo.cjs

@@ -32,10 +32,25 @@ class MongoVectorStore extends base_js_1.VectorStore {
         this.client = args.client;
         this.indexName = args.indexName || "default";
     }
+    /**
+     * Method that adds documents to the MongoDB collection. It first converts
+     * the documents into vectors using the `embedDocuments` method of the
+     * `embeddings` instance, and then adds these vectors to the collection.
+     * @param documents Array of Document instances to be added to the MongoDB collection.
+     * @returns Promise that resolves when the documents have been added to the collection.
+     */
     async addDocuments(documents) {
         const texts = documents.map(({ pageContent }) => pageContent);
         return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
     }
+    /**
+     * Method that adds vectors to the MongoDB collection. It creates an array
+     * of items, each containing the content, embedding, and metadata of a
+     * document, and then inserts these items into the collection.
+     * @param vectors Array of vectors to be added to the MongoDB collection.
+     * @param documents Array of Document instances corresponding to the vectors.
+     * @returns Promise that resolves when the vectors have been added to the collection.
+     */
     async addVectors(vectors, documents) {
         const items = vectors.map((embedding, idx) => ({
             content: documents[idx].pageContent,
@@ -44,6 +59,16 @@ class MongoVectorStore extends base_js_1.VectorStore {
         }));
         await this.collection.insertMany(items);
     }
+    /**
+     * Method that performs a similarity search on vectors and returns the
+     * documents and their similarity scores. It constructs a MongoDB
+     * aggregation pipeline, applies any post-query pipeline steps if
+     * provided, and then executes the pipeline to retrieve the results.
+     * @param query Query vector for the similarity search.
+     * @param k Number of nearest neighbors to return.
+     * @param filter Optional filter for the query, which can include post-query pipeline steps.
+     * @returns Promise that resolves to an array of tuples, each containing a Document instance and its similarity score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         // Search has to be the first pipeline step (https://www.mongodb.com/docs/atlas/atlas-search/query-syntax/#behavior)
         // We hopefully this changes in the future
@@ -97,6 +122,17 @@ class MongoVectorStore extends base_js_1.VectorStore {
         }
         return ret;
     }
+    /**
+     * Static method that creates a `MongoVectorStore` instance from an array
+     * of texts. It creates Document instances from the texts and their
+     * corresponding metadata, and then calls the `fromDocuments` method to
+     * create the `MongoVectorStore` instance.
+     * @param texts Array of texts to be converted into Document instances.
+     * @param metadatas Array or single object of metadata corresponding to the texts.
+     * @param embeddings Embeddings instance used to convert the texts into vectors.
+     * @param dbConfig Configuration for the MongoDB database.
+     * @returns Promise that resolves to a new MongoVectorStore instance.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -109,6 +145,15 @@ class MongoVectorStore extends base_js_1.VectorStore {
         }
         return MongoVectorStore.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Static method that creates a `MongoVectorStore` instance from an array
+     * of Document instances. It creates a new `MongoVectorStore` instance,
+     * adds the documents to it, and then returns the instance.
+     * @param docs Array of Document instances to be added to the `MongoVectorStore`.
+     * @param embeddings Embeddings instance used to convert the documents into vectors.
+     * @param dbConfig Configuration for the MongoDB database.
+     * @returns Promise that resolves to a new MongoVectorStore instance.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.addDocuments(docs);

package/dist/vectorstores/mongo.d.ts

@@ -8,6 +8,10 @@ export type MongoLibArgs = {
     collection: Collection<MongoDocument>;
     indexName?: string;
 };
+/**
+ * Type that defines an extension for MongoDB queries. It includes an
+ * optional array of post-query pipeline steps.
+ */
 export type MongoVectorStoreQueryExtension = {
     postQueryPipelineSteps?: MongoDocument[];
 };
@@ -19,9 +23,54 @@ export declare class MongoVectorStore extends VectorStore {
     indexName: string;
     _vectorstoreType(): string;
     constructor(embeddings: Embeddings, args: MongoLibArgs);
+    /**
+     * Method that adds documents to the MongoDB collection. It first converts
+     * the documents into vectors using the `embedDocuments` method of the
+     * `embeddings` instance, and then adds these vectors to the collection.
+     * @param documents Array of Document instances to be added to the MongoDB collection.
+     * @returns Promise that resolves when the documents have been added to the collection.
+     */
     addDocuments(documents: Document[]): Promise<void>;
+    /**
+     * Method that adds vectors to the MongoDB collection. It creates an array
+     * of items, each containing the content, embedding, and metadata of a
+     * document, and then inserts these items into the collection.
+     * @param vectors Array of vectors to be added to the MongoDB collection.
+     * @param documents Array of Document instances corresponding to the vectors.
+     * @returns Promise that resolves when the vectors have been added to the collection.
+     */
     addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    /**
+     * Method that performs a similarity search on vectors and returns the
+     * documents and their similarity scores. It constructs a MongoDB
+     * aggregation pipeline, applies any post-query pipeline steps if
+     * provided, and then executes the pipeline to retrieve the results.
+     * @param query Query vector for the similarity search.
+     * @param k Number of nearest neighbors to return.
+     * @param filter Optional filter for the query, which can include post-query pipeline steps.
+     * @returns Promise that resolves to an array of tuples, each containing a Document instance and its similarity score.
+     */
     similaritySearchVectorWithScore(query: number[], k: number, filter?: MongoVectorStoreQueryExtension): Promise<[Document, number][]>;
+    /**
+     * Static method that creates a `MongoVectorStore` instance from an array
+     * of texts. It creates Document instances from the texts and their
+     * corresponding metadata, and then calls the `fromDocuments` method to
+     * create the `MongoVectorStore` instance.
+     * @param texts Array of texts to be converted into Document instances.
+     * @param metadatas Array or single object of metadata corresponding to the texts.
+     * @param embeddings Embeddings instance used to convert the texts into vectors.
+     * @param dbConfig Configuration for the MongoDB database.
+     * @returns Promise that resolves to a new MongoVectorStore instance.
+     */
     static fromTexts(texts: string[], metadatas: object[] | object, embeddings: Embeddings, dbConfig: MongoLibArgs): Promise<MongoVectorStore>;
+    /**
+     * Static method that creates a `MongoVectorStore` instance from an array
+     * of Document instances. It creates a new `MongoVectorStore` instance,
+     * adds the documents to it, and then returns the instance.
+     * @param docs Array of Document instances to be added to the `MongoVectorStore`.
+     * @param embeddings Embeddings instance used to convert the documents into vectors.
+     * @param dbConfig Configuration for the MongoDB database.
+     * @returns Promise that resolves to a new MongoVectorStore instance.
+     */
     static fromDocuments(docs: Document[], embeddings: Embeddings, dbConfig: MongoLibArgs): Promise<MongoVectorStore>;
 }

package/dist/vectorstores/mongo.js

@@ -29,10 +29,25 @@ export class MongoVectorStore extends VectorStore {
         this.client = args.client;
         this.indexName = args.indexName || "default";
     }
+    /**
+     * Method that adds documents to the MongoDB collection. It first converts
+     * the documents into vectors using the `embedDocuments` method of the
+     * `embeddings` instance, and then adds these vectors to the collection.
+     * @param documents Array of Document instances to be added to the MongoDB collection.
+     * @returns Promise that resolves when the documents have been added to the collection.
+     */
     async addDocuments(documents) {
         const texts = documents.map(({ pageContent }) => pageContent);
         return this.addVectors(await this.embeddings.embedDocuments(texts), documents);
     }
+    /**
+     * Method that adds vectors to the MongoDB collection. It creates an array
+     * of items, each containing the content, embedding, and metadata of a
+     * document, and then inserts these items into the collection.
+     * @param vectors Array of vectors to be added to the MongoDB collection.
+     * @param documents Array of Document instances corresponding to the vectors.
+     * @returns Promise that resolves when the vectors have been added to the collection.
+     */
     async addVectors(vectors, documents) {
         const items = vectors.map((embedding, idx) => ({
             content: documents[idx].pageContent,
@@ -41,6 +56,16 @@ export class MongoVectorStore extends VectorStore {
         }));
         await this.collection.insertMany(items);
     }
+    /**
+     * Method that performs a similarity search on vectors and returns the
+     * documents and their similarity scores. It constructs a MongoDB
+     * aggregation pipeline, applies any post-query pipeline steps if
+     * provided, and then executes the pipeline to retrieve the results.
+     * @param query Query vector for the similarity search.
+     * @param k Number of nearest neighbors to return.
+     * @param filter Optional filter for the query, which can include post-query pipeline steps.
+     * @returns Promise that resolves to an array of tuples, each containing a Document instance and its similarity score.
+     */
     async similaritySearchVectorWithScore(query, k, filter) {
         // Search has to be the first pipeline step (https://www.mongodb.com/docs/atlas/atlas-search/query-syntax/#behavior)
         // We hopefully this changes in the future
@@ -94,6 +119,17 @@ export class MongoVectorStore extends VectorStore {
         }
         return ret;
     }
+    /**
+     * Static method that creates a `MongoVectorStore` instance from an array
+     * of texts. It creates Document instances from the texts and their
+     * corresponding metadata, and then calls the `fromDocuments` method to
+     * create the `MongoVectorStore` instance.
+     * @param texts Array of texts to be converted into Document instances.
+     * @param metadatas Array or single object of metadata corresponding to the texts.
+     * @param embeddings Embeddings instance used to convert the texts into vectors.
+     * @param dbConfig Configuration for the MongoDB database.
+     * @returns Promise that resolves to a new MongoVectorStore instance.
+     */
     static async fromTexts(texts, metadatas, embeddings, dbConfig) {
         const docs = [];
         for (let i = 0; i < texts.length; i += 1) {
@@ -106,6 +142,15 @@ export class MongoVectorStore extends VectorStore {
         }
         return MongoVectorStore.fromDocuments(docs, embeddings, dbConfig);
     }
+    /**
+     * Static method that creates a `MongoVectorStore` instance from an array
+     * of Document instances. It creates a new `MongoVectorStore` instance,
+     * adds the documents to it, and then returns the instance.
+     * @param docs Array of Document instances to be added to the `MongoVectorStore`.
+     * @param embeddings Embeddings instance used to convert the documents into vectors.
+     * @param dbConfig Configuration for the MongoDB database.
+     * @returns Promise that resolves to a new MongoVectorStore instance.
+     */
     static async fromDocuments(docs, embeddings, dbConfig) {
         const instance = new this(embeddings, dbConfig);
         await instance.addDocuments(docs);

package/dist/vectorstores/mongodb_atlas.cjs

@@ -4,6 +4,12 @@ exports.MongoDBAtlasVectorSearch = void 0;
 const base_js_1 = require("./base.cjs");
 const document_js_1 = require("../document.cjs");
 const math_js_1 = require("../util/math.cjs");
+/**
+ * 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.
+ */
 class MongoDBAtlasVectorSearch extends base_js_1.VectorStore {
     _vectorstoreType() {
         return "mongodb_atlas";
@@ -39,6 +45,13 @@ class MongoDBAtlasVectorSearch extends base_js_1.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,
@@ -47,10 +60,26 @@ class MongoDBAtlasVectorSearch extends base_js_1.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,
@@ -141,6 +170,16 @@ class MongoDBAtlasVectorSearch extends base_js_1.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) {
@@ -153,6 +192,15 @@ class MongoDBAtlasVectorSearch extends base_js_1.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);