npm - @langchain/classic - Versions diffs - 1.0.17 → 1.0.18 - Mend

@langchain/classic 1.0.17 → 1.0.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1628) hide show

package/dist/vectorstores/memory.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"memory.cjs","names":["VectorStore","embeddings: EmbeddingsInterface","cosine","documents: Document[]","vectors: number[][]","query: number[]","k: number","filter?: this[\"FilterType\"]","memoryVector: MemoryVector","Document","result: [Document, number][]","query: string","options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>","texts: string[]","metadatas: object[] \| object","dbConfig?: MemoryVectorStoreArgs","docs: 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 // eslint-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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"}
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 // eslint-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,0BAA0BA,yCAAY;CAGjD,gBAAgC,EAAE;CAElC;CAEA,mBAA2B;AACzB,SAAO;;CAGT,YACE,YACA,EAAE,YAAY,GAAG,SAAgC,EAAE,EACnD;AACA,QAAM,YAAY,KAAK;AAEvB,OAAK,aAAa,cAAcC;;;;;;;;;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,OALK,IAAIC,mCAAS;IACvB,UAAU,aAAa;IACvB,aAAa,aAAa;IAC1B,IAAI,aAAa;IAClB,CAAC,CACgB;;AAGpB,SAD8B,KAAK,cAAc,OAAO,eAAe,CAEpE,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,UAViB,MAAM,KAAK,cAAc,OAAO,GAAG,OAAO,EACb,KAAK,WAAW,CAC5D,IAAIA,mCAAS;GACX,UAAU,OAAO;GACjB,aAAa,OAAO;GACpB,IAAI,OAAO;GACZ,CAAC,EACF,OAAO,WACR,CAAC;;CAKJ,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,kEANE,gBAHoB,SAAS,KAAK,eAAe,WAAW,UAAU,EAKtE,QAAQ,QACR,QAAQ,EACT,CAEiB,KACf,QACC,IAAIA,mCAAS;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,IAAIA,mCAAS;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,SADiB,IAAI,KAAK,YAAY,SAAS"}

package/dist/vectorstores/memory.d.cts CHANGED Viewed

@@ -4,7 +4,6 @@ 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
  * (text), the corresponding embedding (vector), and any associated

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

	@@ -1 +1 @@
1	- {"version":3,"file":"memory.d.cts","names":["MaxMarginalRelevanceSearchOptions","VectorStore","EmbeddingsInterface","Document","DocumentInterface","cosine","MemoryVector","Record","MemoryVectorStoreArgs","MemoryVectorStore","similarity","Promise"],"sources":["../../src/vectorstores/memory.d.ts"],"~~sourcesContent~~":["~~import { MaxMarginalRelevanceSearchOptions~~, ~~VectorStore } from \"@langchain/core/vectorstores\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { Document~~, DocumentInterface } from \"@langchain/core/documents\";\nimport { cosine } from \"../util/ml-distance/similarities.js\";\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 metadata: Record<string~~, any>;\n id?: string;\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 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 declare class MemoryVectorStore extends VectorStore {\n FilterType: (doc: Document) => boolean;\n memoryVectors: MemoryVector[];\n similarity: typeof cosine;\n _vectorstoreType(): string;\n constructor(embeddings: EmbeddingsInterface, ~~{ similarity~~, ~~...rest }?: MemoryVectorStoreArgs);\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 addDocuments(documents: Document[]): Promise<void>;\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 addVectors(vectors: number[][], ~~documents: Document[]): Promise<void>;\n protected _queryVectors(query: number[]~~, ~~k: number~~, ~~filter?: this[\"FilterType\"]): Promise<{\n similarity: number;\n index: number;\n metadata: Record<string~~, any>;\n content: string;\n embedding: number[];\n id: string \| undefined;\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 similaritySearchVectorWithScore(query: number[]~~, ~~k: number~~, ~~filter?: this[\"FilterType\"]): Promise<[Document~~, ~~number][]>;\n maxMarginalRelevanceSearch(query: string~~, options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>): Promise<DocumentInterface[]>;\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 fromTexts(texts: string[], ~~metadatas: object[] \| object~~, ~~embeddings: EmbeddingsInterface~~, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;\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 fromDocuments(docs: Document[], ~~embeddings: EmbeddingsInterface~~, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;\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 fromExistingIndex(embeddings: EmbeddingsInterface, ~~dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;\n}\nexport {};\n//# sourceMappingURL=memory.d.ts.map"],"mappings":"~~;;;;;;;;;~~AAG6D;AAiB7D;AAiHA;UA5HUM~~,~~YAAAA~~,~~CA6HYH;EACHG~~,~~OAAAA~~,~~EAAAA~~,~~MAAAA;EACID~~,~~SAAAA~~,~~EAAAA~~,~~MAAAA~~,~~EAAAA~~;~~EAEKH~~,~~QAAAA~~,~~EA9HdK~~,~~MA8HcL~~,~~CAAAA~~,~~MAAAA~~,~~EAAAA~~,~~GAAAA~~,~~CAAAA;EAAuBQ~~,~~EAAAA~~,~~CAAAA~~,~~EAAAA~~,~~MAAAA;;;;;;;AAkBmCC~~,~~UAxIrEH~~,~~qBAAAA~~,~~CAwIqEG;EAkBiBR~~,~~UAAAA~~,~~CAAAA~~,~~EAAAA~~,~~OAzJ/EE~~,~~MAyJ+EF;;;;;;;;;;;;;;;;;;;AAzC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArCM~~,~~iBAAAA~~,~~SAA0BR~~,~~WAAAA;oBACzBE;iBACHG;qBACID;;0BAEKH;;;MAA+CM;;;;;;;;0BAQ/CL~~,~~aAAaQ;;;;;;;;;6CASMR~~,~~aAAaQ;oFAC0BA;;;cAGpEJ;;;;;;;;;;;;;;;4FAe4EI~~,~~SAASR;qDAChDH~~,~~wDAAwDW~~,~~QAAQP~~;;;;;;;;;;;~~8EAWvCF~~,~~gCAAgCM~~,~~wBAAwBG~~,~~QAAQF~~;;;;;;;;;~~6BASjHN~~,~~wBAAwBD~~,~~gCAAgCM~~,~~wBAAwBG~~,~~QAAQF~~;;;;;;;;;~~uCAS9EP~~,~~gCAAgCM~~,~~wBAAwBG~~,~~QAAQF~~"}
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"}

package/dist/vectorstores/memory.d.ts CHANGED Viewed

@@ -4,7 +4,6 @@ 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
  * (text), the corresponding embedding (vector), and any associated

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

	@@ -1 +1 @@
1	- {"version":3,"file":"memory.d.ts","names":["MaxMarginalRelevanceSearchOptions","VectorStore","EmbeddingsInterface","Document","DocumentInterface","cosine","MemoryVector","Record","MemoryVectorStoreArgs","MemoryVectorStore","similarity","Promise"],"sources":["../../src/vectorstores/memory.d.ts"],"~~sourcesContent~~":["~~import { MaxMarginalRelevanceSearchOptions~~, ~~VectorStore } from \"@langchain/core/vectorstores\";\nimport type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport { Document~~, DocumentInterface } from \"@langchain/core/documents\";\nimport { cosine } from \"../util/ml-distance/similarities.js\";\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 metadata: Record<string~~, any>;\n id?: string;\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 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 declare class MemoryVectorStore extends VectorStore {\n FilterType: (doc: Document) => boolean;\n memoryVectors: MemoryVector[];\n similarity: typeof cosine;\n _vectorstoreType(): string;\n constructor(embeddings: EmbeddingsInterface, ~~{ similarity~~, ~~...rest }?: MemoryVectorStoreArgs);\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 addDocuments(documents: Document[]): Promise<void>;\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 addVectors(vectors: number[][], ~~documents: Document[]): Promise<void>;\n protected _queryVectors(query: number[]~~, ~~k: number~~, ~~filter?: this[\"FilterType\"]): Promise<{\n similarity: number;\n index: number;\n metadata: Record<string~~, any>;\n content: string;\n embedding: number[];\n id: string \| undefined;\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 similaritySearchVectorWithScore(query: number[]~~, ~~k: number~~, ~~filter?: this[\"FilterType\"]): Promise<[Document~~, ~~number][]>;\n maxMarginalRelevanceSearch(query: string~~, options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>): Promise<DocumentInterface[]>;\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 fromTexts(texts: string[], ~~metadatas: object[] \| object~~, ~~embeddings: EmbeddingsInterface~~, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;\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 fromDocuments(docs: Document[], ~~embeddings: EmbeddingsInterface~~, dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;\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 fromExistingIndex(embeddings: EmbeddingsInterface, ~~dbConfig?: MemoryVectorStoreArgs): Promise<MemoryVectorStore>;\n}\nexport {};\n//# sourceMappingURL=memory.d.ts.map"],"mappings":"~~;;;;;;;;;~~AAG6D;AAiB7D;AAiHA;UA5HUM~~,~~YAAAA~~,~~CA6HYH;EACHG~~,~~OAAAA~~,~~EAAAA~~,~~MAAAA;EACID~~,~~SAAAA~~,~~EAAAA~~,~~MAAAA~~,~~EAAAA~~;~~EAEKH~~,~~QAAAA~~,~~EA9HdK~~,~~MA8HcL~~,~~CAAAA~~,~~MAAAA~~,~~EAAAA~~,~~GAAAA~~,~~CAAAA;EAAuBQ~~,~~EAAAA~~,~~CAAAA~~,~~EAAAA~~,~~MAAAA;;;;;;;AAkBmCC~~,~~UAxIrEH~~,~~qBAAAA~~,~~CAwIqEG;EAkBiBR~~,~~UAAAA~~,~~CAAAA~~,~~EAAAA~~,~~OAzJ/EE~~,~~MAyJ+EF;;;;;;;;;;;;;;;;;;;AAzC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArCM~~,~~iBAAAA~~,~~SAA0BR~~,~~WAAAA;oBACzBE;iBACHG;qBACID;;0BAEKH;;;MAA+CM;;;;;;;;0BAQ/CL~~,~~aAAaQ;;;;;;;;;6CASMR~~,~~aAAaQ;oFAC0BA;;;cAGpEJ;;;;;;;;;;;;;;;4FAe4EI~~,~~SAASR;qDAChDH~~,~~wDAAwDW~~,~~QAAQP~~;;;;;;;;;;;~~8EAWvCF~~,~~gCAAgCM~~,~~wBAAwBG~~,~~QAAQF~~;;;;;;;;;~~6BASjHN~~,~~wBAAwBD~~,~~gCAAgCM~~,~~wBAAwBG~~,~~QAAQF~~;;;;;;;;;~~uCAS9EP~~,~~gCAAgCM~~,~~wBAAwBG~~,~~QAAQF~~"}
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"}

package/dist/vectorstores/memory.js CHANGED Viewed

@@ -1,12 +1,11 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { cosine } from "../util/ml-distance/similarities.js";
 import { Document } from "@langchain/core/documents";
 import { maximalMarginalRelevance } from "@langchain/core/utils/math";
 import { VectorStore } from "@langchain/core/vectorstores";
 //#region src/vectorstores/memory.ts
-var memory_exports = {};
-__export(memory_exports, { MemoryVectorStore: () => MemoryVectorStore });
+var memory_exports = /* @__PURE__ */ __exportAll({ MemoryVectorStore: () => MemoryVectorStore });
 /**
 * In-memory, ephemeral vector store.
 *
@@ -123,7 +122,7 @@ var MemoryVectorStore = class MemoryVectorStore extends VectorStore {
 	_vectorstoreType() {
 		return "memory";
 	}
-	constructor(embeddings, { similarity,...rest } = {}) {
+	constructor(embeddings, { similarity, ...rest } = {}) {
 		super(embeddings, rest);
 		this.similarity = similarity ?? cosine;
 	}
@@ -158,15 +157,13 @@ var MemoryVectorStore = class MemoryVectorStore extends VectorStore {
 	async _queryVectors(query, k, filter) {
 		const filterFunction = (memoryVector) => {
 			if (!filter) return true;
-			const doc = new Document({
+			return filter(new Document({
 				metadata: memoryVector.metadata,
 				pageContent: memoryVector.content,
 				id: memoryVector.id
-			});
-			return filter(doc);
+			}));
 		};
-		const filteredMemoryVectors = this.memoryVectors.filter(filterFunction);
-		return filteredMemoryVectors.map((vector, index) => ({
+		return this.memoryVectors.filter(filterFunction).map((vector, index) => ({
 			similarity: this.similarity(query, vector.embedding),
 			index,
 			metadata: vector.metadata,
@@ -186,20 +183,16 @@ var MemoryVectorStore = class MemoryVectorStore extends VectorStore {
 	* @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 Document({
+		return (await this._queryVectors(query, k, filter)).map((search) => [new Document({
 			metadata: search.metadata,
 			pageContent: search.content,
 			id: search.id
 		}), 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 = maximalMarginalRelevance(queryEmbedding, embeddingList, options.lambda, options.k);
-		return mmrIndexes.map((idx) => new Document({
+		return maximalMarginalRelevance(queryEmbedding, searches.map((searchResp) => searchResp.embedding), options.lambda, options.k).map((idx) => new Document({
 			metadata: searches[idx].metadata,
 			pageContent: searches[idx].content,
 			id: searches[idx].id
@@ -249,8 +242,7 @@ var MemoryVectorStore = class MemoryVectorStore extends VectorStore {
 	* @returns Promise that resolves with a new `MemoryVectorStore` instance.
 	*/
 	static async fromExistingIndex(embeddings, dbConfig) {
-		const instance = new this(embeddings, dbConfig);
-		return instance;
+		return new this(embeddings, dbConfig);
 	}
 };

package/dist/vectorstores/memory.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"memory.js","names":["embeddings: EmbeddingsInterface","documents: Document[]","vectors: number[][]","query: number[]","k: number","filter?: this[\"FilterType\"]","memoryVector: MemoryVector","result: [Document, number][]","query: string","options: MaxMarginalRelevanceSearchOptions<this[\"FilterType\"]>","texts: string[]","metadatas: object[] \| object","dbConfig?: MemoryVectorStoreArgs","docs: 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 // eslint-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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"}
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 // eslint-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,OALK,IAAI,SAAS;IACvB,UAAU,aAAa;IACvB,aAAa,aAAa;IAC1B,IAAI,aAAa;IAClB,CAAC,CACgB;;AAGpB,SAD8B,KAAK,cAAc,OAAO,eAAe,CAEpE,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,UAViB,MAAM,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,CAAC;;CAKJ,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,UAAU,EAKtE,QAAQ,QACR,QAAQ,EACT,CAEiB,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,SADiB,IAAI,KAAK,YAAY,SAAS"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/classic",
-  "version": "1.0.17",
+  "version": "1.0.18",
   "description": "Old abstractions from LangChain.js",
   "author": "LangChain",
   "license": "MIT",
@@ -105,7 +105,7 @@
     "@faker-js/faker": "^10.0.0",
     "@getmetal/metal-sdk": "^4.0.0",
     "@getzep/zep-cloud": "^1.0.12",
-    "@getzep/zep-js": "^0.9.0",
+    "@getzep/zep-js": "^2.0.2",
     "@gomomento/sdk": "1.117.2",
     "@google/generative-ai": "^0.7.0",
     "@lancedb/lancedb": "^0.19.1",
@@ -118,7 +118,7 @@
     "@qdrant/js-client-rest": "^1.15.0",
     "@rockset/client": "^0.9.1",
     "@supabase/supabase-js": "^2.53.0",
-    "@tensorflow/tfjs-backend-cpu": "^4.4.0",
+    "@tensorflow/tfjs-backend-cpu": "^4.22.0",
     "@tsconfig/recommended": "^1.0.2",
     "@types/js-yaml": "^4",
     "@types/jsdom": "^21.1.1",
@@ -132,11 +132,11 @@
     "@xata.io/client": "^0.28.4",
     "@zilliz/milvus2-sdk-node": "^2.3.5",
     "axios": "^1.13.5",
-    "cheerio": "1.0.0-rc.12",
+    "cheerio": "1.2.0",
     "chromadb": "^1.5.3",
     "cohere-ai": "^7.14.0",
     "convex": "^1.3.1",
-    "date-fns": "^3.6.0",
+    "date-fns": "^4.1.0",
     "dotenv": "^16.0.3",
     "dpdm": "^3.14.0",
     "duck-duck-scrape": "^2.2.5",
@@ -170,23 +170,23 @@
     "voy-search": "0.6.2",
     "weaviate-client": "^3.8.0",
     "zod-to-json-schema": "^3.24.6",
-    "@langchain/anthropic": "1.3.17",
-    "@langchain/aws": "1.2.2",
+    "@langchain/anthropic": "1.3.18",
+    "@langchain/aws": "1.2.3",
     "@langchain/azure-cosmosdb": "1.1.0",
     "@langchain/azure-dynamic-sessions": "1.0.1",
     "@langchain/baidu-qianfan": "1.0.1",
     "@langchain/cloudflare": "1.0.2",
     "@langchain/cohere": "1.0.2",
-    "@langchain/core": "^1.1.21",
-    "@langchain/deepseek": "1.0.11",
+    "@langchain/core": "^1.1.25",
+    "@langchain/deepseek": "1.0.12",
     "@langchain/eslint": "0.1.1",
     "@langchain/exa": "1.0.1",
-    "@langchain/google-cloud-sql-pg": "1.0.21",
-    "@langchain/google-common": "2.1.17",
-    "@langchain/google-genai": "2.1.17",
-    "@langchain/google-vertexai": "2.1.17",
-    "@langchain/google-vertexai-web": "2.1.17",
-    "@langchain/groq": "1.1.0",
+    "@langchain/google-cloud-sql-pg": "1.0.22",
+    "@langchain/google-common": "2.1.19",
+    "@langchain/google-genai": "2.1.19",
+    "@langchain/google-vertexai": "2.1.19",
+    "@langchain/google-vertexai-web": "2.1.19",
+    "@langchain/groq": "1.1.1",
     "@langchain/mistralai": "1.0.4",
     "@langchain/mongodb": "1.1.0",
     "@langchain/nomic": "1.0.1",
@@ -197,10 +197,10 @@
     "@langchain/tavily": "1.2.0",
     "@langchain/textsplitters": "1.0.1",
     "@langchain/weaviate": "1.0.1",
-    "@langchain/xai": "1.3.3",
+    "@langchain/xai": "1.3.4",
     "@langchain/yandex": "1.0.1",
     "@langchain/tsconfig": "0.0.1",
-    "langchain": "1.2.20"
+    "langchain": "1.2.24"
   },
   "peerDependencies": {
     "@langchain/core": "^1.0.0",
@@ -227,7 +227,7 @@
     "uuid": "^10.0.0",
     "yaml": "^2.2.1",
     "zod": "^3.25.76 || ^4",
-    "@langchain/openai": "1.2.7",
+    "@langchain/openai": "1.2.8",
     "@langchain/textsplitters": "1.0.1"
   },
   "optionalDependencies": {

package/dist/_virtual/rolldown_runtime.js DELETED Viewed

@@ -1,25 +0,0 @@
-//#region rolldown:runtime
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-//#endregion
-export { __export, __reExport };