langchain 0.0.202 → 0.0.204-rc.0

package/dist/vectorstores/momento_vector_index.js

@@ -1,292 +1 @@
-/* eslint-disable no-instanceof/no-instanceof */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ALL_VECTOR_METADATA, CreateVectorIndex, VectorUpsertItemBatch, VectorDeleteItemBatch, VectorSearch, VectorSearchAndFetchVectors, } from "@gomomento/sdk-core";
-import * as uuid from "uuid";
-import { Document } from "../document.js";
-import { VectorStore } from "./base.js";
-import { maximalMarginalRelevance } from "../util/math.js";
-/**
- * A vector store that uses the Momento Vector Index.
- *
- * @remarks
- * To sign up for a free Momento account, visit https://console.gomomento.com.
- */
-export class MomentoVectorIndex extends VectorStore {
-    _vectorstoreType() {
-        return "momento";
-    }
-    /**
-     * Creates a new `MomentoVectorIndex` instance.
-     * @param embeddings The embeddings instance to use to generate embeddings from documents.
-     * @param args The arguments to use to configure the vector store.
-     */
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        Object.defineProperty(this, "client", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "indexName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "textField", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_ensureIndexExists", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.embeddings = embeddings;
-        this.client = args.client;
-        this.indexName = args.indexName ?? "default";
-        this.textField = args.textField ?? "text";
-        this._ensureIndexExists = args.ensureIndexExists ?? true;
-    }
-    /**
-     * Returns the Momento Vector Index client.
-     * @returns The Momento Vector Index client.
-     */
-    getClient() {
-        return this.client;
-    }
-    /**
-     * Creates the index if it does not already exist.
-     * @param numDimensions The number of dimensions of the vectors to be stored in the index.
-     * @returns Promise that resolves to true if the index was created, false if it already existed.
-     */
-    async ensureIndexExists(numDimensions) {
-        const response = await this.client.createIndex(this.indexName, numDimensions);
-        if (response instanceof CreateVectorIndex.Success) {
-            return true;
-        }
-        else if (response instanceof CreateVectorIndex.AlreadyExists) {
-            return false;
-        }
-        else if (response instanceof CreateVectorIndex.Error) {
-            throw new Error(response.toString());
-        }
-        else {
-            throw new Error(`Unknown response type: ${response.toString()}`);
-        }
-    }
-    /**
-     * Converts the documents to a format that can be stored in the index.
-     *
-     * This is necessary because the Momento Vector Index requires that the metadata
-     * be a map of strings to strings.
-     * @param vectors The vectors to convert.
-     * @param documents The documents to convert.
-     * @param ids The ids to convert.
-     * @returns The converted documents.
-     */
-    prepareItemBatch(vectors, documents, ids) {
-        return vectors.map((vector, idx) => ({
-            id: ids[idx],
-            vector,
-            metadata: {
-                ...documents[idx].metadata,
-                [this.textField]: documents[idx].pageContent,
-            },
-        }));
-    }
-    /**
-     * Adds vectors to the index.
-     *
-     * @remarks If the index does not already exist, it will be created if `ensureIndexExists` is true.
-     * @param vectors The vectors to add to the index.
-     * @param documents The documents to add to the index.
-     * @param documentProps The properties of the documents to add to the index, specifically the ids.
-     * @returns Promise that resolves when the vectors have been added to the index. Also returns the ids of the
-     * documents that were added.
-     */
-    async addVectors(vectors, documents, documentProps) {
-        if (vectors.length === 0) {
-            return;
-        }
-        if (documents.length !== vectors.length) {
-            throw new Error(`Number of vectors (${vectors.length}) does not equal number of documents (${documents.length})`);
-        }
-        if (vectors.some((v) => v.length !== vectors[0].length)) {
-            throw new Error("All vectors must have the same length");
-        }
-        if (documentProps?.ids !== undefined &&
-            documentProps.ids.length !== vectors.length) {
-            throw new Error(`Number of ids (${documentProps?.ids?.length || "null"}) does not equal number of vectors (${vectors.length})`);
-        }
-        if (this._ensureIndexExists) {
-            await this.ensureIndexExists(vectors[0].length);
-        }
-        const documentIds = documentProps?.ids ?? documents.map(() => uuid.v4());
-        const batchSize = 128;
-        const numBatches = Math.ceil(vectors.length / batchSize);
-        // Add each batch of vectors to the index
-        for (let i = 0; i < numBatches; i += 1) {
-            const [startIndex, endIndex] = [
-                i * batchSize,
-                Math.min((i + 1) * batchSize, vectors.length),
-            ];
-            const batchVectors = vectors.slice(startIndex, endIndex);
-            const batchDocuments = documents.slice(startIndex, endIndex);
-            const batchDocumentIds = documentIds.slice(startIndex, endIndex);
-            // Insert the items to the index
-            const response = await this.client.upsertItemBatch(this.indexName, this.prepareItemBatch(batchVectors, batchDocuments, batchDocumentIds));
-            if (response instanceof VectorUpsertItemBatch.Success) {
-                // eslint-disable-next-line no-continue
-                continue;
-            }
-            else if (response instanceof VectorUpsertItemBatch.Error) {
-                throw new Error(response.toString());
-            }
-            else {
-                throw new Error(`Unknown response type: ${response.toString()}`);
-            }
-        }
-    }
-    /**
-     * Adds vectors to the index. Generates embeddings from the documents
-     * using the `Embeddings` instance passed to the constructor.
-     * @param documents Array of `Document` instances to be added to the index.
-     * @returns Promise that resolves when the documents have been added to the index.
-     */
-    async addDocuments(documents, documentProps) {
-        const texts = documents.map(({ pageContent }) => pageContent);
-        await this.addVectors(await this.embeddings.embedDocuments(texts), documents, documentProps);
-    }
-    /**
-     * Deletes vectors from the index by id.
-     * @param params The parameters to use to delete the vectors, specifically the ids.
-     */
-    async delete(params) {
-        const response = await this.client.deleteItemBatch(this.indexName, params.ids);
-        if (response instanceof VectorDeleteItemBatch.Success) {
-            // pass
-        }
-        else if (response instanceof VectorDeleteItemBatch.Error) {
-            throw new Error(response.toString());
-        }
-        else {
-            throw new Error(`Unknown response type: ${response.toString()}`);
-        }
-    }
-    /**
-     * Searches the index for the most similar vectors to the query vector.
-     * @param query The query vector.
-     * @param k The number of results to return.
-     * @returns Promise that resolves to the documents of the most similar vectors
-     * to the query vector.
-     */
-    async similaritySearchVectorWithScore(query, k) {
-        const response = await this.client.search(this.indexName, query, {
-            topK: k,
-            metadataFields: ALL_VECTOR_METADATA,
-        });
-        if (response instanceof VectorSearch.Success) {
-            if (response.hits === undefined) {
-                return [];
-            }
-            return response.hits().map((hit) => [
-                new Document({
-                    pageContent: hit.metadata[this.textField]?.toString() ?? "",
-                    metadata: Object.fromEntries(Object.entries(hit.metadata).filter(([key]) => key !== this.textField)),
-                }),
-                hit.score,
-            ]);
-        }
-        else if (response instanceof VectorSearch.Error) {
-            throw new Error(response.toString());
-        }
-        else {
-            throw new Error(`Unknown response type: ${response.toString()}`);
-        }
-    }
-    /**
-     * Return documents selected using the maximal marginal relevance.
-     * Maximal marginal relevance optimizes for similarity to the query AND diversity
-     * among selected documents.
-     *
-     * @param {string} query - Text to look up documents similar to.
-     * @param {number} options.k - Number of documents to return.
-     * @param {number} options.fetchK - Number of documents to fetch before passing to the MMR algorithm.
-     * @param {number} options.lambda - Number between 0 and 1 that determines the degree of diversity among the results,
-     *                 where 0 corresponds to maximum diversity and 1 to minimum diversity.
-     * @param {this["FilterType"]} options.filter - Optional filter
-     * @param _callbacks
-     *
-     * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
-     */
-    async maxMarginalRelevanceSearch(query, options) {
-        const queryEmbedding = await this.embeddings.embedQuery(query);
-        const response = await this.client.searchAndFetchVectors(this.indexName, queryEmbedding, { topK: options.fetchK ?? 20, metadataFields: ALL_VECTOR_METADATA });
-        if (response instanceof VectorSearchAndFetchVectors.Success) {
-            const hits = response.hits();
-            // Gather the embeddings of the search results
-            const embeddingList = hits.map((hit) => hit.vector);
-            // Gather the ids of the most relevant results when applying MMR
-            const mmrIndexes = maximalMarginalRelevance(queryEmbedding, embeddingList, options.lambda, options.k);
-            const finalResult = mmrIndexes.map((index) => {
-                const hit = hits[index];
-                const { [this.textField]: pageContent, ...metadata } = hit.metadata;
-                return new Document({ metadata, pageContent: pageContent });
-            });
-            return finalResult;
-        }
-        else if (response instanceof VectorSearchAndFetchVectors.Error) {
-            throw new Error(response.toString());
-        }
-        else {
-            throw new Error(`Unknown response type: ${response.toString()}`);
-        }
-    }
-    /**
-     * Stores the documents in the index.
-     *
-     * Converts the documents to vectors using the `Embeddings` instance passed.
-     * @param texts The texts to store in the index.
-     * @param metadatas The metadata to store in the index.
-     * @param embeddings The embeddings instance to use to generate embeddings from the documents.
-     * @param dbConfig The configuration to use to instantiate the vector store.
-     * @param documentProps The properties of the documents to add to the index, specifically the ids.
-     * @returns Promise that resolves to the vector store.
-     */
-    static async fromTexts(texts, metadatas, embeddings, dbConfig, documentProps) {
-        if (Array.isArray(metadatas) && texts.length !== metadatas.length) {
-            throw new Error(`Number of texts (${texts.length}) does not equal number of metadatas (${metadatas.length})`);
-        }
-        const docs = [];
-        for (let i = 0; i < texts.length; i += 1) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const metadata = Array.isArray(metadatas)
-                ? metadatas[i]
-                : metadatas;
-            const newDoc = new Document({
-                pageContent: texts[i],
-                metadata,
-            });
-            docs.push(newDoc);
-        }
-        return await this.fromDocuments(docs, embeddings, dbConfig, documentProps);
-    }
-    /**
-     * Stores the documents in the index.
-     * @param docs The documents to store in the index.
-     * @param embeddings The embeddings instance to use to generate embeddings from the documents.
-     * @param dbConfig The configuration to use to instantiate the vector store.
-     * @param documentProps The properties of the documents to add to the index, specifically the ids.
-     * @returns Promise that resolves to the vector store.
-     */
-    static async fromDocuments(docs, embeddings, dbConfig, documentProps) {
-        const vectorStore = new MomentoVectorIndex(embeddings, dbConfig);
-        await vectorStore.addDocuments(docs, documentProps);
-        return vectorStore;
-    }
-}
+export * from "@langchain/community/vectorstores/momento_vector_index";

package/dist/vectorstores/mongodb_atlas.cjs

@@ -1,220 +1,17 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.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";
-    }
-    constructor(embeddings, args) {
-        super(embeddings, args);
-        Object.defineProperty(this, "collection", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "indexName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "textKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "embeddingKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.collection = args.collection;
-        this.indexName = args.indexName ?? "default";
-        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,
-            [this.embeddingKey]: embedding,
-            ...documents[idx].metadata,
-        }));
-        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 postFilterPipeline = filter?.postFilterPipeline ?? [];
-        const preFilter = filter?.preFilter ||
-            filter?.postFilterPipeline ||
-            filter?.includeEmbeddings
-            ? filter.preFilter
-            : filter;
-        const removeEmbeddingsPipeline = !filter?.includeEmbeddings
-            ? [
-                {
-                    $project: {
-                        [this.embeddingKey]: 0,
-                    },
-                },
-            ]
-            : [];
-        const pipeline = [
-            {
-                $vectorSearch: {
-                    queryVector: MongoDBAtlasVectorSearch.fixArrayPrecision(query),
-                    index: this.indexName,
-                    path: this.embeddingKey,
-                    limit: k,
-                    numCandidates: 10 * k,
-                    ...(preFilter && { filter: preFilter }),
-                },
-            },
-            {
-                $set: {
-                    score: { $meta: "vectorSearchScore" },
-                },
-            },
-            ...removeEmbeddingsPipeline,
-            ...postFilterPipeline,
-        ];
-        const results = this.collection
-            .aggregate(pipeline)
-            .map((result) => {
-            const { score, [this.textKey]: text, ...metadata } = result;
-            return [new document_js_1.Document({ pageContent: text, metadata }), score];
-        });
-        return results.toArray();
-    }
-    /**
-     * Return documents selected using the maximal marginal relevance.
-     * Maximal marginal relevance optimizes for similarity to the query AND diversity
-     * among selected documents.
-     *
-     * @param {string} query - Text to look up documents similar to.
-     * @param {number} options.k - Number of documents to return.
-     * @param {number} options.fetchK=20- Number of documents to fetch before passing to the MMR algorithm.
-     * @param {number} options.lambda=0.5 - Number between 0 and 1 that determines the degree of diversity among the results,
-     *                 where 0 corresponds to maximum diversity and 1 to minimum diversity.
-     * @param {MongoDBAtlasFilter} options.filter - Optional Atlas Search operator to pre-filter on document fields
-     *                                      or post-filter following the knnBeta search.
-     *
-     * @returns {Promise<Document[]>} - List of documents selected by maximal marginal relevance.
-     */
-    async maxMarginalRelevanceSearch(query, options) {
-        const { k, fetchK = 20, lambda = 0.5, filter } = options;
-        const queryEmbedding = await this.embeddings.embedQuery(query);
-        // preserve the original value of includeEmbeddings
-        const includeEmbeddingsFlag = options.filter?.includeEmbeddings || false;
-        // update filter to include embeddings, as they will be used in MMR
-        const includeEmbeddingsFilter = {
-            ...filter,
-            includeEmbeddings: true,
-        };
-        const resultDocs = await this.similaritySearchVectorWithScore(MongoDBAtlasVectorSearch.fixArrayPrecision(queryEmbedding), fetchK, includeEmbeddingsFilter);
-        const embeddingList = resultDocs.map((doc) => doc[0].metadata[this.embeddingKey]);
-        const mmrIndexes = (0, math_js_1.maximalMarginalRelevance)(queryEmbedding, embeddingList, lambda, k);
-        return mmrIndexes.map((idx) => {
-            const doc = resultDocs[idx][0];
-            // remove embeddings if they were not requested originally
-            if (!includeEmbeddingsFlag) {
-                delete doc.metadata[this.embeddingKey];
-            }
-            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) {
-            const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;
-            const newDoc = new document_js_1.Document({
-                pageContent: texts[i],
-                metadata,
-            });
-            docs.push(newDoc);
-        }
-        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);
-        return instance;
-    }
-    /**
-     * Static method to fix the precision of the array that ensures that
-     * every number in this array is always float when casted to other types.
-     * This is needed since MongoDB Atlas Vector Search does not cast integer
-     * inside vector search to float automatically.
-     * This method shall introduce a hint of error but should be safe to use
-     * since introduced error is very small, only applies to integer numbers
-     * returned by embeddings, and most embeddings shall not have precision
-     * as high as 15 decimal places.
-     * @param array Array of number to be fixed.
-     * @returns
-     */
-    static fixArrayPrecision(array) {
-        return array.map((value) => {
-            if (Number.isInteger(value)) {
-                return value + 0.000000000000001;
-            }
-            return value;
-        });
-    }
-}
-exports.MongoDBAtlasVectorSearch = MongoDBAtlasVectorSearch;
+__exportStar(require("@langchain/community/vectorstores/mongodb_atlas"), exports);

package/dist/vectorstores/mongodb_atlas.d.ts

@@ -1,118 +1 @@
-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;
-    private readonly indexName;
-    private readonly textKey;
-    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.
-     * Maximal marginal relevance optimizes for similarity to the query AND diversity
-     * among selected documents.
-     *
-     * @param {string} query - Text to look up documents similar to.
-     * @param {number} options.k - Number of documents to return.
-     * @param {number} options.fetchK=20- Number of documents to fetch before passing to the MMR algorithm.
-     * @param {number} options.lambda=0.5 - Number between 0 and 1 that determines the degree of diversity among the results,
-     *                 where 0 corresponds to maximum diversity and 1 to minimum diversity.
-     * @param {MongoDBAtlasFilter} options.filter - Optional Atlas Search operator to pre-filter on document fields
-     *                                      or post-filter following the knnBeta search.
-     *
-     * @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>;
-    /**
-     * Static method to fix the precision of the array that ensures that
-     * every number in this array is always float when casted to other types.
-     * This is needed since MongoDB Atlas Vector Search does not cast integer
-     * inside vector search to float automatically.
-     * This method shall introduce a hint of error but should be safe to use
-     * since introduced error is very small, only applies to integer numbers
-     * returned by embeddings, and most embeddings shall not have precision
-     * as high as 15 decimal places.
-     * @param array Array of number to be fixed.
-     * @returns
-     */
-    static fixArrayPrecision(array: number[]): number[];
-}
-export {};
+export * from "@langchain/community/vectorstores/mongodb_atlas";