langchain 0.0.130 → 0.0.132

package/dist/chains/query_constructor/index.d.ts

@@ -19,6 +19,10 @@ declare const queryInputSchema: z.ZodObject<{
     query: string;
     filter?: string | undefined;
 }>;
+/**
+ * A class that extends AsymmetricStructuredOutputParser to parse
+ * structured query output.
+ */
 export declare class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser<typeof queryInputSchema, StructuredQuery> {
     lc_namespace: string[];
     queryTransformer: QueryTransformer;
@@ -26,10 +30,26 @@ export declare class StructuredQueryOutputParser extends AsymmetricStructuredOut
         allowedComparators: Comparator[];
         allowedOperators: Operator[];
     });
+    /**
+     * Processes the output of a structured query.
+     * @param query The query string.
+     * @param filter The filter condition.
+     * @returns A Promise that resolves to a StructuredQuery instance.
+     */
     outputProcessor({ query, filter, }: z.infer<typeof queryInputSchema>): Promise<StructuredQuery>;
+    /**
+     * Creates a new StructuredQueryOutputParser instance from the provided
+     * components.
+     * @param allowedComparators An array of allowed Comparator instances.
+     * @param allowedOperators An array of allowed Operator instances.
+     * @returns A new StructuredQueryOutputParser instance.
+     */
     static fromComponents(allowedComparators?: Comparator[], allowedOperators?: Operator[]): StructuredQueryOutputParser;
 }
 export declare function formatAttributeInfo(info: AttributeInfo[]): string;
+/**
+ * A type that represents options for the query constructor chain.
+ */
 export type QueryConstructorChainOptions = {
     llm: BaseLanguageModel;
     documentContents: string;

package/dist/chains/query_constructor/index.js

@@ -17,6 +17,10 @@ const queryInputSchema = /* #__PURE__ */ z.object({
         .optional()
         .describe("logical condition statement for filtering documents"),
 });
+/**
+ * A class that extends AsymmetricStructuredOutputParser to parse
+ * structured query output.
+ */
 export class StructuredQueryOutputParser extends AsymmetricStructuredOutputParser {
     constructor(fields) {
         super({ ...fields, inputSchema: queryInputSchema });
@@ -35,6 +39,12 @@ export class StructuredQueryOutputParser extends AsymmetricStructuredOutputParse
         const { allowedComparators, allowedOperators } = fields;
         this.queryTransformer = new QueryTransformer(allowedComparators, allowedOperators);
     }
+    /**
+     * Processes the output of a structured query.
+     * @param query The query string.
+     * @param filter The filter condition.
+     * @returns A Promise that resolves to a StructuredQuery instance.
+     */
     async outputProcessor({ query, filter, }) {
         let myQuery = query;
         if (myQuery.length === 0) {
@@ -48,6 +58,13 @@ export class StructuredQueryOutputParser extends AsymmetricStructuredOutputParse
             return new StructuredQuery(query, parsedFilter);
         }
     }
+    /**
+     * Creates a new StructuredQueryOutputParser instance from the provided
+     * components.
+     * @param allowedComparators An array of allowed Comparator instances.
+     * @param allowedOperators An array of allowed Operator instances.
+     * @returns A new StructuredQueryOutputParser instance.
+     */
     static fromComponents(allowedComparators = [], allowedOperators = []) {
         return new StructuredQueryOutputParser({
             allowedComparators,

package/dist/chains/query_constructor/ir.cjs

@@ -14,9 +14,17 @@ exports.Comparators = {
     lte: "lte",
     gte: "gte",
 };
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
 class Visitor {
 }
 exports.Visitor = Visitor;
+/**
+ * Abstract class representing an expression. Subclasses must implement
+ * the exprName property and the accept method.
+ */
 class Expression {
     accept(visitor) {
         if (this.exprName === "Operation") {
@@ -34,9 +42,17 @@ class Expression {
     }
 }
 exports.Expression = Expression;
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
 class FilterDirective extends Expression {
 }
 exports.FilterDirective = FilterDirective;
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
 class Comparison extends FilterDirective {
     constructor(comparator, attribute, value) {
         super();
@@ -67,6 +83,10 @@ class Comparison extends FilterDirective {
     }
 }
 exports.Comparison = Comparison;
+/**
+ * Class representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
 class Operation extends FilterDirective {
     constructor(operator, args) {
         super();
@@ -91,6 +111,10 @@ class Operation extends FilterDirective {
     }
 }
 exports.Operation = Operation;
+/**
+ * Class representing a structured query expression. It extends the
+ * Expression class.
+ */
 class StructuredQuery extends Expression {
     constructor(query, filter) {
         super();

package/dist/chains/query_constructor/ir.d.ts

@@ -1,14 +1,48 @@
 import { VectorStore } from "../../vectorstores/base.js";
+/**
+ * Represents logical AND operator.
+ */
 export type AND = "and";
+/**
+ * Represents logical OR operator.
+ */
 export type OR = "or";
+/**
+ * Represents logical NOT operator.
+ */
 export type NOT = "not";
+/**
+ * Represents a logical operator which can be AND, OR, or NOT.
+ */
 export type Operator = AND | OR | NOT;
+/**
+ * Represents equality comparison operator.
+ */
 export type EQ = "eq";
+/**
+ * Represents inequality comparison operator.
+ */
 export type NE = "ne";
+/**
+ * Represents less than comparison operator.
+ */
 export type LT = "lt";
+/**
+ * Represents greater than comparison operator.
+ */
 export type GT = "gt";
+/**
+ * Represents less than or equal to comparison operator.
+ */
 export type LTE = "lte";
+/**
+ * Represents greater than or equal to comparison operator.
+ */
 export type GTE = "gte";
+/**
+ * Represents a comparison operator which can be EQ, NE, LT, GT, LTE, or
+ * GTE.
+ */
 export type Comparator = EQ | NE | LT | GT | LTE | GTE;
 export declare const Operators: {
     [key: string]: Operator;
@@ -16,18 +50,35 @@ export declare const Operators: {
 export declare const Comparators: {
     [key: string]: Comparator;
 };
+/**
+ * Represents the result of visiting an operation or comparison
+ * expression.
+ */
 export type VisitorResult = VisitorOperationResult | VisitorComparisonResult;
+/**
+ * Represents the result of visiting an operation expression.
+ */
 export type VisitorOperationResult = {
     [operator: string]: VisitorResult[];
 };
+/**
+ * Represents the result of visiting a comparison expression.
+ */
 export type VisitorComparisonResult = {
     [attr: string]: {
         [comparator: string]: string | number;
     };
 };
+/**
+ * Represents the result of visiting a structured query expression.
+ */
 export type VisitorStructuredQueryResult = {
     filter?: VisitorComparisonResult | VisitorOperationResult;
 };
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
 export declare abstract class Visitor<T extends VectorStore = VectorStore> {
     VisitOperationOutput: object;
     VisitComparisonOutput: object;
@@ -40,12 +91,24 @@ export declare abstract class Visitor<T extends VectorStore = VectorStore> {
     abstract visitComparison(comparison: Comparison): this["VisitComparisonOutput"];
     abstract visitStructuredQuery(structuredQuery: StructuredQuery): this["VisitStructuredQueryOutput"];
 }
+/**
+ * Abstract class representing an expression. Subclasses must implement
+ * the exprName property and the accept method.
+ */
 export declare abstract class Expression {
     abstract exprName: "Operation" | "Comparison" | "StructuredQuery";
     accept(visitor: Visitor): object;
 }
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
 export declare abstract class FilterDirective extends Expression {
 }
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
 export declare class Comparison extends FilterDirective {
     comparator: Comparator;
     attribute: string;
@@ -53,12 +116,20 @@ export declare class Comparison extends FilterDirective {
     exprName: "Comparison";
     constructor(comparator: Comparator, attribute: string, value: string | number);
 }
+/**
+ * Class representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
 export declare class Operation extends FilterDirective {
     operator: Operator;
     args?: FilterDirective[] | undefined;
     exprName: "Operation";
     constructor(operator: Operator, args?: FilterDirective[] | undefined);
 }
+/**
+ * Class representing a structured query expression. It extends the
+ * Expression class.
+ */
 export declare class StructuredQuery extends Expression {
     query: string;
     filter?: FilterDirective | undefined;

package/dist/chains/query_constructor/ir.js

@@ -11,8 +11,16 @@ export const Comparators = {
     lte: "lte",
     gte: "gte",
 };
+/**
+ * Abstract class for visiting expressions. Subclasses must implement
+ * visitOperation, visitComparison, and visitStructuredQuery methods.
+ */
 export class Visitor {
 }
+/**
+ * Abstract class representing an expression. Subclasses must implement
+ * the exprName property and the accept method.
+ */
 export class Expression {
     accept(visitor) {
         if (this.exprName === "Operation") {
@@ -29,8 +37,16 @@ export class Expression {
         }
     }
 }
+/**
+ * Abstract class representing a filter directive. It extends the
+ * Expression class.
+ */
 export class FilterDirective extends Expression {
 }
+/**
+ * Class representing a comparison filter directive. It extends the
+ * FilterDirective class.
+ */
 export class Comparison extends FilterDirective {
     constructor(comparator, attribute, value) {
         super();
@@ -60,6 +76,10 @@ export class Comparison extends FilterDirective {
         });
     }
 }
+/**
+ * Class representing an operation filter directive. It extends the
+ * FilterDirective class.
+ */
 export class Operation extends FilterDirective {
     constructor(operator, args) {
         super();
@@ -83,6 +103,10 @@ export class Operation extends FilterDirective {
         });
     }
 }
+/**
+ * Class representing a structured query expression. It extends the
+ * Expression class.
+ */
 export class StructuredQuery extends Expression {
     constructor(query, filter) {
         super();

package/dist/chains/query_constructor/parser.cjs

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryTransformer = void 0;
 const ir_js_1 = require("./ir.cjs");
 const expression_js_1 = require("../../output_parsers/expression.cjs");
+/**
+ * A class for transforming and parsing query expressions.
+ */
 class QueryTransformer {
     constructor(allowedComparators = [], allowedOperators = []) {
         Object.defineProperty(this, "allowedComparators", {
@@ -18,6 +21,12 @@ class QueryTransformer {
             value: allowedOperators
         });
     }
+    /**
+     * Matches a function name to a comparator or operator. Throws an error if
+     * the function name is unknown or not allowed.
+     * @param funcName The function name to match.
+     * @returns The matched function name.
+     */
     matchFunctionName(funcName) {
         if (funcName in ir_js_1.Comparators) {
             if (this.allowedComparators.length > 0) {
@@ -47,6 +56,12 @@ class QueryTransformer {
         }
         throw new Error("Unknown function name");
     }
+    /**
+     * Transforms a parsed expression into an operation or comparison. Throws
+     * an error if the parsed expression is not supported.
+     * @param parsed The parsed expression to transform.
+     * @returns The transformed operation or comparison.
+     */
     transform(parsed) {
         const traverse = (node) => {
             switch (node.type) {
@@ -91,6 +106,12 @@ class QueryTransformer {
         };
         return traverse(parsed);
     }
+    /**
+     * Parses an expression and returns the transformed operation or
+     * comparison. Throws an error if the expression cannot be parsed.
+     * @param expression The expression to parse.
+     * @returns A Promise that resolves to the transformed operation or comparison.
+     */
     async parse(expression) {
         const expressionParser = new expression_js_1.ExpressionParser();
         const parsed = (await expressionParser.parse(expression));

package/dist/chains/query_constructor/parser.d.ts

@@ -1,12 +1,37 @@
 import { Comparator, Comparison, Operation, Operator } from "./ir.js";
+/**
+ * A type representing the possible types that can be traversed in an
+ * expression.
+ */
 export type TraverseType = boolean | Operation | Comparison | string | number | {
     [key: string]: TraverseType;
 } | TraverseType[];
+/**
+ * A class for transforming and parsing query expressions.
+ */
 export declare class QueryTransformer {
     allowedComparators: Comparator[];
     allowedOperators: Operator[];
     constructor(allowedComparators?: Comparator[], allowedOperators?: Operator[]);
+    /**
+     * Matches a function name to a comparator or operator. Throws an error if
+     * the function name is unknown or not allowed.
+     * @param funcName The function name to match.
+     * @returns The matched function name.
+     */
     private matchFunctionName;
+    /**
+     * Transforms a parsed expression into an operation or comparison. Throws
+     * an error if the parsed expression is not supported.
+     * @param parsed The parsed expression to transform.
+     * @returns The transformed operation or comparison.
+     */
     private transform;
+    /**
+     * Parses an expression and returns the transformed operation or
+     * comparison. Throws an error if the expression cannot be parsed.
+     * @param expression The expression to parse.
+     * @returns A Promise that resolves to the transformed operation or comparison.
+     */
     parse(expression: string): Promise<Operation | Comparison>;
 }

package/dist/chains/query_constructor/parser.js

@@ -1,5 +1,8 @@
 import { Comparators, Comparison, Operation, Operators, } from "./ir.js";
 import { ExpressionParser, } from "../../output_parsers/expression.js";
+/**
+ * A class for transforming and parsing query expressions.
+ */
 export class QueryTransformer {
     constructor(allowedComparators = [], allowedOperators = []) {
         Object.defineProperty(this, "allowedComparators", {
@@ -15,6 +18,12 @@ export class QueryTransformer {
             value: allowedOperators
         });
     }
+    /**
+     * Matches a function name to a comparator or operator. Throws an error if
+     * the function name is unknown or not allowed.
+     * @param funcName The function name to match.
+     * @returns The matched function name.
+     */
     matchFunctionName(funcName) {
         if (funcName in Comparators) {
             if (this.allowedComparators.length > 0) {
@@ -44,6 +53,12 @@ export class QueryTransformer {
         }
         throw new Error("Unknown function name");
     }
+    /**
+     * Transforms a parsed expression into an operation or comparison. Throws
+     * an error if the parsed expression is not supported.
+     * @param parsed The parsed expression to transform.
+     * @returns The transformed operation or comparison.
+     */
     transform(parsed) {
         const traverse = (node) => {
             switch (node.type) {
@@ -88,6 +103,12 @@ export class QueryTransformer {
         };
         return traverse(parsed);
     }
+    /**
+     * Parses an expression and returns the transformed operation or
+     * comparison. Throws an error if the expression cannot be parsed.
+     * @param expression The expression to parse.
+     * @returns A Promise that resolves to the transformed operation or comparison.
+     */
     async parse(expression) {
         const expressionParser = new ExpressionParser();
         const parsed = (await expressionParser.parse(expression));

package/dist/chains/question_answering/load.cjs

@@ -20,6 +20,13 @@ const loadQAChain = (llm, params = { type: "stuff" }) => {
     throw new Error(`Invalid _type: ${type}`);
 };
 exports.loadQAChain = loadQAChain;
+/**
+ * Loads a StuffQAChain based on the provided parameters. It takes an LLM
+ * instance and StuffQAChainParams as parameters.
+ * @param llm An instance of BaseLanguageModel.
+ * @param params Parameters for creating a StuffQAChain.
+ * @returns A StuffQAChain instance.
+ */
 function loadQAStuffChain(llm, params = {}) {
     const { prompt = stuff_prompts_js_1.QA_PROMPT_SELECTOR.getPrompt(llm), verbose } = params;
     const llmChain = new llm_chain_js_1.LLMChain({ prompt, llm, verbose });
@@ -27,6 +34,13 @@ function loadQAStuffChain(llm, params = {}) {
     return chain;
 }
 exports.loadQAStuffChain = loadQAStuffChain;
+/**
+ * Loads a MapReduceQAChain based on the provided parameters. It takes an
+ * LLM instance and MapReduceQAChainParams as parameters.
+ * @param llm An instance of BaseLanguageModel.
+ * @param params Parameters for creating a MapReduceQAChain.
+ * @returns A MapReduceQAChain instance.
+ */
 function loadQAMapReduceChain(llm, params = {}) {
     const { combineMapPrompt = map_reduce_prompts_js_1.COMBINE_QA_PROMPT_SELECTOR.getPrompt(llm), combinePrompt = map_reduce_prompts_js_1.COMBINE_PROMPT_SELECTOR.getPrompt(llm), verbose, returnIntermediateSteps, } = params;
     const llmChain = new llm_chain_js_1.LLMChain({ prompt: combineMapPrompt, llm, verbose });
@@ -45,6 +59,13 @@ function loadQAMapReduceChain(llm, params = {}) {
     return chain;
 }
 exports.loadQAMapReduceChain = loadQAMapReduceChain;
+/**
+ * Loads a RefineQAChain based on the provided parameters. It takes an LLM
+ * instance and RefineQAChainParams as parameters.
+ * @param llm An instance of BaseLanguageModel.
+ * @param params Parameters for creating a RefineQAChain.
+ * @returns A RefineQAChain instance.
+ */
 function loadQARefineChain(llm, params = {}) {
     const { questionPrompt = refine_prompts_js_1.QUESTION_PROMPT_SELECTOR.getPrompt(llm), refinePrompt = refine_prompts_js_1.REFINE_PROMPT_SELECTOR.getPrompt(llm), verbose, } = params;
     const llmChain = new llm_chain_js_1.LLMChain({ prompt: questionPrompt, llm, verbose });

package/dist/chains/question_answering/load.d.ts

@@ -1,6 +1,10 @@
 import { BasePromptTemplate } from "../../prompts/base.js";
 import { StuffDocumentsChain, MapReduceDocumentsChain, RefineDocumentsChain, MapReduceDocumentsChainInput } from "../combine_docs_chain.js";
 import { BaseLanguageModel } from "../../base_language/index.js";
+/**
+ * Represents the parameters for creating a QAChain. It can be of three
+ * types: "stuff", "map_reduce", or "refine".
+ */
 export type QAChainParams = ({
     type?: "stuff";
 } & StuffQAChainParams) | ({
@@ -9,21 +13,51 @@ export type QAChainParams = ({
     type?: "refine";
 } & RefineQAChainParams);
 export declare const loadQAChain: (llm: BaseLanguageModel, params?: QAChainParams) => StuffDocumentsChain | MapReduceDocumentsChain | RefineDocumentsChain;
+/**
+ * Represents the parameters for creating a StuffQAChain.
+ */
 export interface StuffQAChainParams {
     prompt?: BasePromptTemplate;
     verbose?: boolean;
 }
+/**
+ * Loads a StuffQAChain based on the provided parameters. It takes an LLM
+ * instance and StuffQAChainParams as parameters.
+ * @param llm An instance of BaseLanguageModel.
+ * @param params Parameters for creating a StuffQAChain.
+ * @returns A StuffQAChain instance.
+ */
 export declare function loadQAStuffChain(llm: BaseLanguageModel, params?: StuffQAChainParams): StuffDocumentsChain;
+/**
+ * Represents the parameters for creating a MapReduceQAChain.
+ */
 export interface MapReduceQAChainParams {
     returnIntermediateSteps?: MapReduceDocumentsChainInput["returnIntermediateSteps"];
     combineMapPrompt?: BasePromptTemplate;
     combinePrompt?: BasePromptTemplate;
     verbose?: boolean;
 }
+/**
+ * Loads a MapReduceQAChain based on the provided parameters. It takes an
+ * LLM instance and MapReduceQAChainParams as parameters.
+ * @param llm An instance of BaseLanguageModel.
+ * @param params Parameters for creating a MapReduceQAChain.
+ * @returns A MapReduceQAChain instance.
+ */
 export declare function loadQAMapReduceChain(llm: BaseLanguageModel, params?: MapReduceQAChainParams): MapReduceDocumentsChain;
+/**
+ * Represents the parameters for creating a RefineQAChain.
+ */
 export interface RefineQAChainParams {
     questionPrompt?: BasePromptTemplate;
     refinePrompt?: BasePromptTemplate;
     verbose?: boolean;
 }
+/**
+ * Loads a RefineQAChain based on the provided parameters. It takes an LLM
+ * instance and RefineQAChainParams as parameters.
+ * @param llm An instance of BaseLanguageModel.
+ * @param params Parameters for creating a RefineQAChain.
+ * @returns A RefineQAChain instance.
+ */
 export declare function loadQARefineChain(llm: BaseLanguageModel, params?: RefineQAChainParams): RefineDocumentsChain;

package/dist/chains/question_answering/load.js

@@ -16,12 +16,26 @@ export const loadQAChain = (llm, params = { type: "stuff" }) => {
     }
     throw new Error(`Invalid _type: ${type}`);
 };
+/**
+ * Loads a StuffQAChain based on the provided parameters. It takes an LLM
+ * instance and StuffQAChainParams as parameters.
+ * @param llm An instance of BaseLanguageModel.
+ * @param params Parameters for creating a StuffQAChain.
+ * @returns A StuffQAChain instance.
+ */
 export function loadQAStuffChain(llm, params = {}) {
     const { prompt = QA_PROMPT_SELECTOR.getPrompt(llm), verbose } = params;
     const llmChain = new LLMChain({ prompt, llm, verbose });
     const chain = new StuffDocumentsChain({ llmChain, verbose });
     return chain;
 }
+/**
+ * Loads a MapReduceQAChain based on the provided parameters. It takes an
+ * LLM instance and MapReduceQAChainParams as parameters.
+ * @param llm An instance of BaseLanguageModel.
+ * @param params Parameters for creating a MapReduceQAChain.
+ * @returns A MapReduceQAChain instance.
+ */
 export function loadQAMapReduceChain(llm, params = {}) {
     const { combineMapPrompt = COMBINE_QA_PROMPT_SELECTOR.getPrompt(llm), combinePrompt = COMBINE_PROMPT_SELECTOR.getPrompt(llm), verbose, returnIntermediateSteps, } = params;
     const llmChain = new LLMChain({ prompt: combineMapPrompt, llm, verbose });
@@ -39,6 +53,13 @@ export function loadQAMapReduceChain(llm, params = {}) {
     });
     return chain;
 }
+/**
+ * Loads a RefineQAChain based on the provided parameters. It takes an LLM
+ * instance and RefineQAChainParams as parameters.
+ * @param llm An instance of BaseLanguageModel.
+ * @param params Parameters for creating a RefineQAChain.
+ * @returns A RefineQAChain instance.
+ */
 export function loadQARefineChain(llm, params = {}) {
     const { questionPrompt = QUESTION_PROMPT_SELECTOR.getPrompt(llm), refinePrompt = REFINE_PROMPT_SELECTOR.getPrompt(llm), verbose, } = params;
     const llmChain = new LLMChain({ prompt: questionPrompt, llm, verbose });

package/dist/chains/retrieval_qa.cjs

@@ -3,7 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RetrievalQAChain = void 0;
 const base_js_1 = require("./base.cjs");
 const load_js_1 = require("./question_answering/load.cjs");
+/**
+ * Class representing a chain for performing question-answering tasks with
+ * a retrieval component.
+ */
 class RetrievalQAChain extends base_js_1.BaseChain {
+    static lc_name() {
+        return "RetrievalQAChain";
+    }
     get inputKeys() {
         return [this.inputKey];
     }
@@ -68,6 +75,14 @@ class RetrievalQAChain extends base_js_1.BaseChain {
     serialize() {
         throw new Error("Not implemented");
     }
+    /**
+     * Creates a new instance of RetrievalQAChain using a BaseLanguageModel
+     * and a BaseRetriever.
+     * @param llm The BaseLanguageModel used to generate a new question.
+     * @param retriever The BaseRetriever used to retrieve relevant documents.
+     * @param options Optional parameters for the RetrievalQAChain.
+     * @returns A new instance of RetrievalQAChain.
+     */
     static fromLLM(llm, retriever, options) {
         const qaChain = (0, load_js_1.loadQAStuffChain)(llm, {
             prompt: options?.prompt,

package/dist/chains/retrieval_qa.d.ts

@@ -6,13 +6,21 @@ import { BaseRetriever } from "../schema/retriever.js";
 import { StuffQAChainParams } from "./question_answering/load.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
 export type LoadValues = Record<string, any>;
+/**
+ * Interface for the input parameters of the RetrievalQAChain class.
+ */
 export interface RetrievalQAChainInput extends Omit<ChainInputs, "memory"> {
     retriever: BaseRetriever;
     combineDocumentsChain: BaseChain;
     inputKey?: string;
     returnSourceDocuments?: boolean;
 }
+/**
+ * Class representing a chain for performing question-answering tasks with
+ * a retrieval component.
+ */
 export declare class RetrievalQAChain extends BaseChain implements RetrievalQAChainInput {
+    static lc_name(): string;
     inputKey: string;
     get inputKeys(): string[];
     get outputKeys(): string[];
@@ -25,5 +33,13 @@ export declare class RetrievalQAChain extends BaseChain implements RetrievalQACh
     _chainType(): "retrieval_qa";
     static deserialize(_data: SerializedVectorDBQAChain, _values: LoadValues): Promise<RetrievalQAChain>;
     serialize(): SerializedVectorDBQAChain;
+    /**
+     * Creates a new instance of RetrievalQAChain using a BaseLanguageModel
+     * and a BaseRetriever.
+     * @param llm The BaseLanguageModel used to generate a new question.
+     * @param retriever The BaseRetriever used to retrieve relevant documents.
+     * @param options Optional parameters for the RetrievalQAChain.
+     * @returns A new instance of RetrievalQAChain.
+     */
     static fromLLM(llm: BaseLanguageModel, retriever: BaseRetriever, options?: Partial<Omit<RetrievalQAChainInput, "retriever" | "combineDocumentsChain" | "index">> & StuffQAChainParams): RetrievalQAChain;
 }