langchain 0.0.191 → 0.0.193

package/dist/cache/file_system.d.ts

@@ -0,0 +1,33 @@
+import { BaseCache, Generation } from "../schema/index.js";
+/**
+ * A cache that uses the local filesystem as the backing store.
+ * This is useful for local development and testing. But it is not recommended for production use.
+ */
+export declare class LocalFileCache extends BaseCache {
+    private cacheDir;
+    private constructor();
+    /**
+     * Create a new cache backed by the local filesystem.
+     * It ensures that the cache directory exists before returning.
+     * @param cacheDir
+     */
+    static create(cacheDir?: string): Promise<LocalFileCache>;
+    /**
+     * Retrieves data from the cache. It constructs a cache key from the given
+     * `prompt` and `llmKey`, and retrieves the corresponding value from the
+     * cache files.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @returns An array of Generations if found, null otherwise.
+     */
+    lookup(prompt: string, llmKey: string): Promise<any>;
+    /**
+     * Updates the cache with new data. It constructs a cache key from the
+     * given `prompt` and `llmKey`, and stores the `value` in a specific
+     * file in the cache directory.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @param generations The value to be stored in the cache.
+     */
+    update(prompt: string, llmKey: string, generations: Generation[]): Promise<void>;
+}

package/dist/cache/file_system.js

@@ -0,0 +1,66 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { BaseCache } from "../schema/index.js";
+import { getCacheKey, serializeGeneration, deserializeStoredGeneration, } from "./base.js";
+/**
+ * A cache that uses the local filesystem as the backing store.
+ * This is useful for local development and testing. But it is not recommended for production use.
+ */
+export class LocalFileCache extends BaseCache {
+    constructor(cacheDir) {
+        super();
+        Object.defineProperty(this, "cacheDir", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.cacheDir = cacheDir;
+    }
+    /**
+     * Create a new cache backed by the local filesystem.
+     * It ensures that the cache directory exists before returning.
+     * @param cacheDir
+     */
+    static async create(cacheDir) {
+        if (!cacheDir) {
+            // eslint-disable-next-line no-param-reassign
+            cacheDir = await fs.mkdtemp("langchain-cache-");
+        }
+        else {
+            // ensure the cache directory exists
+            await fs.mkdir(cacheDir, { recursive: true });
+        }
+        return new LocalFileCache(cacheDir);
+    }
+    /**
+     * Retrieves data from the cache. It constructs a cache key from the given
+     * `prompt` and `llmKey`, and retrieves the corresponding value from the
+     * cache files.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @returns An array of Generations if found, null otherwise.
+     */
+    async lookup(prompt, llmKey) {
+        const key = `${getCacheKey(prompt, llmKey)}.json`;
+        try {
+            const content = await fs.readFile(path.join(this.cacheDir, key));
+            return JSON.parse(content.toString()).map(deserializeStoredGeneration);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Updates the cache with new data. It constructs a cache key from the
+     * given `prompt` and `llmKey`, and stores the `value` in a specific
+     * file in the cache directory.
+     * @param prompt The prompt used to construct the cache key.
+     * @param llmKey The LLM key used to construct the cache key.
+     * @param generations The value to be stored in the cache.
+     */
+    async update(prompt, llmKey, generations) {
+        const key = `${getCacheKey(prompt, llmKey)}.json`;
+        await fs.writeFile(path.join(this.cacheDir, key), JSON.stringify(generations.map(serializeGeneration)));
+    }
+}

package/dist/cache/ioredis.cjs

@@ -5,6 +5,19 @@ const index_js_1 = require("../schema/index.cjs");
 const base_js_1 = require("./base.cjs");
 /**
  * Cache LLM results using Redis.
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({
+ *   cache: new RedisCache(new Redis(), { ttl: 60 }),
+ * });
+ *
+ * // Invoke the model with a prompt
+ * const response = await model.invoke("Do something random!");
+ * console.log(response);
+ *
+ * // Remember to disconnect the Redis client when done
+ * await redisClient.disconnect();
+ * ```
  */
 class RedisCache extends index_js_1.BaseCache {
     constructor(redisClient, config) {

package/dist/cache/ioredis.d.ts

@@ -2,6 +2,19 @@ import { Redis } from "ioredis";
 import { BaseCache, Generation } from "../schema/index.js";
 /**
  * Cache LLM results using Redis.
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({
+ *   cache: new RedisCache(new Redis(), { ttl: 60 }),
+ * });
+ *
+ * // Invoke the model with a prompt
+ * const response = await model.invoke("Do something random!");
+ * console.log(response);
+ *
+ * // Remember to disconnect the Redis client when done
+ * await redisClient.disconnect();
+ * ```
  */
 export declare class RedisCache extends BaseCache {
     protected redisClient: Redis;

package/dist/cache/ioredis.js

@@ -2,6 +2,19 @@ import { BaseCache } from "../schema/index.js";
 import { serializeGeneration, deserializeStoredGeneration, getCacheKey, } from "./base.js";
 /**
  * Cache LLM results using Redis.
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({
+ *   cache: new RedisCache(new Redis(), { ttl: 60 }),
+ * });
+ *
+ * // Invoke the model with a prompt
+ * const response = await model.invoke("Do something random!");
+ * console.log(response);
+ *
+ * // Remember to disconnect the Redis client when done
+ * await redisClient.disconnect();
+ * ```
  */
 export class RedisCache extends BaseCache {
     constructor(redisClient, config) {

package/dist/cache/momento.cjs

@@ -9,6 +9,25 @@ const momento_js_1 = require("../util/momento.cjs");
 /**
  * A cache that uses Momento as the backing store.
  * See https://gomomento.com.
+ * @example
+ * ```typescript
+ * const cache = new MomentoCache({
+ *   client: new CacheClient({
+ *     configuration: Configurations.Laptop.v1(),
+ *     credentialProvider: CredentialProvider.fromEnvironmentVariable({
+ *       environmentVariableName: "MOMENTO_API_KEY",
+ *     }),
+ *     defaultTtlSeconds: 60 * 60 * 24, // Cache TTL set to 24 hours.
+ *   }),
+ *   cacheName: "langchain",
+ * });
+ * // Initialize the OpenAI model with Momento cache for caching responses
+ * const model = new ChatOpenAI({
+ *   cache,
+ * });
+ * await model.invoke("How are you today?");
+ * const cachedValues = await cache.lookup("How are you today?", "llmKey");
+ * ```
  */
 class MomentoCache extends index_js_1.BaseCache {
     constructor(props) {

package/dist/cache/momento.d.ts

@@ -27,6 +27,25 @@ export interface MomentoCacheProps {
 /**
  * A cache that uses Momento as the backing store.
  * See https://gomomento.com.
+ * @example
+ * ```typescript
+ * const cache = new MomentoCache({
+ *   client: new CacheClient({
+ *     configuration: Configurations.Laptop.v1(),
+ *     credentialProvider: CredentialProvider.fromEnvironmentVariable({
+ *       environmentVariableName: "MOMENTO_API_KEY",
+ *     }),
+ *     defaultTtlSeconds: 60 * 60 * 24, // Cache TTL set to 24 hours.
+ *   }),
+ *   cacheName: "langchain",
+ * });
+ * // Initialize the OpenAI model with Momento cache for caching responses
+ * const model = new ChatOpenAI({
+ *   cache,
+ * });
+ * await model.invoke("How are you today?");
+ * const cachedValues = await cache.lookup("How are you today?", "llmKey");
+ * ```
  */
 export declare class MomentoCache extends BaseCache {
     private client;

package/dist/cache/momento.js

@@ -6,6 +6,25 @@ import { ensureCacheExists } from "../util/momento.js";
 /**
  * A cache that uses Momento as the backing store.
  * See https://gomomento.com.
+ * @example
+ * ```typescript
+ * const cache = new MomentoCache({
+ *   client: new CacheClient({
+ *     configuration: Configurations.Laptop.v1(),
+ *     credentialProvider: CredentialProvider.fromEnvironmentVariable({
+ *       environmentVariableName: "MOMENTO_API_KEY",
+ *     }),
+ *     defaultTtlSeconds: 60 * 60 * 24, // Cache TTL set to 24 hours.
+ *   }),
+ *   cacheName: "langchain",
+ * });
+ * // Initialize the OpenAI model with Momento cache for caching responses
+ * const model = new ChatOpenAI({
+ *   cache,
+ * });
+ * await model.invoke("How are you today?");
+ * const cachedValues = await cache.lookup("How are you today?", "llmKey");
+ * ```
  */
 export class MomentoCache extends BaseCache {
     constructor(props) {

package/dist/cache/redis.cjs

@@ -7,6 +7,16 @@ const base_js_1 = require("./base.cjs");
  * Represents a specific implementation of a caching mechanism using Redis
  * as the underlying storage system. It extends the `BaseCache` class and
  * overrides its methods to provide the Redis-specific logic.
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({
+ * cache: new RedisCache(new Redis(), { ttl: 60 }),
+ * });
+ *
+ * // Invoke the model to perform an action
+ * const response = await model.invoke("Do something random!");
+ * console.log(response);
+ * ```
  */
 class RedisCache extends index_js_1.BaseCache {
     constructor(redisClient) {

package/dist/cache/redis.d.ts

@@ -9,6 +9,16 @@ type RedisClientType = ReturnType<typeof createClient> | ReturnType<typeof creat
  * Represents a specific implementation of a caching mechanism using Redis
  * as the underlying storage system. It extends the `BaseCache` class and
  * overrides its methods to provide the Redis-specific logic.
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({
+ * cache: new RedisCache(new Redis(), { ttl: 60 }),
+ * });
+ *
+ * // Invoke the model to perform an action
+ * const response = await model.invoke("Do something random!");
+ * console.log(response);
+ * ```
  */
 export declare class RedisCache extends BaseCache {
     private redisClient;

package/dist/cache/redis.js

@@ -4,6 +4,16 @@ import { deserializeStoredGeneration, getCacheKey, serializeGeneration, } from "
  * Represents a specific implementation of a caching mechanism using Redis
  * as the underlying storage system. It extends the `BaseCache` class and
  * overrides its methods to provide the Redis-specific logic.
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({
+ * cache: new RedisCache(new Redis(), { ttl: 60 }),
+ * });
+ *
+ * // Invoke the model to perform an action
+ * const response = await model.invoke("Do something random!");
+ * console.log(response);
+ * ```
  */
 export class RedisCache extends BaseCache {
     constructor(redisClient) {

package/dist/cache/upstash_redis.cjs

@@ -7,6 +7,21 @@ const base_js_1 = require("./base.cjs");
 /**
  * A cache that uses Upstash as the backing store.
  * See https://docs.upstash.com/redis.
+ * @example
+ * ```typescript
+ * const cache = new UpstashRedisCache({
+ *   config: {
+ *     url: "UPSTASH_REDIS_REST_URL",
+ *     token: "UPSTASH_REDIS_REST_TOKEN",
+ *   },
+ * });
+ * // Initialize the OpenAI model with Upstash Redis cache for caching responses
+ * const model = new ChatOpenAI({
+ *   cache,
+ * });
+ * await model.invoke("How are you today?");
+ * const cachedValues = await cache.lookup("How are you today?", "llmKey");
+ * ```
  */
 class UpstashRedisCache extends index_js_1.BaseCache {
     constructor(props) {

package/dist/cache/upstash_redis.d.ts

@@ -13,6 +13,21 @@ export type UpstashRedisCacheProps = {
 /**
  * A cache that uses Upstash as the backing store.
  * See https://docs.upstash.com/redis.
+ * @example
+ * ```typescript
+ * const cache = new UpstashRedisCache({
+ *   config: {
+ *     url: "UPSTASH_REDIS_REST_URL",
+ *     token: "UPSTASH_REDIS_REST_TOKEN",
+ *   },
+ * });
+ * // Initialize the OpenAI model with Upstash Redis cache for caching responses
+ * const model = new ChatOpenAI({
+ *   cache,
+ * });
+ * await model.invoke("How are you today?");
+ * const cachedValues = await cache.lookup("How are you today?", "llmKey");
+ * ```
  */
 export declare class UpstashRedisCache extends BaseCache {
     private redisClient;

package/dist/cache/upstash_redis.js

@@ -4,6 +4,21 @@ import { deserializeStoredGeneration, getCacheKey, serializeGeneration, } from "
 /**
  * A cache that uses Upstash as the backing store.
  * See https://docs.upstash.com/redis.
+ * @example
+ * ```typescript
+ * const cache = new UpstashRedisCache({
+ *   config: {
+ *     url: "UPSTASH_REDIS_REST_URL",
+ *     token: "UPSTASH_REDIS_REST_TOKEN",
+ *   },
+ * });
+ * // Initialize the OpenAI model with Upstash Redis cache for caching responses
+ * const model = new ChatOpenAI({
+ *   cache,
+ * });
+ * await model.invoke("How are you today?");
+ * const cachedValues = await cache.lookup("How are you today?", "llmKey");
+ * ```
  */
 export class UpstashRedisCache extends BaseCache {
     constructor(props) {

package/dist/callbacks/handlers/console.cjs

@@ -31,6 +31,16 @@ const { color } = ansi_styles_1.default;
  * A tracer that logs all events to the console. It extends from the
  * `BaseTracer` class and overrides its methods to provide custom logging
  * functionality.
+ * @example
+ * ```typescript
+ *
+ * const llm = new ChatAnthropic({
+ *   temperature: 0,
+ *   tags: ["example", "callbacks", "constructor"],
+ *   callbacks: [new ConsoleCallbackHandler()],
+ * });
+ *
+ * ```
  */
 class ConsoleCallbackHandler extends tracer_js_1.BaseTracer {
     constructor() {

package/dist/callbacks/handlers/console.d.ts

@@ -3,6 +3,16 @@ import { BaseTracer, Run } from "./tracer.js";
  * A tracer that logs all events to the console. It extends from the
  * `BaseTracer` class and overrides its methods to provide custom logging
  * functionality.
+ * @example
+ * ```typescript
+ *
+ * const llm = new ChatAnthropic({
+ *   temperature: 0,
+ *   tags: ["example", "callbacks", "constructor"],
+ *   callbacks: [new ConsoleCallbackHandler()],
+ * });
+ *
+ * ```
  */
 export declare class ConsoleCallbackHandler extends BaseTracer {
     name: "console_callback_handler";

package/dist/callbacks/handlers/console.js

@@ -25,6 +25,16 @@ const { color } = styles;
  * A tracer that logs all events to the console. It extends from the
  * `BaseTracer` class and overrides its methods to provide custom logging
  * functionality.
+ * @example
+ * ```typescript
+ *
+ * const llm = new ChatAnthropic({
+ *   temperature: 0,
+ *   tags: ["example", "callbacks", "constructor"],
+ *   callbacks: [new ConsoleCallbackHandler()],
+ * });
+ *
+ * ```
  */
 export class ConsoleCallbackHandler extends BaseTracer {
     constructor() {

package/dist/callbacks/manager.cjs

@@ -275,6 +275,24 @@ class CallbackManagerForToolRun extends BaseRunManager {
     }
 }
 exports.CallbackManagerForToolRun = CallbackManagerForToolRun;
+/**
+ * @example
+ * ```typescript
+ * const prompt = PromptTemplate.fromTemplate("What is the answer to {question}?");
+ *
+ * // Example of using LLMChain with OpenAI and a simple prompt
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ * });
+ *
+ * // Running the chain with a single question
+ * const result = await chain.call({
+ *   question: "What is the airspeed velocity of an unladen swallow?",
+ * });
+ * console.log("The answer is:", result);
+ * ```
+ */
 class CallbackManager extends BaseCallbackManager {
     constructor(parentRunId) {
         super();
@@ -552,6 +570,37 @@ function ensureHandler(handler) {
     }
     return base_js_1.BaseCallbackHandler.fromMethods(handler);
 }
+/**
+ * @example
+ * ```typescript
+ * const prompt = PromptTemplate.fromTemplate(`What is the answer to {question}?`);
+ *
+ * // Example of using LLMChain to process a series of questions
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ * });
+ *
+ * // Process questions using the chain
+ * const processQuestions = async (questions) => {
+ *   for (const question of questions) {
+ *     const result = await chain.call({ question });
+ *     console.log(result);
+ *   }
+ * };
+ *
+ * // Example questions
+ * const questions = [
+ *   "What is your name?",
+ *   "What is your quest?",
+ *   "What is your favorite color?",
+ * ];
+ *
+ * // Run the example
+ * processQuestions(questions).catch(console.error);
+ *
+ * ```
+ */
 class TraceGroup {
     constructor(groupName, options) {
         Object.defineProperty(this, "groupName", {

package/dist/callbacks/manager.d.ts

@@ -86,6 +86,24 @@ export declare class CallbackManagerForToolRun extends BaseRunManager implements
     handleToolError(err: Error | unknown): Promise<void>;
     handleToolEnd(output: string): Promise<void>;
 }
+/**
+ * @example
+ * ```typescript
+ * const prompt = PromptTemplate.fromTemplate("What is the answer to {question}?");
+ *
+ * // Example of using LLMChain with OpenAI and a simple prompt
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ * });
+ *
+ * // Running the chain with a single question
+ * const result = await chain.call({
+ *   question: "What is the airspeed velocity of an unladen swallow?",
+ * });
+ * console.log("The answer is:", result);
+ * ```
+ */
 export declare class CallbackManager extends BaseCallbackManager implements BaseCallbackManagerMethods {
     handlers: BaseCallbackHandler[];
     inheritableHandlers: BaseCallbackHandler[];
@@ -112,6 +130,37 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
     static fromHandlers(handlers: CallbackHandlerMethods): CallbackManager;
     static configure(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): Promise<CallbackManager | undefined>;
 }
+/**
+ * @example
+ * ```typescript
+ * const prompt = PromptTemplate.fromTemplate(`What is the answer to {question}?`);
+ *
+ * // Example of using LLMChain to process a series of questions
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ * });
+ *
+ * // Process questions using the chain
+ * const processQuestions = async (questions) => {
+ *   for (const question of questions) {
+ *     const result = await chain.call({ question });
+ *     console.log(result);
+ *   }
+ * };
+ *
+ * // Example questions
+ * const questions = [
+ *   "What is your name?",
+ *   "What is your quest?",
+ *   "What is your favorite color?",
+ * ];
+ *
+ * // Run the example
+ * processQuestions(questions).catch(console.error);
+ *
+ * ```
+ */
 export declare class TraceGroup {
     private groupName;
     private options?;

package/dist/callbacks/manager.js

@@ -266,6 +266,24 @@ export class CallbackManagerForToolRun extends BaseRunManager {
         }, handler.awaitHandlers)));
     }
 }
+/**
+ * @example
+ * ```typescript
+ * const prompt = PromptTemplate.fromTemplate("What is the answer to {question}?");
+ *
+ * // Example of using LLMChain with OpenAI and a simple prompt
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ * });
+ *
+ * // Running the chain with a single question
+ * const result = await chain.call({
+ *   question: "What is the airspeed velocity of an unladen swallow?",
+ * });
+ * console.log("The answer is:", result);
+ * ```
+ */
 export class CallbackManager extends BaseCallbackManager {
     constructor(parentRunId) {
         super();
@@ -542,6 +560,37 @@ function ensureHandler(handler) {
     }
     return BaseCallbackHandler.fromMethods(handler);
 }
+/**
+ * @example
+ * ```typescript
+ * const prompt = PromptTemplate.fromTemplate(`What is the answer to {question}?`);
+ *
+ * // Example of using LLMChain to process a series of questions
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ * });
+ *
+ * // Process questions using the chain
+ * const processQuestions = async (questions) => {
+ *   for (const question of questions) {
+ *     const result = await chain.call({ question });
+ *     console.log(result);
+ *   }
+ * };
+ *
+ * // Example questions
+ * const questions = [
+ *   "What is your name?",
+ *   "What is your quest?",
+ *   "What is your favorite color?",
+ * ];
+ *
+ * // Run the example
+ * processQuestions(questions).catch(console.error);
+ *
+ * ```
+ */
 export class TraceGroup {
     constructor(groupName, options) {
         Object.defineProperty(this, "groupName", {

package/dist/chains/analyze_documents_chain.cjs

@@ -7,6 +7,24 @@ const text_splitter_js_1 = require("../text_splitter.cjs");
  * Chain that combines documents by stuffing into context.
  * @augments BaseChain
  * @augments StuffDocumentsChainInput
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({ temperature: 0 });
+ * const combineDocsChain = loadSummarizationChain(model);
+ * const chain = new AnalyzeDocumentChain({
+ *   combineDocumentsChain: combineDocsChain,
+ * });
+ *
+ * // Read the text from a file (this is a placeholder for actual file reading)
+ * const text = readTextFromFile("state_of_the_union.txt");
+ *
+ * // Invoke the chain to analyze the document
+ * const res = await chain.call({
+ *   input_document: text,
+ * });
+ *
+ * console.log({ res });
+ * ```
  */
 class AnalyzeDocumentChain extends base_js_1.BaseChain {
     static lc_name() {

package/dist/chains/analyze_documents_chain.d.ts

@@ -17,6 +17,24 @@ export interface AnalyzeDocumentChainInput extends Omit<ChainInputs, "memory"> {
  * Chain that combines documents by stuffing into context.
  * @augments BaseChain
  * @augments StuffDocumentsChainInput
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({ temperature: 0 });
+ * const combineDocsChain = loadSummarizationChain(model);
+ * const chain = new AnalyzeDocumentChain({
+ *   combineDocumentsChain: combineDocsChain,
+ * });
+ *
+ * // Read the text from a file (this is a placeholder for actual file reading)
+ * const text = readTextFromFile("state_of_the_union.txt");
+ *
+ * // Invoke the chain to analyze the document
+ * const res = await chain.call({
+ *   input_document: text,
+ * });
+ *
+ * console.log({ res });
+ * ```
  */
 export declare class AnalyzeDocumentChain extends BaseChain implements AnalyzeDocumentChainInput {
     static lc_name(): string;