langchain 1.0.3 → 1.0.4

package/dist/embeddings/cache_backed.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache_backed.cjs","names":["Embeddings","fields: CacheBackedEmbeddingsFields","document: string","documents: string[]","keyValuePairs: [string, number[]][]","underlyingEmbeddings: EmbeddingsInterface","documentEmbeddingStore: BaseStore<string, Uint8Array>","options?: {\n      namespace?: string;\n    }","EncoderBackedStore"],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { sha256 } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors = await this.underlyingEmbeddings.embedDocuments(\n        missingDocuments\n      );\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + sha256(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2CA,uCAAW;CACpD,AAAU;CAEV,AAAU;CAEV,YAAYC,QAAqC;EAC/C,MAAM,OAAO;EACb,KAAK,uBAAuB,OAAO;EACnC,KAAK,yBAAyB,OAAO;CACtC;;;;;;;;;;;;;;;;CAiBD,MAAM,WAAWC,UAAqC;AACpD,SAAO,KAAK,qBAAqB,WAAW,SAAS;CACtD;;;;;;;;;;;CAYD,MAAM,eAAeC,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,UAAU;EACjE,MAAM,kBAAkB,CAAE;EAC1B,MAAM,mBAAmB,CAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,EACvC,KAAI,QAAQ,OAAO,QAAW;GAC5B,gBAAgB,KAAK,EAAE;GACvB,iBAAiB,KAAK,UAAU,GAAG;EACpC;AAEH,MAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBAAiB,MAAM,KAAK,qBAAqB,eACrD,iBACD;GACD,MAAMC,gBAAsC,iBAAiB,IAC3D,CAAC,UAAU,MAAM,CAAC,UAAU,eAAe,EAAG,EAC/C;GACD,MAAM,KAAK,uBAAuB,KAAK,cAAc;AACrD,QAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,GAC/C,QAAQ,gBAAgB,MAAM,eAAe;EAEhD;AACD,SAAO;CACR;;;;;;;;;CAUD,OAAO,eACLC,sBACAC,wBACAC,SAGA;EACA,MAAM,UAAU,IAAI;EACpB,MAAM,UAAU,IAAI;EACpB,MAAM,qBAAqB,IAAIC,kDAI7B;GACA,OAAO;GACP,YAAY,CAAC,SAAS,SAAS,aAAa,8CAAa,IAAI;GAC7D,iBAAiB,CAAC,UAAU,QAAQ,OAAO,KAAK,UAAU,MAAM,CAAC;GACjE,mBAAmB,CAAC,oBAClB,KAAK,MAAM,QAAQ,OAAO,gBAAgB,CAAC;EAC9C;AACD,SAAO,IAAI,KAAK;GACd;GACA,wBAAwB;EACzB;CACF;AACF"}

package/dist/embeddings/cache_backed.d.cts

@@ -1,107 +0,0 @@
-import { Embeddings, EmbeddingsInterface } from "@langchain/core/embeddings";
-import { BaseStore } from "@langchain/core/stores";
-import { AsyncCallerParams } from "@langchain/core/utils/async_caller";
-
-//#region src/embeddings/cache_backed.d.ts
-
-/**
- * Interface for the fields required to initialize an instance of the
- * CacheBackedEmbeddings class.
- */
-interface CacheBackedEmbeddingsFields extends AsyncCallerParams {
-  underlyingEmbeddings: EmbeddingsInterface;
-  documentEmbeddingStore: BaseStore<string, number[]>;
-}
-/**
- * Interface for caching results from embedding models.
- *
- * The interface allows works with any store that implements
- * the abstract store interface accepting keys of type str and values of list of
- * floats.
- *
- * If need be, the interface can be extended to accept other implementations
- * of the value serializer and deserializer, as well as the key encoder.
- * @example
- * ```typescript
- * const underlyingEmbeddings = new OpenAIEmbeddings();
- *
- * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(
- *   underlyingEmbeddings,
- *   new ConvexKVStore({ ctx }),
- *   {
- *     namespace: underlyingEmbeddings.modelName,
- *   },
- * );
- *
- * const loader = new TextLoader("./state_of_the_union.txt");
- * const rawDocuments = await loader.load();
- * const splitter = new RecursiveCharacterTextSplitter({
- *   chunkSize: 1000,
- *   chunkOverlap: 0,
- * });
- * const documents = await splitter.splitDocuments(rawDocuments);
- *
- * let time = Date.now();
- * const vectorstore = await ConvexVectorStore.fromDocuments(
- *   documents,
- *   cacheBackedEmbeddings,
- *   { ctx },
- * );
- * console.log(`Initial creation time: ${Date.now() - time}ms`);
- *
- * time = Date.now();
- * const vectorstore2 = await ConvexVectorStore.fromDocuments(
- *   documents,
- *   cacheBackedEmbeddings,
- *   { ctx },
- * );
- * console.log(`Cached creation time: ${Date.now() - time}ms`);
- *
- * ```
- */
-declare class CacheBackedEmbeddings extends Embeddings {
-  protected underlyingEmbeddings: EmbeddingsInterface;
-  protected documentEmbeddingStore: BaseStore<string, number[]>;
-  constructor(fields: CacheBackedEmbeddingsFields);
-  /**
-   * Embed query text.
-   *
-   * This method does not support caching at the moment.
-   *
-   * Support for caching queries is easy to implement, but might make
-   * sense to hold off to see the most common patterns.
-   *
-   * If the cache has an eviction policy, we may need to be a bit more careful
-   * about sharing the cache between documents and queries. Generally,
-   * one is OK evicting query caches, but document caches should be kept.
-   *
-   * @param document The text to embed.
-   * @returns The embedding for the given text.
-   */
-  embedQuery(document: string): Promise<number[]>;
-  /**
-   * Embed a list of texts.
-   *
-   * The method first checks the cache for the embeddings.
-   * If the embeddings are not found, the method uses the underlying embedder
-   * to embed the documents and stores the results in the cache.
-   *
-   * @param documents
-   * @returns A list of embeddings for the given texts.
-   */
-  embedDocuments(documents: string[]): Promise<number[][]>;
-  /**
-   * Create a new CacheBackedEmbeddings instance from another embeddings instance
-   * and a storage instance.
-   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.
-   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.
-   * @param options.namespace Optional namespace for store keys.
-   * @returns A new CacheBackedEmbeddings instance.
-   */
-  static fromBytesStore(underlyingEmbeddings: EmbeddingsInterface, documentEmbeddingStore: BaseStore<string, Uint8Array>, options?: {
-    namespace?: string;
-  }): CacheBackedEmbeddings;
-}
-//#endregion
-export { CacheBackedEmbeddings, CacheBackedEmbeddingsFields };
-//# sourceMappingURL=cache_backed.d.cts.map

package/dist/embeddings/cache_backed.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache_backed.d.cts","names":["EmbeddingsInterface","Embeddings","BaseStore","AsyncCallerParams","CacheBackedEmbeddingsFields","CacheBackedEmbeddings","Promise","Uint8Array"],"sources":["../../src/embeddings/cache_backed.d.ts"],"sourcesContent":["import { type EmbeddingsInterface, Embeddings } from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n    underlyingEmbeddings: EmbeddingsInterface;\n    documentEmbeddingStore: BaseStore<string, number[]>;\n}\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport declare class CacheBackedEmbeddings extends Embeddings {\n    protected underlyingEmbeddings: EmbeddingsInterface;\n    protected documentEmbeddingStore: BaseStore<string, number[]>;\n    constructor(fields: CacheBackedEmbeddingsFields);\n    /**\n     * Embed query text.\n     *\n     * This method does not support caching at the moment.\n     *\n     * Support for caching queries is easy to implement, but might make\n     * sense to hold off to see the most common patterns.\n     *\n     * If the cache has an eviction policy, we may need to be a bit more careful\n     * about sharing the cache between documents and queries. Generally,\n     * one is OK evicting query caches, but document caches should be kept.\n     *\n     * @param document The text to embed.\n     * @returns The embedding for the given text.\n     */\n    embedQuery(document: string): Promise<number[]>;\n    /**\n     * Embed a list of texts.\n     *\n     * The method first checks the cache for the embeddings.\n     * If the embeddings are not found, the method uses the underlying embedder\n     * to embed the documents and stores the results in the cache.\n     *\n     * @param documents\n     * @returns A list of embeddings for the given texts.\n     */\n    embedDocuments(documents: string[]): Promise<number[][]>;\n    /**\n     * Create a new CacheBackedEmbeddings instance from another embeddings instance\n     * and a storage instance.\n     * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n     * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n     * @param options.namespace Optional namespace for store keys.\n     * @returns A new CacheBackedEmbeddings instance.\n     */\n    static fromBytesStore(underlyingEmbeddings: EmbeddingsInterface, documentEmbeddingStore: BaseStore<string, Uint8Array>, options?: {\n        namespace?: string;\n    }): CacheBackedEmbeddings;\n}\n"],"mappings":";;;;;;;;AAOA;;AAC0BA,UADTI,2BAAAA,SAAoCD,iBAC3BH,CAAAA;EAAmB,oBACjBE,EADFF,mBACEE;EAAS,sBAFgBC,EAEzBD,SAFyBC,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,CAAAA;AAAiB;AAmDtE;;;;;;;;;;;;AAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAxCE,qBAAAA,SAA8BJ,UAAAA;kCACfD;oCACEE;sBACdE;;;;;;;;;;;;;;;;gCAgBUE;;;;;;;;;;;uCAWOA;;;;;;;;;8CASON,6CAA6CE,kBAAkBK;;MAEvGF"}

package/dist/embeddings/cache_backed.d.ts

@@ -1,107 +0,0 @@
-import { BaseStore } from "@langchain/core/stores";
-import { Embeddings, EmbeddingsInterface } from "@langchain/core/embeddings";
-import { AsyncCallerParams } from "@langchain/core/utils/async_caller";
-
-//#region src/embeddings/cache_backed.d.ts
-
-/**
- * Interface for the fields required to initialize an instance of the
- * CacheBackedEmbeddings class.
- */
-interface CacheBackedEmbeddingsFields extends AsyncCallerParams {
-  underlyingEmbeddings: EmbeddingsInterface;
-  documentEmbeddingStore: BaseStore<string, number[]>;
-}
-/**
- * Interface for caching results from embedding models.
- *
- * The interface allows works with any store that implements
- * the abstract store interface accepting keys of type str and values of list of
- * floats.
- *
- * If need be, the interface can be extended to accept other implementations
- * of the value serializer and deserializer, as well as the key encoder.
- * @example
- * ```typescript
- * const underlyingEmbeddings = new OpenAIEmbeddings();
- *
- * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(
- *   underlyingEmbeddings,
- *   new ConvexKVStore({ ctx }),
- *   {
- *     namespace: underlyingEmbeddings.modelName,
- *   },
- * );
- *
- * const loader = new TextLoader("./state_of_the_union.txt");
- * const rawDocuments = await loader.load();
- * const splitter = new RecursiveCharacterTextSplitter({
- *   chunkSize: 1000,
- *   chunkOverlap: 0,
- * });
- * const documents = await splitter.splitDocuments(rawDocuments);
- *
- * let time = Date.now();
- * const vectorstore = await ConvexVectorStore.fromDocuments(
- *   documents,
- *   cacheBackedEmbeddings,
- *   { ctx },
- * );
- * console.log(`Initial creation time: ${Date.now() - time}ms`);
- *
- * time = Date.now();
- * const vectorstore2 = await ConvexVectorStore.fromDocuments(
- *   documents,
- *   cacheBackedEmbeddings,
- *   { ctx },
- * );
- * console.log(`Cached creation time: ${Date.now() - time}ms`);
- *
- * ```
- */
-declare class CacheBackedEmbeddings extends Embeddings {
-  protected underlyingEmbeddings: EmbeddingsInterface;
-  protected documentEmbeddingStore: BaseStore<string, number[]>;
-  constructor(fields: CacheBackedEmbeddingsFields);
-  /**
-   * Embed query text.
-   *
-   * This method does not support caching at the moment.
-   *
-   * Support for caching queries is easy to implement, but might make
-   * sense to hold off to see the most common patterns.
-   *
-   * If the cache has an eviction policy, we may need to be a bit more careful
-   * about sharing the cache between documents and queries. Generally,
-   * one is OK evicting query caches, but document caches should be kept.
-   *
-   * @param document The text to embed.
-   * @returns The embedding for the given text.
-   */
-  embedQuery(document: string): Promise<number[]>;
-  /**
-   * Embed a list of texts.
-   *
-   * The method first checks the cache for the embeddings.
-   * If the embeddings are not found, the method uses the underlying embedder
-   * to embed the documents and stores the results in the cache.
-   *
-   * @param documents
-   * @returns A list of embeddings for the given texts.
-   */
-  embedDocuments(documents: string[]): Promise<number[][]>;
-  /**
-   * Create a new CacheBackedEmbeddings instance from another embeddings instance
-   * and a storage instance.
-   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.
-   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.
-   * @param options.namespace Optional namespace for store keys.
-   * @returns A new CacheBackedEmbeddings instance.
-   */
-  static fromBytesStore(underlyingEmbeddings: EmbeddingsInterface, documentEmbeddingStore: BaseStore<string, Uint8Array>, options?: {
-    namespace?: string;
-  }): CacheBackedEmbeddings;
-}
-//#endregion
-export { CacheBackedEmbeddings, CacheBackedEmbeddingsFields };
-//# sourceMappingURL=cache_backed.d.ts.map

package/dist/embeddings/cache_backed.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache_backed.d.ts","names":["EmbeddingsInterface","Embeddings","BaseStore","AsyncCallerParams","CacheBackedEmbeddingsFields","CacheBackedEmbeddings","Promise","Uint8Array"],"sources":["../../src/embeddings/cache_backed.d.ts"],"sourcesContent":["import { type EmbeddingsInterface, Embeddings } from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n    underlyingEmbeddings: EmbeddingsInterface;\n    documentEmbeddingStore: BaseStore<string, number[]>;\n}\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport declare class CacheBackedEmbeddings extends Embeddings {\n    protected underlyingEmbeddings: EmbeddingsInterface;\n    protected documentEmbeddingStore: BaseStore<string, number[]>;\n    constructor(fields: CacheBackedEmbeddingsFields);\n    /**\n     * Embed query text.\n     *\n     * This method does not support caching at the moment.\n     *\n     * Support for caching queries is easy to implement, but might make\n     * sense to hold off to see the most common patterns.\n     *\n     * If the cache has an eviction policy, we may need to be a bit more careful\n     * about sharing the cache between documents and queries. Generally,\n     * one is OK evicting query caches, but document caches should be kept.\n     *\n     * @param document The text to embed.\n     * @returns The embedding for the given text.\n     */\n    embedQuery(document: string): Promise<number[]>;\n    /**\n     * Embed a list of texts.\n     *\n     * The method first checks the cache for the embeddings.\n     * If the embeddings are not found, the method uses the underlying embedder\n     * to embed the documents and stores the results in the cache.\n     *\n     * @param documents\n     * @returns A list of embeddings for the given texts.\n     */\n    embedDocuments(documents: string[]): Promise<number[][]>;\n    /**\n     * Create a new CacheBackedEmbeddings instance from another embeddings instance\n     * and a storage instance.\n     * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n     * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n     * @param options.namespace Optional namespace for store keys.\n     * @returns A new CacheBackedEmbeddings instance.\n     */\n    static fromBytesStore(underlyingEmbeddings: EmbeddingsInterface, documentEmbeddingStore: BaseStore<string, Uint8Array>, options?: {\n        namespace?: string;\n    }): CacheBackedEmbeddings;\n}\n"],"mappings":";;;;;;;;AAOA;;AAC0BA,UADTI,2BAAAA,SAAoCD,iBAC3BH,CAAAA;EAAmB,oBACjBE,EADFF,mBACEE;EAAS,sBAFgBC,EAEzBD,SAFyBC,CAAAA,MAAAA,EAAAA,MAAAA,EAAAA,CAAAA;AAAiB;AAmDtE;;;;;;;;;;;;AAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAxCE,qBAAAA,SAA8BJ,UAAAA;kCACfD;oCACEE;sBACdE;;;;;;;;;;;;;;;;gCAgBUE;;;;;;;;;;;uCAWOA;;;;;;;;;8CASON,6CAA6CE,kBAAkBK;;MAEvGF"}

package/dist/embeddings/cache_backed.js

@@ -1,134 +0,0 @@
-import { __export } from "../_virtual/rolldown_runtime.js";
-import { EncoderBackedStore } from "../storage/encoder_backed.js";
-import { sha256 } from "@langchain/core/utils/hash";
-import { Embeddings } from "@langchain/core/embeddings";
-
-//#region src/embeddings/cache_backed.ts
-var cache_backed_exports = {};
-__export(cache_backed_exports, { CacheBackedEmbeddings: () => CacheBackedEmbeddings });
-/**
-* Interface for caching results from embedding models.
-*
-* The interface allows works with any store that implements
-* the abstract store interface accepting keys of type str and values of list of
-* floats.
-*
-* If need be, the interface can be extended to accept other implementations
-* of the value serializer and deserializer, as well as the key encoder.
-* @example
-* ```typescript
-* const underlyingEmbeddings = new OpenAIEmbeddings();
-*
-* const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(
-*   underlyingEmbeddings,
-*   new ConvexKVStore({ ctx }),
-*   {
-*     namespace: underlyingEmbeddings.modelName,
-*   },
-* );
-*
-* const loader = new TextLoader("./state_of_the_union.txt");
-* const rawDocuments = await loader.load();
-* const splitter = new RecursiveCharacterTextSplitter({
-*   chunkSize: 1000,
-*   chunkOverlap: 0,
-* });
-* const documents = await splitter.splitDocuments(rawDocuments);
-*
-* let time = Date.now();
-* const vectorstore = await ConvexVectorStore.fromDocuments(
-*   documents,
-*   cacheBackedEmbeddings,
-*   { ctx },
-* );
-* console.log(`Initial creation time: ${Date.now() - time}ms`);
-*
-* time = Date.now();
-* const vectorstore2 = await ConvexVectorStore.fromDocuments(
-*   documents,
-*   cacheBackedEmbeddings,
-*   { ctx },
-* );
-* console.log(`Cached creation time: ${Date.now() - time}ms`);
-*
-* ```
-*/
-var CacheBackedEmbeddings = class extends Embeddings {
-	underlyingEmbeddings;
-	documentEmbeddingStore;
-	constructor(fields) {
-		super(fields);
-		this.underlyingEmbeddings = fields.underlyingEmbeddings;
-		this.documentEmbeddingStore = fields.documentEmbeddingStore;
-	}
-	/**
-	* Embed query text.
-	*
-	* This method does not support caching at the moment.
-	*
-	* Support for caching queries is easy to implement, but might make
-	* sense to hold off to see the most common patterns.
-	*
-	* If the cache has an eviction policy, we may need to be a bit more careful
-	* about sharing the cache between documents and queries. Generally,
-	* one is OK evicting query caches, but document caches should be kept.
-	*
-	* @param document The text to embed.
-	* @returns The embedding for the given text.
-	*/
-	async embedQuery(document) {
-		return this.underlyingEmbeddings.embedQuery(document);
-	}
-	/**
-	* Embed a list of texts.
-	*
-	* The method first checks the cache for the embeddings.
-	* If the embeddings are not found, the method uses the underlying embedder
-	* to embed the documents and stores the results in the cache.
-	*
-	* @param documents
-	* @returns A list of embeddings for the given texts.
-	*/
-	async embedDocuments(documents) {
-		const vectors = await this.documentEmbeddingStore.mget(documents);
-		const missingIndicies = [];
-		const missingDocuments = [];
-		for (let i = 0; i < vectors.length; i += 1) if (vectors[i] === void 0) {
-			missingIndicies.push(i);
-			missingDocuments.push(documents[i]);
-		}
-		if (missingDocuments.length) {
-			const missingVectors = await this.underlyingEmbeddings.embedDocuments(missingDocuments);
-			const keyValuePairs = missingDocuments.map((document, i) => [document, missingVectors[i]]);
-			await this.documentEmbeddingStore.mset(keyValuePairs);
-			for (let i = 0; i < missingIndicies.length; i += 1) vectors[missingIndicies[i]] = missingVectors[i];
-		}
-		return vectors;
-	}
-	/**
-	* Create a new CacheBackedEmbeddings instance from another embeddings instance
-	* and a storage instance.
-	* @param underlyingEmbeddings Embeddings used to populate the cache for new documents.
-	* @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.
-	* @param options.namespace Optional namespace for store keys.
-	* @returns A new CacheBackedEmbeddings instance.
-	*/
-	static fromBytesStore(underlyingEmbeddings, documentEmbeddingStore, options) {
-		const encoder = new TextEncoder();
-		const decoder = new TextDecoder();
-		const encoderBackedStore = new EncoderBackedStore({
-			store: documentEmbeddingStore,
-			keyEncoder: (key) => (options?.namespace ?? "") + sha256(key),
-			valueSerializer: (value) => encoder.encode(JSON.stringify(value)),
-			valueDeserializer: (serializedValue) => JSON.parse(decoder.decode(serializedValue))
-		});
-		return new this({
-			underlyingEmbeddings,
-			documentEmbeddingStore: encoderBackedStore
-		});
-	}
-};
-
-//#endregion
-export { CacheBackedEmbeddings, cache_backed_exports };
-//# sourceMappingURL=cache_backed.js.map

package/dist/embeddings/cache_backed.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache_backed.js","names":["fields: CacheBackedEmbeddingsFields","document: string","documents: string[]","keyValuePairs: [string, number[]][]","underlyingEmbeddings: EmbeddingsInterface","documentEmbeddingStore: BaseStore<string, Uint8Array>","options?: {\n      namespace?: string;\n    }"],"sources":["../../src/embeddings/cache_backed.ts"],"sourcesContent":["import { sha256 } from \"@langchain/core/utils/hash\";\nimport {\n  type EmbeddingsInterface,\n  Embeddings,\n} from \"@langchain/core/embeddings\";\nimport { BaseStore } from \"@langchain/core/stores\";\n\nimport { AsyncCallerParams } from \"@langchain/core/utils/async_caller\";\nimport { EncoderBackedStore } from \"../storage/encoder_backed.js\";\n\n/**\n * Interface for the fields required to initialize an instance of the\n * CacheBackedEmbeddings class.\n */\nexport interface CacheBackedEmbeddingsFields extends AsyncCallerParams {\n  underlyingEmbeddings: EmbeddingsInterface;\n  documentEmbeddingStore: BaseStore<string, number[]>;\n}\n\n/**\n * Interface for caching results from embedding models.\n *\n * The interface allows works with any store that implements\n * the abstract store interface accepting keys of type str and values of list of\n * floats.\n *\n * If need be, the interface can be extended to accept other implementations\n * of the value serializer and deserializer, as well as the key encoder.\n * @example\n * ```typescript\n * const underlyingEmbeddings = new OpenAIEmbeddings();\n *\n * const cacheBackedEmbeddings = CacheBackedEmbeddings.fromBytesStore(\n *   underlyingEmbeddings,\n *   new ConvexKVStore({ ctx }),\n *   {\n *     namespace: underlyingEmbeddings.modelName,\n *   },\n * );\n *\n * const loader = new TextLoader(\"./state_of_the_union.txt\");\n * const rawDocuments = await loader.load();\n * const splitter = new RecursiveCharacterTextSplitter({\n *   chunkSize: 1000,\n *   chunkOverlap: 0,\n * });\n * const documents = await splitter.splitDocuments(rawDocuments);\n *\n * let time = Date.now();\n * const vectorstore = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Initial creation time: ${Date.now() - time}ms`);\n *\n * time = Date.now();\n * const vectorstore2 = await ConvexVectorStore.fromDocuments(\n *   documents,\n *   cacheBackedEmbeddings,\n *   { ctx },\n * );\n * console.log(`Cached creation time: ${Date.now() - time}ms`);\n *\n * ```\n */\nexport class CacheBackedEmbeddings extends Embeddings {\n  protected underlyingEmbeddings: EmbeddingsInterface;\n\n  protected documentEmbeddingStore: BaseStore<string, number[]>;\n\n  constructor(fields: CacheBackedEmbeddingsFields) {\n    super(fields);\n    this.underlyingEmbeddings = fields.underlyingEmbeddings;\n    this.documentEmbeddingStore = fields.documentEmbeddingStore;\n  }\n\n  /**\n   * Embed query text.\n   *\n   * This method does not support caching at the moment.\n   *\n   * Support for caching queries is easy to implement, but might make\n   * sense to hold off to see the most common patterns.\n   *\n   * If the cache has an eviction policy, we may need to be a bit more careful\n   * about sharing the cache between documents and queries. Generally,\n   * one is OK evicting query caches, but document caches should be kept.\n   *\n   * @param document The text to embed.\n   * @returns The embedding for the given text.\n   */\n  async embedQuery(document: string): Promise<number[]> {\n    return this.underlyingEmbeddings.embedQuery(document);\n  }\n\n  /**\n   * Embed a list of texts.\n   *\n   * The method first checks the cache for the embeddings.\n   * If the embeddings are not found, the method uses the underlying embedder\n   * to embed the documents and stores the results in the cache.\n   *\n   * @param documents\n   * @returns A list of embeddings for the given texts.\n   */\n  async embedDocuments(documents: string[]): Promise<number[][]> {\n    const vectors = await this.documentEmbeddingStore.mget(documents);\n    const missingIndicies = [];\n    const missingDocuments = [];\n    for (let i = 0; i < vectors.length; i += 1) {\n      if (vectors[i] === undefined) {\n        missingIndicies.push(i);\n        missingDocuments.push(documents[i]);\n      }\n    }\n    if (missingDocuments.length) {\n      const missingVectors = await this.underlyingEmbeddings.embedDocuments(\n        missingDocuments\n      );\n      const keyValuePairs: [string, number[]][] = missingDocuments.map(\n        (document, i) => [document, missingVectors[i]]\n      );\n      await this.documentEmbeddingStore.mset(keyValuePairs);\n      for (let i = 0; i < missingIndicies.length; i += 1) {\n        vectors[missingIndicies[i]] = missingVectors[i];\n      }\n    }\n    return vectors as number[][];\n  }\n\n  /**\n   * Create a new CacheBackedEmbeddings instance from another embeddings instance\n   * and a storage instance.\n   * @param underlyingEmbeddings Embeddings used to populate the cache for new documents.\n   * @param documentEmbeddingStore Stores raw document embedding values. Keys are hashes of the document content.\n   * @param options.namespace Optional namespace for store keys.\n   * @returns A new CacheBackedEmbeddings instance.\n   */\n  static fromBytesStore(\n    underlyingEmbeddings: EmbeddingsInterface,\n    documentEmbeddingStore: BaseStore<string, Uint8Array>,\n    options?: {\n      namespace?: string;\n    }\n  ) {\n    const encoder = new TextEncoder();\n    const decoder = new TextDecoder();\n    const encoderBackedStore = new EncoderBackedStore<\n      string,\n      number[],\n      Uint8Array\n    >({\n      store: documentEmbeddingStore,\n      keyEncoder: (key) => (options?.namespace ?? \"\") + sha256(key),\n      valueSerializer: (value) => encoder.encode(JSON.stringify(value)),\n      valueDeserializer: (serializedValue) =>\n        JSON.parse(decoder.decode(serializedValue)),\n    });\n    return new this({\n      underlyingEmbeddings,\n      documentEmbeddingStore: encoderBackedStore,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,IAAa,wBAAb,cAA2C,WAAW;CACpD,AAAU;CAEV,AAAU;CAEV,YAAYA,QAAqC;EAC/C,MAAM,OAAO;EACb,KAAK,uBAAuB,OAAO;EACnC,KAAK,yBAAyB,OAAO;CACtC;;;;;;;;;;;;;;;;CAiBD,MAAM,WAAWC,UAAqC;AACpD,SAAO,KAAK,qBAAqB,WAAW,SAAS;CACtD;;;;;;;;;;;CAYD,MAAM,eAAeC,WAA0C;EAC7D,MAAM,UAAU,MAAM,KAAK,uBAAuB,KAAK,UAAU;EACjE,MAAM,kBAAkB,CAAE;EAC1B,MAAM,mBAAmB,CAAE;AAC3B,OAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK,EACvC,KAAI,QAAQ,OAAO,QAAW;GAC5B,gBAAgB,KAAK,EAAE;GACvB,iBAAiB,KAAK,UAAU,GAAG;EACpC;AAEH,MAAI,iBAAiB,QAAQ;GAC3B,MAAM,iBAAiB,MAAM,KAAK,qBAAqB,eACrD,iBACD;GACD,MAAMC,gBAAsC,iBAAiB,IAC3D,CAAC,UAAU,MAAM,CAAC,UAAU,eAAe,EAAG,EAC/C;GACD,MAAM,KAAK,uBAAuB,KAAK,cAAc;AACrD,QAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK,GAC/C,QAAQ,gBAAgB,MAAM,eAAe;EAEhD;AACD,SAAO;CACR;;;;;;;;;CAUD,OAAO,eACLC,sBACAC,wBACAC,SAGA;EACA,MAAM,UAAU,IAAI;EACpB,MAAM,UAAU,IAAI;EACpB,MAAM,qBAAqB,IAAI,mBAI7B;GACA,OAAO;GACP,YAAY,CAAC,SAAS,SAAS,aAAa,MAAM,OAAO,IAAI;GAC7D,iBAAiB,CAAC,UAAU,QAAQ,OAAO,KAAK,UAAU,MAAM,CAAC;GACjE,mBAAmB,CAAC,oBAClB,KAAK,MAAM,QAAQ,OAAO,gBAAgB,CAAC;EAC9C;AACD,SAAO,IAAI,KAAK;GACd;GACA,wBAAwB;EACzB;CACF;AACF"}

package/dist/embeddings/fake.cjs

@@ -1,22 +0,0 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-
-//#region src/embeddings/fake.ts
-var fake_exports = {};
-require_rolldown_runtime.__reExport(fake_exports, require("@langchain/core/utils/testing"));
-
-//#endregion
-Object.defineProperty(exports, 'fake_exports', {
-  enumerable: true,
-  get: function () {
-    return fake_exports;
-  }
-});
-var __langchain_core_utils_testing = require("@langchain/core/utils/testing");
-Object.keys(__langchain_core_utils_testing).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return __langchain_core_utils_testing[k]; }
-  });
-});
-
-//# sourceMappingURL=fake.cjs.map

package/dist/embeddings/fake.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"fake.cjs","names":[],"sources":["../../src/embeddings/fake.ts"],"sourcesContent":["export * from \"@langchain/core/utils/testing\";\n"],"mappings":""}

package/dist/embeddings/fake.d.cts

@@ -1 +0,0 @@
-export * from "@langchain/core/utils/testing";

package/dist/embeddings/fake.d.ts

@@ -1 +0,0 @@
-export * from "@langchain/core/utils/testing";

package/dist/embeddings/fake.js

@@ -1,12 +0,0 @@
-import { __reExport } from "../_virtual/rolldown_runtime.js";
-
-export * from "@langchain/core/utils/testing"
-
-//#region src/embeddings/fake.ts
-var fake_exports = {};
-import * as import___langchain_core_utils_testing from "@langchain/core/utils/testing";
-__reExport(fake_exports, import___langchain_core_utils_testing);
-
-//#endregion
-export { fake_exports };
-//# sourceMappingURL=fake.js.map

package/dist/embeddings/fake.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fake.js","names":[],"sources":["../../src/embeddings/fake.ts"],"sourcesContent":["export * from \"@langchain/core/utils/testing\";\n"],"mappings":""}