langchain 0.0.212 → 0.0.214

package/dist/chains/history_aware_retriever.cjs

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHistoryAwareRetriever = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+const output_parsers_1 = require("@langchain/core/output_parsers");
+/**
+ * Create a chain that takes conversation history and returns documents.
+ * If there is no `chat_history`, then the `input` is just passed directly to the
+ * retriever. If there is `chat_history`, then the prompt and LLM will be used
+ * to generate a search query. That search query is then passed to the retriever.
+ * @param {CreateHistoryAwareRetriever} params
+ * @returns An LCEL Runnable. The runnable input must take in `input`, and if there
+ * is chat history should take it in the form of `chat_history`.
+ * The Runnable output is a list of Documents
+ * @example
+ * ```typescript
+ * // yarn add langchain @langchain/openai
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { pull } from "langchain/hub";
+ * import { createRetrievalChain } from "langchain/chains/retrieval";
+ * import { createStuffDocumentsChain } from "langchain/chains/combine_documents";
+ *
+ * const rephrasePrompt = await pull("langchain-ai/chat-langchain-rephrase");
+ * const llm = new ChatOpenAI({});
+ * const retriever = ...
+ * const historyAwareRetrieverChain = await createHistoryAwareRetriever({
+ *   llm,
+ *   retriever,
+ *   rephrasePrompt,
+ * });
+ * const result = await chain.invoke({"input": "...", "chat_history": [] })
+ * ```
+ */
+async function createHistoryAwareRetriever({ llm, retriever, rephrasePrompt, }) {
+    if (!rephrasePrompt.inputVariables.includes("input")) {
+        throw new Error(`Expected "input" to be a prompt variable, but got ${JSON.stringify(rephrasePrompt.inputVariables)}`);
+    }
+    const retrieveDocuments = runnables_1.RunnableBranch.from([
+        [
+            (input) => !input.chat_history || input.chat_history.length === 0,
+            runnables_1.RunnableSequence.from([(input) => input.input, retriever]),
+        ],
+        runnables_1.RunnableSequence.from([
+            rephrasePrompt,
+            llm,
+            new output_parsers_1.StringOutputParser(),
+            retriever,
+        ]),
+    ]).withConfig({
+        runName: "history_aware_retriever",
+    });
+    return retrieveDocuments;
+}
+exports.createHistoryAwareRetriever = createHistoryAwareRetriever;

package/dist/chains/history_aware_retriever.d.ts

@@ -0,0 +1,55 @@
+import type { LanguageModelLike } from "@langchain/core/language_models/base";
+import { type RunnableInterface } from "@langchain/core/runnables";
+import { type BasePromptTemplate } from "@langchain/core/prompts";
+import type { DocumentInterface } from "@langchain/core/documents";
+import type { BaseMessage } from "../schema/index.js";
+/**
+ * Params for the createHistoryAwareRetriever method.
+ */
+export type CreateHistoryAwareRetriever = {
+    /**
+     * Language model to use for generating a search term given chat history.
+     */
+    llm: LanguageModelLike;
+    /**
+     * RetrieverLike object that takes a string as input and outputs a list of Documents.
+     */
+    retriever: RunnableInterface<string, DocumentInterface[]>;
+    /**
+     * The prompt used to generate the search query for the retriever.
+     */
+    rephrasePrompt: BasePromptTemplate;
+};
+/**
+ * Create a chain that takes conversation history and returns documents.
+ * If there is no `chat_history`, then the `input` is just passed directly to the
+ * retriever. If there is `chat_history`, then the prompt and LLM will be used
+ * to generate a search query. That search query is then passed to the retriever.
+ * @param {CreateHistoryAwareRetriever} params
+ * @returns An LCEL Runnable. The runnable input must take in `input`, and if there
+ * is chat history should take it in the form of `chat_history`.
+ * The Runnable output is a list of Documents
+ * @example
+ * ```typescript
+ * // yarn add langchain @langchain/openai
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { pull } from "langchain/hub";
+ * import { createRetrievalChain } from "langchain/chains/retrieval";
+ * import { createStuffDocumentsChain } from "langchain/chains/combine_documents";
+ *
+ * const rephrasePrompt = await pull("langchain-ai/chat-langchain-rephrase");
+ * const llm = new ChatOpenAI({});
+ * const retriever = ...
+ * const historyAwareRetrieverChain = await createHistoryAwareRetriever({
+ *   llm,
+ *   retriever,
+ *   rephrasePrompt,
+ * });
+ * const result = await chain.invoke({"input": "...", "chat_history": [] })
+ * ```
+ */
+export declare function createHistoryAwareRetriever({ llm, retriever, rephrasePrompt, }: CreateHistoryAwareRetriever): Promise<RunnableInterface<{
+    input: string;
+    chat_history: string | BaseMessage[];
+}, DocumentInterface[]>>;

package/dist/chains/history_aware_retriever.js

@@ -0,0 +1,51 @@
+import { RunnableSequence, RunnableBranch, } from "@langchain/core/runnables";
+import { StringOutputParser } from "@langchain/core/output_parsers";
+/**
+ * Create a chain that takes conversation history and returns documents.
+ * If there is no `chat_history`, then the `input` is just passed directly to the
+ * retriever. If there is `chat_history`, then the prompt and LLM will be used
+ * to generate a search query. That search query is then passed to the retriever.
+ * @param {CreateHistoryAwareRetriever} params
+ * @returns An LCEL Runnable. The runnable input must take in `input`, and if there
+ * is chat history should take it in the form of `chat_history`.
+ * The Runnable output is a list of Documents
+ * @example
+ * ```typescript
+ * // yarn add langchain @langchain/openai
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { pull } from "langchain/hub";
+ * import { createRetrievalChain } from "langchain/chains/retrieval";
+ * import { createStuffDocumentsChain } from "langchain/chains/combine_documents";
+ *
+ * const rephrasePrompt = await pull("langchain-ai/chat-langchain-rephrase");
+ * const llm = new ChatOpenAI({});
+ * const retriever = ...
+ * const historyAwareRetrieverChain = await createHistoryAwareRetriever({
+ *   llm,
+ *   retriever,
+ *   rephrasePrompt,
+ * });
+ * const result = await chain.invoke({"input": "...", "chat_history": [] })
+ * ```
+ */
+export async function createHistoryAwareRetriever({ llm, retriever, rephrasePrompt, }) {
+    if (!rephrasePrompt.inputVariables.includes("input")) {
+        throw new Error(`Expected "input" to be a prompt variable, but got ${JSON.stringify(rephrasePrompt.inputVariables)}`);
+    }
+    const retrieveDocuments = RunnableBranch.from([
+        [
+            (input) => !input.chat_history || input.chat_history.length === 0,
+            RunnableSequence.from([(input) => input.input, retriever]),
+        ],
+        RunnableSequence.from([
+            rephrasePrompt,
+            llm,
+            new StringOutputParser(),
+            retriever,
+        ]),
+    ]).withConfig({
+        runName: "history_aware_retriever",
+    });
+    return retrieveDocuments;
+}

package/dist/chains/openai_functions/structured_output.cjs

@@ -3,23 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStructuredOutputChainFromZod = exports.createStructuredOutputChain = exports.FunctionCallStructuredOutputParser = void 0;
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const json_schema_1 = require("@langchain/core/utils/json_schema");
+const openai_1 = require("@langchain/openai");
+const output_parsers_1 = require("@langchain/core/output_parsers");
 const llm_chain_js_1 = require("../llm_chain.cjs");
-const openai_js_1 = require("../../chat_models/openai.cjs");
-const output_parser_js_1 = require("../../schema/output_parser.cjs");
 const openai_functions_js_1 = require("../../output_parsers/openai_functions.cjs");
+function isJsonSchema7Type(x) {
+    return (x.jsonSchema === undefined &&
+        x.zodSchema === undefined);
+}
 /**
  * Class that extends the BaseLLMOutputParser class. It provides
  * functionality for parsing the structured output based on a JSON schema.
  */
-class FunctionCallStructuredOutputParser extends output_parser_js_1.BaseLLMOutputParser {
-    constructor(schema) {
-        super();
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: schema
-        });
+class FunctionCallStructuredOutputParser extends output_parsers_1.BaseLLMOutputParser {
+    constructor(fieldsOrSchema) {
+        let fields;
+        if (isJsonSchema7Type(fieldsOrSchema)) {
+            fields = { jsonSchema: fieldsOrSchema };
+        }
+        else {
+            fields = fieldsOrSchema;
+        }
+        if (fields.jsonSchema === undefined && fields.zodSchema === undefined) {
+            throw new Error(`Must provide one of "jsonSchema" or "zodSchema".`);
+        }
+        super(fields);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -38,13 +46,26 @@ class FunctionCallStructuredOutputParser extends output_parser_js_1.BaseLLMOutpu
             writable: true,
             value: void 0
         });
-        this.jsonSchemaValidator = new json_schema_1.Validator(schema, "7");
+        Object.defineProperty(this, "zodSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (fields.jsonSchema !== undefined) {
+            this.jsonSchemaValidator = new json_schema_1.Validator(fields.jsonSchema, "7");
+        }
+        else {
+            this.zodSchema = fields.zodSchema;
+        }
     }
     /**
      * Method to parse the result of chat generations. It first parses the
-     * result using the functionOutputParser, then validates the parsed result
-     * against the JSON schema. If the result is valid, it returns the parsed
-     * result. Otherwise, it throws an OutputParserException.
+     * result using the functionOutputParser, then parses the result against a
+     * zod schema if the zod schema is available which allows the result to undergo
+     * Zod preprocessing, then it parses that result against the JSON schema.
+     * If the result is valid, it returns the parsed result. Otherwise, it throws
+     * an OutputParserException.
      * @param generations Array of ChatGeneration instances to be parsed.
      * @returns The parsed result if it is valid according to the JSON schema.
      */
@@ -56,12 +77,26 @@ class FunctionCallStructuredOutputParser extends output_parser_js_1.BaseLLMOutpu
             }
             return value;
         });
-        const result = this.jsonSchemaValidator.validate(parsedResult);
-        if (result.valid) {
-            return parsedResult;
+        if (this.zodSchema) {
+            const zodParsedResult = this.zodSchema.safeParse(parsedResult);
+            if (zodParsedResult.success) {
+                return zodParsedResult.data;
+            }
+            else {
+                throw new output_parsers_1.OutputParserException(`Failed to parse. Text: "${initialResult}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, initialResult);
+            }
+        }
+        else if (this.jsonSchemaValidator !== undefined) {
+            const result = this.jsonSchemaValidator.validate(parsedResult);
+            if (result.valid) {
+                return parsedResult;
+            }
+            else {
+                throw new output_parsers_1.OutputParserException(`Failed to parse. Text: "${initialResult}". Error: ${JSON.stringify(result.errors)}`, initialResult);
+            }
         }
         else {
-            throw new output_parser_js_1.OutputParserException(`Failed to parse. Text: "${initialResult}". Error: ${JSON.stringify(result.errors)}`, initialResult);
+            throw new Error("This parser requires an input JSON Schema or an input Zod schema.");
         }
     }
 }
@@ -73,7 +108,10 @@ exports.FunctionCallStructuredOutputParser = FunctionCallStructuredOutputParser;
  * @returns OpenAPIChain
  */
 function createStructuredOutputChain(input) {
-    const { outputSchema, llm = new openai_js_1.ChatOpenAI({ modelName: "gpt-3.5-turbo-0613", temperature: 0 }), outputKey = "output", llmKwargs = {}, ...rest } = input;
+    const { outputSchema, llm = new openai_1.ChatOpenAI({ modelName: "gpt-3.5-turbo-0613", temperature: 0 }), outputKey = "output", llmKwargs = {}, zodSchema, ...rest } = input;
+    if (outputSchema === undefined && zodSchema === undefined) {
+        throw new Error(`Must provide one of "outputSchema" or "zodSchema".`);
+    }
     const functionName = "output_formatter";
     return new llm_chain_js_1.LLMChain({
         llm,
@@ -91,7 +129,10 @@ function createStructuredOutputChain(input) {
             },
         },
         outputKey,
-        outputParser: new FunctionCallStructuredOutputParser(outputSchema),
+        outputParser: new FunctionCallStructuredOutputParser({
+            jsonSchema: outputSchema,
+            zodSchema,
+        }),
         ...rest,
     });
 }
@@ -100,6 +141,7 @@ function createStructuredOutputChainFromZod(zodSchema, input) {
     return createStructuredOutputChain({
         ...input,
         outputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zodSchema),
+        zodSchema,
     });
 }
 exports.createStructuredOutputChainFromZod = createStructuredOutputChainFromZod;

package/dist/chains/openai_functions/structured_output.d.ts

@@ -1,40 +1,48 @@
 import { z } from "zod";
 import { JsonSchema7Type } from "zod-to-json-schema/src/parseDef.js";
 import { Validator } from "@langchain/core/utils/json_schema";
-import { LLMChain, LLMChainInput } from "../llm_chain.js";
-import { ChatOpenAI } from "../../chat_models/openai.js";
-import { BasePromptTemplate } from "../../prompts/index.js";
-import { BaseLLMOutputParser } from "../../schema/output_parser.js";
+import { ChatOpenAI } from "@langchain/openai";
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
+import { ChatGeneration } from "@langchain/core/outputs";
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import type { BaseFunctionCallOptions } from "@langchain/core/language_models/base";
+import { LLMChain, type LLMChainInput } from "../llm_chain.js";
 import { OutputFunctionsParser } from "../../output_parsers/openai_functions.js";
-import { ChatGeneration } from "../../schema/index.js";
-import { BaseChatModel } from "../../chat_models/base.js";
-import { BaseFunctionCallOptions } from "../../base_language/index.js";
 /**
  * Type representing the input for creating a structured output chain. It
  * extends the LLMChainInput type and includes an additional
  * 'outputSchema' field representing the JSON schema for the expected
  * output.
  */
-export type StructuredOutputChainInput = Omit<LLMChainInput, "outputParser" | "llm"> & {
-    outputSchema: JsonSchema7Type;
+export type StructuredOutputChainInput<T extends z.AnyZodObject = z.AnyZodObject> = Omit<LLMChainInput, "outputParser" | "llm"> & {
+    outputSchema?: JsonSchema7Type;
     prompt: BasePromptTemplate;
     llm?: BaseChatModel<BaseFunctionCallOptions>;
+    zodSchema?: T;
+};
+export type FunctionCallStructuredOutputParserFields<T extends z.AnyZodObject = z.AnyZodObject> = {
+    jsonSchema?: JsonSchema7Type;
+    zodSchema?: T;
 };
 /**
  * Class that extends the BaseLLMOutputParser class. It provides
  * functionality for parsing the structured output based on a JSON schema.
  */
 export declare class FunctionCallStructuredOutputParser<T extends z.AnyZodObject> extends BaseLLMOutputParser<z.infer<T>> {
-    schema: JsonSchema7Type;
     lc_namespace: string[];
     protected functionOutputParser: OutputFunctionsParser;
-    protected jsonSchemaValidator: Validator;
-    constructor(schema: JsonSchema7Type);
+    protected jsonSchemaValidator?: Validator;
+    protected zodSchema?: T;
+    constructor(fieldsOrSchema: JsonSchema7Type);
+    constructor(fieldsOrSchema: FunctionCallStructuredOutputParserFields<T>);
     /**
      * Method to parse the result of chat generations. It first parses the
-     * result using the functionOutputParser, then validates the parsed result
-     * against the JSON schema. If the result is valid, it returns the parsed
-     * result. Otherwise, it throws an OutputParserException.
+     * result using the functionOutputParser, then parses the result against a
+     * zod schema if the zod schema is available which allows the result to undergo
+     * Zod preprocessing, then it parses that result against the JSON schema.
+     * If the result is valid, it returns the parsed result. Otherwise, it throws
+     * an OutputParserException.
      * @param generations Array of ChatGeneration instances to be parsed.
      * @returns The parsed result if it is valid according to the JSON schema.
      */
@@ -46,5 +54,5 @@ export declare class FunctionCallStructuredOutputParser<T extends z.AnyZodObject
  * as well as an additional required "outputSchema" JSON Schema object.
  * @returns OpenAPIChain
  */
-export declare function createStructuredOutputChain<T extends z.AnyZodObject = z.AnyZodObject>(input: StructuredOutputChainInput): LLMChain<any, BaseChatModel<BaseFunctionCallOptions> | ChatOpenAI<BaseFunctionCallOptions>>;
-export declare function createStructuredOutputChainFromZod<T extends z.AnyZodObject>(zodSchema: T, input: Omit<StructuredOutputChainInput, "outputSchema">): LLMChain<any, BaseChatModel<BaseFunctionCallOptions> | ChatOpenAI<BaseFunctionCallOptions>>;
+export declare function createStructuredOutputChain<T extends z.AnyZodObject = z.AnyZodObject>(input: StructuredOutputChainInput<T>): LLMChain<any, BaseChatModel<BaseFunctionCallOptions> | ChatOpenAI<BaseFunctionCallOptions>>;
+export declare function createStructuredOutputChainFromZod<T extends z.AnyZodObject>(zodSchema: T, input: Omit<StructuredOutputChainInput<T>, "outputSchema">): LLMChain<any, BaseChatModel<BaseFunctionCallOptions> | ChatOpenAI<BaseFunctionCallOptions>>;

package/dist/chains/openai_functions/structured_output.js

@@ -1,22 +1,30 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { Validator } from "@langchain/core/utils/json_schema";
+import { ChatOpenAI } from "@langchain/openai";
+import { BaseLLMOutputParser, OutputParserException, } from "@langchain/core/output_parsers";
 import { LLMChain } from "../llm_chain.js";
-import { ChatOpenAI } from "../../chat_models/openai.js";
-import { BaseLLMOutputParser, OutputParserException, } from "../../schema/output_parser.js";
 import { OutputFunctionsParser } from "../../output_parsers/openai_functions.js";
+function isJsonSchema7Type(x) {
+    return (x.jsonSchema === undefined &&
+        x.zodSchema === undefined);
+}
 /**
  * Class that extends the BaseLLMOutputParser class. It provides
  * functionality for parsing the structured output based on a JSON schema.
  */
 export class FunctionCallStructuredOutputParser extends BaseLLMOutputParser {
-    constructor(schema) {
-        super();
-        Object.defineProperty(this, "schema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: schema
-        });
+    constructor(fieldsOrSchema) {
+        let fields;
+        if (isJsonSchema7Type(fieldsOrSchema)) {
+            fields = { jsonSchema: fieldsOrSchema };
+        }
+        else {
+            fields = fieldsOrSchema;
+        }
+        if (fields.jsonSchema === undefined && fields.zodSchema === undefined) {
+            throw new Error(`Must provide one of "jsonSchema" or "zodSchema".`);
+        }
+        super(fields);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
             configurable: true,
@@ -35,13 +43,26 @@ export class FunctionCallStructuredOutputParser extends BaseLLMOutputParser {
             writable: true,
             value: void 0
         });
-        this.jsonSchemaValidator = new Validator(schema, "7");
+        Object.defineProperty(this, "zodSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (fields.jsonSchema !== undefined) {
+            this.jsonSchemaValidator = new Validator(fields.jsonSchema, "7");
+        }
+        else {
+            this.zodSchema = fields.zodSchema;
+        }
     }
     /**
      * Method to parse the result of chat generations. It first parses the
-     * result using the functionOutputParser, then validates the parsed result
-     * against the JSON schema. If the result is valid, it returns the parsed
-     * result. Otherwise, it throws an OutputParserException.
+     * result using the functionOutputParser, then parses the result against a
+     * zod schema if the zod schema is available which allows the result to undergo
+     * Zod preprocessing, then it parses that result against the JSON schema.
+     * If the result is valid, it returns the parsed result. Otherwise, it throws
+     * an OutputParserException.
      * @param generations Array of ChatGeneration instances to be parsed.
      * @returns The parsed result if it is valid according to the JSON schema.
      */
@@ -53,12 +74,26 @@ export class FunctionCallStructuredOutputParser extends BaseLLMOutputParser {
             }
             return value;
         });
-        const result = this.jsonSchemaValidator.validate(parsedResult);
-        if (result.valid) {
-            return parsedResult;
+        if (this.zodSchema) {
+            const zodParsedResult = this.zodSchema.safeParse(parsedResult);
+            if (zodParsedResult.success) {
+                return zodParsedResult.data;
+            }
+            else {
+                throw new OutputParserException(`Failed to parse. Text: "${initialResult}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`, initialResult);
+            }
+        }
+        else if (this.jsonSchemaValidator !== undefined) {
+            const result = this.jsonSchemaValidator.validate(parsedResult);
+            if (result.valid) {
+                return parsedResult;
+            }
+            else {
+                throw new OutputParserException(`Failed to parse. Text: "${initialResult}". Error: ${JSON.stringify(result.errors)}`, initialResult);
+            }
         }
         else {
-            throw new OutputParserException(`Failed to parse. Text: "${initialResult}". Error: ${JSON.stringify(result.errors)}`, initialResult);
+            throw new Error("This parser requires an input JSON Schema or an input Zod schema.");
         }
     }
 }
@@ -69,7 +104,10 @@ export class FunctionCallStructuredOutputParser extends BaseLLMOutputParser {
  * @returns OpenAPIChain
  */
 export function createStructuredOutputChain(input) {
-    const { outputSchema, llm = new ChatOpenAI({ modelName: "gpt-3.5-turbo-0613", temperature: 0 }), outputKey = "output", llmKwargs = {}, ...rest } = input;
+    const { outputSchema, llm = new ChatOpenAI({ modelName: "gpt-3.5-turbo-0613", temperature: 0 }), outputKey = "output", llmKwargs = {}, zodSchema, ...rest } = input;
+    if (outputSchema === undefined && zodSchema === undefined) {
+        throw new Error(`Must provide one of "outputSchema" or "zodSchema".`);
+    }
     const functionName = "output_formatter";
     return new LLMChain({
         llm,
@@ -87,7 +125,10 @@ export function createStructuredOutputChain(input) {
             },
         },
         outputKey,
-        outputParser: new FunctionCallStructuredOutputParser(outputSchema),
+        outputParser: new FunctionCallStructuredOutputParser({
+            jsonSchema: outputSchema,
+            zodSchema,
+        }),
         ...rest,
     });
 }
@@ -95,5 +136,6 @@ export function createStructuredOutputChainFromZod(zodSchema, input) {
     return createStructuredOutputChain({
         ...input,
         outputSchema: zodToJsonSchema(zodSchema),
+        zodSchema,
     });
 }

package/dist/chains/retrieval.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRetrievalChain = void 0;
+const runnables_1 = require("@langchain/core/runnables");
+function isBaseRetriever(x) {
+    return (!!x &&
+        typeof x.getRelevantDocuments === "function");
+}
+/**
+ * Create a retrieval chain that retrieves documents and then passes them on.
+ * @param {CreateRetrievalChainParams} params A params object
+ *     containing a retriever and a combineDocsChain.
+ * @returns An LCEL Runnable which returns a an object
+ *     containing at least `context` and `answer` keys.
+ * @example
+ * ```typescript
+ * // yarn add langchain @langchain/openai
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { pull } from "langchain/hub";
+ * import { createRetrievalChain } from "langchain/chains/retrieval";
+ * import { createStuffDocumentsChain } from "langchain/chains/combine_documents";
+ *
+ * const retrievalQAChatPrompt = await pull("langchain-ai/retrieval-qa-chat");
+ * const llm = new ChatOpenAI({});
+ * const retriever = ...
+ * const combineDocsChain = await createStuffDocumentsChain(...);
+ * const retrievalChain = await createRetrievalChain({
+ *   retriever,
+ *   combineDocsChain,
+ * });
+ * const response = await chain.invoke({ input: "..." });
+ * ```
+ */
+async function createRetrievalChain({ retriever, combineDocsChain, }) {
+    let retrieveDocumentsChain;
+    if (isBaseRetriever(retriever)) {
+        retrieveDocumentsChain = runnables_1.RunnableSequence.from([
+            (input) => input.input,
+            retriever,
+        ]);
+    }
+    else {
+        // TODO: Fix typing by adding withConfig to core RunnableInterface
+        retrieveDocumentsChain = retriever;
+    }
+    const retrievalChain = runnables_1.RunnableSequence.from([
+        runnables_1.RunnablePassthrough.assign({
+            context: retrieveDocumentsChain.withConfig({
+                runName: "retrieve_documents",
+            }),
+            chat_history: (input) => input.chat_history ?? [],
+        }),
+        runnables_1.RunnablePassthrough.assign({
+            answer: combineDocsChain,
+        }),
+    ]).withConfig({ runName: "retrieval_chain" });
+    return retrievalChain;
+}
+exports.createRetrievalChain = createRetrievalChain;

package/dist/chains/retrieval.d.ts

@@ -0,0 +1,65 @@
+import type { BaseRetrieverInterface } from "@langchain/core/retrievers";
+import { type RunnableInterface } from "@langchain/core/runnables";
+import type { BaseMessage } from "@langchain/core/messages";
+import type { DocumentInterface } from "@langchain/core/documents";
+/**
+ * Parameters for the createRetrievalChain method.
+ */
+export type CreateRetrievalChainParams<RunOutput> = {
+    /**
+     * Retriever-like object that returns list of documents. Should
+     * either be a subclass of BaseRetriever or a Runnable that returns
+     * a list of documents. If a subclass of BaseRetriever, then it
+     * is expected that an `input` key be passed in - this is what
+     * is will be used to pass into the retriever. If this is NOT a
+     * subclass of BaseRetriever, then all the inputs will be passed
+     * into this runnable, meaning that runnable should take a object
+     * as input.
+     */
+    retriever: BaseRetrieverInterface | RunnableInterface<Record<string, any>, DocumentInterface[]>;
+    /**
+     * Runnable that takes inputs and produces a string output.
+     * The inputs to this will be any original inputs to this chain, a new
+     * context key with the retrieved documents, and chat_history (if not present
+     * in the inputs) with a value of `[]` (to easily enable conversational
+     * retrieval).
+     */
+    combineDocsChain: RunnableInterface<Record<string, any>, RunOutput>;
+};
+/**
+ * Create a retrieval chain that retrieves documents and then passes them on.
+ * @param {CreateRetrievalChainParams} params A params object
+ *     containing a retriever and a combineDocsChain.
+ * @returns An LCEL Runnable which returns a an object
+ *     containing at least `context` and `answer` keys.
+ * @example
+ * ```typescript
+ * // yarn add langchain @langchain/openai
+ *
+ * import { ChatOpenAI } from "@langchain/openai";
+ * import { pull } from "langchain/hub";
+ * import { createRetrievalChain } from "langchain/chains/retrieval";
+ * import { createStuffDocumentsChain } from "langchain/chains/combine_documents";
+ *
+ * const retrievalQAChatPrompt = await pull("langchain-ai/retrieval-qa-chat");
+ * const llm = new ChatOpenAI({});
+ * const retriever = ...
+ * const combineDocsChain = await createStuffDocumentsChain(...);
+ * const retrievalChain = await createRetrievalChain({
+ *   retriever,
+ *   combineDocsChain,
+ * });
+ * const response = await chain.invoke({ input: "..." });
+ * ```
+ */
+export declare function createRetrievalChain<RunOutput>({ retriever, combineDocsChain, }: CreateRetrievalChainParams<RunOutput>): Promise<RunnableInterface<{
+    input: string;
+    chat_history?: BaseMessage[] | string;
+} & {
+    [key: string]: unknown;
+}, {
+    context: string;
+    answer: RunOutput;
+} & {
+    [key: string]: unknown;
+}>>;