@langchain/classic 1.0.4 → 1.0.6-dev-1765431816670

package/dist/retrievers/document_compressors/embeddings_filter.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"embeddings_filter.d.cts","names":["EmbeddingsInterface","DocumentInterface","cosineSimilarity","BaseDocumentCompressor","EmbeddingsFilterParams","EmbeddingsFilter","Promise"],"sources":["../../../src/retrievers/document_compressors/embeddings_filter.d.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { cosineSimilarity } from \"@langchain/core/utils/math\";\nimport { BaseDocumentCompressor } from \"./index.js\";\n/**\n * Interface for the parameters of the `EmbeddingsFilter` class.\n */\nexport interface EmbeddingsFilterParams {\n    embeddings: EmbeddingsInterface;\n    similarityFn?: (x: number[][], y: number[][]) => number[][];\n    similarityThreshold?: number;\n    k?: number;\n}\n/**\n * Class that represents a document compressor that uses embeddings to\n * drop documents unrelated to the query.\n * @example\n * ```typescript\n * const embeddingsFilter = new EmbeddingsFilter({\n *   embeddings: new OpenAIEmbeddings(),\n *   similarityThreshold: 0.8,\n *   k: 5,\n * });\n * const retrievedDocs = await embeddingsFilter.filterDocuments(\n *   getDocuments(),\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class EmbeddingsFilter extends BaseDocumentCompressor {\n    /**\n     * Embeddings to use for embedding document contents and queries.\n     */\n    embeddings: EmbeddingsInterface;\n    /**\n     * Similarity function for comparing documents.\n     */\n    similarityFn: typeof cosineSimilarity;\n    /**\n     * Threshold for determining when two documents are similar enough\n     * to be considered redundant. Must be specified if `k` is not set.\n     */\n    similarityThreshold?: number;\n    /**\n     * The number of relevant documents to return. Can be explicitly set to undefined, in which case\n     * similarity_threshold` must be specified. Defaults to 20\n     */\n    k?: number | undefined;\n    constructor(params: EmbeddingsFilterParams);\n    compressDocuments(documents: DocumentInterface[], query: string): Promise<DocumentInterface[]>;\n}\n"],"mappings":";;;;;;;;;AAOA;AAuBqBK,UAvBJD,sBAAAA,CAuBoB;EAAA,UAAA,EAtBrBJ,mBAsBqB;EAAA,YAIrBA,CAAAA,EAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,GAAAA,MAAAA,EAAAA,EAAAA;EAAmB,mBAIVE,CAAAA,EAAAA,MAAAA;EAAgB,CAAA,CAAA,EAWjBE,MAAAA;;;;;AAnB4C;;;;;;;;;;;;;;cAA/CC,gBAAAA,SAAyBF,sBAAAA;;;;cAI9BH;;;;uBAISE;;;;;;;;;;;sBAWDE;+BACSH,qCAAqCK,QAAQL"}
+{"version":3,"file":"embeddings_filter.d.cts","names":["EmbeddingsInterface","DocumentInterface","cosineSimilarity","BaseDocumentCompressor","EmbeddingsFilterParams","EmbeddingsFilter","Promise"],"sources":["../../../src/retrievers/document_compressors/embeddings_filter.d.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { cosineSimilarity } from \"@langchain/core/utils/math\";\nimport { BaseDocumentCompressor } from \"./index.js\";\n/**\n * Interface for the parameters of the `EmbeddingsFilter` class.\n */\nexport interface EmbeddingsFilterParams {\n    embeddings: EmbeddingsInterface;\n    similarityFn?: (x: number[][], y: number[][]) => number[][];\n    similarityThreshold?: number;\n    k?: number;\n}\n/**\n * Class that represents a document compressor that uses embeddings to\n * drop documents unrelated to the query.\n * @example\n * ```typescript\n * const embeddingsFilter = new EmbeddingsFilter({\n *   embeddings: new OpenAIEmbeddings(),\n *   similarityThreshold: 0.8,\n *   k: 5,\n * });\n * const retrievedDocs = await embeddingsFilter.filterDocuments(\n *   getDocuments(),\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class EmbeddingsFilter extends BaseDocumentCompressor {\n    /**\n     * Embeddings to use for embedding document contents and queries.\n     */\n    embeddings: EmbeddingsInterface;\n    /**\n     * Similarity function for comparing documents.\n     */\n    similarityFn: typeof cosineSimilarity;\n    /**\n     * Threshold for determining when two documents are similar enough\n     * to be considered redundant. Must be specified if `k` is not set.\n     */\n    similarityThreshold?: number;\n    /**\n     * The number of relevant documents to return. Can be explicitly set to undefined, in which case\n     * similarity_threshold` must be specified. Defaults to 20\n     */\n    k?: number | undefined;\n    constructor(params: EmbeddingsFilterParams);\n    compressDocuments(documents: DocumentInterface[], query: string): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=embeddings_filter.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAuBqBK,UAvBJD,sBAAAA,CAuBoB;EAIrBJ,UAAAA,EA1BAA,mBA0BAA;EAISE,YAAAA,CAAAA,EAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,GAAAA,MAAAA,EAAAA,EAAAA;EAWDE,mBAAAA,CAAAA,EAAAA,MAAAA;EACSH,CAAAA,CAAAA,EAAAA,MAAAA;;;;AApBmC;;;;;;;;;;;;;;;cAA/CI,gBAAAA,SAAyBF,sBAAAA;;;;cAI9BH;;;;uBAISE;;;;;;;;;;;sBAWDE;+BACSH,qCAAqCK,QAAQL"}

package/dist/retrievers/document_compressors/embeddings_filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"embeddings_filter.d.ts","names":["EmbeddingsInterface","DocumentInterface","cosineSimilarity","BaseDocumentCompressor","EmbeddingsFilterParams","EmbeddingsFilter","Promise"],"sources":["../../../src/retrievers/document_compressors/embeddings_filter.d.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { cosineSimilarity } from \"@langchain/core/utils/math\";\nimport { BaseDocumentCompressor } from \"./index.js\";\n/**\n * Interface for the parameters of the `EmbeddingsFilter` class.\n */\nexport interface EmbeddingsFilterParams {\n    embeddings: EmbeddingsInterface;\n    similarityFn?: (x: number[][], y: number[][]) => number[][];\n    similarityThreshold?: number;\n    k?: number;\n}\n/**\n * Class that represents a document compressor that uses embeddings to\n * drop documents unrelated to the query.\n * @example\n * ```typescript\n * const embeddingsFilter = new EmbeddingsFilter({\n *   embeddings: new OpenAIEmbeddings(),\n *   similarityThreshold: 0.8,\n *   k: 5,\n * });\n * const retrievedDocs = await embeddingsFilter.filterDocuments(\n *   getDocuments(),\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class EmbeddingsFilter extends BaseDocumentCompressor {\n    /**\n     * Embeddings to use for embedding document contents and queries.\n     */\n    embeddings: EmbeddingsInterface;\n    /**\n     * Similarity function for comparing documents.\n     */\n    similarityFn: typeof cosineSimilarity;\n    /**\n     * Threshold for determining when two documents are similar enough\n     * to be considered redundant. Must be specified if `k` is not set.\n     */\n    similarityThreshold?: number;\n    /**\n     * The number of relevant documents to return. Can be explicitly set to undefined, in which case\n     * similarity_threshold` must be specified. Defaults to 20\n     */\n    k?: number | undefined;\n    constructor(params: EmbeddingsFilterParams);\n    compressDocuments(documents: DocumentInterface[], query: string): Promise<DocumentInterface[]>;\n}\n"],"mappings":";;;;;;;;;AAOA;AAuBqBK,UAvBJD,sBAAAA,CAuBoB;EAAA,UAAA,EAtBrBJ,mBAsBqB;EAAA,YAIrBA,CAAAA,EAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,GAAAA,MAAAA,EAAAA,EAAAA;EAAmB,mBAIVE,CAAAA,EAAAA,MAAAA;EAAgB,CAAA,CAAA,EAWjBE,MAAAA;;;;;AAnB4C;;;;;;;;;;;;;;cAA/CC,gBAAAA,SAAyBF,sBAAAA;;;;cAI9BH;;;;uBAISE;;;;;;;;;;;sBAWDE;+BACSH,qCAAqCK,QAAQL"}
+{"version":3,"file":"embeddings_filter.d.ts","names":["EmbeddingsInterface","DocumentInterface","cosineSimilarity","BaseDocumentCompressor","EmbeddingsFilterParams","EmbeddingsFilter","Promise"],"sources":["../../../src/retrievers/document_compressors/embeddings_filter.d.ts"],"sourcesContent":["import type { EmbeddingsInterface } from \"@langchain/core/embeddings\";\nimport type { DocumentInterface } from \"@langchain/core/documents\";\nimport { cosineSimilarity } from \"@langchain/core/utils/math\";\nimport { BaseDocumentCompressor } from \"./index.js\";\n/**\n * Interface for the parameters of the `EmbeddingsFilter` class.\n */\nexport interface EmbeddingsFilterParams {\n    embeddings: EmbeddingsInterface;\n    similarityFn?: (x: number[][], y: number[][]) => number[][];\n    similarityThreshold?: number;\n    k?: number;\n}\n/**\n * Class that represents a document compressor that uses embeddings to\n * drop documents unrelated to the query.\n * @example\n * ```typescript\n * const embeddingsFilter = new EmbeddingsFilter({\n *   embeddings: new OpenAIEmbeddings(),\n *   similarityThreshold: 0.8,\n *   k: 5,\n * });\n * const retrievedDocs = await embeddingsFilter.filterDocuments(\n *   getDocuments(),\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class EmbeddingsFilter extends BaseDocumentCompressor {\n    /**\n     * Embeddings to use for embedding document contents and queries.\n     */\n    embeddings: EmbeddingsInterface;\n    /**\n     * Similarity function for comparing documents.\n     */\n    similarityFn: typeof cosineSimilarity;\n    /**\n     * Threshold for determining when two documents are similar enough\n     * to be considered redundant. Must be specified if `k` is not set.\n     */\n    similarityThreshold?: number;\n    /**\n     * The number of relevant documents to return. Can be explicitly set to undefined, in which case\n     * similarity_threshold` must be specified. Defaults to 20\n     */\n    k?: number | undefined;\n    constructor(params: EmbeddingsFilterParams);\n    compressDocuments(documents: DocumentInterface[], query: string): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=embeddings_filter.d.ts.map"],"mappings":";;;;;;;;;AAOA;AAuBqBK,UAvBJD,sBAAAA,CAuBoB;EAIrBJ,UAAAA,EA1BAA,mBA0BAA;EAISE,YAAAA,CAAAA,EAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,CAAAA,EAAAA,MAAAA,EAAAA,EAAAA,EAAAA,GAAAA,MAAAA,EAAAA,EAAAA;EAWDE,mBAAAA,CAAAA,EAAAA,MAAAA;EACSH,CAAAA,CAAAA,EAAAA,MAAAA;;;;AApBmC;;;;;;;;;;;;;;;cAA/CI,gBAAAA,SAAyBF,sBAAAA;;;;cAI9BH;;;;uBAISE;;;;;;;;;;;sBAWDE;+BACSH,qCAAqCK,QAAQL"}

package/dist/retrievers/document_compressors/index.d.cts

@@ -17,7 +17,6 @@ declare abstract class BaseDocumentCompressor {
    * @returns A Promise that resolves with an array of compressed `Document` objects.
    */
   abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;
 }
 /**

package/dist/retrievers/document_compressors/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["DocumentInterface","BaseDocumentTransformer","Callbacks","BaseDocumentCompressor","Promise","DocumentCompressorPipeline"],"sources":["../../../src/retrievers/document_compressors/index.d.ts"],"sourcesContent":["import type { DocumentInterface } from \"@langchain/core/documents\";\nimport { BaseDocumentTransformer } from \"@langchain/core/documents\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\n/**\n * Base Document Compression class. All compressors should extend this class.\n */\nexport declare abstract class BaseDocumentCompressor {\n    /**\n     * Abstract method that must be implemented by any class that extends\n     * `BaseDocumentCompressor`. This method takes an array of `Document`\n     * objects and a query string as parameters and returns a Promise that\n     * resolves with an array of compressed `Document` objects.\n     * @param documents An array of `Document` objects to be compressed.\n     * @param query A query string.\n     * @returns A Promise that resolves with an array of compressed `Document` objects.\n     */\n    abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;\n}\n/**\n * Document compressor that uses a pipeline of Transformers.\n * @example\n * ```typescript\n * const compressorPipeline = new DocumentCompressorPipeline({\n *   transformers: [\n *     new RecursiveCharacterTextSplitter({\n *       chunkSize: 200,\n *       chunkOverlap: 0,\n *     }),\n *     new EmbeddingsFilter({\n *       embeddings: new OpenAIEmbeddings(),\n *       similarityThreshold: 0.8,\n *       k: 5,\n *     }),\n *   ],\n * });\n * const retriever = new ContextualCompressionRetriever({\n *   baseCompressor: compressorPipeline,\n *   baseRetriever: new TavilySearchAPIRetriever({\n *     includeRawContent: true,\n *   }),\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class DocumentCompressorPipeline extends BaseDocumentCompressor {\n    transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    constructor(fields: {\n        transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    });\n    compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n}\n"],"mappings":";;;;;;AAMA;;AAU0CA,uBAVZG,sBAAAA,CAUYH;EAAiB;;;;AAEa;AA+BxE;;;;EACmE,SAE5CC,iBAAAA,CAAAA,SAAAA,EApCmBD,iBAoCnBC,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,SAAAA,CAAAA,EApCmEC,SAoCnED,CAAAA,EApC+EG,OAoC/EH,CApCuFD,iBAoCvFC,EAAAA,CAAAA;EAAuB;EAAyB,OAEtCD,wBAAAA,CAAAA,CAAAA,EAAAA,GAAAA,CAAAA,EAAAA,CAAAA,IApCiBG,sBAoCjBH;;;;;AAL6C;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzDK,0BAAAA,SAAmCF,sBAAAA;iBACrCF,0BAA0BE;;mBAEtBF,0BAA0BE;;+BAEhBH,gDAAgDE,YAAYE,QAAQJ"}
+{"version":3,"file":"index.d.cts","names":["DocumentInterface","BaseDocumentTransformer","Callbacks","BaseDocumentCompressor","Promise","DocumentCompressorPipeline"],"sources":["../../../src/retrievers/document_compressors/index.d.ts"],"sourcesContent":["import type { DocumentInterface } from \"@langchain/core/documents\";\nimport { BaseDocumentTransformer } from \"@langchain/core/documents\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\n/**\n * Base Document Compression class. All compressors should extend this class.\n */\nexport declare abstract class BaseDocumentCompressor {\n    /**\n     * Abstract method that must be implemented by any class that extends\n     * `BaseDocumentCompressor`. This method takes an array of `Document`\n     * objects and a query string as parameters and returns a Promise that\n     * resolves with an array of compressed `Document` objects.\n     * @param documents An array of `Document` objects to be compressed.\n     * @param query A query string.\n     * @returns A Promise that resolves with an array of compressed `Document` objects.\n     */\n    abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n    static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;\n}\n/**\n * Document compressor that uses a pipeline of Transformers.\n * @example\n * ```typescript\n * const compressorPipeline = new DocumentCompressorPipeline({\n *   transformers: [\n *     new RecursiveCharacterTextSplitter({\n *       chunkSize: 200,\n *       chunkOverlap: 0,\n *     }),\n *     new EmbeddingsFilter({\n *       embeddings: new OpenAIEmbeddings(),\n *       similarityThreshold: 0.8,\n *       k: 5,\n *     }),\n *   ],\n * });\n * const retriever = new ContextualCompressionRetriever({\n *   baseCompressor: compressorPipeline,\n *   baseRetriever: new TavilySearchAPIRetriever({\n *     includeRawContent: true,\n *   }),\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class DocumentCompressorPipeline extends BaseDocumentCompressor {\n    transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    constructor(fields: {\n        transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    });\n    compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;AAMA;;AAU0FE,uBAV5DC,sBAAAA,CAU4DD;EAAoBF;;;AACtC;AA+BxE;;;;;EAKiCA,SAAAA,iBAAAA,CAAAA,SAAAA,EArCSA,iBAqCTA,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,SAAAA,CAAAA,EArCyDE,SAqCzDF,CAAAA,EArCqEI,OAqCrEJ,CArC6EA,iBAqC7EA,EAAAA,CAAAA;EAAgDE,OAAAA,wBAAAA,CAAAA,CAAAA,EAAAA,GAAAA,CAAAA,EAAAA,CAAAA,IApC/BC,sBAoC+BD;;;;AALH;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzDG,0BAAAA,SAAmCF,sBAAAA;iBACrCF,0BAA0BE;;mBAEtBF,0BAA0BE;;+BAEhBH,gDAAgDE,YAAYE,QAAQJ"}

package/dist/retrievers/document_compressors/index.d.ts

@@ -17,7 +17,6 @@ declare abstract class BaseDocumentCompressor {
    * @returns A Promise that resolves with an array of compressed `Document` objects.
    */
   abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;
 }
 /**

package/dist/retrievers/document_compressors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["DocumentInterface","BaseDocumentTransformer","Callbacks","BaseDocumentCompressor","Promise","DocumentCompressorPipeline"],"sources":["../../../src/retrievers/document_compressors/index.d.ts"],"sourcesContent":["import type { DocumentInterface } from \"@langchain/core/documents\";\nimport { BaseDocumentTransformer } from \"@langchain/core/documents\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\n/**\n * Base Document Compression class. All compressors should extend this class.\n */\nexport declare abstract class BaseDocumentCompressor {\n    /**\n     * Abstract method that must be implemented by any class that extends\n     * `BaseDocumentCompressor`. This method takes an array of `Document`\n     * objects and a query string as parameters and returns a Promise that\n     * resolves with an array of compressed `Document` objects.\n     * @param documents An array of `Document` objects to be compressed.\n     * @param query A query string.\n     * @returns A Promise that resolves with an array of compressed `Document` objects.\n     */\n    abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;\n}\n/**\n * Document compressor that uses a pipeline of Transformers.\n * @example\n * ```typescript\n * const compressorPipeline = new DocumentCompressorPipeline({\n *   transformers: [\n *     new RecursiveCharacterTextSplitter({\n *       chunkSize: 200,\n *       chunkOverlap: 0,\n *     }),\n *     new EmbeddingsFilter({\n *       embeddings: new OpenAIEmbeddings(),\n *       similarityThreshold: 0.8,\n *       k: 5,\n *     }),\n *   ],\n * });\n * const retriever = new ContextualCompressionRetriever({\n *   baseCompressor: compressorPipeline,\n *   baseRetriever: new TavilySearchAPIRetriever({\n *     includeRawContent: true,\n *   }),\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class DocumentCompressorPipeline extends BaseDocumentCompressor {\n    transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    constructor(fields: {\n        transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    });\n    compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n}\n"],"mappings":";;;;;;AAMA;;AAU0CA,uBAVZG,sBAAAA,CAUYH;EAAiB;;;;AAEa;AA+BxE;;;;EACmE,SAE5CC,iBAAAA,CAAAA,SAAAA,EApCmBD,iBAoCnBC,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,SAAAA,CAAAA,EApCmEC,SAoCnED,CAAAA,EApC+EG,OAoC/EH,CApCuFD,iBAoCvFC,EAAAA,CAAAA;EAAuB;EAAyB,OAEtCD,wBAAAA,CAAAA,CAAAA,EAAAA,GAAAA,CAAAA,EAAAA,CAAAA,IApCiBG,sBAoCjBH;;;;;AAL6C;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzDK,0BAAAA,SAAmCF,sBAAAA;iBACrCF,0BAA0BE;;mBAEtBF,0BAA0BE;;+BAEhBH,gDAAgDE,YAAYE,QAAQJ"}
+{"version":3,"file":"index.d.ts","names":["DocumentInterface","BaseDocumentTransformer","Callbacks","BaseDocumentCompressor","Promise","DocumentCompressorPipeline"],"sources":["../../../src/retrievers/document_compressors/index.d.ts"],"sourcesContent":["import type { DocumentInterface } from \"@langchain/core/documents\";\nimport { BaseDocumentTransformer } from \"@langchain/core/documents\";\nimport { Callbacks } from \"@langchain/core/callbacks/manager\";\n/**\n * Base Document Compression class. All compressors should extend this class.\n */\nexport declare abstract class BaseDocumentCompressor {\n    /**\n     * Abstract method that must be implemented by any class that extends\n     * `BaseDocumentCompressor`. This method takes an array of `Document`\n     * objects and a query string as parameters and returns a Promise that\n     * resolves with an array of compressed `Document` objects.\n     * @param documents An array of `Document` objects to be compressed.\n     * @param query A query string.\n     * @returns A Promise that resolves with an array of compressed `Document` objects.\n     */\n    abstract compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n    static isBaseDocumentCompressor(x: any): x is BaseDocumentCompressor;\n}\n/**\n * Document compressor that uses a pipeline of Transformers.\n * @example\n * ```typescript\n * const compressorPipeline = new DocumentCompressorPipeline({\n *   transformers: [\n *     new RecursiveCharacterTextSplitter({\n *       chunkSize: 200,\n *       chunkOverlap: 0,\n *     }),\n *     new EmbeddingsFilter({\n *       embeddings: new OpenAIEmbeddings(),\n *       similarityThreshold: 0.8,\n *       k: 5,\n *     }),\n *   ],\n * });\n * const retriever = new ContextualCompressionRetriever({\n *   baseCompressor: compressorPipeline,\n *   baseRetriever: new TavilySearchAPIRetriever({\n *     includeRawContent: true,\n *   }),\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What did the speaker say about Justice Breyer in the 2022 State of the Union?\",\n * );\n * console.log({ retrievedDocs });\n * ```\n */\nexport declare class DocumentCompressorPipeline extends BaseDocumentCompressor {\n    transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    constructor(fields: {\n        transformers: (BaseDocumentTransformer | BaseDocumentCompressor)[];\n    });\n    compressDocuments(documents: DocumentInterface[], query: string, callbacks?: Callbacks): Promise<DocumentInterface[]>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;AAMA;;AAU0FE,uBAV5DC,sBAAAA,CAU4DD;EAAoBF;;;AACtC;AA+BxE;;;;;EAKiCA,SAAAA,iBAAAA,CAAAA,SAAAA,EArCSA,iBAqCTA,EAAAA,EAAAA,KAAAA,EAAAA,MAAAA,EAAAA,SAAAA,CAAAA,EArCyDE,SAqCzDF,CAAAA,EArCqEI,OAqCrEJ,CArC6EA,iBAqC7EA,EAAAA,CAAAA;EAAgDE,OAAAA,wBAAAA,CAAAA,CAAAA,EAAAA,GAAAA,CAAAA,EAAAA,CAAAA,IApC/BC,sBAoC+BD;;;;AALH;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAzDG,0BAAAA,SAAmCF,sBAAAA;iBACrCF,0BAA0BE;;mBAEtBF,0BAA0BE;;+BAEhBH,gDAAgDE,YAAYE,QAAQJ"}

package/dist/retrievers/ensemble.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"ensemble.d.cts","names":["BaseRetriever","BaseRetrieverInput","Document","DocumentInterface","CallbackManagerForRetrieverRun","EnsembleRetrieverInput","EnsembleRetriever","Record","Promise"],"sources":["../../src/retrievers/ensemble.d.ts"],"sourcesContent":["import { BaseRetriever, BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nexport interface EnsembleRetrieverInput extends BaseRetrieverInput {\n    /** A list of retrievers to ensemble. */\n    retrievers: BaseRetriever[];\n    /**\n     * A list of weights corresponding to the retrievers. Defaults to equal\n     * weighting for all retrievers.\n     */\n    weights?: number[];\n    /**\n     * A constant added to the rank, controlling the balance between the importance\n     * of high-ranked items and the consideration given to lower-ranked items.\n     * Default is 60.\n     */\n    c?: number;\n}\n/**\n * Ensemble retriever that aggregates and orders the results of\n * multiple retrievers by using weighted Reciprocal Rank Fusion.\n */\nexport declare class EnsembleRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    retrievers: BaseRetriever[];\n    weights: number[];\n    c: number;\n    constructor(args: EnsembleRetrieverInput);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _rankFusion(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _weightedReciprocalRank(docList: DocumentInterface[][]): Promise<Document<Record<string, any>>[]>;\n    private _uniqueUnion;\n}\n"],"mappings":";;;;;UAGiBK,sBAAAA,SAA+BJ;;EAA/BI,UAAAA,EAEDL,aAFuB,EAAA;EAAA;;;AAA2B;EAmB7CM,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAiB;;;;;EAOwE,CAAA,CAAA,EAAfJ,MAAAA;;;;;;AAE1DC,cAThBG,iBAAAA,SAA0BN,aAAAA,CASVG;EAAiB,OAAwBI,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAM,YAAfL,EAAAA,MAAAA,EAAAA;EAAQ,UAAhBM,EAN7CR,aAM6CQ,EAAAA;EAAO,OATrBR,EAAAA,MAAAA,EAAAA;EAAa,CAAA,EAAA,MAAA;oBAMtCK;oDACgCD,iCAAiCI,QAAQN,SAASK;0CAC5DH,iCAAiCI,QAAQN,SAASK;mCACzDJ,wBAAwBK,QAAQN,SAASK"}
+{"version":3,"file":"ensemble.d.cts","names":["BaseRetriever","BaseRetrieverInput","Document","DocumentInterface","CallbackManagerForRetrieverRun","EnsembleRetrieverInput","EnsembleRetriever","Record","Promise"],"sources":["../../src/retrievers/ensemble.d.ts"],"sourcesContent":["import { BaseRetriever, BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nexport interface EnsembleRetrieverInput extends BaseRetrieverInput {\n    /** A list of retrievers to ensemble. */\n    retrievers: BaseRetriever[];\n    /**\n     * A list of weights corresponding to the retrievers. Defaults to equal\n     * weighting for all retrievers.\n     */\n    weights?: number[];\n    /**\n     * A constant added to the rank, controlling the balance between the importance\n     * of high-ranked items and the consideration given to lower-ranked items.\n     * Default is 60.\n     */\n    c?: number;\n}\n/**\n * Ensemble retriever that aggregates and orders the results of\n * multiple retrievers by using weighted Reciprocal Rank Fusion.\n */\nexport declare class EnsembleRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    retrievers: BaseRetriever[];\n    weights: number[];\n    c: number;\n    constructor(args: EnsembleRetrieverInput);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _rankFusion(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _weightedReciprocalRank(docList: DocumentInterface[][]): Promise<Document<Record<string, any>>[]>;\n    private _uniqueUnion;\n}\n//# sourceMappingURL=ensemble.d.ts.map"],"mappings":";;;;;UAGiBK,sBAAAA,SAA+BJ;;EAA/BI,UAAAA,EAEDL,aAFuB,EAAA;EAmBlBM;;;;EAOmFC,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAATL;;;;;EAClBM,CAAAA,CAAAA,EAAAA,MAAAA;;;;;;AARjB,cAAvCF,iBAAAA,SAA0BN,aAAAA,CAAa;;;cAG5CA;;;oBAGMK;oDACgCD,iCAAiCI,QAAQN,SAASK;0CAC5DH,iCAAiCI,QAAQN,SAASK;mCACzDJ,wBAAwBK,QAAQN,SAASK"}

package/dist/retrievers/ensemble.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ensemble.d.ts","names":["BaseRetriever","BaseRetrieverInput","Document","DocumentInterface","CallbackManagerForRetrieverRun","EnsembleRetrieverInput","EnsembleRetriever","Record","Promise"],"sources":["../../src/retrievers/ensemble.d.ts"],"sourcesContent":["import { BaseRetriever, BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nexport interface EnsembleRetrieverInput extends BaseRetrieverInput {\n    /** A list of retrievers to ensemble. */\n    retrievers: BaseRetriever[];\n    /**\n     * A list of weights corresponding to the retrievers. Defaults to equal\n     * weighting for all retrievers.\n     */\n    weights?: number[];\n    /**\n     * A constant added to the rank, controlling the balance between the importance\n     * of high-ranked items and the consideration given to lower-ranked items.\n     * Default is 60.\n     */\n    c?: number;\n}\n/**\n * Ensemble retriever that aggregates and orders the results of\n * multiple retrievers by using weighted Reciprocal Rank Fusion.\n */\nexport declare class EnsembleRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    retrievers: BaseRetriever[];\n    weights: number[];\n    c: number;\n    constructor(args: EnsembleRetrieverInput);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _rankFusion(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _weightedReciprocalRank(docList: DocumentInterface[][]): Promise<Document<Record<string, any>>[]>;\n    private _uniqueUnion;\n}\n"],"mappings":";;;;;UAGiBK,sBAAAA,SAA+BJ;;EAA/BI,UAAAA,EAEDL,aAFuB,EAAA;EAAA;;;AAA2B;EAmB7CM,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAiB;;;;;EAOwE,CAAA,CAAA,EAAfJ,MAAAA;;;;;;AAE1DC,cAThBG,iBAAAA,SAA0BN,aAAAA,CASVG;EAAiB,OAAwBI,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAM,YAAfL,EAAAA,MAAAA,EAAAA;EAAQ,UAAhBM,EAN7CR,aAM6CQ,EAAAA;EAAO,OATrBR,EAAAA,MAAAA,EAAAA;EAAa,CAAA,EAAA,MAAA;oBAMtCK;oDACgCD,iCAAiCI,QAAQN,SAASK;0CAC5DH,iCAAiCI,QAAQN,SAASK;mCACzDJ,wBAAwBK,QAAQN,SAASK"}
+{"version":3,"file":"ensemble.d.ts","names":["BaseRetriever","BaseRetrieverInput","Document","DocumentInterface","CallbackManagerForRetrieverRun","EnsembleRetrieverInput","EnsembleRetriever","Record","Promise"],"sources":["../../src/retrievers/ensemble.d.ts"],"sourcesContent":["import { BaseRetriever, BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document, DocumentInterface } from \"@langchain/core/documents\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nexport interface EnsembleRetrieverInput extends BaseRetrieverInput {\n    /** A list of retrievers to ensemble. */\n    retrievers: BaseRetriever[];\n    /**\n     * A list of weights corresponding to the retrievers. Defaults to equal\n     * weighting for all retrievers.\n     */\n    weights?: number[];\n    /**\n     * A constant added to the rank, controlling the balance between the importance\n     * of high-ranked items and the consideration given to lower-ranked items.\n     * Default is 60.\n     */\n    c?: number;\n}\n/**\n * Ensemble retriever that aggregates and orders the results of\n * multiple retrievers by using weighted Reciprocal Rank Fusion.\n */\nexport declare class EnsembleRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    retrievers: BaseRetriever[];\n    weights: number[];\n    c: number;\n    constructor(args: EnsembleRetrieverInput);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _rankFusion(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, any>>[]>;\n    _weightedReciprocalRank(docList: DocumentInterface[][]): Promise<Document<Record<string, any>>[]>;\n    private _uniqueUnion;\n}\n//# sourceMappingURL=ensemble.d.ts.map"],"mappings":";;;;;UAGiBK,sBAAAA,SAA+BJ;;EAA/BI,UAAAA,EAEDL,aAFuB,EAAA;EAmBlBM;;;;EAOmFC,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAATL;;;;;EAClBM,CAAAA,CAAAA,EAAAA,MAAAA;;;;;;AARjB,cAAvCF,iBAAAA,SAA0BN,aAAAA,CAAa;;;cAG5CA;;;oBAGMK;oDACgCD,iCAAiCI,QAAQN,SAASK;0CAC5DH,iCAAiCI,QAAQN,SAASK;mCACzDJ,wBAAwBK,QAAQN,SAASK"}

package/dist/retrievers/hyde.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"hyde.d.cts","names":["BaseLanguageModelInterface","Document","BasePromptTemplate","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","CallbackManagerForRetrieverRun","PromptKey","HydeRetrieverOptions","V","HydeRetriever","Promise","getPromptTemplateFromKey"],"sources":["../../src/retrievers/hyde.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\n/**\n * A string that corresponds to a specific prompt template.\n */\nexport type PromptKey = \"websearch\" | \"scifact\" | \"arguana\" | \"trec-covid\" | \"fiqa\" | \"dbpedia-entity\" | \"trec-news\" | \"mr-tydi\";\n/**\n * Options for the HydeRetriever class, which includes a BaseLanguageModel\n * instance, a VectorStore instance, and an optional promptTemplate which\n * can either be a BasePromptTemplate instance or a PromptKey.\n */\nexport type HydeRetrieverOptions<V extends VectorStore> = VectorStoreRetrieverInput<V> & {\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate | PromptKey;\n};\n/**\n * A class for retrieving relevant documents based on a given query. It\n * extends the VectorStoreRetriever class and uses a BaseLanguageModel to\n * generate a hypothetical answer to the query, which is then used to\n * retrieve relevant documents.\n * @example\n * ```typescript\n * const retriever = new HydeRetriever({\n *   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   k: 1,\n * });\n * await vectorStore.addDocuments(\n *   [\n *     \"My name is John.\",\n *     \"My name is Bob.\",\n *     \"My favourite food is pizza.\",\n *     \"My favourite food is pasta.\",\n *   ].map((pageContent) => new Document({ pageContent })),\n * );\n * const results = await retriever.invoke(\n *   \"What is my favourite food?\",\n * );\n * ```\n */\nexport declare class HydeRetriever<V extends VectorStore = VectorStore> extends VectorStoreRetriever<V> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate;\n    constructor(fields: HydeRetrieverOptions<V>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\n/**\n * Returns a BasePromptTemplate instance based on a given PromptKey.\n */\nexport declare function getPromptTemplateFromKey(key: PromptKey): BasePromptTemplate;\n"],"mappings":";;;;;;;;;;AAQA;AAMYQ,KANAD,SAAAA,GAMAC,WAAoB,GAAA,SAAA,GAAA,SAAA,GAAA,YAAA,GAAA,MAAA,GAAA,gBAAA,GAAA,WAAA,GAAA,SAAA;;;;;;AAEXN,KAFTM,oBAESN,CAAAA,UAFsBC,WAEtBD,CAAAA,GAFqCG,yBAErCH,CAF+DO,CAE/DP,CAAAA,GAAAA;EAAkB,GAAGK,EADjCP,0BACiCO;EAAS,cAAA,CAAA,EAA9BL,kBAA8B,GAATK,SAAS;AA2BnD,CAAA;;;;;;;;;;;;;AAAoG;AAWpG;;;;AAAoF;;;;;;;;cAX/DG,wBAAwBP,cAAcA,qBAAqBC,qBAAqBK;;;OAG5FT;mBACYE;sBACGM,qBAAqBC;oDACSH,iCAAiCK,QAAQV;;;;;iBAKvEW,wBAAAA,MAA8BL,YAAYL"}
+{"version":3,"file":"hyde.d.cts","names":["BaseLanguageModelInterface","Document","BasePromptTemplate","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","CallbackManagerForRetrieverRun","PromptKey","HydeRetrieverOptions","V","HydeRetriever","Promise","getPromptTemplateFromKey"],"sources":["../../src/retrievers/hyde.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\n/**\n * A string that corresponds to a specific prompt template.\n */\nexport type PromptKey = \"websearch\" | \"scifact\" | \"arguana\" | \"trec-covid\" | \"fiqa\" | \"dbpedia-entity\" | \"trec-news\" | \"mr-tydi\";\n/**\n * Options for the HydeRetriever class, which includes a BaseLanguageModel\n * instance, a VectorStore instance, and an optional promptTemplate which\n * can either be a BasePromptTemplate instance or a PromptKey.\n */\nexport type HydeRetrieverOptions<V extends VectorStore> = VectorStoreRetrieverInput<V> & {\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate | PromptKey;\n};\n/**\n * A class for retrieving relevant documents based on a given query. It\n * extends the VectorStoreRetriever class and uses a BaseLanguageModel to\n * generate a hypothetical answer to the query, which is then used to\n * retrieve relevant documents.\n * @example\n * ```typescript\n * const retriever = new HydeRetriever({\n *   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   k: 1,\n * });\n * await vectorStore.addDocuments(\n *   [\n *     \"My name is John.\",\n *     \"My name is Bob.\",\n *     \"My favourite food is pizza.\",\n *     \"My favourite food is pasta.\",\n *   ].map((pageContent) => new Document({ pageContent })),\n * );\n * const results = await retriever.invoke(\n *   \"What is my favourite food?\",\n * );\n * ```\n */\nexport declare class HydeRetriever<V extends VectorStore = VectorStore> extends VectorStoreRetriever<V> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate;\n    constructor(fields: HydeRetrieverOptions<V>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\n/**\n * Returns a BasePromptTemplate instance based on a given PromptKey.\n */\nexport declare function getPromptTemplateFromKey(key: PromptKey): BasePromptTemplate;\n//# sourceMappingURL=hyde.d.ts.map"],"mappings":";;;;;;;;;;AAQA;AAMYQ,KANAD,SAAAA,GAMAC,WAAoBC,GAAAA,SAAA,GAAA,SAAA,GAAA,YAAA,GAAA,MAAA,GAAA,gBAAA,GAAA,WAAA,GAAA,SAAA;;;;;;AAEUF,KAF9BC,oBAE8BD,CAAAA,UAFCJ,WAEDI,CAAAA,GAFgBF,yBAEhBE,CAF0CE,CAE1CF,CAAAA,GAAAA;EAAS,GAAA,EAD1CP,0BAC0C;EA2B9BU,cAAAA,CAAAA,EA3BAR,kBA2Ba,GA3BQK,SA2BR;CAAWJ;;;;;;;;;;;AAAuD;AAWpG;;;;;;;;;;;;;;cAXqBO,wBAAwBP,cAAcA,qBAAqBC,qBAAqBK;;;OAG5FT;mBACYE;sBACGM,qBAAqBC;oDACSH,iCAAiCK,QAAQV;;;;;iBAKvEW,wBAAAA,MAA8BL,YAAYL"}

package/dist/retrievers/hyde.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hyde.d.ts","names":["BaseLanguageModelInterface","Document","BasePromptTemplate","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","CallbackManagerForRetrieverRun","PromptKey","HydeRetrieverOptions","V","HydeRetriever","Promise","getPromptTemplateFromKey"],"sources":["../../src/retrievers/hyde.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\n/**\n * A string that corresponds to a specific prompt template.\n */\nexport type PromptKey = \"websearch\" | \"scifact\" | \"arguana\" | \"trec-covid\" | \"fiqa\" | \"dbpedia-entity\" | \"trec-news\" | \"mr-tydi\";\n/**\n * Options for the HydeRetriever class, which includes a BaseLanguageModel\n * instance, a VectorStore instance, and an optional promptTemplate which\n * can either be a BasePromptTemplate instance or a PromptKey.\n */\nexport type HydeRetrieverOptions<V extends VectorStore> = VectorStoreRetrieverInput<V> & {\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate | PromptKey;\n};\n/**\n * A class for retrieving relevant documents based on a given query. It\n * extends the VectorStoreRetriever class and uses a BaseLanguageModel to\n * generate a hypothetical answer to the query, which is then used to\n * retrieve relevant documents.\n * @example\n * ```typescript\n * const retriever = new HydeRetriever({\n *   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   k: 1,\n * });\n * await vectorStore.addDocuments(\n *   [\n *     \"My name is John.\",\n *     \"My name is Bob.\",\n *     \"My favourite food is pizza.\",\n *     \"My favourite food is pasta.\",\n *   ].map((pageContent) => new Document({ pageContent })),\n * );\n * const results = await retriever.invoke(\n *   \"What is my favourite food?\",\n * );\n * ```\n */\nexport declare class HydeRetriever<V extends VectorStore = VectorStore> extends VectorStoreRetriever<V> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate;\n    constructor(fields: HydeRetrieverOptions<V>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\n/**\n * Returns a BasePromptTemplate instance based on a given PromptKey.\n */\nexport declare function getPromptTemplateFromKey(key: PromptKey): BasePromptTemplate;\n"],"mappings":";;;;;;;;;;AAQA;AAMYQ,KANAD,SAAAA,GAMAC,WAAoB,GAAA,SAAA,GAAA,SAAA,GAAA,YAAA,GAAA,MAAA,GAAA,gBAAA,GAAA,WAAA,GAAA,SAAA;;;;;;AAEXN,KAFTM,oBAESN,CAAAA,UAFsBC,WAEtBD,CAAAA,GAFqCG,yBAErCH,CAF+DO,CAE/DP,CAAAA,GAAAA;EAAkB,GAAGK,EADjCP,0BACiCO;EAAS,cAAA,CAAA,EAA9BL,kBAA8B,GAATK,SAAS;AA2BnD,CAAA;;;;;;;;;;;;;AAAoG;AAWpG;;;;AAAoF;;;;;;;;cAX/DG,wBAAwBP,cAAcA,qBAAqBC,qBAAqBK;;;OAG5FT;mBACYE;sBACGM,qBAAqBC;oDACSH,iCAAiCK,QAAQV;;;;;iBAKvEW,wBAAAA,MAA8BL,YAAYL"}
+{"version":3,"file":"hyde.d.ts","names":["BaseLanguageModelInterface","Document","BasePromptTemplate","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","CallbackManagerForRetrieverRun","PromptKey","HydeRetrieverOptions","V","HydeRetriever","Promise","getPromptTemplateFromKey"],"sources":["../../src/retrievers/hyde.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\n/**\n * A string that corresponds to a specific prompt template.\n */\nexport type PromptKey = \"websearch\" | \"scifact\" | \"arguana\" | \"trec-covid\" | \"fiqa\" | \"dbpedia-entity\" | \"trec-news\" | \"mr-tydi\";\n/**\n * Options for the HydeRetriever class, which includes a BaseLanguageModel\n * instance, a VectorStore instance, and an optional promptTemplate which\n * can either be a BasePromptTemplate instance or a PromptKey.\n */\nexport type HydeRetrieverOptions<V extends VectorStore> = VectorStoreRetrieverInput<V> & {\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate | PromptKey;\n};\n/**\n * A class for retrieving relevant documents based on a given query. It\n * extends the VectorStoreRetriever class and uses a BaseLanguageModel to\n * generate a hypothetical answer to the query, which is then used to\n * retrieve relevant documents.\n * @example\n * ```typescript\n * const retriever = new HydeRetriever({\n *   vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   k: 1,\n * });\n * await vectorStore.addDocuments(\n *   [\n *     \"My name is John.\",\n *     \"My name is Bob.\",\n *     \"My favourite food is pizza.\",\n *     \"My favourite food is pasta.\",\n *   ].map((pageContent) => new Document({ pageContent })),\n * );\n * const results = await retriever.invoke(\n *   \"What is my favourite food?\",\n * );\n * ```\n */\nexport declare class HydeRetriever<V extends VectorStore = VectorStore> extends VectorStoreRetriever<V> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    llm: BaseLanguageModelInterface;\n    promptTemplate?: BasePromptTemplate;\n    constructor(fields: HydeRetrieverOptions<V>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\n/**\n * Returns a BasePromptTemplate instance based on a given PromptKey.\n */\nexport declare function getPromptTemplateFromKey(key: PromptKey): BasePromptTemplate;\n//# sourceMappingURL=hyde.d.ts.map"],"mappings":";;;;;;;;;;AAQA;AAMYQ,KANAD,SAAAA,GAMAC,WAAoBC,GAAAA,SAAA,GAAA,SAAA,GAAA,YAAA,GAAA,MAAA,GAAA,gBAAA,GAAA,WAAA,GAAA,SAAA;;;;;;AAEUF,KAF9BC,oBAE8BD,CAAAA,UAFCJ,WAEDI,CAAAA,GAFgBF,yBAEhBE,CAF0CE,CAE1CF,CAAAA,GAAAA;EAAS,GAAA,EAD1CP,0BAC0C;EA2B9BU,cAAAA,CAAAA,EA3BAR,kBA2Ba,GA3BQK,SA2BR;CAAWJ;;;;;;;;;;;AAAuD;AAWpG;;;;;;;;;;;;;;cAXqBO,wBAAwBP,cAAcA,qBAAqBC,qBAAqBK;;;OAG5FT;mBACYE;sBACGM,qBAAqBC;oDACSH,iCAAiCK,QAAQV;;;;;iBAKvEW,wBAAAA,MAA8BL,YAAYL"}

package/dist/retrievers/matryoshka_retriever.d.cts

@@ -7,7 +7,6 @@ import { Embeddings } from "@langchain/core/embeddings";
 /**
  * Type for options when adding a document to the VectorStore.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AddDocumentOptions = Record<string, any>;
 interface MatryoshkaRetrieverFields {
   /**

package/dist/retrievers/matryoshka_retriever.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"matryoshka_retriever.d.cts","names":["DocumentInterface","Embeddings","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","AddDocumentOptions","Record","MatryoshkaRetrieverFields","MatryoshkaRetriever","Store","Promise"],"sources":["../../src/retrievers/matryoshka_retriever.d.ts"],"sourcesContent":["import { DocumentInterface } from \"@langchain/core/documents\";\nimport { Embeddings } from \"@langchain/core/embeddings\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\n/**\n * Type for options when adding a document to the VectorStore.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype AddDocumentOptions = Record<string, any>;\nexport interface MatryoshkaRetrieverFields {\n    /**\n     * The number of documents to retrieve from the small store.\n     * @default 50\n     */\n    smallK?: number;\n    /**\n     * The number of documents to retrieve from the large store.\n     * @default 8\n     */\n    largeK?: number;\n    /**\n     * The metadata key to store the larger embeddings.\n     * @default \"lc_large_embedding\"\n     */\n    largeEmbeddingKey?: string;\n    /**\n     * The embedding model to use when generating the large\n     * embeddings.\n     */\n    largeEmbeddingModel: Embeddings;\n    /**\n     * The type of search to perform using the large embeddings.\n     * @default \"cosine\"\n     */\n    searchType?: \"cosine\" | \"innerProduct\" | \"euclidean\";\n}\n/**\n * A retriever that uses two sets of embeddings to perform adaptive retrieval. Based\n * off of the \"Matryoshka embeddings: faster OpenAI vector search using Adaptive Retrieval\"\n * blog post {@link https://supabase.com/blog/matryoshka-embeddings}.\n *\n *\n * This class performs \"Adaptive Retrieval\" for searching text embeddings efficiently using the\n * Matryoshka Representation Learning (MRL) technique. It retrieves documents similar to a query\n * embedding in two steps:\n *\n * First-pass: Uses a lower dimensional sub-vector from the MRL embedding for an initial, fast,\n * but less accurate search.\n *\n * Second-pass: Re-ranks the top results from the first pass using the full, high-dimensional\n * embedding for higher accuracy.\n *\n *\n * This code implements MRL embeddings for efficient vector search by combining faster,\n * lower-dimensional initial search with accurate, high-dimensional re-ranking.\n */\nexport declare class MatryoshkaRetriever<Store extends VectorStore = VectorStore> extends VectorStoreRetriever<Store> {\n    smallK: number;\n    largeK: number;\n    largeEmbeddingKey: string;\n    largeEmbeddingModel: Embeddings;\n    searchType: \"cosine\" | \"innerProduct\" | \"euclidean\";\n    constructor(fields: MatryoshkaRetrieverFields & VectorStoreRetrieverInput<Store>);\n    /**\n     * Ranks documents based on their similarity to a query embedding using larger embeddings.\n     *\n     * This method takes a query embedding and a list of documents (smallResults) as input. Each document\n     * in the smallResults array has previously been associated with a large embedding stored in its metadata.\n     * Depending on the `searchType` (cosine, innerProduct, or euclidean), it calculates the similarity scores\n     * between the query embedding and each document's large embedding. It then ranks the documents based on\n     * these similarity scores, from the most similar to the least similar.\n     *\n     * The method returns a promise that resolves to an array of the top `largeK` documents, where `largeK`\n     * is a class property defining the number of documents to return. This subset of documents is determined\n     * by sorting the entire list of documents based on their similarity scores and then selecting the top\n     * `largeK` documents.\n     *\n     * @param {number[]} embeddedQuery The embedding of the query, represented as an array of numbers.\n     * @param {DocumentInterface[]} smallResults An array of documents, each with metadata that includes a large embedding for similarity comparison.\n     * @returns {Promise<DocumentInterface[]>} A promise that resolves to an array of the top `largeK` ranked documents based on their similarity to the query embedding.\n     */\n    private _rankByLargeEmbeddings;\n    _getRelevantDocuments(query: string): Promise<DocumentInterface[]>;\n    /**\n     * Override the default `addDocuments` method to embed the documents twice,\n     * once using the larger embeddings model, and then again using the default\n     * embedding model linked to the vector store.\n     *\n     * @param {DocumentInterface[]} documents - An array of documents to add to the vector store.\n     * @param {AddDocumentOptions} options - An optional object containing additional options for adding documents.\n     * @returns {Promise<string[] | void>} A promise that resolves to an array of the document IDs that were added to the vector store.\n     */\n    addDocuments: (documents: DocumentInterface<Record<string, any>>[], options?: AddDocumentOptions | undefined) => Promise<void | string[]>;\n}\nexport {};\n"],"mappings":";;;;;;;;AAE4G;AAM5G;AA+CA,KAhDKK,kBAAAA,GAAqBC,MAgDc,CAAA,MAAA,EAAA,GAAA,CAAA;AAAA,UA/CvBC,yBAAAA,CA+CuB;EAAA;;;;EAIL,MAEXA,CAAAA,EAAAA,MAAAA;EAAyB;;;;EAoBA,MAUDD,CAAAA,EAAAA,MAAAA;EAAM;;;;EApCwD,iBAAA,CAAA,EAAA,MAAA;;;;;uBA3BrFL;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BJO,kCAAkCN,cAAcA,qBAAqBC,qBAAqBM;;;;uBAItFR;;sBAEDM,4BAA4BH,0BAA0BK;;;;;;;;;;;;;;;;;;;;wCAoBpCC,QAAQV;;;;;;;;;;4BAUpBA,kBAAkBM,kCAAkCD,mCAAmCK"}
+{"version":3,"file":"matryoshka_retriever.d.cts","names":["DocumentInterface","Embeddings","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","AddDocumentOptions","Record","MatryoshkaRetrieverFields","MatryoshkaRetriever","Store","Promise"],"sources":["../../src/retrievers/matryoshka_retriever.d.ts"],"sourcesContent":["import { DocumentInterface } from \"@langchain/core/documents\";\nimport { Embeddings } from \"@langchain/core/embeddings\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\n/**\n * Type for options when adding a document to the VectorStore.\n */\ntype AddDocumentOptions = Record<string, any>;\nexport interface MatryoshkaRetrieverFields {\n    /**\n     * The number of documents to retrieve from the small store.\n     * @default 50\n     */\n    smallK?: number;\n    /**\n     * The number of documents to retrieve from the large store.\n     * @default 8\n     */\n    largeK?: number;\n    /**\n     * The metadata key to store the larger embeddings.\n     * @default \"lc_large_embedding\"\n     */\n    largeEmbeddingKey?: string;\n    /**\n     * The embedding model to use when generating the large\n     * embeddings.\n     */\n    largeEmbeddingModel: Embeddings;\n    /**\n     * The type of search to perform using the large embeddings.\n     * @default \"cosine\"\n     */\n    searchType?: \"cosine\" | \"innerProduct\" | \"euclidean\";\n}\n/**\n * A retriever that uses two sets of embeddings to perform adaptive retrieval. Based\n * off of the \"Matryoshka embeddings: faster OpenAI vector search using Adaptive Retrieval\"\n * blog post {@link https://supabase.com/blog/matryoshka-embeddings}.\n *\n *\n * This class performs \"Adaptive Retrieval\" for searching text embeddings efficiently using the\n * Matryoshka Representation Learning (MRL) technique. It retrieves documents similar to a query\n * embedding in two steps:\n *\n * First-pass: Uses a lower dimensional sub-vector from the MRL embedding for an initial, fast,\n * but less accurate search.\n *\n * Second-pass: Re-ranks the top results from the first pass using the full, high-dimensional\n * embedding for higher accuracy.\n *\n *\n * This code implements MRL embeddings for efficient vector search by combining faster,\n * lower-dimensional initial search with accurate, high-dimensional re-ranking.\n */\nexport declare class MatryoshkaRetriever<Store extends VectorStore = VectorStore> extends VectorStoreRetriever<Store> {\n    smallK: number;\n    largeK: number;\n    largeEmbeddingKey: string;\n    largeEmbeddingModel: Embeddings;\n    searchType: \"cosine\" | \"innerProduct\" | \"euclidean\";\n    constructor(fields: MatryoshkaRetrieverFields & VectorStoreRetrieverInput<Store>);\n    /**\n     * Ranks documents based on their similarity to a query embedding using larger embeddings.\n     *\n     * This method takes a query embedding and a list of documents (smallResults) as input. Each document\n     * in the smallResults array has previously been associated with a large embedding stored in its metadata.\n     * Depending on the `searchType` (cosine, innerProduct, or euclidean), it calculates the similarity scores\n     * between the query embedding and each document's large embedding. It then ranks the documents based on\n     * these similarity scores, from the most similar to the least similar.\n     *\n     * The method returns a promise that resolves to an array of the top `largeK` documents, where `largeK`\n     * is a class property defining the number of documents to return. This subset of documents is determined\n     * by sorting the entire list of documents based on their similarity scores and then selecting the top\n     * `largeK` documents.\n     *\n     * @param {number[]} embeddedQuery The embedding of the query, represented as an array of numbers.\n     * @param {DocumentInterface[]} smallResults An array of documents, each with metadata that includes a large embedding for similarity comparison.\n     * @returns {Promise<DocumentInterface[]>} A promise that resolves to an array of the top `largeK` ranked documents based on their similarity to the query embedding.\n     */\n    private _rankByLargeEmbeddings;\n    _getRelevantDocuments(query: string): Promise<DocumentInterface[]>;\n    /**\n     * Override the default `addDocuments` method to embed the documents twice,\n     * once using the larger embeddings model, and then again using the default\n     * embedding model linked to the vector store.\n     *\n     * @param {DocumentInterface[]} documents - An array of documents to add to the vector store.\n     * @param {AddDocumentOptions} options - An optional object containing additional options for adding documents.\n     * @returns {Promise<string[] | void>} A promise that resolves to an array of the document IDs that were added to the vector store.\n     */\n    addDocuments: (documents: DocumentInterface<Record<string, any>>[], options?: AddDocumentOptions | undefined) => Promise<void | string[]>;\n}\nexport {};\n//# sourceMappingURL=matryoshka_retriever.d.ts.map"],"mappings":";;;;;;;;AAE4G;AAK5G,KADKK,kBAAAA,GAAqBC,MACgB,CAAA,MAAA,EAAA,GAoBjBL,CAAAA;AA2BJO,UA/CJD,yBAAAA,CA+CuB;EAAeL;;;;EAM/BK,MAAAA,CAAAA,EAAAA,MAAAA;EAAsDE;;;;EA8B9BH,MAAAA,CAAAA,EAAAA,MAAAA;EAAlBN;;;;EApCgF,iBAAA,CAAA,EAAA,MAAA;;;;;uBA3BrFC;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BJO,kCAAkCN,cAAcA,qBAAqBC,qBAAqBM;;;;uBAItFR;;sBAEDM,4BAA4BH,0BAA0BK;;;;;;;;;;;;;;;;;;;;wCAoBpCC,QAAQV;;;;;;;;;;4BAUpBA,kBAAkBM,kCAAkCD,mCAAmCK"}

package/dist/retrievers/matryoshka_retriever.d.ts

@@ -7,7 +7,6 @@ import { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from "@l
 /**
  * Type for options when adding a document to the VectorStore.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AddDocumentOptions = Record<string, any>;
 interface MatryoshkaRetrieverFields {
   /**

package/dist/retrievers/matryoshka_retriever.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matryoshka_retriever.d.ts","names":["DocumentInterface","Embeddings","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","AddDocumentOptions","Record","MatryoshkaRetrieverFields","MatryoshkaRetriever","Store","Promise"],"sources":["../../src/retrievers/matryoshka_retriever.d.ts"],"sourcesContent":["import { DocumentInterface } from \"@langchain/core/documents\";\nimport { Embeddings } from \"@langchain/core/embeddings\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\n/**\n * Type for options when adding a document to the VectorStore.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype AddDocumentOptions = Record<string, any>;\nexport interface MatryoshkaRetrieverFields {\n    /**\n     * The number of documents to retrieve from the small store.\n     * @default 50\n     */\n    smallK?: number;\n    /**\n     * The number of documents to retrieve from the large store.\n     * @default 8\n     */\n    largeK?: number;\n    /**\n     * The metadata key to store the larger embeddings.\n     * @default \"lc_large_embedding\"\n     */\n    largeEmbeddingKey?: string;\n    /**\n     * The embedding model to use when generating the large\n     * embeddings.\n     */\n    largeEmbeddingModel: Embeddings;\n    /**\n     * The type of search to perform using the large embeddings.\n     * @default \"cosine\"\n     */\n    searchType?: \"cosine\" | \"innerProduct\" | \"euclidean\";\n}\n/**\n * A retriever that uses two sets of embeddings to perform adaptive retrieval. Based\n * off of the \"Matryoshka embeddings: faster OpenAI vector search using Adaptive Retrieval\"\n * blog post {@link https://supabase.com/blog/matryoshka-embeddings}.\n *\n *\n * This class performs \"Adaptive Retrieval\" for searching text embeddings efficiently using the\n * Matryoshka Representation Learning (MRL) technique. It retrieves documents similar to a query\n * embedding in two steps:\n *\n * First-pass: Uses a lower dimensional sub-vector from the MRL embedding for an initial, fast,\n * but less accurate search.\n *\n * Second-pass: Re-ranks the top results from the first pass using the full, high-dimensional\n * embedding for higher accuracy.\n *\n *\n * This code implements MRL embeddings for efficient vector search by combining faster,\n * lower-dimensional initial search with accurate, high-dimensional re-ranking.\n */\nexport declare class MatryoshkaRetriever<Store extends VectorStore = VectorStore> extends VectorStoreRetriever<Store> {\n    smallK: number;\n    largeK: number;\n    largeEmbeddingKey: string;\n    largeEmbeddingModel: Embeddings;\n    searchType: \"cosine\" | \"innerProduct\" | \"euclidean\";\n    constructor(fields: MatryoshkaRetrieverFields & VectorStoreRetrieverInput<Store>);\n    /**\n     * Ranks documents based on their similarity to a query embedding using larger embeddings.\n     *\n     * This method takes a query embedding and a list of documents (smallResults) as input. Each document\n     * in the smallResults array has previously been associated with a large embedding stored in its metadata.\n     * Depending on the `searchType` (cosine, innerProduct, or euclidean), it calculates the similarity scores\n     * between the query embedding and each document's large embedding. It then ranks the documents based on\n     * these similarity scores, from the most similar to the least similar.\n     *\n     * The method returns a promise that resolves to an array of the top `largeK` documents, where `largeK`\n     * is a class property defining the number of documents to return. This subset of documents is determined\n     * by sorting the entire list of documents based on their similarity scores and then selecting the top\n     * `largeK` documents.\n     *\n     * @param {number[]} embeddedQuery The embedding of the query, represented as an array of numbers.\n     * @param {DocumentInterface[]} smallResults An array of documents, each with metadata that includes a large embedding for similarity comparison.\n     * @returns {Promise<DocumentInterface[]>} A promise that resolves to an array of the top `largeK` ranked documents based on their similarity to the query embedding.\n     */\n    private _rankByLargeEmbeddings;\n    _getRelevantDocuments(query: string): Promise<DocumentInterface[]>;\n    /**\n     * Override the default `addDocuments` method to embed the documents twice,\n     * once using the larger embeddings model, and then again using the default\n     * embedding model linked to the vector store.\n     *\n     * @param {DocumentInterface[]} documents - An array of documents to add to the vector store.\n     * @param {AddDocumentOptions} options - An optional object containing additional options for adding documents.\n     * @returns {Promise<string[] | void>} A promise that resolves to an array of the document IDs that were added to the vector store.\n     */\n    addDocuments: (documents: DocumentInterface<Record<string, any>>[], options?: AddDocumentOptions | undefined) => Promise<void | string[]>;\n}\nexport {};\n"],"mappings":";;;;;;;;AAE4G;AAM5G;AA+CA,KAhDKK,kBAAAA,GAAqBC,MAgDc,CAAA,MAAA,EAAA,GAAA,CAAA;AAAA,UA/CvBC,yBAAAA,CA+CuB;EAAA;;;;EAIL,MAEXA,CAAAA,EAAAA,MAAAA;EAAyB;;;;EAoBA,MAUDD,CAAAA,EAAAA,MAAAA;EAAM;;;;EApCwD,iBAAA,CAAA,EAAA,MAAA;;;;;uBA3BrFL;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BJO,kCAAkCN,cAAcA,qBAAqBC,qBAAqBM;;;;uBAItFR;;sBAEDM,4BAA4BH,0BAA0BK;;;;;;;;;;;;;;;;;;;;wCAoBpCC,QAAQV;;;;;;;;;;4BAUpBA,kBAAkBM,kCAAkCD,mCAAmCK"}
+{"version":3,"file":"matryoshka_retriever.d.ts","names":["DocumentInterface","Embeddings","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","AddDocumentOptions","Record","MatryoshkaRetrieverFields","MatryoshkaRetriever","Store","Promise"],"sources":["../../src/retrievers/matryoshka_retriever.d.ts"],"sourcesContent":["import { DocumentInterface } from \"@langchain/core/documents\";\nimport { Embeddings } from \"@langchain/core/embeddings\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\n/**\n * Type for options when adding a document to the VectorStore.\n */\ntype AddDocumentOptions = Record<string, any>;\nexport interface MatryoshkaRetrieverFields {\n    /**\n     * The number of documents to retrieve from the small store.\n     * @default 50\n     */\n    smallK?: number;\n    /**\n     * The number of documents to retrieve from the large store.\n     * @default 8\n     */\n    largeK?: number;\n    /**\n     * The metadata key to store the larger embeddings.\n     * @default \"lc_large_embedding\"\n     */\n    largeEmbeddingKey?: string;\n    /**\n     * The embedding model to use when generating the large\n     * embeddings.\n     */\n    largeEmbeddingModel: Embeddings;\n    /**\n     * The type of search to perform using the large embeddings.\n     * @default \"cosine\"\n     */\n    searchType?: \"cosine\" | \"innerProduct\" | \"euclidean\";\n}\n/**\n * A retriever that uses two sets of embeddings to perform adaptive retrieval. Based\n * off of the \"Matryoshka embeddings: faster OpenAI vector search using Adaptive Retrieval\"\n * blog post {@link https://supabase.com/blog/matryoshka-embeddings}.\n *\n *\n * This class performs \"Adaptive Retrieval\" for searching text embeddings efficiently using the\n * Matryoshka Representation Learning (MRL) technique. It retrieves documents similar to a query\n * embedding in two steps:\n *\n * First-pass: Uses a lower dimensional sub-vector from the MRL embedding for an initial, fast,\n * but less accurate search.\n *\n * Second-pass: Re-ranks the top results from the first pass using the full, high-dimensional\n * embedding for higher accuracy.\n *\n *\n * This code implements MRL embeddings for efficient vector search by combining faster,\n * lower-dimensional initial search with accurate, high-dimensional re-ranking.\n */\nexport declare class MatryoshkaRetriever<Store extends VectorStore = VectorStore> extends VectorStoreRetriever<Store> {\n    smallK: number;\n    largeK: number;\n    largeEmbeddingKey: string;\n    largeEmbeddingModel: Embeddings;\n    searchType: \"cosine\" | \"innerProduct\" | \"euclidean\";\n    constructor(fields: MatryoshkaRetrieverFields & VectorStoreRetrieverInput<Store>);\n    /**\n     * Ranks documents based on their similarity to a query embedding using larger embeddings.\n     *\n     * This method takes a query embedding and a list of documents (smallResults) as input. Each document\n     * in the smallResults array has previously been associated with a large embedding stored in its metadata.\n     * Depending on the `searchType` (cosine, innerProduct, or euclidean), it calculates the similarity scores\n     * between the query embedding and each document's large embedding. It then ranks the documents based on\n     * these similarity scores, from the most similar to the least similar.\n     *\n     * The method returns a promise that resolves to an array of the top `largeK` documents, where `largeK`\n     * is a class property defining the number of documents to return. This subset of documents is determined\n     * by sorting the entire list of documents based on their similarity scores and then selecting the top\n     * `largeK` documents.\n     *\n     * @param {number[]} embeddedQuery The embedding of the query, represented as an array of numbers.\n     * @param {DocumentInterface[]} smallResults An array of documents, each with metadata that includes a large embedding for similarity comparison.\n     * @returns {Promise<DocumentInterface[]>} A promise that resolves to an array of the top `largeK` ranked documents based on their similarity to the query embedding.\n     */\n    private _rankByLargeEmbeddings;\n    _getRelevantDocuments(query: string): Promise<DocumentInterface[]>;\n    /**\n     * Override the default `addDocuments` method to embed the documents twice,\n     * once using the larger embeddings model, and then again using the default\n     * embedding model linked to the vector store.\n     *\n     * @param {DocumentInterface[]} documents - An array of documents to add to the vector store.\n     * @param {AddDocumentOptions} options - An optional object containing additional options for adding documents.\n     * @returns {Promise<string[] | void>} A promise that resolves to an array of the document IDs that were added to the vector store.\n     */\n    addDocuments: (documents: DocumentInterface<Record<string, any>>[], options?: AddDocumentOptions | undefined) => Promise<void | string[]>;\n}\nexport {};\n//# sourceMappingURL=matryoshka_retriever.d.ts.map"],"mappings":";;;;;;;;AAE4G;AAK5G,KADKK,kBAAAA,GAAqBC,MACgB,CAAA,MAAA,EAAA,GAAA,CAoBjBL;AA2BJO,UA/CJD,yBAAAA,CA+CuB;EAAeL;;;;EAM/BK,MAAAA,CAAAA,EAAAA,MAAAA;EAAsDE;;;;EA8B9BH,MAAAA,CAAAA,EAAAA,MAAAA;EAAlBN;;;;EApCgF,iBAAA,CAAA,EAAA,MAAA;;;;;uBA3BrFC;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BJO,kCAAkCN,cAAcA,qBAAqBC,qBAAqBM;;;;uBAItFR;;sBAEDM,4BAA4BH,0BAA0BK;;;;;;;;;;;;;;;;;;;;wCAoBpCC,QAAQV;;;;;;;;;;4BAUpBA,kBAAkBM,kCAAkCD,mCAAmCK"}

package/dist/retrievers/multi_query.d.cts

@@ -10,7 +10,6 @@ import { Document } from "@langchain/core/documents";
 interface LineList {
   lines: string[];
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type MultiDocs = Document<Record<string, any>>[];
 interface MultiQueryRetrieverInput extends BaseRetrieverInput {
   retriever: BaseRetrieverInterface;
@@ -50,7 +49,6 @@ declare class MultiQueryRetriever extends BaseRetriever {
   }): MultiQueryRetriever;
   private _generateQueries;
   private _retrieveDocuments;
-  // Deduplicate the documents that were returned in multiple retrievals
   private _uniqueUnion;
   _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;
 }

package/dist/retrievers/multi_query.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"multi_query.d.cts","names":["BaseLanguageModelInterface","BaseRetriever","BaseRetrieverInput","BaseRetrieverInterface","Document","BasePromptTemplate","CallbackManagerForRetrieverRun","LLMChain","BaseDocumentCompressor","LineList","MultiDocs","Record","MultiQueryRetrieverInput","MultiQueryRetriever","Omit","Promise"],"sources":["../../src/retrievers/multi_query.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseRetriever, type BaseRetrieverInput, type BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\ninterface LineList {\n    lines: string[];\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type MultiDocs = Document<Record<string, any>>[];\nexport interface MultiQueryRetrieverInput extends BaseRetrieverInput {\n    retriever: BaseRetrieverInterface;\n    /** @deprecated Pass a custom prompt into `.fromLLM` instead. */\n    llmChain: LLMChain<LineList>;\n    queryCount?: number;\n    parserKey?: string;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: MultiDocs) => MultiDocs;\n}\n/**\n * @example\n * ```typescript\n * const retriever = new MultiQueryRetriever.fromLLM({\n *   llm: new ChatAnthropic({}),\n *   retriever: new MemoryVectorStore().asRetriever(),\n *   verbose: true,\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What are mitochondria made of?\",\n * );\n * ```\n */\nexport declare class MultiQueryRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    private retriever;\n    private llmChain;\n    private queryCount;\n    private parserKey;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: MultiQueryRetrieverInput[\"documentCompressorFilteringFn\"];\n    constructor(fields: MultiQueryRetrieverInput);\n    static fromLLM(fields: Omit<MultiQueryRetrieverInput, \"llmChain\"> & {\n        llm: BaseLanguageModelInterface;\n        prompt?: BasePromptTemplate;\n    }): MultiQueryRetriever;\n    private _generateQueries;\n    private _retrieveDocuments;\n    // Deduplicate the documents that were returned in multiple retrievals\n    private _uniqueUnion;\n    _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\nexport {};\n"],"mappings":";;;;;;;;;UAOUS,QAAAA;;AADoE;AAK9E;AAAqB,KAATC,SAAAA,GAAYN,QAAH,CAAYO,MAAZ,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,EAAA;AAAYA,UAChBC,wBAAAA,SAAiCV,kBADjBS,CAAAA;EAAM,SAAfP,EAETD,sBAFSC;EAAQ;EACfQ,QAAAA,EAGHL,QAHGK,CAGMH,QAHkB,CAAA;EAAA,UAAA,CAAA,EAAA,MAAA;EAAA,SAC1BN,CAAAA,EAAAA,MAAAA;EAAsB,kBAEdM,CAAAA,EAGED,sBAHFC,GAAAA,SAAAA;EAAQ,6BAAjBF,CAAAA,EAAAA,CAAAA,IAAAA,EAI6BG,SAJ7BH,EAAAA,GAI2CG,SAJ3CH;;;;;AAHsD;AAsBpE;;;;;;;;;AAaQM,cAbaA,mBAAAA,SAA4BZ,aAAAA,CAazCY;EAAmB,OAK8BP,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA8B,YAAWF,EAAAA,MAAAA,EAAAA;EAAQ,QAAhBW,SAAAA;EAAO,QAlBhDd,QAAAA;EAAa,QAAA,UAAA;;sBAOtCO;kCACYI;sBACZA;yBACGE,KAAKF;SACnBZ;aACIK;MACTQ;;;;;uDAKiDP,iCAAiCS,QAAQX"}
+{"version":3,"file":"multi_query.d.cts","names":["BaseLanguageModelInterface","BaseRetriever","BaseRetrieverInput","BaseRetrieverInterface","Document","BasePromptTemplate","CallbackManagerForRetrieverRun","LLMChain","BaseDocumentCompressor","LineList","MultiDocs","Record","MultiQueryRetrieverInput","MultiQueryRetriever","Omit","Promise"],"sources":["../../src/retrievers/multi_query.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseRetriever, type BaseRetrieverInput, type BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\ninterface LineList {\n    lines: string[];\n}\nexport type MultiDocs = Document<Record<string, any>>[];\nexport interface MultiQueryRetrieverInput extends BaseRetrieverInput {\n    retriever: BaseRetrieverInterface;\n    /** @deprecated Pass a custom prompt into `.fromLLM` instead. */\n    llmChain: LLMChain<LineList>;\n    queryCount?: number;\n    parserKey?: string;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: MultiDocs) => MultiDocs;\n}\n/**\n * @example\n * ```typescript\n * const retriever = new MultiQueryRetriever.fromLLM({\n *   llm: new ChatAnthropic({}),\n *   retriever: new MemoryVectorStore().asRetriever(),\n *   verbose: true,\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What are mitochondria made of?\",\n * );\n * ```\n */\nexport declare class MultiQueryRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    private retriever;\n    private llmChain;\n    private queryCount;\n    private parserKey;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: MultiQueryRetrieverInput[\"documentCompressorFilteringFn\"];\n    constructor(fields: MultiQueryRetrieverInput);\n    static fromLLM(fields: Omit<MultiQueryRetrieverInput, \"llmChain\"> & {\n        llm: BaseLanguageModelInterface;\n        prompt?: BasePromptTemplate;\n    }): MultiQueryRetriever;\n    private _generateQueries;\n    private _retrieveDocuments;\n    private _uniqueUnion;\n    _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\nexport {};\n//# sourceMappingURL=multi_query.d.ts.map"],"mappings":";;;;;;;;;UAOUS,QAAAA;;AADoE;AAIlEC,KAAAA,SAAAA,GAAYN,QAASO,CAAAA,MAATP,CAAAA,MAAQ,EAAA,GAAA,CAAA,CAAA,EAAA;AACfQ,UAAAA,wBAAAA,SAAiCV,kBAAT,CAAA;EAC1BC,SAAAA,EAAAA,sBAAAA;EAEQM;EAATF,QAAAA,EAAAA,QAAAA,CAASE,QAATF,CAAAA;EAGWC,UAAAA,CAAAA,EAAAA,MAAAA;EACkBE,SAAAA,CAAAA,EAAAA,MAAAA;EAAcA,kBAAAA,CAAAA,EADhCF,sBACgCE,GAAAA,SAAAA;EAPPR,6BAAAA,CAAAA,EAAAA,CAAAA,IAAAA,EAOPQ,SAPOR,EAAAA,GAOOQ,SAPPR;AAAkB;AAsBpE;;;;;;;;;;;;;AAA8D,cAAzCW,mBAAAA,SAA4BZ,aAAAA,CAAa;;;;;;;sBAOtCO;kCACYI;sBACZA;yBACGE,KAAKF;SACnBZ;aACIK;MACTQ;;;;uDAIiDP,iCAAiCS,QAAQX"}

package/dist/retrievers/multi_query.d.ts

@@ -10,7 +10,6 @@ import { BaseRetriever, BaseRetrieverInput, BaseRetrieverInterface } from "@lang
 interface LineList {
   lines: string[];
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type MultiDocs = Document<Record<string, any>>[];
 interface MultiQueryRetrieverInput extends BaseRetrieverInput {
   retriever: BaseRetrieverInterface;
@@ -50,7 +49,6 @@ declare class MultiQueryRetriever extends BaseRetriever {
   }): MultiQueryRetriever;
   private _generateQueries;
   private _retrieveDocuments;
-  // Deduplicate the documents that were returned in multiple retrievals
   private _uniqueUnion;
   _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;
 }

package/dist/retrievers/multi_query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multi_query.d.ts","names":["BaseLanguageModelInterface","BaseRetriever","BaseRetrieverInput","BaseRetrieverInterface","Document","BasePromptTemplate","CallbackManagerForRetrieverRun","LLMChain","BaseDocumentCompressor","LineList","MultiDocs","Record","MultiQueryRetrieverInput","MultiQueryRetriever","Omit","Promise"],"sources":["../../src/retrievers/multi_query.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseRetriever, type BaseRetrieverInput, type BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\ninterface LineList {\n    lines: string[];\n}\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type MultiDocs = Document<Record<string, any>>[];\nexport interface MultiQueryRetrieverInput extends BaseRetrieverInput {\n    retriever: BaseRetrieverInterface;\n    /** @deprecated Pass a custom prompt into `.fromLLM` instead. */\n    llmChain: LLMChain<LineList>;\n    queryCount?: number;\n    parserKey?: string;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: MultiDocs) => MultiDocs;\n}\n/**\n * @example\n * ```typescript\n * const retriever = new MultiQueryRetriever.fromLLM({\n *   llm: new ChatAnthropic({}),\n *   retriever: new MemoryVectorStore().asRetriever(),\n *   verbose: true,\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What are mitochondria made of?\",\n * );\n * ```\n */\nexport declare class MultiQueryRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    private retriever;\n    private llmChain;\n    private queryCount;\n    private parserKey;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: MultiQueryRetrieverInput[\"documentCompressorFilteringFn\"];\n    constructor(fields: MultiQueryRetrieverInput);\n    static fromLLM(fields: Omit<MultiQueryRetrieverInput, \"llmChain\"> & {\n        llm: BaseLanguageModelInterface;\n        prompt?: BasePromptTemplate;\n    }): MultiQueryRetriever;\n    private _generateQueries;\n    private _retrieveDocuments;\n    // Deduplicate the documents that were returned in multiple retrievals\n    private _uniqueUnion;\n    _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\nexport {};\n"],"mappings":";;;;;;;;;UAOUS,QAAAA;;AADoE;AAK9E;AAAqB,KAATC,SAAAA,GAAYN,QAAH,CAAYO,MAAZ,CAAA,MAAA,EAAA,GAAA,CAAA,CAAA,EAAA;AAAYA,UAChBC,wBAAAA,SAAiCV,kBADjBS,CAAAA;EAAM,SAAfP,EAETD,sBAFSC;EAAQ;EACfQ,QAAAA,EAGHL,QAHGK,CAGMH,QAHkB,CAAA;EAAA,UAAA,CAAA,EAAA,MAAA;EAAA,SAC1BN,CAAAA,EAAAA,MAAAA;EAAsB,kBAEdM,CAAAA,EAGED,sBAHFC,GAAAA,SAAAA;EAAQ,6BAAjBF,CAAAA,EAAAA,CAAAA,IAAAA,EAI6BG,SAJ7BH,EAAAA,GAI2CG,SAJ3CH;;;;;AAHsD;AAsBpE;;;;;;;;;AAaQM,cAbaA,mBAAAA,SAA4BZ,aAAAA,CAazCY;EAAmB,OAK8BP,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA8B,YAAWF,EAAAA,MAAAA,EAAAA;EAAQ,QAAhBW,SAAAA;EAAO,QAlBhDd,QAAAA;EAAa,QAAA,UAAA;;sBAOtCO;kCACYI;sBACZA;yBACGE,KAAKF;SACnBZ;aACIK;MACTQ;;;;;uDAKiDP,iCAAiCS,QAAQX"}
+{"version":3,"file":"multi_query.d.ts","names":["BaseLanguageModelInterface","BaseRetriever","BaseRetrieverInput","BaseRetrieverInterface","Document","BasePromptTemplate","CallbackManagerForRetrieverRun","LLMChain","BaseDocumentCompressor","LineList","MultiDocs","Record","MultiQueryRetrieverInput","MultiQueryRetriever","Omit","Promise"],"sources":["../../src/retrievers/multi_query.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseRetriever, type BaseRetrieverInput, type BaseRetrieverInterface } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { LLMChain } from \"../chains/llm_chain.js\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\ninterface LineList {\n    lines: string[];\n}\nexport type MultiDocs = Document<Record<string, any>>[];\nexport interface MultiQueryRetrieverInput extends BaseRetrieverInput {\n    retriever: BaseRetrieverInterface;\n    /** @deprecated Pass a custom prompt into `.fromLLM` instead. */\n    llmChain: LLMChain<LineList>;\n    queryCount?: number;\n    parserKey?: string;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: MultiDocs) => MultiDocs;\n}\n/**\n * @example\n * ```typescript\n * const retriever = new MultiQueryRetriever.fromLLM({\n *   llm: new ChatAnthropic({}),\n *   retriever: new MemoryVectorStore().asRetriever(),\n *   verbose: true,\n * });\n * const retrievedDocs = await retriever.invoke(\n *   \"What are mitochondria made of?\",\n * );\n * ```\n */\nexport declare class MultiQueryRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    private retriever;\n    private llmChain;\n    private queryCount;\n    private parserKey;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: MultiQueryRetrieverInput[\"documentCompressorFilteringFn\"];\n    constructor(fields: MultiQueryRetrieverInput);\n    static fromLLM(fields: Omit<MultiQueryRetrieverInput, \"llmChain\"> & {\n        llm: BaseLanguageModelInterface;\n        prompt?: BasePromptTemplate;\n    }): MultiQueryRetriever;\n    private _generateQueries;\n    private _retrieveDocuments;\n    private _uniqueUnion;\n    _getRelevantDocuments(question: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document[]>;\n}\nexport {};\n//# sourceMappingURL=multi_query.d.ts.map"],"mappings":";;;;;;;;;UAOUS,QAAAA;;AADoE;AAIlEC,KAAAA,SAAAA,GAAYN,QAASO,CAAAA,MAATP,CAAAA,MAAQ,EAAA,GAAA,CAAA,CAAA,EAAA;AACfQ,UAAAA,wBAAAA,SAAiCV,kBAAT,CAAA;EAC1BC,SAAAA,EAAAA,sBAAAA;EAEQM;EAATF,QAAAA,EAAAA,QAAAA,CAASE,QAATF,CAAAA;EAGWC,UAAAA,CAAAA,EAAAA,MAAAA;EACkBE,SAAAA,CAAAA,EAAAA,MAAAA;EAAcA,kBAAAA,CAAAA,EADhCF,sBACgCE,GAAAA,SAAAA;EAPPR,6BAAAA,CAAAA,EAAAA,CAAAA,IAAAA,EAOPQ,SAPOR,EAAAA,GAOOQ,SAPPR;AAAkB;AAsBpE;;;;;;;;;;;;;AAA8D,cAAzCW,mBAAAA,SAA4BZ,aAAAA,CAAa;;;;;;;sBAOtCO;kCACYI;sBACZA;yBACGE,KAAKF;SACnBZ;aACIK;MACTQ;;;;uDAIiDP,iCAAiCS,QAAQX"}

package/dist/retrievers/multi_vector.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"multi_vector.d.cts","names":["BaseRetriever","BaseRetrieverInput","VectorStoreInterface","Document","BaseStore","BaseStoreInterface","MultiVectorRetrieverInput","Uint8Array","MultiVectorRetriever","Promise"],"sources":["../../src/retrievers/multi_vector.d.ts"],"sourcesContent":["import { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseStore, type BaseStoreInterface } from \"@langchain/core/stores\";\n/**\n * Arguments for the MultiVectorRetriever class.\n */\nexport interface MultiVectorRetrieverInput extends BaseRetrieverInput {\n    vectorstore: VectorStoreInterface;\n    /** @deprecated Prefer `byteStore`. */\n    docstore?: BaseStoreInterface<string, Document>;\n    byteStore?: BaseStore<string, Uint8Array>;\n    idKey?: string;\n    childK?: number;\n    parentK?: number;\n}\n/**\n * A retriever that retrieves documents from a vector store and a document\n * store. It uses the vector store to find relevant documents based on a\n * query, and then retrieves the full documents from the document store.\n * @example\n * ```typescript\n * const retriever = new MultiVectorRetriever({\n *   vectorstore: new FaissStore(),\n *   byteStore: new InMemoryStore<Unit8Array>(),\n *   idKey: \"doc_id\",\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const retrieverResult = await retriever.invoke(\"justice breyer\");\n * console.log(retrieverResult[0].pageContent.length);\n * ```\n */\nexport declare class MultiVectorRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    docstore: BaseStoreInterface<string, Document>;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    constructor(args: MultiVectorRetrieverInput);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n}\n"],"mappings":";;;;;;;;;AAOA;AAA0C,UAAzBM,yBAAAA,SAAkCL,kBAAT,CAAA;EAAA,WACzBC,EAAAA,oBAAAA;EAAoB;EAEa,QAAnCG,CAAAA,EAAAA,kBAAAA,CAAAA,MAAAA,EAA2BF,QAA3BE,CAAAA;EAAkB,SACCE,CAAAA,EAAlBH,SAAkBG,CAAAA,MAAAA,EAAAA,UAAAA,CAAAA;EAAU,KAA5BH,CAAAA,EAAAA,MAAAA;EAAS,MAJ0BH,CAAAA,EAAAA,MAAAA;EAAkB,OAAA,CAAA,EAAA,MAAA;AA2BrE;;;;;;;;;AAA+D;;;;;;;;;;cAA1CO,oBAAAA,SAA6BR,aAAAA;;;eAGjCE;YACHG,2BAA2BF;;;;oBAInBG;wCACoBG,QAAQN"}
+{"version":3,"file":"multi_vector.d.cts","names":["BaseRetriever","BaseRetrieverInput","VectorStoreInterface","Document","BaseStore","BaseStoreInterface","MultiVectorRetrieverInput","Uint8Array","MultiVectorRetriever","Promise"],"sources":["../../src/retrievers/multi_vector.d.ts"],"sourcesContent":["import { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseStore, type BaseStoreInterface } from \"@langchain/core/stores\";\n/**\n * Arguments for the MultiVectorRetriever class.\n */\nexport interface MultiVectorRetrieverInput extends BaseRetrieverInput {\n    vectorstore: VectorStoreInterface;\n    /** @deprecated Prefer `byteStore`. */\n    docstore?: BaseStoreInterface<string, Document>;\n    byteStore?: BaseStore<string, Uint8Array>;\n    idKey?: string;\n    childK?: number;\n    parentK?: number;\n}\n/**\n * A retriever that retrieves documents from a vector store and a document\n * store. It uses the vector store to find relevant documents based on a\n * query, and then retrieves the full documents from the document store.\n * @example\n * ```typescript\n * const retriever = new MultiVectorRetriever({\n *   vectorstore: new FaissStore(),\n *   byteStore: new InMemoryStore<Unit8Array>(),\n *   idKey: \"doc_id\",\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const retrieverResult = await retriever.invoke(\"justice breyer\");\n * console.log(retrieverResult[0].pageContent.length);\n * ```\n */\nexport declare class MultiVectorRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    docstore: BaseStoreInterface<string, Document>;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    constructor(args: MultiVectorRetrieverInput);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n}\n//# sourceMappingURL=multi_vector.d.ts.map"],"mappings":";;;;;;;;;AAOA;AACiBE,UADAI,yBAAAA,SAAkCL,kBAClCC,CAAAA;EAEyBC,WAAAA,EAFzBD,oBAEyBC;EAA3BE;EACmBE,QAAAA,CAAAA,EADnBF,kBACmBE,CAAAA,MAAAA,EADQJ,QACRI,CAAAA;EAAlBH,SAAAA,CAAAA,EAAAA,SAAAA,CAAAA,MAAAA,EAAkBG,UAAlBH,CAAAA;EAJmCH,KAAAA,CAAAA,EAAAA,MAAAA;EAAkB,MAAA,CAAA,EAAA,MAAA;EA2BhDO,OAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;AAA0C;;;;;;;;;;;;cAA1CA,oBAAAA,SAA6BR,aAAAA;;;eAGjCE;YACHG,2BAA2BF;;;;oBAInBG;wCACoBG,QAAQN"}

package/dist/retrievers/multi_vector.d.ts

@@ -1,7 +1,7 @@
 import { Document } from "@langchain/core/documents";
 import { BaseStore, BaseStoreInterface } from "@langchain/core/stores";
-import { VectorStoreInterface } from "@langchain/core/vectorstores";
 import { BaseRetriever, BaseRetrieverInput } from "@langchain/core/retrievers";
+import { VectorStoreInterface } from "@langchain/core/vectorstores";
 
 //#region src/retrievers/multi_vector.d.ts
 

package/dist/retrievers/multi_vector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multi_vector.d.ts","names":["BaseRetriever","BaseRetrieverInput","VectorStoreInterface","Document","BaseStore","BaseStoreInterface","MultiVectorRetrieverInput","Uint8Array","MultiVectorRetriever","Promise"],"sources":["../../src/retrievers/multi_vector.d.ts"],"sourcesContent":["import { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseStore, type BaseStoreInterface } from \"@langchain/core/stores\";\n/**\n * Arguments for the MultiVectorRetriever class.\n */\nexport interface MultiVectorRetrieverInput extends BaseRetrieverInput {\n    vectorstore: VectorStoreInterface;\n    /** @deprecated Prefer `byteStore`. */\n    docstore?: BaseStoreInterface<string, Document>;\n    byteStore?: BaseStore<string, Uint8Array>;\n    idKey?: string;\n    childK?: number;\n    parentK?: number;\n}\n/**\n * A retriever that retrieves documents from a vector store and a document\n * store. It uses the vector store to find relevant documents based on a\n * query, and then retrieves the full documents from the document store.\n * @example\n * ```typescript\n * const retriever = new MultiVectorRetriever({\n *   vectorstore: new FaissStore(),\n *   byteStore: new InMemoryStore<Unit8Array>(),\n *   idKey: \"doc_id\",\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const retrieverResult = await retriever.invoke(\"justice breyer\");\n * console.log(retrieverResult[0].pageContent.length);\n * ```\n */\nexport declare class MultiVectorRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    docstore: BaseStoreInterface<string, Document>;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    constructor(args: MultiVectorRetrieverInput);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n}\n"],"mappings":";;;;;;;;;AAOA;AAA0C,UAAzBM,yBAAAA,SAAkCL,kBAAT,CAAA;EAAA,WACzBC,EAAAA,oBAAAA;EAAoB;EAEa,QAAnCG,CAAAA,EAAAA,kBAAAA,CAAAA,MAAAA,EAA2BF,QAA3BE,CAAAA;EAAkB,SACCE,CAAAA,EAAlBH,SAAkBG,CAAAA,MAAAA,EAAAA,UAAAA,CAAAA;EAAU,KAA5BH,CAAAA,EAAAA,MAAAA;EAAS,MAJ0BH,CAAAA,EAAAA,MAAAA;EAAkB,OAAA,CAAA,EAAA,MAAA;AA2BrE;;;;;;;;;AAA+D;;;;;;;;;;cAA1CO,oBAAAA,SAA6BR,aAAAA;;;eAGjCE;YACHG,2BAA2BF;;;;oBAInBG;wCACoBG,QAAQN"}
+{"version":3,"file":"multi_vector.d.ts","names":["BaseRetriever","BaseRetrieverInput","VectorStoreInterface","Document","BaseStore","BaseStoreInterface","MultiVectorRetrieverInput","Uint8Array","MultiVectorRetriever","Promise"],"sources":["../../src/retrievers/multi_vector.d.ts"],"sourcesContent":["import { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport type { VectorStoreInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { BaseStore, type BaseStoreInterface } from \"@langchain/core/stores\";\n/**\n * Arguments for the MultiVectorRetriever class.\n */\nexport interface MultiVectorRetrieverInput extends BaseRetrieverInput {\n    vectorstore: VectorStoreInterface;\n    /** @deprecated Prefer `byteStore`. */\n    docstore?: BaseStoreInterface<string, Document>;\n    byteStore?: BaseStore<string, Uint8Array>;\n    idKey?: string;\n    childK?: number;\n    parentK?: number;\n}\n/**\n * A retriever that retrieves documents from a vector store and a document\n * store. It uses the vector store to find relevant documents based on a\n * query, and then retrieves the full documents from the document store.\n * @example\n * ```typescript\n * const retriever = new MultiVectorRetriever({\n *   vectorstore: new FaissStore(),\n *   byteStore: new InMemoryStore<Unit8Array>(),\n *   idKey: \"doc_id\",\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const retrieverResult = await retriever.invoke(\"justice breyer\");\n * console.log(retrieverResult[0].pageContent.length);\n * ```\n */\nexport declare class MultiVectorRetriever extends BaseRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    docstore: BaseStoreInterface<string, Document>;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    constructor(args: MultiVectorRetrieverInput);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n}\n//# sourceMappingURL=multi_vector.d.ts.map"],"mappings":";;;;;;;;;AAOA;AACiBE,UADAI,yBAAAA,SAAkCL,kBAClCC,CAAAA;EAEyBC,WAAAA,EAFzBD,oBAEyBC;EAA3BE;EACmBE,QAAAA,CAAAA,EADnBF,kBACmBE,CAAAA,MAAAA,EADQJ,QACRI,CAAAA;EAAlBH,SAAAA,CAAAA,EAAAA,SAAAA,CAAAA,MAAAA,EAAkBG,UAAlBH,CAAAA;EAJmCH,KAAAA,CAAAA,EAAAA,MAAAA;EAAkB,MAAA,CAAA,EAAA,MAAA;EA2BhDO,OAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;AAA0C;;;;;;;;;;;;cAA1CA,oBAAAA,SAA6BR,aAAAA;;;eAGjCE;YACHG,2BAA2BF;;;;oBAInBG;wCACoBG,QAAQN"}

package/dist/retrievers/parent_document.d.cts

@@ -5,7 +5,6 @@ import { Document } from "@langchain/core/documents";
 import { TextSplitter, TextSplitterChunkHeaderOptions } from "@langchain/textsplitters";
 
 //#region src/retrievers/parent_document.d.ts
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type SubDocs = Document<Record<string, any>>[];
 /**
  * Interface for the fields required to initialize a

package/dist/retrievers/parent_document.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"parent_document.d.cts","names":["VectorStoreInterface","VectorStoreRetrieverInterface","Document","TextSplitter","TextSplitterChunkHeaderOptions","BaseDocumentCompressor","MultiVectorRetriever","MultiVectorRetrieverInput","SubDocs","Record","ParentDocumentRetrieverFields","ParentDocumentRetriever","Promise"],"sources":["../../src/retrievers/parent_document.d.ts"],"sourcesContent":["import { type VectorStoreInterface, type VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { TextSplitter, TextSplitterChunkHeaderOptions } from \"@langchain/textsplitters\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\nimport { MultiVectorRetriever, type MultiVectorRetrieverInput } from \"./multi_vector.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type SubDocs = Document<Record<string, any>>[];\n/**\n * Interface for the fields required to initialize a\n * ParentDocumentRetriever instance.\n */\nexport type ParentDocumentRetrieverFields = MultiVectorRetrieverInput & {\n    childSplitter: TextSplitter;\n    parentSplitter?: TextSplitter;\n    /**\n     * A custom retriever to use when retrieving instead of\n     * the `.similaritySearch` method of the vectorstore.\n     */\n    childDocumentRetriever?: VectorStoreRetrieverInterface<VectorStoreInterface>;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: SubDocs) => SubDocs;\n};\n/**\n * A type of document retriever that splits input documents into smaller chunks\n * while separately storing and preserving the original documents.\n * The small chunks are embedded, then on retrieval, the original\n * \"parent\" documents are retrieved.\n *\n * This strikes a balance between better targeted retrieval with small documents\n * and the more context-rich larger documents.\n * @example\n * ```typescript\n * const retriever = new ParentDocumentRetriever({\n *   vectorstore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   byteStore: new InMemoryStore<Uint8Array>(),\n *   parentSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 500,\n *   }),\n *   childSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 50,\n *   }),\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const parentDocuments = await getDocuments();\n * await retriever.addDocuments(parentDocuments);\n * const retrievedDocs = await retriever.invoke(\"justice breyer\");\n * ```\n */\nexport declare class ParentDocumentRetriever extends MultiVectorRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    protected childSplitter: TextSplitter;\n    protected parentSplitter?: TextSplitter;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    childDocumentRetriever: VectorStoreRetrieverInterface<VectorStoreInterface> | undefined;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: ParentDocumentRetrieverFields[\"documentCompressorFilteringFn\"];\n    constructor(fields: ParentDocumentRetrieverFields);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n    _storeDocuments(parentDoc: Record<string, Document>, childDocs: Document[], addToDocstore: boolean): Promise<void>;\n    /**\n     * Adds documents to the docstore and vectorstores.\n     * If a retriever is provided, it will be used to add documents instead of the vectorstore.\n     * @param docs The documents to add\n     * @param config.ids Optional list of ids for documents. If provided should be the same\n     *   length as the list of documents. Can provided if parent documents\n     *   are already in the document store and you don't want to re-add\n     *   to the docstore. If not provided, random UUIDs will be used as ids.\n     * @param config.addToDocstore Boolean of whether to add documents to docstore.\n     * This can be false if and only if `ids` are provided. You may want\n     *   to set this to False if the documents are already in the docstore\n     *   and you don't want to re-add them.\n     * @param config.chunkHeaderOptions Object with options for adding Contextual chunk headers\n     */\n    addDocuments(docs: Document[], config?: {\n        ids?: string[];\n        addToDocstore?: boolean;\n        childDocChunkHeaderOptions?: TextSplitterChunkHeaderOptions;\n    }): Promise<void>;\n}\n"],"mappings":";;;;;;;;KAMYQ,OAAAA,GAAUN,SAASO;AAA/B;;;;AAA8B,KAKlBC,6BAAAA,GAAgCH,yBALd,GAAA;EAKlBG,aAAAA,EACOP,YADPO;EAA6B,cAAA,CAAA,EAEpBP,YAFoB;EAAA;;;;EAOsC,sBAAlDF,CAAAA,EAAAA,6BAAAA,CAA8BD,oBAA9BC,CAAAA;EAA6B,kBACjCI,CAAAA,EAAAA,sBAAAA,GAAAA,SAAAA;EAAsB,6BACJG,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,OAAAA,EAAAA,GAAYA,OAAZA;CAAO;AAAY;AAgC9D;;;;;;;;;;;;;;;;;;;;AAAyE;;;;;;;;;cAApDG,uBAAAA,SAAgCL,oBAAAA;;;eAGpCN;2BACYG;6BACEA;;;;0BAIHF,8BAA8BD;sBAClCK;kCACYK;sBACZA;wCACkBE,QAAQV;6BACnBO,eAAeP,sBAAsBA,qCAAqCU;;;;;;;;;;;;;;;qBAelFV;;;iCAGcE;MAC7BQ"}
+{"version":3,"file":"parent_document.d.cts","names":["VectorStoreInterface","VectorStoreRetrieverInterface","Document","TextSplitter","TextSplitterChunkHeaderOptions","BaseDocumentCompressor","MultiVectorRetriever","MultiVectorRetrieverInput","SubDocs","Record","ParentDocumentRetrieverFields","ParentDocumentRetriever","Promise"],"sources":["../../src/retrievers/parent_document.d.ts"],"sourcesContent":["import { type VectorStoreInterface, type VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { TextSplitter, TextSplitterChunkHeaderOptions } from \"@langchain/textsplitters\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\nimport { MultiVectorRetriever, type MultiVectorRetrieverInput } from \"./multi_vector.js\";\nexport type SubDocs = Document<Record<string, any>>[];\n/**\n * Interface for the fields required to initialize a\n * ParentDocumentRetriever instance.\n */\nexport type ParentDocumentRetrieverFields = MultiVectorRetrieverInput & {\n    childSplitter: TextSplitter;\n    parentSplitter?: TextSplitter;\n    /**\n     * A custom retriever to use when retrieving instead of\n     * the `.similaritySearch` method of the vectorstore.\n     */\n    childDocumentRetriever?: VectorStoreRetrieverInterface<VectorStoreInterface>;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: SubDocs) => SubDocs;\n};\n/**\n * A type of document retriever that splits input documents into smaller chunks\n * while separately storing and preserving the original documents.\n * The small chunks are embedded, then on retrieval, the original\n * \"parent\" documents are retrieved.\n *\n * This strikes a balance between better targeted retrieval with small documents\n * and the more context-rich larger documents.\n * @example\n * ```typescript\n * const retriever = new ParentDocumentRetriever({\n *   vectorstore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   byteStore: new InMemoryStore<Uint8Array>(),\n *   parentSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 500,\n *   }),\n *   childSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 50,\n *   }),\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const parentDocuments = await getDocuments();\n * await retriever.addDocuments(parentDocuments);\n * const retrievedDocs = await retriever.invoke(\"justice breyer\");\n * ```\n */\nexport declare class ParentDocumentRetriever extends MultiVectorRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    protected childSplitter: TextSplitter;\n    protected parentSplitter?: TextSplitter;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    childDocumentRetriever: VectorStoreRetrieverInterface<VectorStoreInterface> | undefined;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: ParentDocumentRetrieverFields[\"documentCompressorFilteringFn\"];\n    constructor(fields: ParentDocumentRetrieverFields);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n    _storeDocuments(parentDoc: Record<string, Document>, childDocs: Document[], addToDocstore: boolean): Promise<void>;\n    /**\n     * Adds documents to the docstore and vectorstores.\n     * If a retriever is provided, it will be used to add documents instead of the vectorstore.\n     * @param docs The documents to add\n     * @param config.ids Optional list of ids for documents. If provided should be the same\n     *   length as the list of documents. Can provided if parent documents\n     *   are already in the document store and you don't want to re-add\n     *   to the docstore. If not provided, random UUIDs will be used as ids.\n     * @param config.addToDocstore Boolean of whether to add documents to docstore.\n     * This can be false if and only if `ids` are provided. You may want\n     *   to set this to False if the documents are already in the docstore\n     *   and you don't want to re-add them.\n     * @param config.chunkHeaderOptions Object with options for adding Contextual chunk headers\n     */\n    addDocuments(docs: Document[], config?: {\n        ids?: string[];\n        addToDocstore?: boolean;\n        childDocChunkHeaderOptions?: TextSplitterChunkHeaderOptions;\n    }): Promise<void>;\n}\n//# sourceMappingURL=parent_document.d.ts.map"],"mappings":";;;;;;;KAKYQ,OAAAA,GAAUN,SAASO;;AAA/B;AAKA;;AACmBN,KADPO,6BAAAA,GAAgCH,yBACzBJ,GAAAA;EACEA,aAAAA,EADFA,YACEA;EAKsCH,cAAAA,CAAAA,EALtCG,YAKsCH;EAA9BC;;;;EAEiC,sBAAA,CAAA,EAFjCA,6BAEiC,CAFHD,oBAEG,CAAA;EAgCzCW,kBAAAA,CAAAA,EAjCIN,sBAiCmB,GAAA,SAAA;EAG3BL,6BAAAA,CAAAA,EAAAA,CAAAA,IAAAA,EAnC0BQ,OAmC1BR,EAAAA,GAnCsCQ,OAmCtCR;CACYG;;;;;;;;;;;;;;;;;AAJ4C;;;;;;;;;;;;;;cAApDQ,uBAAAA,SAAgCL,oBAAAA;;;eAGpCN;2BACYG;6BACEA;;;;0BAIHF,8BAA8BD;sBAClCK;kCACYK;sBACZA;wCACkBE,QAAQV;6BACnBO,eAAeP,sBAAsBA,qCAAqCU;;;;;;;;;;;;;;;qBAelFV;;;iCAGcE;MAC7BQ"}

package/dist/retrievers/parent_document.d.ts

@@ -5,7 +5,6 @@ import { TextSplitter, TextSplitterChunkHeaderOptions } from "@langchain/textspl
 import { VectorStoreInterface, VectorStoreRetrieverInterface } from "@langchain/core/vectorstores";
 
 //#region src/retrievers/parent_document.d.ts
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type SubDocs = Document<Record<string, any>>[];
 /**
  * Interface for the fields required to initialize a

package/dist/retrievers/parent_document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parent_document.d.ts","names":["VectorStoreInterface","VectorStoreRetrieverInterface","Document","TextSplitter","TextSplitterChunkHeaderOptions","BaseDocumentCompressor","MultiVectorRetriever","MultiVectorRetrieverInput","SubDocs","Record","ParentDocumentRetrieverFields","ParentDocumentRetriever","Promise"],"sources":["../../src/retrievers/parent_document.d.ts"],"sourcesContent":["import { type VectorStoreInterface, type VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { TextSplitter, TextSplitterChunkHeaderOptions } from \"@langchain/textsplitters\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\nimport { MultiVectorRetriever, type MultiVectorRetrieverInput } from \"./multi_vector.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type SubDocs = Document<Record<string, any>>[];\n/**\n * Interface for the fields required to initialize a\n * ParentDocumentRetriever instance.\n */\nexport type ParentDocumentRetrieverFields = MultiVectorRetrieverInput & {\n    childSplitter: TextSplitter;\n    parentSplitter?: TextSplitter;\n    /**\n     * A custom retriever to use when retrieving instead of\n     * the `.similaritySearch` method of the vectorstore.\n     */\n    childDocumentRetriever?: VectorStoreRetrieverInterface<VectorStoreInterface>;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: SubDocs) => SubDocs;\n};\n/**\n * A type of document retriever that splits input documents into smaller chunks\n * while separately storing and preserving the original documents.\n * The small chunks are embedded, then on retrieval, the original\n * \"parent\" documents are retrieved.\n *\n * This strikes a balance between better targeted retrieval with small documents\n * and the more context-rich larger documents.\n * @example\n * ```typescript\n * const retriever = new ParentDocumentRetriever({\n *   vectorstore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   byteStore: new InMemoryStore<Uint8Array>(),\n *   parentSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 500,\n *   }),\n *   childSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 50,\n *   }),\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const parentDocuments = await getDocuments();\n * await retriever.addDocuments(parentDocuments);\n * const retrievedDocs = await retriever.invoke(\"justice breyer\");\n * ```\n */\nexport declare class ParentDocumentRetriever extends MultiVectorRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    protected childSplitter: TextSplitter;\n    protected parentSplitter?: TextSplitter;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    childDocumentRetriever: VectorStoreRetrieverInterface<VectorStoreInterface> | undefined;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: ParentDocumentRetrieverFields[\"documentCompressorFilteringFn\"];\n    constructor(fields: ParentDocumentRetrieverFields);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n    _storeDocuments(parentDoc: Record<string, Document>, childDocs: Document[], addToDocstore: boolean): Promise<void>;\n    /**\n     * Adds documents to the docstore and vectorstores.\n     * If a retriever is provided, it will be used to add documents instead of the vectorstore.\n     * @param docs The documents to add\n     * @param config.ids Optional list of ids for documents. If provided should be the same\n     *   length as the list of documents. Can provided if parent documents\n     *   are already in the document store and you don't want to re-add\n     *   to the docstore. If not provided, random UUIDs will be used as ids.\n     * @param config.addToDocstore Boolean of whether to add documents to docstore.\n     * This can be false if and only if `ids` are provided. You may want\n     *   to set this to False if the documents are already in the docstore\n     *   and you don't want to re-add them.\n     * @param config.chunkHeaderOptions Object with options for adding Contextual chunk headers\n     */\n    addDocuments(docs: Document[], config?: {\n        ids?: string[];\n        addToDocstore?: boolean;\n        childDocChunkHeaderOptions?: TextSplitterChunkHeaderOptions;\n    }): Promise<void>;\n}\n"],"mappings":";;;;;;;;KAMYQ,OAAAA,GAAUN,SAASO;AAA/B;;;;AAA8B,KAKlBC,6BAAAA,GAAgCH,yBALd,GAAA;EAKlBG,aAAAA,EACOP,YADPO;EAA6B,cAAA,CAAA,EAEpBP,YAFoB;EAAA;;;;EAOsC,sBAAlDF,CAAAA,EAAAA,6BAAAA,CAA8BD,oBAA9BC,CAAAA;EAA6B,kBACjCI,CAAAA,EAAAA,sBAAAA,GAAAA,SAAAA;EAAsB,6BACJG,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,OAAAA,EAAAA,GAAYA,OAAZA;CAAO;AAAY;AAgC9D;;;;;;;;;;;;;;;;;;;;AAAyE;;;;;;;;;cAApDG,uBAAAA,SAAgCL,oBAAAA;;;eAGpCN;2BACYG;6BACEA;;;;0BAIHF,8BAA8BD;sBAClCK;kCACYK;sBACZA;wCACkBE,QAAQV;6BACnBO,eAAeP,sBAAsBA,qCAAqCU;;;;;;;;;;;;;;;qBAelFV;;;iCAGcE;MAC7BQ"}
+{"version":3,"file":"parent_document.d.ts","names":["VectorStoreInterface","VectorStoreRetrieverInterface","Document","TextSplitter","TextSplitterChunkHeaderOptions","BaseDocumentCompressor","MultiVectorRetriever","MultiVectorRetrieverInput","SubDocs","Record","ParentDocumentRetrieverFields","ParentDocumentRetriever","Promise"],"sources":["../../src/retrievers/parent_document.d.ts"],"sourcesContent":["import { type VectorStoreInterface, type VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport { TextSplitter, TextSplitterChunkHeaderOptions } from \"@langchain/textsplitters\";\nimport type { BaseDocumentCompressor } from \"./document_compressors/index.js\";\nimport { MultiVectorRetriever, type MultiVectorRetrieverInput } from \"./multi_vector.js\";\nexport type SubDocs = Document<Record<string, any>>[];\n/**\n * Interface for the fields required to initialize a\n * ParentDocumentRetriever instance.\n */\nexport type ParentDocumentRetrieverFields = MultiVectorRetrieverInput & {\n    childSplitter: TextSplitter;\n    parentSplitter?: TextSplitter;\n    /**\n     * A custom retriever to use when retrieving instead of\n     * the `.similaritySearch` method of the vectorstore.\n     */\n    childDocumentRetriever?: VectorStoreRetrieverInterface<VectorStoreInterface>;\n    documentCompressor?: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: (docs: SubDocs) => SubDocs;\n};\n/**\n * A type of document retriever that splits input documents into smaller chunks\n * while separately storing and preserving the original documents.\n * The small chunks are embedded, then on retrieval, the original\n * \"parent\" documents are retrieved.\n *\n * This strikes a balance between better targeted retrieval with small documents\n * and the more context-rich larger documents.\n * @example\n * ```typescript\n * const retriever = new ParentDocumentRetriever({\n *   vectorstore: new MemoryVectorStore(new OpenAIEmbeddings()),\n *   byteStore: new InMemoryStore<Uint8Array>(),\n *   parentSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 500,\n *   }),\n *   childSplitter: new RecursiveCharacterTextSplitter({\n *     chunkOverlap: 0,\n *     chunkSize: 50,\n *   }),\n *   childK: 20,\n *   parentK: 5,\n * });\n *\n * const parentDocuments = await getDocuments();\n * await retriever.addDocuments(parentDocuments);\n * const retrievedDocs = await retriever.invoke(\"justice breyer\");\n * ```\n */\nexport declare class ParentDocumentRetriever extends MultiVectorRetriever {\n    static lc_name(): string;\n    lc_namespace: string[];\n    vectorstore: VectorStoreInterface;\n    protected childSplitter: TextSplitter;\n    protected parentSplitter?: TextSplitter;\n    protected idKey: string;\n    protected childK?: number;\n    protected parentK?: number;\n    childDocumentRetriever: VectorStoreRetrieverInterface<VectorStoreInterface> | undefined;\n    documentCompressor: BaseDocumentCompressor | undefined;\n    documentCompressorFilteringFn?: ParentDocumentRetrieverFields[\"documentCompressorFilteringFn\"];\n    constructor(fields: ParentDocumentRetrieverFields);\n    _getRelevantDocuments(query: string): Promise<Document[]>;\n    _storeDocuments(parentDoc: Record<string, Document>, childDocs: Document[], addToDocstore: boolean): Promise<void>;\n    /**\n     * Adds documents to the docstore and vectorstores.\n     * If a retriever is provided, it will be used to add documents instead of the vectorstore.\n     * @param docs The documents to add\n     * @param config.ids Optional list of ids for documents. If provided should be the same\n     *   length as the list of documents. Can provided if parent documents\n     *   are already in the document store and you don't want to re-add\n     *   to the docstore. If not provided, random UUIDs will be used as ids.\n     * @param config.addToDocstore Boolean of whether to add documents to docstore.\n     * This can be false if and only if `ids` are provided. You may want\n     *   to set this to False if the documents are already in the docstore\n     *   and you don't want to re-add them.\n     * @param config.chunkHeaderOptions Object with options for adding Contextual chunk headers\n     */\n    addDocuments(docs: Document[], config?: {\n        ids?: string[];\n        addToDocstore?: boolean;\n        childDocChunkHeaderOptions?: TextSplitterChunkHeaderOptions;\n    }): Promise<void>;\n}\n//# sourceMappingURL=parent_document.d.ts.map"],"mappings":";;;;;;;KAKYQ,OAAAA,GAAUN,SAASO;;AAA/B;AAKA;;AACmBN,KADPO,6BAAAA,GAAgCH,yBACzBJ,GAAAA;EACEA,aAAAA,EADFA,YACEA;EAKsCH,cAAAA,CAAAA,EALtCG,YAKsCH;EAA9BC;;;;EAEiC,sBAAA,CAAA,EAFjCA,6BAEiC,CAFHD,oBAEG,CAAA;EAgCzCW,kBAAAA,CAAAA,EAjCIN,sBAiCmB,GAAA,SAAA;EAG3BL,6BAAAA,CAAAA,EAAAA,CAAAA,IAAAA,EAnC0BQ,OAmC1BR,EAAAA,GAnCsCQ,OAmCtCR;CACYG;;;;;;;;;;;;;;;;;AAJ4C;;;;;;;;;;;;;;cAApDQ,uBAAAA,SAAgCL,oBAAAA;;;eAGpCN;2BACYG;6BACEA;;;;0BAIHF,8BAA8BD;sBAClCK;kCACYK;sBACZA;wCACkBE,QAAQV;6BACnBO,eAAeP,sBAAsBA,qCAAqCU;;;;;;;;;;;;;;;qBAelFV;;;iCAGcE;MAC7BQ"}

package/dist/retrievers/score_threshold.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"score_threshold.d.cts","names":["Document","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","ScoreThresholdRetrieverInput","V","Omit","ScoreThresholdRetriever","Promise"],"sources":["../../src/retrievers/score_threshold.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nexport type ScoreThresholdRetrieverInput<V extends VectorStore> = Omit<VectorStoreRetrieverInput<V>, \"k\"> & {\n    maxK?: number;\n    kIncrement?: number;\n    minSimilarityScore: number;\n};\nexport declare class ScoreThresholdRetriever<V extends VectorStore> extends VectorStoreRetriever<V> {\n    minSimilarityScore: number;\n    kIncrement: number;\n    maxK: number;\n    constructor(input: ScoreThresholdRetrieverInput<V>);\n    invoke(query: string): Promise<Document[]>;\n    static fromVectorStore<V extends VectorStore>(vectorStore: V, options: Omit<ScoreThresholdRetrieverInput<V>, \"vectorStore\">): ScoreThresholdRetriever<V>;\n}\n"],"mappings":";;;;KAEYI,uCAAuCH,eAAeK,KAAKH,0BAA0BE;;EAArFD,UAAAA,CAAAA,EAAAA,MAAAA;EAA4B,kBAAA,EAAA,MAAA;CAAA;AAAyDC,cAK5EE,uBAL4EF,CAAAA,UAK1CJ,WAL0CI,CAAAA,SAKrBH,oBALqBG,CAKAA,CALAA,CAAAA,CAAAA;EAAC,kBAA3BF,EAAAA,MAAAA;EAAyB,UAA9BG,EAAAA,MAAAA;EAAI,IAAA,EAAA,MAAA;EAKjDC,WAAAA,CAAAA,KAAAA,EAIEH,4BAJqB,CAIQC,CAJR,CAAA;EAAA,MAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAKjBG,OALiB,CAKTR,QALS,EAAA,CAAA;EAAA,OAAWC,eAAAA,CAAAA,UAMlBA,WANkBA,CAAAA,CAAAA,WAAAA,EAMQI,CANRJ,EAAAA,OAAAA,EAMoBK,IANpBL,CAMyBG,4BANzBH,CAMsDI,CANtDJ,CAAAA,EAAAA,aAAAA,CAAAA,CAAAA,EAM2EM,uBAN3EN,CAMmGI,CANnGJ,CAAAA"}
+{"version":3,"file":"score_threshold.d.cts","names":["Document","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","ScoreThresholdRetrieverInput","V","Omit","ScoreThresholdRetriever","Promise"],"sources":["../../src/retrievers/score_threshold.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nexport type ScoreThresholdRetrieverInput<V extends VectorStore> = Omit<VectorStoreRetrieverInput<V>, \"k\"> & {\n    maxK?: number;\n    kIncrement?: number;\n    minSimilarityScore: number;\n};\nexport declare class ScoreThresholdRetriever<V extends VectorStore> extends VectorStoreRetriever<V> {\n    minSimilarityScore: number;\n    kIncrement: number;\n    maxK: number;\n    constructor(input: ScoreThresholdRetrieverInput<V>);\n    invoke(query: string): Promise<Document[]>;\n    static fromVectorStore<V extends VectorStore>(vectorStore: V, options: Omit<ScoreThresholdRetrieverInput<V>, \"vectorStore\">): ScoreThresholdRetriever<V>;\n}\n//# sourceMappingURL=score_threshold.d.ts.map"],"mappings":";;;;KAEYI,uCAAuCH,eAAeK,KAAKH,0BAA0BE;;EAArFD,UAAAA,CAAAA,EAAAA,MAAAA;EAAuCH,kBAAAA,EAAAA,MAAAA;CAA8CI;AAA1BF,cAKlDI,uBALkDJ,CAAAA,UAKhBF,WALgBE,CAAAA,SAKKD,oBALLC,CAK0BE,CAL1BF,CAAAA,CAAAA;EAALG,kBAAAA,EAAAA,MAAAA;EAAI,UAAA,EAAA,MAAA;EAKjDC,IAAAA,EAAAA,MAAAA;EAAkCN,WAAAA,CAAAA,KAAAA,EAIhCG,4BAJgCH,CAIHI,CAJGJ,CAAAA;EAA0CI,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EAKtEG,OALsEH,CAK9DL,QAL8DK,EAAAA,CAAAA;EAI7CA,OAAAA,eAAAA,CAAAA,UAEfJ,WAFeI,CAAAA,CAAAA,WAAAA,EAEWA,CAFXA,EAAAA,OAAAA,EAEuBC,IAFvBD,CAE4BD,4BAF5BC,CAEyDA,CAFzDA,CAAAA,EAAAA,aAAAA,CAAAA,CAAAA,EAE8EE,uBAF9EF,CAEsGA,CAFtGA,CAAAA"}

package/dist/retrievers/score_threshold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"score_threshold.d.ts","names":["Document","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","ScoreThresholdRetrieverInput","V","Omit","ScoreThresholdRetriever","Promise"],"sources":["../../src/retrievers/score_threshold.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nexport type ScoreThresholdRetrieverInput<V extends VectorStore> = Omit<VectorStoreRetrieverInput<V>, \"k\"> & {\n    maxK?: number;\n    kIncrement?: number;\n    minSimilarityScore: number;\n};\nexport declare class ScoreThresholdRetriever<V extends VectorStore> extends VectorStoreRetriever<V> {\n    minSimilarityScore: number;\n    kIncrement: number;\n    maxK: number;\n    constructor(input: ScoreThresholdRetrieverInput<V>);\n    invoke(query: string): Promise<Document[]>;\n    static fromVectorStore<V extends VectorStore>(vectorStore: V, options: Omit<ScoreThresholdRetrieverInput<V>, \"vectorStore\">): ScoreThresholdRetriever<V>;\n}\n"],"mappings":";;;;KAEYI,uCAAuCH,eAAeK,KAAKH,0BAA0BE;;EAArFD,UAAAA,CAAAA,EAAAA,MAAAA;EAA4B,kBAAA,EAAA,MAAA;CAAA;AAAyDC,cAK5EE,uBAL4EF,CAAAA,UAK1CJ,WAL0CI,CAAAA,SAKrBH,oBALqBG,CAKAA,CALAA,CAAAA,CAAAA;EAAC,kBAA3BF,EAAAA,MAAAA;EAAyB,UAA9BG,EAAAA,MAAAA;EAAI,IAAA,EAAA,MAAA;EAKjDC,WAAAA,CAAAA,KAAAA,EAIEH,4BAJqB,CAIQC,CAJR,CAAA;EAAA,MAAA,CAAA,KAAA,EAAA,MAAA,CAAA,EAKjBG,OALiB,CAKTR,QALS,EAAA,CAAA;EAAA,OAAWC,eAAAA,CAAAA,UAMlBA,WANkBA,CAAAA,CAAAA,WAAAA,EAMQI,CANRJ,EAAAA,OAAAA,EAMoBK,IANpBL,CAMyBG,4BANzBH,CAMsDI,CANtDJ,CAAAA,EAAAA,aAAAA,CAAAA,CAAAA,EAM2EM,uBAN3EN,CAMmGI,CANnGJ,CAAAA"}
+{"version":3,"file":"score_threshold.d.ts","names":["Document","VectorStore","VectorStoreRetriever","VectorStoreRetrieverInput","ScoreThresholdRetrieverInput","V","Omit","ScoreThresholdRetriever","Promise"],"sources":["../../src/retrievers/score_threshold.d.ts"],"sourcesContent":["import { Document } from \"@langchain/core/documents\";\nimport { VectorStore, VectorStoreRetriever, VectorStoreRetrieverInput } from \"@langchain/core/vectorstores\";\nexport type ScoreThresholdRetrieverInput<V extends VectorStore> = Omit<VectorStoreRetrieverInput<V>, \"k\"> & {\n    maxK?: number;\n    kIncrement?: number;\n    minSimilarityScore: number;\n};\nexport declare class ScoreThresholdRetriever<V extends VectorStore> extends VectorStoreRetriever<V> {\n    minSimilarityScore: number;\n    kIncrement: number;\n    maxK: number;\n    constructor(input: ScoreThresholdRetrieverInput<V>);\n    invoke(query: string): Promise<Document[]>;\n    static fromVectorStore<V extends VectorStore>(vectorStore: V, options: Omit<ScoreThresholdRetrieverInput<V>, \"vectorStore\">): ScoreThresholdRetriever<V>;\n}\n//# sourceMappingURL=score_threshold.d.ts.map"],"mappings":";;;;KAEYI,uCAAuCH,eAAeK,KAAKH,0BAA0BE;;EAArFD,UAAAA,CAAAA,EAAAA,MAAAA;EAAuCH,kBAAAA,EAAAA,MAAAA;CAA8CI;AAA1BF,cAKlDI,uBALkDJ,CAAAA,UAKhBF,WALgBE,CAAAA,SAKKD,oBALLC,CAK0BE,CAL1BF,CAAAA,CAAAA;EAALG,kBAAAA,EAAAA,MAAAA;EAAI,UAAA,EAAA,MAAA;EAKjDC,IAAAA,EAAAA,MAAAA;EAAkCN,WAAAA,CAAAA,KAAAA,EAIhCG,4BAJgCH,CAIHI,CAJGJ,CAAAA;EAA0CI,MAAAA,CAAAA,KAAAA,EAAAA,MAAAA,CAAAA,EAKtEG,OALsEH,CAK9DL,QAL8DK,EAAAA,CAAAA;EAI7CA,OAAAA,eAAAA,CAAAA,UAEfJ,WAFeI,CAAAA,CAAAA,WAAAA,EAEWA,CAFXA,EAAAA,OAAAA,EAEuBC,IAFvBD,CAE4BD,4BAF5BC,CAEyDA,CAFzDA,CAAAA,EAAAA,aAAAA,CAAAA,CAAAA,EAE8EE,uBAF9EF,CAEsGA,CAFtGA,CAAAA"}

package/dist/retrievers/self_query/index.cjs

@@ -1,7 +1,7 @@
 const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
 const require_chains_query_constructor_index = require('../../chains/query_constructor/index.cjs');
-const __langchain_core_structured_query = require_rolldown_runtime.__toESM(require("@langchain/core/structured_query"));
 const __langchain_core_retrievers = require_rolldown_runtime.__toESM(require("@langchain/core/retrievers"));
+const __langchain_core_structured_query = require_rolldown_runtime.__toESM(require("@langchain/core/structured_query"));
 
 //#region src/retrievers/self_query/index.ts
 var self_query_exports = {};

package/dist/retrievers/self_query/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["RunnableInterface","BaseRetriever","BaseRetrieverInput","Document","VectorStore","BaseTranslator","StructuredQuery","CallbackManagerForRetrieverRun","QueryConstructorRunnableOptions","BasicTranslator","FunctionalTranslator","SelfQueryRetrieverArgs","T","SelfQueryRetriever","Record","Promise","Omit"],"sources":["../../../src/retrievers/self_query/index.d.ts"],"sourcesContent":["import { RunnableInterface } from \"@langchain/core/runnables\";\nimport { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { VectorStore } from \"@langchain/core/vectorstores\";\nimport { BaseTranslator, StructuredQuery } from \"@langchain/core/structured_query\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { QueryConstructorRunnableOptions } from \"../../chains/query_constructor/index.js\";\nexport { BaseTranslator } from \"@langchain/core/structured_query\";\nexport { BasicTranslator, FunctionalTranslator, } from \"@langchain/core/structured_query\";\n/**\n * Interface for the arguments required to create a SelfQueryRetriever\n * instance. It extends the BaseRetrieverInput interface.\n */\nexport interface SelfQueryRetrieverArgs<T extends VectorStore> extends BaseRetrieverInput {\n    vectorStore: T;\n    structuredQueryTranslator: BaseTranslator<T>;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    useOriginalQuery?: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n}\n/**\n * Class for question answering over an index. It retrieves relevant\n * documents based on a query. It extends the BaseRetriever class and\n * implements the SelfQueryRetrieverArgs interface.\n * @example\n * ```typescript\n * const selfQueryRetriever = SelfQueryRetriever.fromLLM({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   vectorStore: await HNSWLib.fromDocuments(docs, new OpenAIEmbeddings()),\n *   documentContents: \"Brief summary of a movie\",\n *   attributeInfo: attributeInfo,\n *   structuredQueryTranslator: new FunctionalTranslator(),\n * });\n * const relevantDocuments = await selfQueryRetriever.invoke(\n *   \"Which movies are directed by Greta Gerwig?\",\n * );\n * ```\n */\nexport declare class SelfQueryRetriever<T extends VectorStore> extends BaseRetriever implements SelfQueryRetrieverArgs<T> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    vectorStore: T;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    structuredQueryTranslator: BaseTranslator<T>;\n    useOriginalQuery: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n    constructor(options: SelfQueryRetrieverArgs<T>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, unknown>>[]>;\n    /**\n     * Static method to create a new SelfQueryRetriever instance from a\n     * BaseLanguageModel and a VectorStore. It first loads a query constructor\n     * chain using the loadQueryConstructorChain function, then creates a new\n     * SelfQueryRetriever instance with the loaded chain and the provided\n     * options.\n     * @param options The options used to create the SelfQueryRetriever instance. It includes the QueryConstructorChainOptions and all the SelfQueryRetrieverArgs except 'llmChain'.\n     * @returns A new instance of SelfQueryRetriever.\n     */\n    static fromLLM<T extends VectorStore>(options: QueryConstructorRunnableOptions & Omit<SelfQueryRetrieverArgs<T>, \"queryConstructor\">): SelfQueryRetriever<T>;\n}\n"],"mappings":";;;;;;;;;;AAaA;;;;AAE8CY,UAF7BD,sBAE6BC,CAAAA,UAFIR,WAEJQ,CAAAA,SAFyBV,kBAEzBU,CAAAA;EAAC,WAAhBP,EADdO,CACcP;EAAc,yBAGtCC,EAHwBD,gBAGxBC,CAHuCM,CAGvCN,CAAAA;EAAe,gBAFAN,EAAAA,iBAAAA,CAAAA;IAOLY,KAAAA,EAAAA,MAAAA;EAAC,CAAA,EALXN,eALgEJ,CAAAA;EAAkB,OAAA,CAAA,EAAA,OAAA;EAiCpEW,gBAAAA,CAAAA,EAAAA,OAAkB;EAAA,YAAA,CAAA,EAAA;IAAWT,CAAAA,CAAAA,EAAAA,MAAAA;IAAqEQ,MAAAA,CAAAA,EAvBtGA,CAuBsGA,CAAAA,YAAAA,CAAAA;IAGtGA,oBAAAA,CAAAA,EAAAA,IAAAA,GAAAA,KAAAA,GAAAA,SAAAA;IAGVN,kBAAAA,CAAAA,EAAAA,OAAAA;EAAe,CAAA;;;;;;;;;;;;;;;;;;;AANgG;cAAjGO,6BAA6BT,qBAAqBH,aAAAA,YAAyBU,uBAAuBC;;;eAGtGA;oBACKZ;;KAEfM;;6BAEwBD,iBAAeO;;;;aAI7BA;;;;uBAIQD,uBAAuBC;oDACML,iCAAiCQ,QAAQZ,SAASW;;;;;;;;;;2BAU3EV,sBAAsBI,kCAAkCQ,KAAKL,uBAAuBC,0BAA0BC,mBAAmBD"}
+{"version":3,"file":"index.d.cts","names":["RunnableInterface","BaseRetriever","BaseRetrieverInput","Document","VectorStore","BaseTranslator","StructuredQuery","CallbackManagerForRetrieverRun","QueryConstructorRunnableOptions","BasicTranslator","FunctionalTranslator","SelfQueryRetrieverArgs","T","SelfQueryRetriever","Record","Promise","Omit"],"sources":["../../../src/retrievers/self_query/index.d.ts"],"sourcesContent":["import { RunnableInterface } from \"@langchain/core/runnables\";\nimport { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { VectorStore } from \"@langchain/core/vectorstores\";\nimport { BaseTranslator, StructuredQuery } from \"@langchain/core/structured_query\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { QueryConstructorRunnableOptions } from \"../../chains/query_constructor/index.js\";\nexport { BaseTranslator } from \"@langchain/core/structured_query\";\nexport { BasicTranslator, FunctionalTranslator, } from \"@langchain/core/structured_query\";\n/**\n * Interface for the arguments required to create a SelfQueryRetriever\n * instance. It extends the BaseRetrieverInput interface.\n */\nexport interface SelfQueryRetrieverArgs<T extends VectorStore> extends BaseRetrieverInput {\n    vectorStore: T;\n    structuredQueryTranslator: BaseTranslator<T>;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    useOriginalQuery?: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n}\n/**\n * Class for question answering over an index. It retrieves relevant\n * documents based on a query. It extends the BaseRetriever class and\n * implements the SelfQueryRetrieverArgs interface.\n * @example\n * ```typescript\n * const selfQueryRetriever = SelfQueryRetriever.fromLLM({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   vectorStore: await HNSWLib.fromDocuments(docs, new OpenAIEmbeddings()),\n *   documentContents: \"Brief summary of a movie\",\n *   attributeInfo: attributeInfo,\n *   structuredQueryTranslator: new FunctionalTranslator(),\n * });\n * const relevantDocuments = await selfQueryRetriever.invoke(\n *   \"Which movies are directed by Greta Gerwig?\",\n * );\n * ```\n */\nexport declare class SelfQueryRetriever<T extends VectorStore> extends BaseRetriever implements SelfQueryRetrieverArgs<T> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    vectorStore: T;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    structuredQueryTranslator: BaseTranslator<T>;\n    useOriginalQuery: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n    constructor(options: SelfQueryRetrieverArgs<T>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, unknown>>[]>;\n    /**\n     * Static method to create a new SelfQueryRetriever instance from a\n     * BaseLanguageModel and a VectorStore. It first loads a query constructor\n     * chain using the loadQueryConstructorChain function, then creates a new\n     * SelfQueryRetriever instance with the loaded chain and the provided\n     * options.\n     * @param options The options used to create the SelfQueryRetriever instance. It includes the QueryConstructorChainOptions and all the SelfQueryRetrieverArgs except 'llmChain'.\n     * @returns A new instance of SelfQueryRetriever.\n     */\n    static fromLLM<T extends VectorStore>(options: QueryConstructorRunnableOptions & Omit<SelfQueryRetrieverArgs<T>, \"queryConstructor\">): SelfQueryRetriever<T>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;AAaA;;;;AAE+BK,UAFdM,sBAEcN,CAAAA,UAFmBD,WAEnBC,CAAAA,SAFwCH,kBAExCG,CAAAA;EAGxBC,WAAAA,EAJUM,CAIVN;EAFeN,yBAAAA,EADSK,gBACTL,CADwBY,CACxBZ,CAAAA;EAOLY,gBAAAA,EAPKZ,iBAOLY,CAAAA;IAVsDV,KAAAA,EAAAA,MAAAA;EAAkB,CAAA,EAKlFI,eALkF,CAAA;EAiCpEO,OAAAA,CAAAA,EAAAA,OAAAA;EAA6BT,gBAAAA,CAAAA,EAAAA,OAAAA;EAAqEQ,YAAAA,CAAAA,EAAAA;IAGtGA,CAAAA,CAAAA,EAAAA,MAAAA;IAGVN,MAAAA,CAAAA,EA7BUM,CA6BVN,CAAAA,YAAAA,CAAAA;IAFeN,oBAAAA,CAAAA,EAAAA,IAAAA,GAAAA,KAAAA,GAAAA,SAAAA;IAIwBY,kBAAAA,CAAAA,EAAAA,OAAAA;EAAfP,CAAAA;;;;;;;;;;;;;;;;;AARuF;;;cAAjGQ,6BAA6BT,qBAAqBH,aAAAA,YAAyBU,uBAAuBC;;;eAGtGA;oBACKZ;;KAEfM;;6BAEwBD,iBAAeO;;;;aAI7BA;;;;uBAIQD,uBAAuBC;oDACML,iCAAiCQ,QAAQZ,SAASW;;;;;;;;;;2BAU3EV,sBAAsBI,kCAAkCQ,KAAKL,uBAAuBC,0BAA0BC,mBAAmBD"}

package/dist/retrievers/self_query/index.d.ts

@@ -2,9 +2,9 @@ import { QueryConstructorRunnableOptions } from "../../chains/query_constructor/
 import { Document } from "@langchain/core/documents";
 import { RunnableInterface } from "@langchain/core/runnables";
 import { CallbackManagerForRetrieverRun } from "@langchain/core/callbacks/manager";
+import { BaseRetriever, BaseRetrieverInput } from "@langchain/core/retrievers";
 import { VectorStore } from "@langchain/core/vectorstores";
 import { BaseTranslator, BaseTranslator as BaseTranslator$1, BasicTranslator, FunctionalTranslator, StructuredQuery } from "@langchain/core/structured_query";
-import { BaseRetriever, BaseRetrieverInput } from "@langchain/core/retrievers";
 
 //#region src/retrievers/self_query/index.d.ts
 

package/dist/retrievers/self_query/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["RunnableInterface","BaseRetriever","BaseRetrieverInput","Document","VectorStore","BaseTranslator","StructuredQuery","CallbackManagerForRetrieverRun","QueryConstructorRunnableOptions","BasicTranslator","FunctionalTranslator","SelfQueryRetrieverArgs","T","SelfQueryRetriever","Record","Promise","Omit"],"sources":["../../../src/retrievers/self_query/index.d.ts"],"sourcesContent":["import { RunnableInterface } from \"@langchain/core/runnables\";\nimport { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { VectorStore } from \"@langchain/core/vectorstores\";\nimport { BaseTranslator, StructuredQuery } from \"@langchain/core/structured_query\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { QueryConstructorRunnableOptions } from \"../../chains/query_constructor/index.js\";\nexport { BaseTranslator } from \"@langchain/core/structured_query\";\nexport { BasicTranslator, FunctionalTranslator, } from \"@langchain/core/structured_query\";\n/**\n * Interface for the arguments required to create a SelfQueryRetriever\n * instance. It extends the BaseRetrieverInput interface.\n */\nexport interface SelfQueryRetrieverArgs<T extends VectorStore> extends BaseRetrieverInput {\n    vectorStore: T;\n    structuredQueryTranslator: BaseTranslator<T>;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    useOriginalQuery?: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n}\n/**\n * Class for question answering over an index. It retrieves relevant\n * documents based on a query. It extends the BaseRetriever class and\n * implements the SelfQueryRetrieverArgs interface.\n * @example\n * ```typescript\n * const selfQueryRetriever = SelfQueryRetriever.fromLLM({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   vectorStore: await HNSWLib.fromDocuments(docs, new OpenAIEmbeddings()),\n *   documentContents: \"Brief summary of a movie\",\n *   attributeInfo: attributeInfo,\n *   structuredQueryTranslator: new FunctionalTranslator(),\n * });\n * const relevantDocuments = await selfQueryRetriever.invoke(\n *   \"Which movies are directed by Greta Gerwig?\",\n * );\n * ```\n */\nexport declare class SelfQueryRetriever<T extends VectorStore> extends BaseRetriever implements SelfQueryRetrieverArgs<T> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    vectorStore: T;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    structuredQueryTranslator: BaseTranslator<T>;\n    useOriginalQuery: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n    constructor(options: SelfQueryRetrieverArgs<T>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, unknown>>[]>;\n    /**\n     * Static method to create a new SelfQueryRetriever instance from a\n     * BaseLanguageModel and a VectorStore. It first loads a query constructor\n     * chain using the loadQueryConstructorChain function, then creates a new\n     * SelfQueryRetriever instance with the loaded chain and the provided\n     * options.\n     * @param options The options used to create the SelfQueryRetriever instance. It includes the QueryConstructorChainOptions and all the SelfQueryRetrieverArgs except 'llmChain'.\n     * @returns A new instance of SelfQueryRetriever.\n     */\n    static fromLLM<T extends VectorStore>(options: QueryConstructorRunnableOptions & Omit<SelfQueryRetrieverArgs<T>, \"queryConstructor\">): SelfQueryRetriever<T>;\n}\n"],"mappings":";;;;;;;;;;AAaA;;;;AAE8CY,UAF7BD,sBAE6BC,CAAAA,UAFIR,WAEJQ,CAAAA,SAFyBV,kBAEzBU,CAAAA;EAAC,WAAhBP,EADdO,CACcP;EAAc,yBAGtCC,EAHwBD,gBAGxBC,CAHuCM,CAGvCN,CAAAA;EAAe,gBAFAN,EAAAA,iBAAAA,CAAAA;IAOLY,KAAAA,EAAAA,MAAAA;EAAC,CAAA,EALXN,eALgEJ,CAAAA;EAAkB,OAAA,CAAA,EAAA,OAAA;EAiCpEW,gBAAAA,CAAAA,EAAAA,OAAkB;EAAA,YAAA,CAAA,EAAA;IAAWT,CAAAA,CAAAA,EAAAA,MAAAA;IAAqEQ,MAAAA,CAAAA,EAvBtGA,CAuBsGA,CAAAA,YAAAA,CAAAA;IAGtGA,oBAAAA,CAAAA,EAAAA,IAAAA,GAAAA,KAAAA,GAAAA,SAAAA;IAGVN,kBAAAA,CAAAA,EAAAA,OAAAA;EAAe,CAAA;;;;;;;;;;;;;;;;;;;AANgG;cAAjGO,6BAA6BT,qBAAqBH,aAAAA,YAAyBU,uBAAuBC;;;eAGtGA;oBACKZ;;KAEfM;;6BAEwBD,iBAAeO;;;;aAI7BA;;;;uBAIQD,uBAAuBC;oDACML,iCAAiCQ,QAAQZ,SAASW;;;;;;;;;;2BAU3EV,sBAAsBI,kCAAkCQ,KAAKL,uBAAuBC,0BAA0BC,mBAAmBD"}
+{"version":3,"file":"index.d.ts","names":["RunnableInterface","BaseRetriever","BaseRetrieverInput","Document","VectorStore","BaseTranslator","StructuredQuery","CallbackManagerForRetrieverRun","QueryConstructorRunnableOptions","BasicTranslator","FunctionalTranslator","SelfQueryRetrieverArgs","T","SelfQueryRetriever","Record","Promise","Omit"],"sources":["../../../src/retrievers/self_query/index.d.ts"],"sourcesContent":["import { RunnableInterface } from \"@langchain/core/runnables\";\nimport { BaseRetriever, type BaseRetrieverInput } from \"@langchain/core/retrievers\";\nimport { Document } from \"@langchain/core/documents\";\nimport { VectorStore } from \"@langchain/core/vectorstores\";\nimport { BaseTranslator, StructuredQuery } from \"@langchain/core/structured_query\";\nimport { CallbackManagerForRetrieverRun } from \"@langchain/core/callbacks/manager\";\nimport { QueryConstructorRunnableOptions } from \"../../chains/query_constructor/index.js\";\nexport { BaseTranslator } from \"@langchain/core/structured_query\";\nexport { BasicTranslator, FunctionalTranslator, } from \"@langchain/core/structured_query\";\n/**\n * Interface for the arguments required to create a SelfQueryRetriever\n * instance. It extends the BaseRetrieverInput interface.\n */\nexport interface SelfQueryRetrieverArgs<T extends VectorStore> extends BaseRetrieverInput {\n    vectorStore: T;\n    structuredQueryTranslator: BaseTranslator<T>;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    useOriginalQuery?: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n}\n/**\n * Class for question answering over an index. It retrieves relevant\n * documents based on a query. It extends the BaseRetriever class and\n * implements the SelfQueryRetrieverArgs interface.\n * @example\n * ```typescript\n * const selfQueryRetriever = SelfQueryRetriever.fromLLM({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\" }),\n *   vectorStore: await HNSWLib.fromDocuments(docs, new OpenAIEmbeddings()),\n *   documentContents: \"Brief summary of a movie\",\n *   attributeInfo: attributeInfo,\n *   structuredQueryTranslator: new FunctionalTranslator(),\n * });\n * const relevantDocuments = await selfQueryRetriever.invoke(\n *   \"Which movies are directed by Greta Gerwig?\",\n * );\n * ```\n */\nexport declare class SelfQueryRetriever<T extends VectorStore> extends BaseRetriever implements SelfQueryRetrieverArgs<T> {\n    static lc_name(): string;\n    get lc_namespace(): string[];\n    vectorStore: T;\n    queryConstructor: RunnableInterface<{\n        query: string;\n    }, StructuredQuery>;\n    verbose?: boolean;\n    structuredQueryTranslator: BaseTranslator<T>;\n    useOriginalQuery: boolean;\n    searchParams?: {\n        k?: number;\n        filter?: T[\"FilterType\"];\n        mergeFiltersOperator?: \"or\" | \"and\" | \"replace\";\n        forceDefaultFilter?: boolean;\n    };\n    constructor(options: SelfQueryRetrieverArgs<T>);\n    _getRelevantDocuments(query: string, runManager?: CallbackManagerForRetrieverRun): Promise<Document<Record<string, unknown>>[]>;\n    /**\n     * Static method to create a new SelfQueryRetriever instance from a\n     * BaseLanguageModel and a VectorStore. It first loads a query constructor\n     * chain using the loadQueryConstructorChain function, then creates a new\n     * SelfQueryRetriever instance with the loaded chain and the provided\n     * options.\n     * @param options The options used to create the SelfQueryRetriever instance. It includes the QueryConstructorChainOptions and all the SelfQueryRetrieverArgs except 'llmChain'.\n     * @returns A new instance of SelfQueryRetriever.\n     */\n    static fromLLM<T extends VectorStore>(options: QueryConstructorRunnableOptions & Omit<SelfQueryRetrieverArgs<T>, \"queryConstructor\">): SelfQueryRetriever<T>;\n}\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;AAaA;;;;AAE+BK,UAFdM,sBAEcN,CAAAA,UAFmBD,WAEnBC,CAAAA,SAFwCH,kBAExCG,CAAAA;EAGxBC,WAAAA,EAJUM,CAIVN;EAFeN,yBAAAA,EADSK,gBACTL,CADwBY,CACxBZ,CAAAA;EAOLY,gBAAAA,EAPKZ,iBAOLY,CAAAA;IAVsDV,KAAAA,EAAAA,MAAAA;EAAkB,CAAA,EAKlFI,eALkF,CAAA;EAiCpEO,OAAAA,CAAAA,EAAAA,OAAAA;EAA6BT,gBAAAA,CAAAA,EAAAA,OAAAA;EAAqEQ,YAAAA,CAAAA,EAAAA;IAGtGA,CAAAA,CAAAA,EAAAA,MAAAA;IAGVN,MAAAA,CAAAA,EA7BUM,CA6BVN,CAAAA,YAAAA,CAAAA;IAFeN,oBAAAA,CAAAA,EAAAA,IAAAA,GAAAA,KAAAA,GAAAA,SAAAA;IAIwBY,kBAAAA,CAAAA,EAAAA,OAAAA;EAAfP,CAAAA;;;;;;;;;;;;;;;;;AARuF;;;cAAjGQ,6BAA6BT,qBAAqBH,aAAAA,YAAyBU,uBAAuBC;;;eAGtGA;oBACKZ;;KAEfM;;6BAEwBD,iBAAeO;;;;aAI7BA;;;;uBAIQD,uBAAuBC;oDACML,iCAAiCQ,QAAQZ,SAASW;;;;;;;;;;2BAU3EV,sBAAsBI,kCAAkCQ,KAAKL,uBAAuBC,0BAA0BC,mBAAmBD"}

package/dist/retrievers/self_query/index.js

@@ -1,7 +1,7 @@
 import { __export } from "../../_virtual/rolldown_runtime.js";
 import { loadQueryConstructorRunnable } from "../../chains/query_constructor/index.js";
-import { BaseTranslator, BasicTranslator, FunctionalTranslator } from "@langchain/core/structured_query";
 import { BaseRetriever } from "@langchain/core/retrievers";
+import { BaseTranslator, BasicTranslator, FunctionalTranslator } from "@langchain/core/structured_query";
 
 //#region src/retrievers/self_query/index.ts
 var self_query_exports = {};