langchain 0.0.131 → 0.0.132

package/dist/callbacks/handlers/console.js

@@ -21,6 +21,11 @@ function elapsed(run) {
     return `${(elapsed / 1000).toFixed(2)}s`;
 }
 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.
+ */
 export class ConsoleCallbackHandler extends BaseTracer {
     constructor() {
         super(...arguments);
@@ -31,10 +36,21 @@ export class ConsoleCallbackHandler extends BaseTracer {
             value: "console_callback_handler"
         });
     }
+    /**
+     * Method used to persist the run. In this case, it simply returns a
+     * resolved promise as there's no persistence logic.
+     * @param _run The run to persist.
+     * @returns A resolved promise.
+     */
     persistRun(_run) {
         return Promise.resolve();
     }
     // utility methods
+    /**
+     * Method used to get all the parent runs of a given run.
+     * @param run The run whose parents are to be retrieved.
+     * @returns An array of parent runs.
+     */
     getParents(run) {
         const parents = [];
         let currentRun = run;
@@ -50,6 +66,12 @@ export class ConsoleCallbackHandler extends BaseTracer {
         }
         return parents;
     }
+    /**
+     * Method used to get a string representation of the run's lineage, which
+     * is used in logging.
+     * @param run The run whose lineage is to be retrieved.
+     * @returns A string representation of the run's lineage.
+     */
     getBreadcrumbs(run) {
         const parents = this.getParents(run).reverse();
         const string = [...parents, run]
@@ -61,18 +83,38 @@ export class ConsoleCallbackHandler extends BaseTracer {
         return wrap(color.grey, string);
     }
     // logging methods
+    /**
+     * Method used to log the start of a chain run.
+     * @param run The chain run that has started.
+     * @returns void
+     */
     onChainStart(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.green, "[chain/start]")} [${crumbs}] Entering Chain run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`);
     }
+    /**
+     * Method used to log the end of a chain run.
+     * @param run The chain run that has ended.
+     * @returns void
+     */
     onChainEnd(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.cyan, "[chain/end]")} [${crumbs}] [${elapsed(run)}] Exiting Chain run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`);
     }
+    /**
+     * Method used to log any errors of a chain run.
+     * @param run The chain run that has errored.
+     * @returns void
+     */
     onChainError(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.red, "[chain/error]")} [${crumbs}] [${elapsed(run)}] Chain run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
+    /**
+     * Method used to log the start of an LLM run.
+     * @param run The LLM run that has started.
+     * @returns void
+     */
     onLLMStart(run) {
         const crumbs = this.getBreadcrumbs(run);
         const inputs = "prompts" in run.inputs
@@ -80,38 +122,83 @@ export class ConsoleCallbackHandler extends BaseTracer {
             : run.inputs;
         console.log(`${wrap(color.green, "[llm/start]")} [${crumbs}] Entering LLM run with input: ${tryJsonStringify(inputs, "[inputs]")}`);
     }
+    /**
+     * Method used to log the end of an LLM run.
+     * @param run The LLM run that has ended.
+     * @returns void
+     */
     onLLMEnd(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.cyan, "[llm/end]")} [${crumbs}] [${elapsed(run)}] Exiting LLM run with output: ${tryJsonStringify(run.outputs, "[response]")}`);
     }
+    /**
+     * Method used to log any errors of an LLM run.
+     * @param run The LLM run that has errored.
+     * @returns void
+     */
     onLLMError(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.red, "[llm/error]")} [${crumbs}] [${elapsed(run)}] LLM run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
+    /**
+     * Method used to log the start of a tool run.
+     * @param run The tool run that has started.
+     * @returns void
+     */
     onToolStart(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.green, "[tool/start]")} [${crumbs}] Entering Tool run with input: "${run.inputs.input?.trim()}"`);
     }
+    /**
+     * Method used to log the end of a tool run.
+     * @param run The tool run that has ended.
+     * @returns void
+     */
     onToolEnd(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.cyan, "[tool/end]")} [${crumbs}] [${elapsed(run)}] Exiting Tool run with output: "${run.outputs?.output?.trim()}"`);
     }
+    /**
+     * Method used to log any errors of a tool run.
+     * @param run The tool run that has errored.
+     * @returns void
+     */
     onToolError(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.red, "[tool/error]")} [${crumbs}] [${elapsed(run)}] Tool run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
+    /**
+     * Method used to log the start of a retriever run.
+     * @param run The retriever run that has started.
+     * @returns void
+     */
     onRetrieverStart(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.green, "[retriever/start]")} [${crumbs}] Entering Retriever run with input: ${tryJsonStringify(run.inputs, "[inputs]")}`);
     }
+    /**
+     * Method used to log the end of a retriever run.
+     * @param run The retriever run that has ended.
+     * @returns void
+     */
     onRetrieverEnd(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.cyan, "[retriever/end]")} [${crumbs}] [${elapsed(run)}] Exiting Retriever run with output: ${tryJsonStringify(run.outputs, "[outputs]")}`);
     }
+    /**
+     * Method used to log any errors of a retriever run.
+     * @param run The retriever run that has errored.
+     * @returns void
+     */
     onRetrieverError(run) {
         const crumbs = this.getBreadcrumbs(run);
         console.log(`${wrap(color.red, "[retriever/error]")} [${crumbs}] [${elapsed(run)}] Retriever run errored with error: ${tryJsonStringify(run.error, "[error]")}`);
     }
+    /**
+     * Method used to log the action selected by the agent.
+     * @param run The run in which the agent action occurred.
+     * @returns void
+     */
     onAgentAction(run) {
         const agentRun = run;
         const crumbs = this.getBreadcrumbs(run);

package/dist/callbacks/handlers/initialize.cjs

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTracingV2CallbackHandler = exports.getTracingCallbackHandler = void 0;
 const tracer_langchain_js_1 = require("./tracer_langchain.cjs");
 const tracer_langchain_v1_js_1 = require("./tracer_langchain_v1.cjs");
+/**
+ * Function that returns an instance of `LangChainTracerV1`. If a session
+ * is provided, it loads that session into the tracer; otherwise, it loads
+ * a default session.
+ * @param session Optional session to load into the tracer.
+ * @returns An instance of `LangChainTracerV1`.
+ */
 async function getTracingCallbackHandler(session) {
     const tracer = new tracer_langchain_v1_js_1.LangChainTracerV1();
     if (session) {
@@ -14,6 +21,11 @@ async function getTracingCallbackHandler(session) {
     return tracer;
 }
 exports.getTracingCallbackHandler = getTracingCallbackHandler;
+/**
+ * Function that returns an instance of `LangChainTracer`. It does not
+ * load any session data.
+ * @returns An instance of `LangChainTracer`.
+ */
 async function getTracingV2CallbackHandler() {
     return new tracer_langchain_js_1.LangChainTracer();
 }

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

@@ -1,4 +1,16 @@
 import { LangChainTracer } from "./tracer_langchain.js";
 import { LangChainTracerV1 } from "./tracer_langchain_v1.js";
+/**
+ * Function that returns an instance of `LangChainTracerV1`. If a session
+ * is provided, it loads that session into the tracer; otherwise, it loads
+ * a default session.
+ * @param session Optional session to load into the tracer.
+ * @returns An instance of `LangChainTracerV1`.
+ */
 export declare function getTracingCallbackHandler(session?: string): Promise<LangChainTracerV1>;
+/**
+ * Function that returns an instance of `LangChainTracer`. It does not
+ * load any session data.
+ * @returns An instance of `LangChainTracer`.
+ */
 export declare function getTracingV2CallbackHandler(): Promise<LangChainTracer>;

package/dist/callbacks/handlers/initialize.js

@@ -1,5 +1,12 @@
 import { LangChainTracer } from "./tracer_langchain.js";
 import { LangChainTracerV1 } from "./tracer_langchain_v1.js";
+/**
+ * Function that returns an instance of `LangChainTracerV1`. If a session
+ * is provided, it loads that session into the tracer; otherwise, it loads
+ * a default session.
+ * @param session Optional session to load into the tracer.
+ * @returns An instance of `LangChainTracerV1`.
+ */
 export async function getTracingCallbackHandler(session) {
     const tracer = new LangChainTracerV1();
     if (session) {
@@ -10,6 +17,11 @@ export async function getTracingCallbackHandler(session) {
     }
     return tracer;
 }
+/**
+ * Function that returns an instance of `LangChainTracer`. It does not
+ * load any session data.
+ * @returns An instance of `LangChainTracer`.
+ */
 export async function getTracingV2CallbackHandler() {
     return new LangChainTracer();
 }

package/dist/callbacks/manager.cjs

@@ -21,12 +21,18 @@ function parseCallbackConfigArg(arg) {
     }
 }
 exports.parseCallbackConfigArg = parseCallbackConfigArg;
+/**
+ * Manage callbacks from different components of LangChain.
+ */
 class BaseCallbackManager {
     setHandler(handler) {
         return this.setHandlers([handler]);
     }
 }
 exports.BaseCallbackManager = BaseCallbackManager;
+/**
+ * Base class for run manager in LangChain.
+ */
 class BaseRunManager {
     constructor(runId, handlers, inheritableHandlers, tags, inheritableTags, metadata, inheritableMetadata, _parentRunId) {
         Object.defineProperty(this, "runId", {
@@ -89,6 +95,9 @@ class BaseRunManager {
         }, handler.awaitHandlers)));
     }
 }
+/**
+ * Manages callbacks for retriever runs.
+ */
 class CallbackManagerForRetrieverRun extends BaseRunManager {
     getChild(tag) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define

package/dist/callbacks/manager.d.ts

@@ -29,12 +29,18 @@ export interface BaseCallbackConfig {
     callbacks?: Callbacks;
 }
 export declare function parseCallbackConfigArg(arg: Callbacks | BaseCallbackConfig | undefined): BaseCallbackConfig;
+/**
+ * Manage callbacks from different components of LangChain.
+ */
 export declare abstract class BaseCallbackManager {
     abstract addHandler(handler: BaseCallbackHandler): void;
     abstract removeHandler(handler: BaseCallbackHandler): void;
     abstract setHandlers(handlers: BaseCallbackHandler[]): void;
     setHandler(handler: BaseCallbackHandler): void;
 }
+/**
+ * Base class for run manager in LangChain.
+ */
 declare class BaseRunManager {
     readonly runId: string;
     protected readonly handlers: BaseCallbackHandler[];
@@ -47,6 +53,9 @@ declare class BaseRunManager {
     constructor(runId: string, handlers: BaseCallbackHandler[], inheritableHandlers: BaseCallbackHandler[], tags: string[], inheritableTags: string[], metadata: Record<string, unknown>, inheritableMetadata: Record<string, unknown>, _parentRunId?: string | undefined);
     handleText(text: string): Promise<void>;
 }
+/**
+ * Manages callbacks for retriever runs.
+ */
 export declare class CallbackManagerForRetrieverRun extends BaseRunManager implements BaseCallbackManagerMethods {
     getChild(tag?: string): CallbackManager;
     handleRetrieverEnd(documents: Document[]): Promise<void>;

package/dist/callbacks/manager.js

@@ -17,11 +17,17 @@ export function parseCallbackConfigArg(arg) {
         return arg;
     }
 }
+/**
+ * Manage callbacks from different components of LangChain.
+ */
 export class BaseCallbackManager {
     setHandler(handler) {
         return this.setHandlers([handler]);
     }
 }
+/**
+ * Base class for run manager in LangChain.
+ */
 class BaseRunManager {
     constructor(runId, handlers, inheritableHandlers, tags, inheritableTags, metadata, inheritableMetadata, _parentRunId) {
         Object.defineProperty(this, "runId", {
@@ -84,6 +90,9 @@ class BaseRunManager {
         }, handler.awaitHandlers)));
     }
 }
+/**
+ * Manages callbacks for retriever runs.
+ */
 export class CallbackManagerForRetrieverRun extends BaseRunManager {
     getChild(tag) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define

package/dist/callbacks/promises.cjs

@@ -6,6 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.awaitAllCallbacks = exports.consumeCallback = void 0;
 const p_queue_1 = __importDefault(require("p-queue"));
 let queue;
+/**
+ * Creates a queue using the p-queue library. The queue is configured to
+ * auto-start and has a concurrency of 1, meaning it will process tasks
+ * one at a time.
+ */
 function createQueue() {
     const PQueue = "default" in p_queue_1.default ? p_queue_1.default.default : p_queue_1.default;
     return new PQueue({
@@ -30,6 +35,10 @@ async function consumeCallback(promiseFn, wait) {
     }
 }
 exports.consumeCallback = consumeCallback;
+/**
+ * Waits for all promises in the queue to resolve. If the queue is
+ * undefined, it immediately resolves a promise.
+ */
 function awaitAllCallbacks() {
     return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
 }

package/dist/callbacks/promises.d.ts

@@ -4,4 +4,8 @@
  * @param wait Whether to wait for the promise to resolve or resolve immediately
  */
 export declare function consumeCallback<T>(promiseFn: () => Promise<T> | T | void, wait: boolean): Promise<void>;
+/**
+ * Waits for all promises in the queue to resolve. If the queue is
+ * undefined, it immediately resolves a promise.
+ */
 export declare function awaitAllCallbacks(): Promise<void>;

package/dist/callbacks/promises.js

@@ -1,5 +1,10 @@
 import PQueueMod from "p-queue";
 let queue;
+/**
+ * Creates a queue using the p-queue library. The queue is configured to
+ * auto-start and has a concurrency of 1, meaning it will process tasks
+ * one at a time.
+ */
 function createQueue() {
     const PQueue = "default" in PQueueMod ? PQueueMod.default : PQueueMod;
     return new PQueue({
@@ -23,6 +28,10 @@ export async function consumeCallback(promiseFn, wait) {
         void queue.add(promiseFn);
     }
 }
+/**
+ * Waits for all promises in the queue to resolve. If the queue is
+ * undefined, it immediately resolves a promise.
+ */
 export function awaitAllCallbacks() {
     return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
 }

package/dist/chains/analyze_documents_chain.d.ts

@@ -4,6 +4,10 @@ import { ChainValues } from "../schema/index.js";
 import { SerializedAnalyzeDocumentChain } from "./serde.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
 export type LoadValues = Record<string, any>;
+/**
+ * Interface for the input parameters required by the AnalyzeDocumentChain
+ * class.
+ */
 export interface AnalyzeDocumentChainInput extends Omit<ChainInputs, "memory"> {
     combineDocumentsChain: BaseChain;
     textSplitter?: TextSplitter;

package/dist/chains/api/api_chain.cjs

@@ -4,6 +4,10 @@ exports.APIChain = void 0;
 const base_js_1 = require("../base.cjs");
 const llm_chain_js_1 = require("../llm_chain.cjs");
 const prompts_js_1 = require("./prompts.cjs");
+/**
+ * Class that extends BaseChain and represents a chain specifically
+ * designed for making API requests and processing API responses.
+ */
 class APIChain extends base_js_1.BaseChain {
     get inputKeys() {
         return [this.inputKey];
@@ -93,6 +97,14 @@ class APIChain extends base_js_1.BaseChain {
             api_docs: this.apiDocs,
         };
     }
+    /**
+     * Static method to create a new APIChain from a BaseLanguageModel and API
+     * documentation.
+     * @param llm BaseLanguageModel instance.
+     * @param apiDocs API documentation.
+     * @param options Optional configuration options for the APIChain.
+     * @returns New APIChain instance.
+     */
     static fromLLMAndAPIDocs(llm, apiDocs, options = {}) {
         const { apiUrlPrompt = prompts_js_1.API_URL_PROMPT_TEMPLATE, apiResponsePrompt = prompts_js_1.API_RESPONSE_PROMPT_TEMPLATE, } = options;
         const apiRequestChain = new llm_chain_js_1.LLMChain({ prompt: apiUrlPrompt, llm });

package/dist/chains/api/api_chain.d.ts

@@ -5,6 +5,10 @@ import { BaseLanguageModel } from "../../base_language/index.js";
 import { CallbackManagerForChainRun } from "../../callbacks/manager.js";
 import { ChainValues } from "../../schema/index.js";
 import { BasePromptTemplate } from "../../index.js";
+/**
+ * Interface that extends ChainInputs and defines additional input
+ * parameters specific to an APIChain.
+ */
 export interface APIChainInput extends Omit<ChainInputs, "memory"> {
     apiAnswerChain: LLMChain;
     apiRequestChain: LLMChain;
@@ -14,11 +18,18 @@ export interface APIChainInput extends Omit<ChainInputs, "memory"> {
     /** Key to use for output, defaults to `output` */
     outputKey?: string;
 }
+/**
+ * Type that defines optional configuration options for an APIChain.
+ */
 export type APIChainOptions = {
     headers?: Record<string, string>;
     apiUrlPrompt?: BasePromptTemplate;
     apiResponsePrompt?: BasePromptTemplate;
 };
+/**
+ * Class that extends BaseChain and represents a chain specifically
+ * designed for making API requests and processing API responses.
+ */
 export declare class APIChain extends BaseChain implements APIChainInput {
     apiAnswerChain: LLMChain;
     apiRequestChain: LLMChain;
@@ -34,5 +45,13 @@ export declare class APIChain extends BaseChain implements APIChainInput {
     _chainType(): "api_chain";
     static deserialize(data: SerializedAPIChain): Promise<APIChain>;
     serialize(): SerializedAPIChain;
+    /**
+     * Static method to create a new APIChain from a BaseLanguageModel and API
+     * documentation.
+     * @param llm BaseLanguageModel instance.
+     * @param apiDocs API documentation.
+     * @param options Optional configuration options for the APIChain.
+     * @returns New APIChain instance.
+     */
     static fromLLMAndAPIDocs(llm: BaseLanguageModel, apiDocs: string, options?: APIChainOptions & Omit<APIChainInput, "apiAnswerChain" | "apiRequestChain" | "apiDocs">): APIChain;
 }

package/dist/chains/api/api_chain.js

@@ -1,6 +1,10 @@
 import { BaseChain } from "../base.js";
 import { LLMChain } from "../llm_chain.js";
 import { API_URL_PROMPT_TEMPLATE, API_RESPONSE_PROMPT_TEMPLATE, } from "./prompts.js";
+/**
+ * Class that extends BaseChain and represents a chain specifically
+ * designed for making API requests and processing API responses.
+ */
 export class APIChain extends BaseChain {
     get inputKeys() {
         return [this.inputKey];
@@ -90,6 +94,14 @@ export class APIChain extends BaseChain {
             api_docs: this.apiDocs,
         };
     }
+    /**
+     * Static method to create a new APIChain from a BaseLanguageModel and API
+     * documentation.
+     * @param llm BaseLanguageModel instance.
+     * @param apiDocs API documentation.
+     * @param options Optional configuration options for the APIChain.
+     * @returns New APIChain instance.
+     */
     static fromLLMAndAPIDocs(llm, apiDocs, options = {}) {
         const { apiUrlPrompt = API_URL_PROMPT_TEMPLATE, apiResponsePrompt = API_RESPONSE_PROMPT_TEMPLATE, } = options;
         const apiRequestChain = new LLMChain({ prompt: apiUrlPrompt, llm });

package/dist/chains/base.cjs

@@ -41,6 +41,12 @@ class BaseChain extends index_js_2.BaseLangChain {
         }
         return valuesForMemory;
     }
+    /**
+     * Invoke the chain with the provided input and returns the output.
+     * @param input Input values for the chain run.
+     * @param config Optional configuration for the Runnable.
+     * @returns Promise that resolves with the output of the chain run.
+     */
     async invoke(input, config) {
         return this.call(input, config);
     }

package/dist/chains/base.d.ts

@@ -25,6 +25,12 @@ export declare abstract class BaseChain<RunInput extends ChainValues = ChainValu
     callbacks?: Callbacks);
     /** @ignore */
     _selectMemoryInputs(values: ChainValues): ChainValues;
+    /**
+     * Invoke the chain with the provided input and returns the output.
+     * @param input Input values for the chain run.
+     * @param config Optional configuration for the Runnable.
+     * @returns Promise that resolves with the output of the chain run.
+     */
     invoke(input: RunInput, config?: RunnableConfig): Promise<RunOutput>;
     /**
      * Run the core logic of this chain and return the output

package/dist/chains/base.js

@@ -38,6 +38,12 @@ export class BaseChain extends BaseLangChain {
         }
         return valuesForMemory;
     }
+    /**
+     * Invoke the chain with the provided input and returns the output.
+     * @param input Input values for the chain run.
+     * @param config Optional configuration for the Runnable.
+     * @returns Promise that resolves with the output of the chain run.
+     */
     async invoke(input, config) {
         return this.call(input, config);
     }

package/dist/chains/chat_vector_db_chain.cjs

@@ -147,6 +147,14 @@ class ChatVectorDBQAChain extends base_js_1.BaseChain {
             k: this.k,
         };
     }
+    /**
+     * Creates an instance of ChatVectorDBQAChain using a BaseLanguageModel
+     * and other options.
+     * @param llm Instance of BaseLanguageModel used to generate a new question.
+     * @param vectorstore Instance of VectorStore used for vector operations.
+     * @param options (Optional) Additional options for creating the ChatVectorDBQAChain instance.
+     * @returns New instance of ChatVectorDBQAChain.
+     */
     static fromLLM(llm, vectorstore, options = {}) {
         const { questionGeneratorTemplate, qaTemplate, verbose, ...rest } = options;
         const question_generator_prompt = prompt_js_1.PromptTemplate.fromTemplate(questionGeneratorTemplate || question_generator_template);

package/dist/chains/chat_vector_db_chain.d.ts

@@ -6,6 +6,9 @@ import { BaseChain, ChainInputs } from "./base.js";
 import { LLMChain } from "./llm_chain.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
 export type LoadValues = Record<string, any>;
+/**
+ * Interface for the input parameters of the ChatVectorDBQAChain class.
+ */
 export interface ChatVectorDBQAChainInput extends ChainInputs {
     vectorstore: VectorStore;
     combineDocumentsChain: BaseChain;
@@ -33,6 +36,14 @@ export declare class ChatVectorDBQAChain extends BaseChain implements ChatVector
     _chainType(): "chat-vector-db";
     static deserialize(data: SerializedChatVectorDBQAChain, values: LoadValues): Promise<ChatVectorDBQAChain>;
     serialize(): SerializedChatVectorDBQAChain;
+    /**
+     * Creates an instance of ChatVectorDBQAChain using a BaseLanguageModel
+     * and other options.
+     * @param llm Instance of BaseLanguageModel used to generate a new question.
+     * @param vectorstore Instance of VectorStore used for vector operations.
+     * @param options (Optional) Additional options for creating the ChatVectorDBQAChain instance.
+     * @returns New instance of ChatVectorDBQAChain.
+     */
     static fromLLM(llm: BaseLanguageModel, vectorstore: VectorStore, options?: {
         inputKey?: string;
         outputKey?: string;

package/dist/chains/chat_vector_db_chain.js

@@ -144,6 +144,14 @@ export class ChatVectorDBQAChain extends BaseChain {
             k: this.k,
         };
     }
+    /**
+     * Creates an instance of ChatVectorDBQAChain using a BaseLanguageModel
+     * and other options.
+     * @param llm Instance of BaseLanguageModel used to generate a new question.
+     * @param vectorstore Instance of VectorStore used for vector operations.
+     * @param options (Optional) Additional options for creating the ChatVectorDBQAChain instance.
+     * @returns New instance of ChatVectorDBQAChain.
+     */
     static fromLLM(llm, vectorstore, options = {}) {
         const { questionGeneratorTemplate, qaTemplate, verbose, ...rest } = options;
         const question_generator_prompt = PromptTemplate.fromTemplate(questionGeneratorTemplate || question_generator_template);

package/dist/chains/combine_docs_chain.d.ts

@@ -5,6 +5,9 @@ import { Document } from "../document.js";
 import { ChainValues } from "../schema/index.js";
 import { BasePromptTemplate } from "../prompts/base.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
+/**
+ * Interface for the input properties of the StuffDocumentsChain class.
+ */
 export interface StuffDocumentsChainInput extends ChainInputs {
     /** LLM Wrapper to use after formatting documents */
     llmChain: LLMChain;
@@ -33,6 +36,10 @@ export declare class StuffDocumentsChain extends BaseChain implements StuffDocum
     static deserialize(data: SerializedStuffDocumentsChain): Promise<StuffDocumentsChain>;
     serialize(): SerializedStuffDocumentsChain;
 }
+/**
+ * Interface for the input properties of the MapReduceDocumentsChain
+ * class.
+ */
 export interface MapReduceDocumentsChainInput extends StuffDocumentsChainInput {
     /** The maximum number of tokens before requiring to do the reduction */
     maxTokens?: number;
@@ -69,6 +76,9 @@ export declare class MapReduceDocumentsChain extends BaseChain implements MapRed
     static deserialize(data: SerializedMapReduceDocumentsChain): Promise<MapReduceDocumentsChain>;
     serialize(): SerializedMapReduceDocumentsChain;
 }
+/**
+ * Interface for the input properties of the RefineDocumentsChain class.
+ */
 export interface RefineDocumentsChainInput extends StuffDocumentsChainInput {
     refineLLMChain: LLMChain;
     documentPrompt?: BasePromptTemplate;

package/dist/chains/constitutional_ai/constitutional_chain.cjs

@@ -5,6 +5,10 @@ const base_js_1 = require("../base.cjs");
 const llm_chain_js_1 = require("../llm_chain.cjs");
 const constitutional_principle_js_1 = require("./constitutional_principle.cjs");
 const constitutional_prompts_js_1 = require("./constitutional_prompts.cjs");
+/**
+ * Class representing a ConstitutionalChain. Extends BaseChain and
+ * implements ConstitutionalChainInput.
+ */
 class ConstitutionalChain extends base_js_1.BaseChain {
     static lc_name() {
         return "ConstitutionalChain";
@@ -69,12 +73,25 @@ class ConstitutionalChain extends base_js_1.BaseChain {
             output: response,
         };
     }
+    /**
+     * Static method that returns an array of ConstitutionalPrinciple objects
+     * based on the provided names.
+     * @param names Optional array of principle names.
+     * @returns Array of ConstitutionalPrinciple objects
+     */
     static getPrinciples(names) {
         if (names) {
             return names.map((name) => constitutional_principle_js_1.PRINCIPLES[name]);
         }
         return Object.values(constitutional_principle_js_1.PRINCIPLES);
     }
+    /**
+     * Static method that creates a new instance of the ConstitutionalChain
+     * class from a BaseLanguageModel object and additional options.
+     * @param llm BaseLanguageModel instance.
+     * @param options Options for the ConstitutionalChain.
+     * @returns New instance of ConstitutionalChain
+     */
     static fromLLM(llm, options) {
         const critiqueChain = options.critiqueChain ??
             new llm_chain_js_1.LLMChain({