langchain 0.2.12 → 0.2.14

package/dist/agents/openai_tools/index.cjs

@@ -70,7 +70,9 @@ async function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable, }) {
             `Found ${JSON.stringify(prompt.inputVariables)} instead.`,
         ].join("\n"));
     }
-    const modelWithTools = llm.bind({ tools: tools.map(function_calling_1.convertToOpenAITool) });
+    const modelWithTools = llm.bind({
+        tools: tools.map((tool) => (0, function_calling_1.convertToOpenAITool)(tool)),
+    });
     const agent = agent_js_1.AgentRunnableSequence.fromRunnables([
         runnables_1.RunnablePassthrough.assign({
             agent_scratchpad: (input) => (0, openai_tools_js_1.formatToOpenAIToolMessages)(input.steps),

package/dist/agents/openai_tools/index.js

@@ -67,7 +67,9 @@ export async function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnabl
             `Found ${JSON.stringify(prompt.inputVariables)} instead.`,
         ].join("\n"));
     }
-    const modelWithTools = llm.bind({ tools: tools.map(convertToOpenAITool) });
+    const modelWithTools = llm.bind({
+        tools: tools.map((tool) => convertToOpenAITool(tool)),
+    });
     const agent = AgentRunnableSequence.fromRunnables([
         RunnablePassthrough.assign({
             agent_scratchpad: (input) => formatToOpenAIToolMessages(input.steps),

package/dist/agents/openai_tools/output_parser.cjs

@@ -23,7 +23,7 @@ const types_js_1 = require("../types.cjs");
  *   new ChatOpenAI({
  *     modelName: "gpt-3.5-turbo-1106",
  *     temperature: 0,
- *   }).bind({ tools: tools.map(convertToOpenAITool) }),
+ *   }).bind({ tools: tools.map((tool) => convertToOpenAITool(tool)) }),
  *   new OpenAIToolsAgentOutputParser(),
  * ]).withConfig({ runName: "OpenAIToolsAgent" });
  *

package/dist/agents/openai_tools/output_parser.d.ts

@@ -23,7 +23,7 @@ export type { ToolsAgentAction, ToolsAgentStep };
  *   new ChatOpenAI({
  *     modelName: "gpt-3.5-turbo-1106",
  *     temperature: 0,
- *   }).bind({ tools: tools.map(convertToOpenAITool) }),
+ *   }).bind({ tools: tools.map((tool) => convertToOpenAITool(tool)) }),
  *   new OpenAIToolsAgentOutputParser(),
  * ]).withConfig({ runName: "OpenAIToolsAgent" });
  *

package/dist/agents/openai_tools/output_parser.js

@@ -20,7 +20,7 @@ import { AgentMultiActionOutputParser } from "../types.js";
  *   new ChatOpenAI({
  *     modelName: "gpt-3.5-turbo-1106",
  *     temperature: 0,
- *   }).bind({ tools: tools.map(convertToOpenAITool) }),
+ *   }).bind({ tools: tools.map((tool) => convertToOpenAITool(tool)) }),
  *   new OpenAIToolsAgentOutputParser(),
  * ]).withConfig({ runName: "OpenAIToolsAgent" });
  *

package/dist/chat_models/universal.d.ts

@@ -1,5 +1,5 @@
 import { BaseLanguageModelInput, ToolDefinition } from "@langchain/core/language_models/base";
-import { BaseChatModel, BaseChatModelParams, type BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
+import { BaseChatModel, BaseChatModelParams, BindToolsInput, type BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
 import { BaseMessage, type AIMessageChunk } from "@langchain/core/messages";
 import { type RunnableBatchOptions, RunnableBinding, type RunnableConfig, type RunnableToolLike } from "@langchain/core/runnables";
 import { IterableReadableStream } from "@langchain/core/utils/stream";
@@ -62,7 +62,7 @@ declare class _ConfigurableModel<RunInput extends BaseLanguageModelInput = BaseL
     constructor(fields: ConfigurableModelFields);
     _model(config?: RunnableConfig): Promise<BaseChatModel<BaseChatModelCallOptions, import("@langchain/core/messages").BaseMessageChunk>>;
     _generate(messages: BaseMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    bindTools(tools: (StructuredToolInterface | Record<string, any> | ToolDefinition | RunnableToolLike)[], params?: Record<string, any>): _ConfigurableModel<RunInput, CallOptions>;
+    bindTools(tools: BindToolsInput[], params?: Record<string, any>): _ConfigurableModel<RunInput, CallOptions>;
     withStructuredOutput: BaseChatModel["withStructuredOutput"];
     _modelParams(config?: RunnableConfig): Record<string, any>;
     _removePrefix(str: string, prefix: string): string;

package/dist/evaluation/embedding_distance/base.cjs

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PairwiseEmbeddingDistanceEvalChain = exports.EmbeddingDistanceEvalChain = exports.computeEvaluationScore = exports.getDistanceCalculationFunction = void 0;
-const ml_distance_1 = require("ml-distance");
 const openai_1 = require("@langchain/openai");
 const base_js_1 = require("../base.cjs");
+const similarities_js_1 = require("../../util/ml-distance/similarities.cjs");
+const distances_js_1 = require("../../util/ml-distance/distances.cjs");
+const euclidean_js_1 = require("../../util/ml-distance-euclidean/euclidean.cjs");
 /**
  * Get the distance function for the given distance type.
  * @param distance The distance type.
@@ -11,10 +13,10 @@ const base_js_1 = require("../base.cjs");
  */
 function getDistanceCalculationFunction(distanceType) {
     const distanceFunctions = {
-        cosine: (X, Y) => 1.0 - ml_distance_1.similarity.cosine(X, Y),
-        euclidean: ml_distance_1.distance.euclidean,
-        manhattan: ml_distance_1.distance.manhattan,
-        chebyshev: ml_distance_1.distance.chebyshev,
+        cosine: (X, Y) => 1.0 - (0, similarities_js_1.cosine)(X, Y),
+        euclidean: euclidean_js_1.euclidean,
+        manhattan: distances_js_1.manhattan,
+        chebyshev: distances_js_1.chebyshev,
     };
     return distanceFunctions[distanceType];
 }

package/dist/evaluation/embedding_distance/base.js

@@ -1,6 +1,8 @@
-import { distance, similarity } from "ml-distance";
 import { OpenAIEmbeddings } from "@langchain/openai";
 import { PairwiseStringEvaluator, StringEvaluator, } from "../base.js";
+import { cosine } from "../../util/ml-distance/similarities.js";
+import { chebyshev, manhattan } from "../../util/ml-distance/distances.js";
+import { euclidean } from "../../util/ml-distance-euclidean/euclidean.js";
 /**
  * Get the distance function for the given distance type.
  * @param distance The distance type.
@@ -8,10 +10,10 @@ import { PairwiseStringEvaluator, StringEvaluator, } from "../base.js";
  */
 export function getDistanceCalculationFunction(distanceType) {
     const distanceFunctions = {
-        cosine: (X, Y) => 1.0 - similarity.cosine(X, Y),
-        euclidean: distance.euclidean,
-        manhattan: distance.manhattan,
-        chebyshev: distance.chebyshev,
+        cosine: (X, Y) => 1.0 - cosine(X, Y),
+        euclidean,
+        manhattan,
+        chebyshev,
     };
     return distanceFunctions[distanceType];
 }

package/dist/hub.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pull = exports.push = void 0;
-const langchainhub_1 = require("langchainhub");
+const langsmith_1 = require("langsmith");
 const index_js_1 = require("./load/index.cjs");
 /**
  * Push a prompt to the hub.
@@ -12,8 +12,16 @@ const index_js_1 = require("./load/index.cjs");
  * @returns The URL of the newly pushed prompt in the hub.
  */
 async function push(repoFullName, runnable, options) {
-    const client = new langchainhub_1.Client(options);
-    return client.push(repoFullName, JSON.stringify(runnable), options);
+    const client = new langsmith_1.Client(options);
+    const payloadOptions = {
+        object: runnable,
+        parentCommitHash: options?.parentCommitHash,
+        isPublic: options?.isPublic ?? options?.newRepoIsPublic,
+        description: options?.description ?? options?.newRepoDescription,
+        readme: options?.readme,
+        tags: options?.tags,
+    };
+    return client.pushPrompt(repoFullName, payloadOptions);
 }
 exports.push = push;
 /**
@@ -23,8 +31,10 @@ exports.push = push;
  * @returns
  */
 async function pull(ownerRepoCommit, options) {
-    const client = new langchainhub_1.Client(options);
-    const result = await client.pull(ownerRepoCommit);
+    const client = new langsmith_1.Client(options);
+    const result = await client._pullPrompt(ownerRepoCommit, {
+        includeModel: options?.includeModel,
+    });
     return (0, index_js_1.load)(result);
 }
 exports.pull = pull;

package/dist/hub.d.ts

@@ -1,4 +1,3 @@
-import { ClientConfiguration, HubPushOptions } from "langchainhub";
 import { Runnable } from "@langchain/core/runnables";
 /**
  * Push a prompt to the hub.
@@ -8,11 +7,27 @@ import { Runnable } from "@langchain/core/runnables";
  * @param options
  * @returns The URL of the newly pushed prompt in the hub.
  */
-export declare function push(repoFullName: string, runnable: Runnable, options?: HubPushOptions & ClientConfiguration): Promise<string>;
+export declare function push(repoFullName: string, runnable: Runnable, options?: {
+    apiKey?: string;
+    apiUrl?: string;
+    parentCommitHash?: string;
+    /** @deprecated Use isPublic instead. */
+    newRepoIsPublic?: boolean;
+    isPublic?: boolean;
+    /** @deprecated Use description instead. */
+    newRepoDescription?: string;
+    description?: string;
+    readme?: string;
+    tags?: string[];
+}): Promise<string>;
 /**
  * Pull a prompt from the hub.
  * @param ownerRepoCommit The name of the repo containing the prompt, as well as an optional commit hash separated by a slash.
  * @param options
  * @returns
  */
-export declare function pull<T extends Runnable>(ownerRepoCommit: string, options?: ClientConfiguration): Promise<T>;
+export declare function pull<T extends Runnable>(ownerRepoCommit: string, options?: {
+    apiKey?: string;
+    apiUrl?: string;
+    includeModel?: boolean;
+}): Promise<T>;

package/dist/hub.js

@@ -1,4 +1,4 @@
-import { Client } from "langchainhub";
+import { Client } from "langsmith";
 import { load } from "./load/index.js";
 /**
  * Push a prompt to the hub.
@@ -10,7 +10,15 @@ import { load } from "./load/index.js";
  */
 export async function push(repoFullName, runnable, options) {
     const client = new Client(options);
-    return client.push(repoFullName, JSON.stringify(runnable), options);
+    const payloadOptions = {
+        object: runnable,
+        parentCommitHash: options?.parentCommitHash,
+        isPublic: options?.isPublic ?? options?.newRepoIsPublic,
+        description: options?.description ?? options?.newRepoDescription,
+        readme: options?.readme,
+        tags: options?.tags,
+    };
+    return client.pushPrompt(repoFullName, payloadOptions);
 }
 /**
  * Pull a prompt from the hub.
@@ -20,6 +28,8 @@ export async function push(repoFullName, runnable, options) {
  */
 export async function pull(ownerRepoCommit, options) {
     const client = new Client(options);
-    const result = await client.pull(ownerRepoCommit);
+    const result = await client._pullPrompt(ownerRepoCommit, {
+        includeModel: options?.includeModel,
+    });
     return load(result);
 }

package/dist/tools/sql.cjs

@@ -172,7 +172,7 @@ class QueryCheckerTool extends tools_1.Tool {
             writable: true,
             value: `
     {query}
-Double check the sqlite query above for common mistakes, including:
+Double check the SQL query above for common mistakes, including:
 - Using NOT IN with NULL values
 - Using UNION when UNION ALL should have been used
 - Using BETWEEN for exclusive ranges

package/dist/tools/sql.js

@@ -166,7 +166,7 @@ export class QueryCheckerTool extends Tool {
             writable: true,
             value: `
     {query}
-Double check the sqlite query above for common mistakes, including:
+Double check the SQL query above for common mistakes, including:
 - Using NOT IN with NULL values
 - Using UNION when UNION ALL should have been used
 - Using BETWEEN for exclusive ranges

package/dist/util/ml-distance/distances.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manhattan = exports.chebyshev = exports.innerProduct = void 0;
+/**
+ *Returns the Inner Product similarity between vectors a and b
+ * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+function innerProduct(a, b) {
+    let ans = 0;
+    for (let i = 0; i < a.length; i++) {
+        ans += a[i] * b[i];
+    }
+    return ans;
+}
+exports.innerProduct = innerProduct;
+/**
+ *Returns the Chebyshev distance between vectors a and b
+ * @link [Chebyshev algorithm](https://en.wikipedia.org/wiki/Chebyshev_distance)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+function chebyshev(a, b) {
+    let max = 0;
+    let aux = 0;
+    for (let i = 0; i < a.length; i++) {
+        aux = Math.abs(a[i] - b[i]);
+        if (max < aux) {
+            max = aux;
+        }
+    }
+    return max;
+}
+exports.chebyshev = chebyshev;
+/**
+ *Returns the Manhattan distance between vectors a and b
+ * @link [Manhattan algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+function manhattan(a, b) {
+    let d = 0;
+    for (let i = 0; i < a.length; i++) {
+        d += Math.abs(a[i] - b[i]);
+    }
+    return d;
+}
+exports.manhattan = manhattan;

package/dist/util/ml-distance/distances.d.ts

@@ -0,0 +1,24 @@
+/**
+ *Returns the Inner Product similarity between vectors a and b
+ * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export declare function innerProduct(a: number[], b: number[]): number;
+/**
+ *Returns the Chebyshev distance between vectors a and b
+ * @link [Chebyshev algorithm](https://en.wikipedia.org/wiki/Chebyshev_distance)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export declare function chebyshev(a: number[], b: number[]): number;
+/**
+ *Returns the Manhattan distance between vectors a and b
+ * @link [Manhattan algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export declare function manhattan(a: number[], b: number[]): number;

package/dist/util/ml-distance/distances.js

@@ -0,0 +1,46 @@
+/**
+ *Returns the Inner Product similarity between vectors a and b
+ * @link [Inner Product Similarity algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export function innerProduct(a, b) {
+    let ans = 0;
+    for (let i = 0; i < a.length; i++) {
+        ans += a[i] * b[i];
+    }
+    return ans;
+}
+/**
+ *Returns the Chebyshev distance between vectors a and b
+ * @link [Chebyshev algorithm](https://en.wikipedia.org/wiki/Chebyshev_distance)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export function chebyshev(a, b) {
+    let max = 0;
+    let aux = 0;
+    for (let i = 0; i < a.length; i++) {
+        aux = Math.abs(a[i] - b[i]);
+        if (max < aux) {
+            max = aux;
+        }
+    }
+    return max;
+}
+/**
+ *Returns the Manhattan distance between vectors a and b
+ * @link [Manhattan algorithm](https://www.naun.org/main/NAUN/ijmmas/mmmas-49.pdf)
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export function manhattan(a, b) {
+    let d = 0;
+    for (let i = 0; i < a.length; i++) {
+        d += Math.abs(a[i] - b[i]);
+    }
+    return d;
+}

package/dist/util/ml-distance/similarities.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cosine = void 0;
+/**
+ * Returns the average of cosine distances between vectors a and b
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+function cosine(a, b) {
+    let p = 0;
+    let p2 = 0;
+    let q2 = 0;
+    for (let i = 0; i < a.length; i++) {
+        p += a[i] * b[i];
+        p2 += a[i] * a[i];
+        q2 += b[i] * b[i];
+    }
+    return p / (Math.sqrt(p2) * Math.sqrt(q2));
+}
+exports.cosine = cosine;

package/dist/util/ml-distance/similarities.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the average of cosine distances between vectors a and b
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export declare function cosine(a: number[], b: number[]): number;

package/dist/util/ml-distance/similarities.js

@@ -0,0 +1,17 @@
+/**
+ * Returns the average of cosine distances between vectors a and b
+ * @param a - first vector
+ * @param b - second vector
+ *
+ */
+export function cosine(a, b) {
+    let p = 0;
+    let p2 = 0;
+    let q2 = 0;
+    for (let i = 0; i < a.length; i++) {
+        p += a[i] * b[i];
+        p2 += a[i] * a[i];
+        q2 += b[i] * b[i];
+    }
+    return p / (Math.sqrt(p2) * Math.sqrt(q2));
+}

package/dist/util/ml-distance-euclidean/euclidean.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.euclidean = exports.squaredEuclidean = void 0;
+function squaredEuclidean(p, q) {
+    let d = 0;
+    for (let i = 0; i < p.length; i++) {
+        d += (p[i] - q[i]) * (p[i] - q[i]);
+    }
+    return d;
+}
+exports.squaredEuclidean = squaredEuclidean;
+function euclidean(p, q) {
+    return Math.sqrt(squaredEuclidean(p, q));
+}
+exports.euclidean = euclidean;

package/dist/util/ml-distance-euclidean/euclidean.d.ts

@@ -0,0 +1,2 @@
+export declare function squaredEuclidean(p: number[], q: number[]): number;
+export declare function euclidean(p: number[], q: number[]): number;

package/dist/util/ml-distance-euclidean/euclidean.js

@@ -0,0 +1,10 @@
+export function squaredEuclidean(p, q) {
+    let d = 0;
+    for (let i = 0; i < p.length; i++) {
+        d += (p[i] - q[i]) * (p[i] - q[i]);
+    }
+    return d;
+}
+export function euclidean(p, q) {
+    return Math.sqrt(squaredEuclidean(p, q));
+}

package/dist/vectorstores/memory.cjs

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryVectorStore = void 0;
-const ml_distance_1 = require("ml-distance");
 const vectorstores_1 = require("@langchain/core/vectorstores");
 const documents_1 = require("@langchain/core/documents");
+const similarities_js_1 = require("../util/ml-distance/similarities.cjs");
+const math_js_1 = require("../util/math.cjs");
 /**
  * Class that extends `VectorStore` to store vectors in memory. Provides
  * methods for adding documents, performing similarity searches, and
@@ -27,7 +28,7 @@ class MemoryVectorStore extends vectorstores_1.VectorStore {
             writable: true,
             value: void 0
         });
-        this.similarity = similarity ?? ml_distance_1.similarity.cosine;
+        this.similarity = similarity ?? similarities_js_1.cosine;
     }
     /**
      * Method to add documents to the memory vector store. It extracts the
@@ -56,17 +57,7 @@ class MemoryVectorStore extends vectorstores_1.VectorStore {
         }));
         this.memoryVectors = this.memoryVectors.concat(memoryVectors);
     }
-    /**
-     * Method to perform a similarity search in the memory vector store. It
-     * calculates the similarity between the query vector and each vector in
-     * the store, sorts the results by similarity, and returns the top `k`
-     * results along with their scores.
-     * @param query Query vector to compare against the vectors in the store.
-     * @param k Number of top results to return.
-     * @param filter Optional filter function to apply to the vectors before performing the search.
-     * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
-     */
-    async similaritySearchVectorWithScore(query, k, filter) {
+    async _queryVectors(query, k, filter) {
         const filterFunction = (memoryVector) => {
             if (!filter) {
                 return true;
@@ -78,22 +69,48 @@ class MemoryVectorStore extends vectorstores_1.VectorStore {
             return filter(doc);
         };
         const filteredMemoryVectors = this.memoryVectors.filter(filterFunction);
-        const searches = filteredMemoryVectors
+        return filteredMemoryVectors
             .map((vector, index) => ({
             similarity: this.similarity(query, vector.embedding),
             index,
+            metadata: vector.metadata,
+            content: vector.content,
+            embedding: vector.embedding,
         }))
             .sort((a, b) => (a.similarity > b.similarity ? -1 : 0))
             .slice(0, k);
+    }
+    /**
+     * Method to perform a similarity search in the memory vector store. It
+     * calculates the similarity between the query vector and each vector in
+     * the store, sorts the results by similarity, and returns the top `k`
+     * results along with their scores.
+     * @param query Query vector to compare against the vectors in the store.
+     * @param k Number of top results to return.
+     * @param filter Optional filter function to apply to the vectors before performing the search.
+     * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
+     */
+    async similaritySearchVectorWithScore(query, k, filter) {
+        const searches = await this._queryVectors(query, k, filter);
         const result = searches.map((search) => [
             new documents_1.Document({
-                metadata: filteredMemoryVectors[search.index].metadata,
-                pageContent: filteredMemoryVectors[search.index].content,
+                metadata: search.metadata,
+                pageContent: search.content,
             }),
             search.similarity,
         ]);
         return result;
     }
+    async maxMarginalRelevanceSearch(query, options) {
+        const queryEmbedding = await this.embeddings.embedQuery(query);
+        const searches = await this._queryVectors(queryEmbedding, options.fetchK ?? 20, options.filter);
+        const embeddingList = searches.map((searchResp) => searchResp.embedding);
+        const mmrIndexes = (0, math_js_1.maximalMarginalRelevance)(queryEmbedding, embeddingList, options.lambda, options.k);
+        return mmrIndexes.map((idx) => new documents_1.Document({
+            metadata: searches[idx].metadata,
+            pageContent: searches[idx].content,
+        }));
+    }
     /**
      * Static method to create a `MemoryVectorStore` instance from an array of
      * texts. It creates a `Document` for each text and metadata pair, and

package/dist/vectorstores/memory.d.ts

@@ -1,7 +1,7 @@
-import { similarity as ml_distance_similarity } from "ml-distance";
-import { VectorStore } from "@langchain/core/vectorstores";
+import { MaxMarginalRelevanceSearchOptions, VectorStore } from "@langchain/core/vectorstores";
 import type { EmbeddingsInterface } from "@langchain/core/embeddings";
-import { Document } from "@langchain/core/documents";
+import { Document, DocumentInterface } from "@langchain/core/documents";
+import { cosine } from "../util/ml-distance/similarities.js";
 /**
  * Interface representing a vector in memory. It includes the content
  * (text), the corresponding embedding (vector), and any associated
@@ -18,7 +18,7 @@ interface MemoryVector {
  * function.
  */
 export interface MemoryVectorStoreArgs {
-    similarity?: typeof ml_distance_similarity.cosine;
+    similarity?: typeof cosine;
 }
 /**
  * Class that extends `VectorStore` to store vectors in memory. Provides
@@ -28,7 +28,7 @@ export interface MemoryVectorStoreArgs {
 export declare class MemoryVectorStore extends VectorStore {
     FilterType: (doc: Document) => boolean;
     memoryVectors: MemoryVector[];
-    similarity: typeof ml_distance_similarity.cosine;
+    similarity: typeof cosine;
     _vectorstoreType(): string;
     constructor(embeddings: EmbeddingsInterface, { similarity, ...rest }?: MemoryVectorStoreArgs);
     /**
@@ -48,6 +48,13 @@ export declare class MemoryVectorStore extends VectorStore {
      * @returns Promise that resolves when all vectors have been added.
      */
     addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    protected _queryVectors(query: number[], k: number, filter?: this["FilterType"]): Promise<{
+        similarity: number;
+        index: number;
+        metadata: Record<string, any>;
+        content: string;
+        embedding: number[];
+    }[]>;
     /**
      * Method to perform a similarity search in the memory vector store. It
      * calculates the similarity between the query vector and each vector in
@@ -59,6 +66,7 @@ export declare class MemoryVectorStore extends VectorStore {
      * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.
      */
     similaritySearchVectorWithScore(query: number[], k: number, filter?: this["FilterType"]): Promise<[Document, number][]>;
+    maxMarginalRelevanceSearch(query: string, options: MaxMarginalRelevanceSearchOptions<this["FilterType"]>): Promise<DocumentInterface[]>;
     /**
      * Static method to create a `MemoryVectorStore` instance from an array of
      * texts. It creates a `Document` for each text and metadata pair, and