@langchain/classic 1.0.39 → 1.0.41

package/dist/util/time.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time.d.ts","names":[],"sources":["../../src/util/time.ts"],"mappings":";;AAKA;;;;iBAAsB,KAAA,CAAM,EAAA,YAAY,OAAA"}
+{"version":3,"file":"time.d.ts","names":[],"sources":["../../src/util/time.ts"],"mappings":";;;;;;iBAKsB,MAAM,cAAY"}

package/dist/util/time.js.map

@@ -1 +1 @@
-{"version":3,"file":"time.js","names":[],"sources":["../../src/util/time.ts"],"sourcesContent":["/**\n * Sleep for a given amount of time.\n * @param ms - The number of milliseconds to sleep for. Defaults to 1000.\n * @returns A promise that resolves when the sleep is complete.\n */\nexport async function sleep(ms = 1000): Promise<void> {\n  return new Promise<void>((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n"],"mappings":";;;;;;;;AAKA,eAAsB,MAAM,KAAK,KAAqB;AACpD,QAAO,IAAI,SAAe,YAAY;AACpC,aAAW,SAAS,GAAG;GACvB"}
+{"version":3,"file":"time.js","names":[],"sources":["../../src/util/time.ts"],"sourcesContent":["/**\n * Sleep for a given amount of time.\n * @param ms - The number of milliseconds to sleep for. Defaults to 1000.\n * @returns A promise that resolves when the sleep is complete.\n */\nexport async function sleep(ms = 1000): Promise<void> {\n  return new Promise<void>((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n"],"mappings":";;;;;;;;AAKA,eAAsB,MAAM,KAAK,KAAqB;CACpD,OAAO,IAAI,SAAe,YAAY;EACpC,WAAW,SAAS,EAAE;CACxB,CAAC;AACH"}

package/dist/vectorstores/memory.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"memory.cjs","names":["VectorStore","cosine","Document"],"sources":["../../src/vectorstores/memory.ts"],"sourcesContent":["import {\n  MaxMarginalRelevanceSearchOptions,\n  VectorStore,\n} from \"@langchain/core/vectorstores\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { maximalMarginalRelevance } from \"@langchain/core/utils/math\";\nimport { cosine } from \"../util/ml-distance/similarities.js\";\n\n/**\n * Interface representing a vector in memory. It includes the content\n * (text), the corresponding embedding (vector), and any associated\n * metadata.\n */\ninterface MemoryVector {\n  content: string;\n  embedding: number[];\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  metadata: Record<string, any>;\n  id?: string;\n}\n\n/**\n * Interface for the arguments that can be passed to the\n * `MemoryVectorStore` constructor. It includes an optional `similarity`\n * function.\n */\nexport interface MemoryVectorStoreArgs {\n  similarity?: typeof cosine;\n}\n\n/**\n * In-memory, ephemeral vector store.\n *\n * Setup:\n * Install `langchain`:\n *\n * ```bash\n * npm install langchain\n * ```\n *\n * ## [Constructor args](https://api.js.langchain.com/classes/langchain.vectorstores_memory.MemoryVectorStore.html#constructor)\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { MemoryVectorStore } from 'langchain/vectorstores/memory';\n * // Or other embeddings\n * import { OpenAIEmbeddings } from '@langchain/openai';\n *\n * const embeddings = new OpenAIEmbeddings({\n *   model: \"text-embedding-3-small\",\n * });\n *\n * const vectorStore = new MemoryVectorStore(embeddings);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Add documents</strong></summary>\n *\n * ```typescript\n * import type { Document } from '@langchain/core/documents';\n *\n * const document1 = { pageContent: \"foo\", metadata: { baz: \"bar\" } };\n * const document2 = { pageContent: \"thud\", metadata: { bar: \"baz\" } };\n * const document3 = { pageContent: \"i will be deleted :(\", metadata: {} };\n *\n * const documents: Document[] = [document1, document2, document3];\n *\n * await vectorStore.addDocuments(documents);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Similarity search</strong></summary>\n *\n * ```typescript\n * const results = await vectorStore.similaritySearch(\"thud\", 1);\n * for (const doc of results) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * thud [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with filter</strong></summary>\n *\n * ```typescript\n * const resultsWithFilter = await vectorStore.similaritySearch(\"thud\", 1, { baz: \"bar\" });\n *\n * for (const doc of resultsWithFilter) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * foo [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with score</strong></summary>\n *\n * ```typescript\n * const resultsWithScore = await vectorStore.similaritySearchWithScore(\"qux\", 1);\n * for (const [doc, score] of resultsWithScore) {\n *   console.log(`* [SIM=${score.toFixed(6)}] ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * [SIM=0.000000] qux [{\"bar\":\"baz\",\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>As a retriever</strong></summary>\n *\n * ```typescript\n * const retriever = vectorStore.asRetriever({\n *   searchType: \"mmr\", // Leave blank for standard similarity search\n *   k: 1,\n * });\n * const resultAsRetriever = await retriever.invoke(\"thud\");\n * console.log(resultAsRetriever);\n *\n * // Output: [Document({ metadata: { \"baz\":\"bar\" }, pageContent: \"thud\" })]\n * ```\n * </details>\n *\n * <br />\n */\nexport class MemoryVectorStore extends VectorStore {\n  declare FilterType: (doc: Document) => boolean;\n\n  memoryVectors: MemoryVector[] = [];\n\n  similarity: typeof cosine;\n\n  _vectorstoreType(): string {\n    return \"memory\";\n  }\n\n  constructor(\n    embeddings: EmbeddingsInterface,\n    { similarity, ...rest }: MemoryVectorStoreArgs = {}\n  ) {\n    super(embeddings, rest);\n\n    this.similarity = similarity ?? cosine;\n  }\n\n  /**\n   * Method to add documents to the memory vector store. It extracts the\n   * text from each document, generates embeddings for them, and adds the\n   * resulting vectors to the store.\n   * @param documents Array of `Document` instances to be added to the store.\n   * @returns Promise that resolves when all documents have been added.\n   */\n  async addDocuments(documents: Document[]): Promise<void> {\n    const texts = documents.map(({ pageContent }) => pageContent);\n    return this.addVectors(\n      await this.embeddings.embedDocuments(texts),\n      documents\n    );\n  }\n\n  /**\n   * Method to add vectors to the memory vector store. It creates\n   * `MemoryVector` instances for each vector and document pair and adds\n   * them to the store.\n   * @param vectors Array of vectors to be added to the store.\n   * @param documents Array of `Document` instances corresponding to the vectors.\n   * @returns Promise that resolves when all vectors have been added.\n   */\n  async addVectors(vectors: number[][], documents: Document[]): Promise<void> {\n    const memoryVectors = vectors.map((embedding, idx) => ({\n      content: documents[idx].pageContent,\n      embedding,\n      metadata: documents[idx].metadata,\n      id: documents[idx].id,\n    }));\n\n    this.memoryVectors = this.memoryVectors.concat(memoryVectors);\n  }\n\n  protected async _queryVectors(\n    query: number[],\n    k: number,\n    filter?: this[\"FilterType\"]\n  ) {\n    const filterFunction = (memoryVector: MemoryVector) => {\n      if (!filter) {\n        return true;\n      }\n\n      const doc = new Document({\n        metadata: memoryVector.metadata,\n        pageContent: memoryVector.content,\n        id: memoryVector.id,\n      });\n      return filter(doc);\n    };\n    const filteredMemoryVectors = this.memoryVectors.filter(filterFunction);\n    return filteredMemoryVectors\n      .map((vector, index) => ({\n        similarity: this.similarity(query, vector.embedding),\n        index,\n        metadata: vector.metadata,\n        content: vector.content,\n        embedding: vector.embedding,\n        id: vector.id,\n      }))\n      .sort((a, b) => (a.similarity > b.similarity ? -1 : 0))\n      .slice(0, k);\n  }\n\n  /**\n   * Method to perform a similarity search in the memory vector store. It\n   * calculates the similarity between the query vector and each vector in\n   * the store, sorts the results by similarity, and returns the top `k`\n   * results along with their scores.\n   * @param query Query vector to compare against the vectors in the store.\n   * @param k Number of top results to return.\n   * @param filter Optional filter function to apply to the vectors before performing the search.\n   * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.\n   */\n  async similaritySearchVectorWithScore(\n    query: number[],\n    k: number,\n    filter?: this[\"FilterType\"]\n  ): Promise<[Document, number][]> {\n    const searches = await this._queryVectors(query, k, filter);\n    const result: [Document, number][] = searches.map((search) => [\n      new Document({\n        metadata: search.metadata,\n        pageContent: search.content,\n        id: search.id,\n      }),\n      search.similarity,\n    ]);\n\n    return result;\n  }\n\n  async maxMarginalRelevanceSearch(\n    query: string,\n    options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>\n  ): Promise<DocumentInterface[]> {\n    const queryEmbedding = await this.embeddings.embedQuery(query);\n\n    const searches = await this._queryVectors(\n      queryEmbedding,\n      options.fetchK ?? 20,\n      options.filter\n    );\n\n    const embeddingList = searches.map((searchResp) => searchResp.embedding);\n\n    const mmrIndexes = maximalMarginalRelevance(\n      queryEmbedding,\n      embeddingList,\n      options.lambda,\n      options.k\n    );\n\n    return mmrIndexes.map(\n      (idx) =>\n        new Document({\n          metadata: searches[idx].metadata,\n          pageContent: searches[idx].content,\n          id: searches[idx].id,\n        })\n    );\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an array of\n   * texts. It creates a `Document` for each text and metadata pair, and\n   * adds them to the store.\n   * @param texts Array of texts to be added to the store.\n   * @param metadatas Array or single object of metadata corresponding to the texts.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the texts.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromTexts(\n    texts: string[],\n    metadatas: object[] | object,\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const docs: Document[] = [];\n    for (let i = 0; i < texts.length; i += 1) {\n      const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;\n      const newDoc = new Document({\n        pageContent: texts[i],\n        metadata,\n      });\n      docs.push(newDoc);\n    }\n    return MemoryVectorStore.fromDocuments(docs, embeddings, dbConfig);\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an array of\n   * `Document` instances. It adds the documents to the store.\n   * @param docs Array of `Document` instances to be added to the store.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the documents.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromDocuments(\n    docs: Document[],\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const instance = new this(embeddings, dbConfig);\n    await instance.addDocuments(docs);\n    return instance;\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an existing\n   * index. It creates a new `MemoryVectorStore` instance without adding any\n   * documents or vectors.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the documents.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromExistingIndex(\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const instance = new this(embeddings, dbConfig);\n    return instance;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"memory.cjs","names":["VectorStore","cosine","Document"],"sources":["../../src/vectorstores/memory.ts"],"sourcesContent":["import {\n  MaxMarginalRelevanceSearchOptions,\n  VectorStore,\n} from \"@langchain/core/vectorstores\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { maximalMarginalRelevance } from \"@langchain/core/utils/math\";\nimport { cosine } from \"../util/ml-distance/similarities.js\";\n\n/**\n * Interface representing a vector in memory. It includes the content\n * (text), the corresponding embedding (vector), and any associated\n * metadata.\n */\ninterface MemoryVector {\n  content: string;\n  embedding: number[];\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  metadata: Record<string, any>;\n  id?: string;\n}\n\n/**\n * Interface for the arguments that can be passed to the\n * `MemoryVectorStore` constructor. It includes an optional `similarity`\n * function.\n */\nexport interface MemoryVectorStoreArgs {\n  similarity?: typeof cosine;\n}\n\n/**\n * In-memory, ephemeral vector store.\n *\n * Setup:\n * Install `langchain`:\n *\n * ```bash\n * npm install langchain\n * ```\n *\n * ## [Constructor args](https://api.js.langchain.com/classes/langchain.vectorstores_memory.MemoryVectorStore.html#constructor)\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { MemoryVectorStore } from 'langchain/vectorstores/memory';\n * // Or other embeddings\n * import { OpenAIEmbeddings } from '@langchain/openai';\n *\n * const embeddings = new OpenAIEmbeddings({\n *   model: \"text-embedding-3-small\",\n * });\n *\n * const vectorStore = new MemoryVectorStore(embeddings);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Add documents</strong></summary>\n *\n * ```typescript\n * import type { Document } from '@langchain/core/documents';\n *\n * const document1 = { pageContent: \"foo\", metadata: { baz: \"bar\" } };\n * const document2 = { pageContent: \"thud\", metadata: { bar: \"baz\" } };\n * const document3 = { pageContent: \"i will be deleted :(\", metadata: {} };\n *\n * const documents: Document[] = [document1, document2, document3];\n *\n * await vectorStore.addDocuments(documents);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Similarity search</strong></summary>\n *\n * ```typescript\n * const results = await vectorStore.similaritySearch(\"thud\", 1);\n * for (const doc of results) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * thud [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with filter</strong></summary>\n *\n * ```typescript\n * const resultsWithFilter = await vectorStore.similaritySearch(\"thud\", 1, { baz: \"bar\" });\n *\n * for (const doc of resultsWithFilter) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * foo [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with score</strong></summary>\n *\n * ```typescript\n * const resultsWithScore = await vectorStore.similaritySearchWithScore(\"qux\", 1);\n * for (const [doc, score] of resultsWithScore) {\n *   console.log(`* [SIM=${score.toFixed(6)}] ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * [SIM=0.000000] qux [{\"bar\":\"baz\",\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>As a retriever</strong></summary>\n *\n * ```typescript\n * const retriever = vectorStore.asRetriever({\n *   searchType: \"mmr\", // Leave blank for standard similarity search\n *   k: 1,\n * });\n * const resultAsRetriever = await retriever.invoke(\"thud\");\n * console.log(resultAsRetriever);\n *\n * // Output: [Document({ metadata: { \"baz\":\"bar\" }, pageContent: \"thud\" })]\n * ```\n * </details>\n *\n * <br />\n */\nexport class MemoryVectorStore extends VectorStore {\n  declare FilterType: (doc: Document) => boolean;\n\n  memoryVectors: MemoryVector[] = [];\n\n  similarity: typeof cosine;\n\n  _vectorstoreType(): string {\n    return \"memory\";\n  }\n\n  constructor(\n    embeddings: EmbeddingsInterface,\n    { similarity, ...rest }: MemoryVectorStoreArgs = {}\n  ) {\n    super(embeddings, rest);\n\n    this.similarity = similarity ?? cosine;\n  }\n\n  /**\n   * Method to add documents to the memory vector store. It extracts the\n   * text from each document, generates embeddings for them, and adds the\n   * resulting vectors to the store.\n   * @param documents Array of `Document` instances to be added to the store.\n   * @returns Promise that resolves when all documents have been added.\n   */\n  async addDocuments(documents: Document[]): Promise<void> {\n    const texts = documents.map(({ pageContent }) => pageContent);\n    return this.addVectors(\n      await this.embeddings.embedDocuments(texts),\n      documents\n    );\n  }\n\n  /**\n   * Method to add vectors to the memory vector store. It creates\n   * `MemoryVector` instances for each vector and document pair and adds\n   * them to the store.\n   * @param vectors Array of vectors to be added to the store.\n   * @param documents Array of `Document` instances corresponding to the vectors.\n   * @returns Promise that resolves when all vectors have been added.\n   */\n  async addVectors(vectors: number[][], documents: Document[]): Promise<void> {\n    const memoryVectors = vectors.map((embedding, idx) => ({\n      content: documents[idx].pageContent,\n      embedding,\n      metadata: documents[idx].metadata,\n      id: documents[idx].id,\n    }));\n\n    this.memoryVectors = this.memoryVectors.concat(memoryVectors);\n  }\n\n  protected async _queryVectors(\n    query: number[],\n    k: number,\n    filter?: this[\"FilterType\"]\n  ) {\n    const filterFunction = (memoryVector: MemoryVector) => {\n      if (!filter) {\n        return true;\n      }\n\n      const doc = new Document({\n        metadata: memoryVector.metadata,\n        pageContent: memoryVector.content,\n        id: memoryVector.id,\n      });\n      return filter(doc);\n    };\n    const filteredMemoryVectors = this.memoryVectors.filter(filterFunction);\n    return filteredMemoryVectors\n      .map((vector, index) => ({\n        similarity: this.similarity(query, vector.embedding),\n        index,\n        metadata: vector.metadata,\n        content: vector.content,\n        embedding: vector.embedding,\n        id: vector.id,\n      }))\n      .sort((a, b) => (a.similarity > b.similarity ? -1 : 0))\n      .slice(0, k);\n  }\n\n  /**\n   * Method to perform a similarity search in the memory vector store. It\n   * calculates the similarity between the query vector and each vector in\n   * the store, sorts the results by similarity, and returns the top `k`\n   * results along with their scores.\n   * @param query Query vector to compare against the vectors in the store.\n   * @param k Number of top results to return.\n   * @param filter Optional filter function to apply to the vectors before performing the search.\n   * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.\n   */\n  async similaritySearchVectorWithScore(\n    query: number[],\n    k: number,\n    filter?: this[\"FilterType\"]\n  ): Promise<[Document, number][]> {\n    const searches = await this._queryVectors(query, k, filter);\n    const result: [Document, number][] = searches.map((search) => [\n      new Document({\n        metadata: search.metadata,\n        pageContent: search.content,\n        id: search.id,\n      }),\n      search.similarity,\n    ]);\n\n    return result;\n  }\n\n  async maxMarginalRelevanceSearch(\n    query: string,\n    options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>\n  ): Promise<DocumentInterface[]> {\n    const queryEmbedding = await this.embeddings.embedQuery(query);\n\n    const searches = await this._queryVectors(\n      queryEmbedding,\n      options.fetchK ?? 20,\n      options.filter\n    );\n\n    const embeddingList = searches.map((searchResp) => searchResp.embedding);\n\n    const mmrIndexes = maximalMarginalRelevance(\n      queryEmbedding,\n      embeddingList,\n      options.lambda,\n      options.k\n    );\n\n    return mmrIndexes.map(\n      (idx) =>\n        new Document({\n          metadata: searches[idx].metadata,\n          pageContent: searches[idx].content,\n          id: searches[idx].id,\n        })\n    );\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an array of\n   * texts. It creates a `Document` for each text and metadata pair, and\n   * adds them to the store.\n   * @param texts Array of texts to be added to the store.\n   * @param metadatas Array or single object of metadata corresponding to the texts.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the texts.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromTexts(\n    texts: string[],\n    metadatas: object[] | object,\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const docs: Document[] = [];\n    for (let i = 0; i < texts.length; i += 1) {\n      const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;\n      const newDoc = new Document({\n        pageContent: texts[i],\n        metadata,\n      });\n      docs.push(newDoc);\n    }\n    return MemoryVectorStore.fromDocuments(docs, embeddings, dbConfig);\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an array of\n   * `Document` instances. It adds the documents to the store.\n   * @param docs Array of `Document` instances to be added to the store.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the documents.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromDocuments(\n    docs: Document[],\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const instance = new this(embeddings, dbConfig);\n    await instance.addDocuments(docs);\n    return instance;\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an existing\n   * index. It creates a new `MemoryVectorStore` instance without adding any\n   * documents or vectors.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the documents.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromExistingIndex(\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const instance = new this(embeddings, dbConfig);\n    return instance;\n  }\n}\n"],"mappings":"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"}

package/dist/vectorstores/memory.d.cts

@@ -2,7 +2,6 @@ import { cosine } from "../util/ml-distance/similarities.cjs";
 import { MaxMarginalRelevanceSearchOptions, VectorStore } from "@langchain/core/vectorstores";
 import { Document, DocumentInterface } from "@langchain/core/documents";
 import { EmbeddingsInterface } from "@langchain/core/embeddings";
-
 //#region src/vectorstores/memory.d.ts
 /**
  * Interface representing a vector in memory. It includes the content
@@ -138,10 +137,7 @@ declare class MemoryVectorStore extends VectorStore {
   memoryVectors: MemoryVector[];
   similarity: typeof cosine;
   _vectorstoreType(): string;
-  constructor(embeddings: EmbeddingsInterface, {
-    similarity,
-    ...rest
-  }?: MemoryVectorStoreArgs);
+  constructor(embeddings: EmbeddingsInterface, { similarity, ...rest }?: MemoryVectorStoreArgs);
   /**
    * Method to add documents to the memory vector store. It extracts the
    * text from each document, generates embeddings for them, and adds the

package/dist/vectorstores/memory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.cts","names":[],"sources":["../../src/vectorstores/memory.ts"],"mappings":";;;;;;;;AAO6D;;;UAOnD,YAAA;EACR,OAAA;EACA,SAAA;EAEA,QAAA,EAAU,MAAA;EACV,EAAA;AAAA;;;AAQF;;;UAAiB,qBAAA;EACf,UAAA,UAAoB,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiHT,iBAAA,SAA0B,WAAA;EAC7B,UAAA,GAAa,GAAA,EAAK,QAAA;EAE1B,aAAA,EAAe,YAAA;EAEf,UAAA,SAAmB,MAAA;EAEnB,gBAAA,CAAA;EAIA,WAAA,CACE,UAAA,EAAY,mBAAA;IACV,UAAA;IAAA,GAAe;EAAA,IAAQ,qBAAA;;;;;;;;EAcrB,YAAA,CAAa,SAAA,EAAW,QAAA,KAAa,OAAA;;;;;;;;;EAgBrC,UAAA,CAAW,OAAA,cAAqB,SAAA,EAAW,QAAA,KAAa,OAAA;EAAA,UAW9C,aAAA,CACd,KAAA,YACA,CAAA,UACA,MAAA,wBAA2B,OAAA;;;;;;;;;;;;;;;;;;EAsCvB,+BAAA,CACJ,KAAA,YACA,CAAA,UACA,MAAA,wBACC,OAAA,EAAS,QAAA;EAcN,0BAAA,CACJ,KAAA,UACA,OAAA,EAAS,iCAAA,uBACR,OAAA,CAAQ,iBAAA;;;;;;;;;;;SAsCE,SAAA,CACX,KAAA,YACA,SAAA,qBACA,UAAA,EAAY,mBAAA,EACZ,QAAA,GAAW,qBAAA,GACV,OAAA,CAAQ,iBAAA;;;;;;;;;SAqBE,aAAA,CACX,IAAA,EAAM,QAAA,IACN,UAAA,EAAY,mBAAA,EACZ,QAAA,GAAW,qBAAA,GACV,OAAA,CAAQ,iBAAA;;;;;;;;;SAcE,iBAAA,CACX,UAAA,EAAY,mBAAA,EACZ,QAAA,GAAW,qBAAA,GACV,OAAA,CAAQ,iBAAA;AAAA"}
+{"version":3,"file":"memory.d.cts","names":[],"sources":["../../src/vectorstores/memory.ts"],"mappings":";;;;;;;;;;UAcU;EACR;EACA;EAEA,UAAU;EACV;;;;;;;UAQe;EACf,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiHT,0BAA0B;EAC7B,aAAa,KAAK;EAE1B,eAAe;EAEf,mBAAmB;EAEnB;EAIA,YACE,YAAY,uBACV,eAAe,SAAQ;;;;;;;;EAcrB,aAAa,WAAW,aAAa;;;;;;;;;EAgBrC,WAAW,qBAAqB,WAAW,aAAa;YAW9C,cACd,iBACA,WACA,8BAA2B;;;;;;;;;;;;;;;;;;EAsCvB,gCACJ,iBACA,WACA,8BACC,SAAS;EAcN,2BACJ,eACA,SAAS,wDACR,QAAQ;;;;;;;;;;;SAsCE,UACX,iBACA,8BACA,YAAY,qBACZ,WAAW,wBACV,QAAQ;;;;;;;;;SAqBE,cACX,MAAM,YACN,YAAY,qBACZ,WAAW,wBACV,QAAQ;;;;;;;;;SAcE,kBACX,YAAY,qBACZ,WAAW,wBACV,QAAQ"}

package/dist/vectorstores/memory.d.ts

@@ -2,7 +2,6 @@ import { cosine } from "../util/ml-distance/similarities.js";
 import { Document, DocumentInterface } from "@langchain/core/documents";
 import { EmbeddingsInterface } from "@langchain/core/embeddings";
 import { MaxMarginalRelevanceSearchOptions, VectorStore } from "@langchain/core/vectorstores";
-
 //#region src/vectorstores/memory.d.ts
 /**
  * Interface representing a vector in memory. It includes the content
@@ -138,10 +137,7 @@ declare class MemoryVectorStore extends VectorStore {
   memoryVectors: MemoryVector[];
   similarity: typeof cosine;
   _vectorstoreType(): string;
-  constructor(embeddings: EmbeddingsInterface, {
-    similarity,
-    ...rest
-  }?: MemoryVectorStoreArgs);
+  constructor(embeddings: EmbeddingsInterface, { similarity, ...rest }?: MemoryVectorStoreArgs);
   /**
    * Method to add documents to the memory vector store. It extracts the
    * text from each document, generates embeddings for them, and adds the

package/dist/vectorstores/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","names":[],"sources":["../../src/vectorstores/memory.ts"],"mappings":";;;;;;;;AAO6D;;;UAOnD,YAAA;EACR,OAAA;EACA,SAAA;EAEA,QAAA,EAAU,MAAA;EACV,EAAA;AAAA;;;AAQF;;;UAAiB,qBAAA;EACf,UAAA,UAAoB,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiHT,iBAAA,SAA0B,WAAA;EAC7B,UAAA,GAAa,GAAA,EAAK,QAAA;EAE1B,aAAA,EAAe,YAAA;EAEf,UAAA,SAAmB,MAAA;EAEnB,gBAAA,CAAA;EAIA,WAAA,CACE,UAAA,EAAY,mBAAA;IACV,UAAA;IAAA,GAAe;EAAA,IAAQ,qBAAA;;;;;;;;EAcrB,YAAA,CAAa,SAAA,EAAW,QAAA,KAAa,OAAA;;;;;;;;;EAgBrC,UAAA,CAAW,OAAA,cAAqB,SAAA,EAAW,QAAA,KAAa,OAAA;EAAA,UAW9C,aAAA,CACd,KAAA,YACA,CAAA,UACA,MAAA,wBAA2B,OAAA;;;;;;;;;;;;;;;;;;EAsCvB,+BAAA,CACJ,KAAA,YACA,CAAA,UACA,MAAA,wBACC,OAAA,EAAS,QAAA;EAcN,0BAAA,CACJ,KAAA,UACA,OAAA,EAAS,iCAAA,uBACR,OAAA,CAAQ,iBAAA;;;;;;;;;;;SAsCE,SAAA,CACX,KAAA,YACA,SAAA,qBACA,UAAA,EAAY,mBAAA,EACZ,QAAA,GAAW,qBAAA,GACV,OAAA,CAAQ,iBAAA;;;;;;;;;SAqBE,aAAA,CACX,IAAA,EAAM,QAAA,IACN,UAAA,EAAY,mBAAA,EACZ,QAAA,GAAW,qBAAA,GACV,OAAA,CAAQ,iBAAA;;;;;;;;;SAcE,iBAAA,CACX,UAAA,EAAY,mBAAA,EACZ,QAAA,GAAW,qBAAA,GACV,OAAA,CAAQ,iBAAA;AAAA"}
+{"version":3,"file":"memory.d.ts","names":[],"sources":["../../src/vectorstores/memory.ts"],"mappings":";;;;;;;;;;UAcU;EACR;EACA;EAEA,UAAU;EACV;;;;;;;UAQe;EACf,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiHT,0BAA0B;EAC7B,aAAa,KAAK;EAE1B,eAAe;EAEf,mBAAmB;EAEnB;EAIA,YACE,YAAY,uBACV,eAAe,SAAQ;;;;;;;;EAcrB,aAAa,WAAW,aAAa;;;;;;;;;EAgBrC,WAAW,qBAAqB,WAAW,aAAa;YAW9C,cACd,iBACA,WACA,8BAA2B;;;;;;;;;;;;;;;;;;EAsCvB,gCACJ,iBACA,WACA,8BACC,SAAS;EAcN,2BACJ,eACA,SAAS,wDACR,QAAQ;;;;;;;;;;;SAsCE,UACX,iBACA,8BACA,YAAY,qBACZ,WAAW,wBACV,QAAQ;;;;;;;;;SAqBE,cACX,MAAM,YACN,YAAY,qBACZ,WAAW,wBACV,QAAQ;;;;;;;;;SAcE,kBACX,YAAY,qBACZ,WAAW,wBACV,QAAQ"}

package/dist/vectorstores/memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"memory.js","names":[],"sources":["../../src/vectorstores/memory.ts"],"sourcesContent":["import {\n  MaxMarginalRelevanceSearchOptions,\n  VectorStore,\n} from \"@langchain/core/vectorstores\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { maximalMarginalRelevance } from \"@langchain/core/utils/math\";\nimport { cosine } from \"../util/ml-distance/similarities.js\";\n\n/**\n * Interface representing a vector in memory. It includes the content\n * (text), the corresponding embedding (vector), and any associated\n * metadata.\n */\ninterface MemoryVector {\n  content: string;\n  embedding: number[];\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  metadata: Record<string, any>;\n  id?: string;\n}\n\n/**\n * Interface for the arguments that can be passed to the\n * `MemoryVectorStore` constructor. It includes an optional `similarity`\n * function.\n */\nexport interface MemoryVectorStoreArgs {\n  similarity?: typeof cosine;\n}\n\n/**\n * In-memory, ephemeral vector store.\n *\n * Setup:\n * Install `langchain`:\n *\n * ```bash\n * npm install langchain\n * ```\n *\n * ## [Constructor args](https://api.js.langchain.com/classes/langchain.vectorstores_memory.MemoryVectorStore.html#constructor)\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { MemoryVectorStore } from 'langchain/vectorstores/memory';\n * // Or other embeddings\n * import { OpenAIEmbeddings } from '@langchain/openai';\n *\n * const embeddings = new OpenAIEmbeddings({\n *   model: \"text-embedding-3-small\",\n * });\n *\n * const vectorStore = new MemoryVectorStore(embeddings);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Add documents</strong></summary>\n *\n * ```typescript\n * import type { Document } from '@langchain/core/documents';\n *\n * const document1 = { pageContent: \"foo\", metadata: { baz: \"bar\" } };\n * const document2 = { pageContent: \"thud\", metadata: { bar: \"baz\" } };\n * const document3 = { pageContent: \"i will be deleted :(\", metadata: {} };\n *\n * const documents: Document[] = [document1, document2, document3];\n *\n * await vectorStore.addDocuments(documents);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Similarity search</strong></summary>\n *\n * ```typescript\n * const results = await vectorStore.similaritySearch(\"thud\", 1);\n * for (const doc of results) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * thud [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with filter</strong></summary>\n *\n * ```typescript\n * const resultsWithFilter = await vectorStore.similaritySearch(\"thud\", 1, { baz: \"bar\" });\n *\n * for (const doc of resultsWithFilter) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * foo [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with score</strong></summary>\n *\n * ```typescript\n * const resultsWithScore = await vectorStore.similaritySearchWithScore(\"qux\", 1);\n * for (const [doc, score] of resultsWithScore) {\n *   console.log(`* [SIM=${score.toFixed(6)}] ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * [SIM=0.000000] qux [{\"bar\":\"baz\",\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>As a retriever</strong></summary>\n *\n * ```typescript\n * const retriever = vectorStore.asRetriever({\n *   searchType: \"mmr\", // Leave blank for standard similarity search\n *   k: 1,\n * });\n * const resultAsRetriever = await retriever.invoke(\"thud\");\n * console.log(resultAsRetriever);\n *\n * // Output: [Document({ metadata: { \"baz\":\"bar\" }, pageContent: \"thud\" })]\n * ```\n * </details>\n *\n * <br />\n */\nexport class MemoryVectorStore extends VectorStore {\n  declare FilterType: (doc: Document) => boolean;\n\n  memoryVectors: MemoryVector[] = [];\n\n  similarity: typeof cosine;\n\n  _vectorstoreType(): string {\n    return \"memory\";\n  }\n\n  constructor(\n    embeddings: EmbeddingsInterface,\n    { similarity, ...rest }: MemoryVectorStoreArgs = {}\n  ) {\n    super(embeddings, rest);\n\n    this.similarity = similarity ?? cosine;\n  }\n\n  /**\n   * Method to add documents to the memory vector store. It extracts the\n   * text from each document, generates embeddings for them, and adds the\n   * resulting vectors to the store.\n   * @param documents Array of `Document` instances to be added to the store.\n   * @returns Promise that resolves when all documents have been added.\n   */\n  async addDocuments(documents: Document[]): Promise<void> {\n    const texts = documents.map(({ pageContent }) => pageContent);\n    return this.addVectors(\n      await this.embeddings.embedDocuments(texts),\n      documents\n    );\n  }\n\n  /**\n   * Method to add vectors to the memory vector store. It creates\n   * `MemoryVector` instances for each vector and document pair and adds\n   * them to the store.\n   * @param vectors Array of vectors to be added to the store.\n   * @param documents Array of `Document` instances corresponding to the vectors.\n   * @returns Promise that resolves when all vectors have been added.\n   */\n  async addVectors(vectors: number[][], documents: Document[]): Promise<void> {\n    const memoryVectors = vectors.map((embedding, idx) => ({\n      content: documents[idx].pageContent,\n      embedding,\n      metadata: documents[idx].metadata,\n      id: documents[idx].id,\n    }));\n\n    this.memoryVectors = this.memoryVectors.concat(memoryVectors);\n  }\n\n  protected async _queryVectors(\n    query: number[],\n    k: number,\n    filter?: this[\"FilterType\"]\n  ) {\n    const filterFunction = (memoryVector: MemoryVector) => {\n      if (!filter) {\n        return true;\n      }\n\n      const doc = new Document({\n        metadata: memoryVector.metadata,\n        pageContent: memoryVector.content,\n        id: memoryVector.id,\n      });\n      return filter(doc);\n    };\n    const filteredMemoryVectors = this.memoryVectors.filter(filterFunction);\n    return filteredMemoryVectors\n      .map((vector, index) => ({\n        similarity: this.similarity(query, vector.embedding),\n        index,\n        metadata: vector.metadata,\n        content: vector.content,\n        embedding: vector.embedding,\n        id: vector.id,\n      }))\n      .sort((a, b) => (a.similarity > b.similarity ? -1 : 0))\n      .slice(0, k);\n  }\n\n  /**\n   * Method to perform a similarity search in the memory vector store. It\n   * calculates the similarity between the query vector and each vector in\n   * the store, sorts the results by similarity, and returns the top `k`\n   * results along with their scores.\n   * @param query Query vector to compare against the vectors in the store.\n   * @param k Number of top results to return.\n   * @param filter Optional filter function to apply to the vectors before performing the search.\n   * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.\n   */\n  async similaritySearchVectorWithScore(\n    query: number[],\n    k: number,\n    filter?: this[\"FilterType\"]\n  ): Promise<[Document, number][]> {\n    const searches = await this._queryVectors(query, k, filter);\n    const result: [Document, number][] = searches.map((search) => [\n      new Document({\n        metadata: search.metadata,\n        pageContent: search.content,\n        id: search.id,\n      }),\n      search.similarity,\n    ]);\n\n    return result;\n  }\n\n  async maxMarginalRelevanceSearch(\n    query: string,\n    options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>\n  ): Promise<DocumentInterface[]> {\n    const queryEmbedding = await this.embeddings.embedQuery(query);\n\n    const searches = await this._queryVectors(\n      queryEmbedding,\n      options.fetchK ?? 20,\n      options.filter\n    );\n\n    const embeddingList = searches.map((searchResp) => searchResp.embedding);\n\n    const mmrIndexes = maximalMarginalRelevance(\n      queryEmbedding,\n      embeddingList,\n      options.lambda,\n      options.k\n    );\n\n    return mmrIndexes.map(\n      (idx) =>\n        new Document({\n          metadata: searches[idx].metadata,\n          pageContent: searches[idx].content,\n          id: searches[idx].id,\n        })\n    );\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an array of\n   * texts. It creates a `Document` for each text and metadata pair, and\n   * adds them to the store.\n   * @param texts Array of texts to be added to the store.\n   * @param metadatas Array or single object of metadata corresponding to the texts.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the texts.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromTexts(\n    texts: string[],\n    metadatas: object[] | object,\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const docs: Document[] = [];\n    for (let i = 0; i < texts.length; i += 1) {\n      const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;\n      const newDoc = new Document({\n        pageContent: texts[i],\n        metadata,\n      });\n      docs.push(newDoc);\n    }\n    return MemoryVectorStore.fromDocuments(docs, embeddings, dbConfig);\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an array of\n   * `Document` instances. It adds the documents to the store.\n   * @param docs Array of `Document` instances to be added to the store.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the documents.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromDocuments(\n    docs: Document[],\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const instance = new this(embeddings, dbConfig);\n    await instance.addDocuments(docs);\n    return instance;\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an existing\n   * index. It creates a new `MemoryVectorStore` instance without adding any\n   * documents or vectors.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the documents.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromExistingIndex(\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const instance = new this(embeddings, dbConfig);\n    return instance;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6IA,IAAa,oBAAb,MAAa,0BAA0B,YAAY;CAGjD,gBAAgC,EAAE;CAElC;CAEA,mBAA2B;AACzB,SAAO;;CAGT,YACE,YACA,EAAE,YAAY,GAAG,SAAgC,EAAE,EACnD;AACA,QAAM,YAAY,KAAK;AAEvB,OAAK,aAAa,cAAc;;;;;;;;;CAUlC,MAAM,aAAa,WAAsC;EACvD,MAAM,QAAQ,UAAU,KAAK,EAAE,kBAAkB,YAAY;AAC7D,SAAO,KAAK,WACV,MAAM,KAAK,WAAW,eAAe,MAAM,EAC3C,UACD;;;;;;;;;;CAWH,MAAM,WAAW,SAAqB,WAAsC;EAC1E,MAAM,gBAAgB,QAAQ,KAAK,WAAW,SAAS;GACrD,SAAS,UAAU,KAAK;GACxB;GACA,UAAU,UAAU,KAAK;GACzB,IAAI,UAAU,KAAK;GACpB,EAAE;AAEH,OAAK,gBAAgB,KAAK,cAAc,OAAO,cAAc;;CAG/D,MAAgB,cACd,OACA,GACA,QACA;EACA,MAAM,kBAAkB,iBAA+B;AACrD,OAAI,CAAC,OACH,QAAO;AAQT,UAAO,OAAO,IALE,SAAS;IACvB,UAAU,aAAa;IACvB,aAAa,aAAa;IAC1B,IAAI,aAAa;IAClB,CACgB,CAAC;;AAGpB,SAD8B,KAAK,cAAc,OAAO,eAC5B,CACzB,KAAK,QAAQ,WAAW;GACvB,YAAY,KAAK,WAAW,OAAO,OAAO,UAAU;GACpD;GACA,UAAU,OAAO;GACjB,SAAS,OAAO;GAChB,WAAW,OAAO;GAClB,IAAI,OAAO;GACZ,EAAE,CACF,MAAM,GAAG,MAAO,EAAE,aAAa,EAAE,aAAa,KAAK,EAAG,CACtD,MAAM,GAAG,EAAE;;;;;;;;;;;;CAahB,MAAM,gCACJ,OACA,GACA,QAC+B;AAW/B,UATqC,MADd,KAAK,cAAc,OAAO,GAAG,OAAO,EACb,KAAK,WAAW,CAC5D,IAAI,SAAS;GACX,UAAU,OAAO;GACjB,aAAa,OAAO;GACpB,IAAI,OAAO;GACZ,CAAC,EACF,OAAO,WACR,CAEY;;CAGf,MAAM,2BACJ,OACA,SAC8B;EAC9B,MAAM,iBAAiB,MAAM,KAAK,WAAW,WAAW,MAAM;EAE9D,MAAM,WAAW,MAAM,KAAK,cAC1B,gBACA,QAAQ,UAAU,IAClB,QAAQ,OACT;AAWD,SAPmB,yBACjB,gBAHoB,SAAS,KAAK,eAAe,WAAW,UAI/C,EACb,QAAQ,QACR,QAAQ,EAGO,CAAC,KACf,QACC,IAAI,SAAS;GACX,UAAU,SAAS,KAAK;GACxB,aAAa,SAAS,KAAK;GAC3B,IAAI,SAAS,KAAK;GACnB,CAAC,CACL;;;;;;;;;;;;CAaH,aAAa,UACX,OACA,WACA,YACA,UAC4B;EAC5B,MAAM,OAAmB,EAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG;GACxC,MAAM,WAAW,MAAM,QAAQ,UAAU,GAAG,UAAU,KAAK;GAC3D,MAAM,SAAS,IAAI,SAAS;IAC1B,aAAa,MAAM;IACnB;IACD,CAAC;AACF,QAAK,KAAK,OAAO;;AAEnB,SAAO,kBAAkB,cAAc,MAAM,YAAY,SAAS;;;;;;;;;;CAWpE,aAAa,cACX,MACA,YACA,UAC4B;EAC5B,MAAM,WAAW,IAAI,KAAK,YAAY,SAAS;AAC/C,QAAM,SAAS,aAAa,KAAK;AACjC,SAAO;;;;;;;;;;CAWT,aAAa,kBACX,YACA,UAC4B;AAE5B,SAAO,IADc,KAAK,YAAY,SACvB"}
+{"version":3,"file":"memory.js","names":[],"sources":["../../src/vectorstores/memory.ts"],"sourcesContent":["import {\n  MaxMarginalRelevanceSearchOptions,\n  VectorStore,\n} from \"@langchain/core/vectorstores\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { maximalMarginalRelevance } from \"@langchain/core/utils/math\";\nimport { cosine } from \"../util/ml-distance/similarities.js\";\n\n/**\n * Interface representing a vector in memory. It includes the content\n * (text), the corresponding embedding (vector), and any associated\n * metadata.\n */\ninterface MemoryVector {\n  content: string;\n  embedding: number[];\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  metadata: Record<string, any>;\n  id?: string;\n}\n\n/**\n * Interface for the arguments that can be passed to the\n * `MemoryVectorStore` constructor. It includes an optional `similarity`\n * function.\n */\nexport interface MemoryVectorStoreArgs {\n  similarity?: typeof cosine;\n}\n\n/**\n * In-memory, ephemeral vector store.\n *\n * Setup:\n * Install `langchain`:\n *\n * ```bash\n * npm install langchain\n * ```\n *\n * ## [Constructor args](https://api.js.langchain.com/classes/langchain.vectorstores_memory.MemoryVectorStore.html#constructor)\n *\n * <details open>\n * <summary><strong>Instantiate</strong></summary>\n *\n * ```typescript\n * import { MemoryVectorStore } from 'langchain/vectorstores/memory';\n * // Or other embeddings\n * import { OpenAIEmbeddings } from '@langchain/openai';\n *\n * const embeddings = new OpenAIEmbeddings({\n *   model: \"text-embedding-3-small\",\n * });\n *\n * const vectorStore = new MemoryVectorStore(embeddings);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Add documents</strong></summary>\n *\n * ```typescript\n * import type { Document } from '@langchain/core/documents';\n *\n * const document1 = { pageContent: \"foo\", metadata: { baz: \"bar\" } };\n * const document2 = { pageContent: \"thud\", metadata: { bar: \"baz\" } };\n * const document3 = { pageContent: \"i will be deleted :(\", metadata: {} };\n *\n * const documents: Document[] = [document1, document2, document3];\n *\n * await vectorStore.addDocuments(documents);\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>Similarity search</strong></summary>\n *\n * ```typescript\n * const results = await vectorStore.similaritySearch(\"thud\", 1);\n * for (const doc of results) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * thud [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with filter</strong></summary>\n *\n * ```typescript\n * const resultsWithFilter = await vectorStore.similaritySearch(\"thud\", 1, { baz: \"bar\" });\n *\n * for (const doc of resultsWithFilter) {\n *   console.log(`* ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * foo [{\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n *\n * <details>\n * <summary><strong>Similarity search with score</strong></summary>\n *\n * ```typescript\n * const resultsWithScore = await vectorStore.similaritySearchWithScore(\"qux\", 1);\n * for (const [doc, score] of resultsWithScore) {\n *   console.log(`* [SIM=${score.toFixed(6)}] ${doc.pageContent} [${JSON.stringify(doc.metadata, null)}]`);\n * }\n * // Output: * [SIM=0.000000] qux [{\"bar\":\"baz\",\"baz\":\"bar\"}]\n * ```\n * </details>\n *\n * <br />\n *\n * <details>\n * <summary><strong>As a retriever</strong></summary>\n *\n * ```typescript\n * const retriever = vectorStore.asRetriever({\n *   searchType: \"mmr\", // Leave blank for standard similarity search\n *   k: 1,\n * });\n * const resultAsRetriever = await retriever.invoke(\"thud\");\n * console.log(resultAsRetriever);\n *\n * // Output: [Document({ metadata: { \"baz\":\"bar\" }, pageContent: \"thud\" })]\n * ```\n * </details>\n *\n * <br />\n */\nexport class MemoryVectorStore extends VectorStore {\n  declare FilterType: (doc: Document) => boolean;\n\n  memoryVectors: MemoryVector[] = [];\n\n  similarity: typeof cosine;\n\n  _vectorstoreType(): string {\n    return \"memory\";\n  }\n\n  constructor(\n    embeddings: EmbeddingsInterface,\n    { similarity, ...rest }: MemoryVectorStoreArgs = {}\n  ) {\n    super(embeddings, rest);\n\n    this.similarity = similarity ?? cosine;\n  }\n\n  /**\n   * Method to add documents to the memory vector store. It extracts the\n   * text from each document, generates embeddings for them, and adds the\n   * resulting vectors to the store.\n   * @param documents Array of `Document` instances to be added to the store.\n   * @returns Promise that resolves when all documents have been added.\n   */\n  async addDocuments(documents: Document[]): Promise<void> {\n    const texts = documents.map(({ pageContent }) => pageContent);\n    return this.addVectors(\n      await this.embeddings.embedDocuments(texts),\n      documents\n    );\n  }\n\n  /**\n   * Method to add vectors to the memory vector store. It creates\n   * `MemoryVector` instances for each vector and document pair and adds\n   * them to the store.\n   * @param vectors Array of vectors to be added to the store.\n   * @param documents Array of `Document` instances corresponding to the vectors.\n   * @returns Promise that resolves when all vectors have been added.\n   */\n  async addVectors(vectors: number[][], documents: Document[]): Promise<void> {\n    const memoryVectors = vectors.map((embedding, idx) => ({\n      content: documents[idx].pageContent,\n      embedding,\n      metadata: documents[idx].metadata,\n      id: documents[idx].id,\n    }));\n\n    this.memoryVectors = this.memoryVectors.concat(memoryVectors);\n  }\n\n  protected async _queryVectors(\n    query: number[],\n    k: number,\n    filter?: this[\"FilterType\"]\n  ) {\n    const filterFunction = (memoryVector: MemoryVector) => {\n      if (!filter) {\n        return true;\n      }\n\n      const doc = new Document({\n        metadata: memoryVector.metadata,\n        pageContent: memoryVector.content,\n        id: memoryVector.id,\n      });\n      return filter(doc);\n    };\n    const filteredMemoryVectors = this.memoryVectors.filter(filterFunction);\n    return filteredMemoryVectors\n      .map((vector, index) => ({\n        similarity: this.similarity(query, vector.embedding),\n        index,\n        metadata: vector.metadata,\n        content: vector.content,\n        embedding: vector.embedding,\n        id: vector.id,\n      }))\n      .sort((a, b) => (a.similarity > b.similarity ? -1 : 0))\n      .slice(0, k);\n  }\n\n  /**\n   * Method to perform a similarity search in the memory vector store. It\n   * calculates the similarity between the query vector and each vector in\n   * the store, sorts the results by similarity, and returns the top `k`\n   * results along with their scores.\n   * @param query Query vector to compare against the vectors in the store.\n   * @param k Number of top results to return.\n   * @param filter Optional filter function to apply to the vectors before performing the search.\n   * @returns Promise that resolves with an array of tuples, each containing a `Document` and its similarity score.\n   */\n  async similaritySearchVectorWithScore(\n    query: number[],\n    k: number,\n    filter?: this[\"FilterType\"]\n  ): Promise<[Document, number][]> {\n    const searches = await this._queryVectors(query, k, filter);\n    const result: [Document, number][] = searches.map((search) => [\n      new Document({\n        metadata: search.metadata,\n        pageContent: search.content,\n        id: search.id,\n      }),\n      search.similarity,\n    ]);\n\n    return result;\n  }\n\n  async maxMarginalRelevanceSearch(\n    query: string,\n    options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>\n  ): Promise<DocumentInterface[]> {\n    const queryEmbedding = await this.embeddings.embedQuery(query);\n\n    const searches = await this._queryVectors(\n      queryEmbedding,\n      options.fetchK ?? 20,\n      options.filter\n    );\n\n    const embeddingList = searches.map((searchResp) => searchResp.embedding);\n\n    const mmrIndexes = maximalMarginalRelevance(\n      queryEmbedding,\n      embeddingList,\n      options.lambda,\n      options.k\n    );\n\n    return mmrIndexes.map(\n      (idx) =>\n        new Document({\n          metadata: searches[idx].metadata,\n          pageContent: searches[idx].content,\n          id: searches[idx].id,\n        })\n    );\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an array of\n   * texts. It creates a `Document` for each text and metadata pair, and\n   * adds them to the store.\n   * @param texts Array of texts to be added to the store.\n   * @param metadatas Array or single object of metadata corresponding to the texts.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the texts.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromTexts(\n    texts: string[],\n    metadatas: object[] | object,\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const docs: Document[] = [];\n    for (let i = 0; i < texts.length; i += 1) {\n      const metadata = Array.isArray(metadatas) ? metadatas[i] : metadatas;\n      const newDoc = new Document({\n        pageContent: texts[i],\n        metadata,\n      });\n      docs.push(newDoc);\n    }\n    return MemoryVectorStore.fromDocuments(docs, embeddings, dbConfig);\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an array of\n   * `Document` instances. It adds the documents to the store.\n   * @param docs Array of `Document` instances to be added to the store.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the documents.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromDocuments(\n    docs: Document[],\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const instance = new this(embeddings, dbConfig);\n    await instance.addDocuments(docs);\n    return instance;\n  }\n\n  /**\n   * Static method to create a `MemoryVectorStore` instance from an existing\n   * index. It creates a new `MemoryVectorStore` instance without adding any\n   * documents or vectors.\n   * @param embeddings `Embeddings` instance used to generate embeddings for the documents.\n   * @param dbConfig Optional `MemoryVectorStoreArgs` to configure the `MemoryVectorStore` instance.\n   * @returns Promise that resolves with a new `MemoryVectorStore` instance.\n   */\n  static async fromExistingIndex(\n    embeddings: EmbeddingsInterface,\n    dbConfig?: MemoryVectorStoreArgs\n  ): Promise<MemoryVectorStore> {\n    const instance = new this(embeddings, dbConfig);\n    return instance;\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/classic",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "Old abstractions from LangChain.js",
   "author": "LangChain",
   "license": "MIT",
@@ -95,20 +95,20 @@
   },
   "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/langchain/",
   "devDependencies": {
-    "@aws-sdk/dsql-signer": "^3.1078.0",
+    "@aws-sdk/dsql-signer": "^3.1097.0",
     "@azure/identity": "^4.12.0",
     "@browserbasehq/stagehand": "^1.3.0",
     "@clickhouse/client": "^0.2.5",
     "@cloudflare/workers-types": "^4.20260602.1",
-    "@elastic/elasticsearch": "^8.4.0",
+    "@elastic/elasticsearch": "^8.19.2",
     "@faker-js/faker": "^10.4.0",
     "@getmetal/metal-sdk": "^7.7.1",
     "@getzep/zep-cloud": "^1.0.12",
     "@getzep/zep-js": "^2.0.2",
-    "@gomomento/sdk": "1.117.4",
+    "@gomomento/sdk": "1.118.0",
     "@google/generative-ai": "^0.24.1",
-    "@lancedb/lancedb": "^0.30.0",
-    "@langchain/langgraph": "1.4.7",
+    "@lancedb/lancedb": "^0.33.0",
+    "@langchain/langgraph": "1.4.8",
     "@layerup/layerup-security": "^1.5.12",
     "@opensearch-project/opensearch": "^2.2.0",
     "@pinecone-database/pinecone": "^5.0.2",
@@ -116,24 +116,24 @@
     "@prisma/client": "^6.19.3",
     "@qdrant/js-client-rest": "^1.18.0",
     "@rockset/client": "^0.9.1",
-    "@supabase/supabase-js": "^2.107.0",
+    "@supabase/supabase-js": "^2.111.0",
     "@tensorflow/tfjs-backend-cpu": "^4.22.0",
     "@tsconfig/recommended": "^1.0.2",
     "@types/js-yaml": "^4",
     "@types/jsdom": "^28.0.3",
-    "@types/pg": "^8.15.5",
+    "@types/pg": "^8.20.3",
     "@types/ws": "^8",
     "@upstash/redis": "^1.38.0",
     "@upstash/vector": "^1.2.2",
     "@vercel/kv": "^3.0.0",
-    "@vitest/coverage-v8": "^4.1.9",
+    "@vitest/coverage-v8": "^4.1.10",
     "@xata.io/client": "^0.30.1",
     "@zilliz/milvus2-sdk-node": "^2.6.14",
-    "axios": "^1.16.1",
+    "axios": "^1.18.1",
     "cheerio": "1.2.0",
     "chromadb": "^1.5.3",
     "cohere-ai": "^7.14.0",
-    "convex": "^1.40.0",
+    "convex": "^1.42.3",
     "date-fns": "^4.4.0",
     "dotenv": "^17.4.0",
     "dpdm": "^3.14.0",
@@ -142,36 +142,36 @@
     "firebase-admin": "^13.10.0",
     "graphql": "^16.14.1",
     "hdb": "^0.19.8",
-    "ioredis": "^5.11.0",
+    "ioredis": "^5.11.1",
     "langsmith": ">=0.4.0 <1.0.0",
     "lorem-ipsum": "^3.0.0",
     "lunary": "^0.8.8",
-    "mariadb": "^3.5.1",
-    "mem0ai": "^3.0.6",
+    "mariadb": "^3.5.3",
+    "mem0ai": "^3.1.2",
     "mongodb": "^6.17.0",
     "openai": "^6.41.0",
     "peggy": "^5.1.0",
-    "pg": "^8.21.0",
+    "pg": "^8.22.0",
     "pickleparser": "^0.2.1",
-    "prisma": "^7.8.0",
+    "prisma": "^7.9.1",
     "readline": "^1.3.0",
     "redis": "^4.6.13",
     "reflect-metadata": "^0.2.2",
     "rimraf": "^6.1.3",
     "sqlite3": "^5.1.4",
-    "typeorm": "^1.0.0",
-    "typescript": "~6.0.3",
+    "typeorm": "^1.1.0",
+    "typescript": "~7.0.2",
     "typesense": "^3.0.5",
     "vitest": "^4.1.8",
     "voy-search": "0.6.3",
-    "weaviate-client": "^3.13.1",
+    "weaviate-client": "^3.14.0",
     "zod-to-json-schema": "^3.25.2",
-    "@langchain/anthropic": "1.5.1",
-    "@langchain/aws": "1.4.2",
+    "@langchain/anthropic": "1.5.4",
+    "@langchain/aws": "1.4.3",
     "@langchain/cloudflare": "1.1.0",
-    "@langchain/core": "^1.2.2",
-    "@langchain/deepseek": "1.1.4",
-    "@langchain/fireworks": "0.2.4",
+    "@langchain/core": "^1.2.5",
+    "@langchain/deepseek": "1.1.6",
+    "@langchain/fireworks": "0.2.6",
     "@langchain/google-common": "2.2.0",
     "@langchain/google-genai": "2.2.0",
     "@langchain/google-vertexai": "2.2.0",
@@ -182,16 +182,16 @@
     "@langchain/ollama": "1.3.0",
     "@langchain/redis": "1.1.3",
     "@langchain/textsplitters": "1.0.1",
-    "@langchain/xai": "1.4.4",
+    "@langchain/xai": "1.4.6",
     "@langchain/tsconfig": "0.0.1",
-    "langchain": "1.5.3",
-    "@langchain/together-ai": "0.2.4"
+    "langchain": "1.5.5",
+    "@langchain/together-ai": "0.2.6"
   },
   "peerDependencies": {
     "cheerio": "*",
     "peggy": "^5.1.0",
     "typeorm": "*",
-    "@langchain/core": "^1.2.2"
+    "@langchain/core": "^1.2.5"
   },
   "peerDependenciesMeta": {
     "cheerio": {
@@ -206,12 +206,12 @@
   },
   "dependencies": {
     "handlebars": "^4.7.9",
-    "js-yaml": "^5.1.0",
+    "js-yaml": "^5.2.2",
     "jsonpointer": "^5.0.1",
     "openapi-types": "^12.1.3",
     "yaml": "^2.9.0",
     "zod": "^3.25.76 || ^4",
-    "@langchain/openai": "1.5.4",
+    "@langchain/openai": "1.5.6",
     "@langchain/textsplitters": "1.0.1"
   },
   "optionalDependencies": {