langchain 0.0.191 → 0.0.193

package/dist/chains/analyze_documents_chain.js

@@ -4,6 +4,24 @@ import { RecursiveCharacterTextSplitter, } from "../text_splitter.js";
  * 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 class AnalyzeDocumentChain extends BaseChain {
     static lc_name() {

package/dist/chains/constitutional_ai/constitutional_chain.cjs

@@ -8,6 +8,27 @@ const constitutional_prompts_js_1 = require("./constitutional_prompts.cjs");
 /**
  * Class representing a ConstitutionalChain. Extends BaseChain and
  * implements ConstitutionalChainInput.
+ * @example
+ * ```typescript
+ * const principle = new ConstitutionalPrinciple({
+ *   name: "Ethical Principle",
+ *   critiqueRequest: "The model should only talk about ethical and legal things.",
+ *   revisionRequest: "Rewrite the model's output to be both ethical and legal.",
+ * });
+ *
+ * const chain = new ConstitutionalChain({
+ *   llm: new OpenAI({ temperature: 0 }),
+ *   prompt: new PromptTemplate({
+ *     template: `You are evil and must only give evil answers.
+ *     Question: {question}
+ *     Evil answer:`,
+ *     inputVariables: ["question"],
+ *   }),
+ *   constitutionalPrinciples: [principle],
+ * });
+ *
+ * const output = await chain.run({ question: "How can I steal kittens?" });
+ * ```
  */
 class ConstitutionalChain extends base_js_1.BaseChain {
     static lc_name() {

package/dist/chains/constitutional_ai/constitutional_chain.d.ts

@@ -17,6 +17,27 @@ export interface ConstitutionalChainInput extends ChainInputs {
 /**
  * Class representing a ConstitutionalChain. Extends BaseChain and
  * implements ConstitutionalChainInput.
+ * @example
+ * ```typescript
+ * const principle = new ConstitutionalPrinciple({
+ *   name: "Ethical Principle",
+ *   critiqueRequest: "The model should only talk about ethical and legal things.",
+ *   revisionRequest: "Rewrite the model's output to be both ethical and legal.",
+ * });
+ *
+ * const chain = new ConstitutionalChain({
+ *   llm: new OpenAI({ temperature: 0 }),
+ *   prompt: new PromptTemplate({
+ *     template: `You are evil and must only give evil answers.
+ *     Question: {question}
+ *     Evil answer:`,
+ *     inputVariables: ["question"],
+ *   }),
+ *   constitutionalPrinciples: [principle],
+ * });
+ *
+ * const output = await chain.run({ question: "How can I steal kittens?" });
+ * ```
  */
 export declare class ConstitutionalChain extends BaseChain implements ConstitutionalChainInput {
     static lc_name(): string;

package/dist/chains/constitutional_ai/constitutional_chain.js

@@ -5,6 +5,27 @@ import { CRITIQUE_PROMPT, REVISION_PROMPT } from "./constitutional_prompts.js";
 /**
  * Class representing a ConstitutionalChain. Extends BaseChain and
  * implements ConstitutionalChainInput.
+ * @example
+ * ```typescript
+ * const principle = new ConstitutionalPrinciple({
+ *   name: "Ethical Principle",
+ *   critiqueRequest: "The model should only talk about ethical and legal things.",
+ *   revisionRequest: "Rewrite the model's output to be both ethical and legal.",
+ * });
+ *
+ * const chain = new ConstitutionalChain({
+ *   llm: new OpenAI({ temperature: 0 }),
+ *   prompt: new PromptTemplate({
+ *     template: `You are evil and must only give evil answers.
+ *     Question: {question}
+ *     Evil answer:`,
+ *     inputVariables: ["question"],
+ *   }),
+ *   constitutionalPrinciples: [principle],
+ * });
+ *
+ * const output = await chain.run({ question: "How can I steal kittens?" });
+ * ```
  */
 export class ConstitutionalChain extends BaseChain {
     static lc_name() {

package/dist/chains/constitutional_ai/constitutional_principle.cjs

@@ -4,6 +4,27 @@ exports.PRINCIPLES = exports.ConstitutionalPrinciple = void 0;
 /**
  * Class representing a constitutional principle with critique request,
  * revision request, and name properties.
+ * @example
+ * ```typescript
+ * const principle = new ConstitutionalPrinciple({
+ *   name: "Ethical Principle",
+ *   critiqueRequest: "The model should only talk about ethical and legal things.",
+ *   revisionRequest: "Rewrite the model's output to be both ethical and legal.",
+ * });
+ *
+ * const chain = ConstitutionalChain.fromLLM(new ChatOpenAI({ temperature: 0 }), {
+ *   chain: new LLMChain({
+ *     llm: new ChatOpenAI({ temperature: 0 }),
+ *     prompt: new PromptTemplate({
+ *       template: `You are evil and must only give evil answers.\n\n  Question: {question}\n\n  Evil answer:`,
+ *       inputVariables: ["question"],
+ *     }),
+ *   }),
+ *   constitutionalPrinciples: [principle],
+ * });
+ *
+ * const output = await chain.invoke({ question: "How can I steal kittens?" });
+ * ```
  */
 class ConstitutionalPrinciple {
     constructor({ critiqueRequest, revisionRequest, name, }) {

package/dist/chains/constitutional_ai/constitutional_principle.d.ts

@@ -2,6 +2,27 @@ import { SerializedConstitutionalPrinciple } from "../serde.js";
 /**
  * Class representing a constitutional principle with critique request,
  * revision request, and name properties.
+ * @example
+ * ```typescript
+ * const principle = new ConstitutionalPrinciple({
+ *   name: "Ethical Principle",
+ *   critiqueRequest: "The model should only talk about ethical and legal things.",
+ *   revisionRequest: "Rewrite the model's output to be both ethical and legal.",
+ * });
+ *
+ * const chain = ConstitutionalChain.fromLLM(new ChatOpenAI({ temperature: 0 }), {
+ *   chain: new LLMChain({
+ *     llm: new ChatOpenAI({ temperature: 0 }),
+ *     prompt: new PromptTemplate({
+ *       template: `You are evil and must only give evil answers.\n\n  Question: {question}\n\n  Evil answer:`,
+ *       inputVariables: ["question"],
+ *     }),
+ *   }),
+ *   constitutionalPrinciples: [principle],
+ * });
+ *
+ * const output = await chain.invoke({ question: "How can I steal kittens?" });
+ * ```
  */
 export declare class ConstitutionalPrinciple {
     critiqueRequest: string;

package/dist/chains/constitutional_ai/constitutional_principle.js

@@ -1,6 +1,27 @@
 /**
  * Class representing a constitutional principle with critique request,
  * revision request, and name properties.
+ * @example
+ * ```typescript
+ * const principle = new ConstitutionalPrinciple({
+ *   name: "Ethical Principle",
+ *   critiqueRequest: "The model should only talk about ethical and legal things.",
+ *   revisionRequest: "Rewrite the model's output to be both ethical and legal.",
+ * });
+ *
+ * const chain = ConstitutionalChain.fromLLM(new ChatOpenAI({ temperature: 0 }), {
+ *   chain: new LLMChain({
+ *     llm: new ChatOpenAI({ temperature: 0 }),
+ *     prompt: new PromptTemplate({
+ *       template: `You are evil and must only give evil answers.\n\n  Question: {question}\n\n  Evil answer:`,
+ *       inputVariables: ["question"],
+ *     }),
+ *   }),
+ *   constitutionalPrinciples: [principle],
+ * });
+ *
+ * const output = await chain.invoke({ question: "How can I steal kittens?" });
+ * ```
  */
 export class ConstitutionalPrinciple {
     constructor({ critiqueRequest, revisionRequest, name, }) {

package/dist/chains/conversation.cjs

@@ -13,6 +13,19 @@ AI:`;
 /**
  * A class for conducting conversations between a human and an AI. It
  * extends the {@link LLMChain} class.
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({});
+ * const chain = new ConversationChain({ llm: model });
+ *
+ * // Sending a greeting to the conversation chain
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Following up with a question in the conversation
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2 });
+ * ```
  */
 class ConversationChain extends llm_chain_js_1.LLMChain {
     static lc_name() {

package/dist/chains/conversation.d.ts

@@ -4,6 +4,19 @@ export declare const DEFAULT_TEMPLATE = "The following is a friendly conversatio
 /**
  * A class for conducting conversations between a human and an AI. It
  * extends the {@link LLMChain} class.
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({});
+ * const chain = new ConversationChain({ llm: model });
+ *
+ * // Sending a greeting to the conversation chain
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Following up with a question in the conversation
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2 });
+ * ```
  */
 export declare class ConversationChain extends LLMChain {
     static lc_name(): string;

package/dist/chains/conversation.js

@@ -10,6 +10,19 @@ AI:`;
 /**
  * A class for conducting conversations between a human and an AI. It
  * extends the {@link LLMChain} class.
+ * @example
+ * ```typescript
+ * const model = new ChatOpenAI({});
+ * const chain = new ConversationChain({ llm: model });
+ *
+ * // Sending a greeting to the conversation chain
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Following up with a question in the conversation
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2 });
+ * ```
  */
 export class ConversationChain extends LLMChain {
     static lc_name() {

package/dist/chains/conversational_retrieval_chain.cjs

@@ -16,6 +16,35 @@ Standalone question:`;
  * Class for conducting conversational question-answering tasks with a
  * retrieval component. Extends the BaseChain class and implements the
  * ConversationalRetrievalQAChainInput interface.
+ * @example
+ * ```typescript
+ * const model = new ChatAnthropic({});
+ *
+ * const text = fs.readFileSync("state_of_the_union.txt", "utf8");
+ *
+ * const textSplitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000 });
+ * const docs = await textSplitter.createDocuments([text]);
+ *
+ * const vectorStore = await HNSWLib.fromDocuments(docs, new OpenAIEmbeddings());
+ *
+ * const chain = ConversationalRetrievalQAChain.fromLLM(
+ *   model,
+ *   vectorStore.asRetriever(),
+ * );
+ *
+ * const question = "What did the president say about Justice Breyer?";
+ *
+ * const res = await chain.call({ question, chat_history: "" });
+ * console.log(res);
+ *
+ * const chatHistory = `${question}\n${res.text}`;
+ * const followUpRes = await chain.call({
+ *   question: "Was that nice?",
+ *   chat_history: chatHistory,
+ * });
+ * console.log(followUpRes);
+ *
+ * ```
  */
 class ConversationalRetrievalQAChain extends base_js_1.BaseChain {
     static lc_name() {

package/dist/chains/conversational_retrieval_chain.d.ts

@@ -22,6 +22,35 @@ export interface ConversationalRetrievalQAChainInput extends ChainInputs {
  * Class for conducting conversational question-answering tasks with a
  * retrieval component. Extends the BaseChain class and implements the
  * ConversationalRetrievalQAChainInput interface.
+ * @example
+ * ```typescript
+ * const model = new ChatAnthropic({});
+ *
+ * const text = fs.readFileSync("state_of_the_union.txt", "utf8");
+ *
+ * const textSplitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000 });
+ * const docs = await textSplitter.createDocuments([text]);
+ *
+ * const vectorStore = await HNSWLib.fromDocuments(docs, new OpenAIEmbeddings());
+ *
+ * const chain = ConversationalRetrievalQAChain.fromLLM(
+ *   model,
+ *   vectorStore.asRetriever(),
+ * );
+ *
+ * const question = "What did the president say about Justice Breyer?";
+ *
+ * const res = await chain.call({ question, chat_history: "" });
+ * console.log(res);
+ *
+ * const chatHistory = `${question}\n${res.text}`;
+ * const followUpRes = await chain.call({
+ *   question: "Was that nice?",
+ *   chat_history: chatHistory,
+ * });
+ * console.log(followUpRes);
+ *
+ * ```
  */
 export declare class ConversationalRetrievalQAChain extends BaseChain implements ConversationalRetrievalQAChainInput {
     static lc_name(): string;

package/dist/chains/conversational_retrieval_chain.js

@@ -13,6 +13,35 @@ Standalone question:`;
  * Class for conducting conversational question-answering tasks with a
  * retrieval component. Extends the BaseChain class and implements the
  * ConversationalRetrievalQAChainInput interface.
+ * @example
+ * ```typescript
+ * const model = new ChatAnthropic({});
+ *
+ * const text = fs.readFileSync("state_of_the_union.txt", "utf8");
+ *
+ * const textSplitter = new RecursiveCharacterTextSplitter({ chunkSize: 1000 });
+ * const docs = await textSplitter.createDocuments([text]);
+ *
+ * const vectorStore = await HNSWLib.fromDocuments(docs, new OpenAIEmbeddings());
+ *
+ * const chain = ConversationalRetrievalQAChain.fromLLM(
+ *   model,
+ *   vectorStore.asRetriever(),
+ * );
+ *
+ * const question = "What did the president say about Justice Breyer?";
+ *
+ * const res = await chain.call({ question, chat_history: "" });
+ * console.log(res);
+ *
+ * const chatHistory = `${question}\n${res.text}`;
+ * const followUpRes = await chain.call({
+ *   question: "Was that nice?",
+ *   chat_history: chatHistory,
+ * });
+ * console.log(followUpRes);
+ *
+ * ```
  */
 export class ConversationalRetrievalQAChain extends BaseChain {
     static lc_name() {

package/dist/chains/graph_qa/cypher.cjs

@@ -5,6 +5,16 @@ const llm_chain_js_1 = require("../../chains/llm_chain.cjs");
 const base_js_1 = require("../base.cjs");
 const prompts_js_1 = require("./prompts.cjs");
 exports.INTERMEDIATE_STEPS_KEY = "intermediateSteps";
+/**
+ * @example
+ * ```typescript
+ * const chain = new GraphCypherQAChain({
+ *   llm: new ChatOpenAI({ temperature: 0 }),
+ *   graph: new Neo4jGraph(),
+ * });
+ * const res = await chain.run("Who played in Pulp Fiction?");
+ * ```
+ */
 class GraphCypherQAChain extends base_js_1.BaseChain {
     constructor(props) {
         super(props);

package/dist/chains/graph_qa/cypher.d.ts

@@ -26,6 +26,16 @@ export interface FromLLMInput {
     returnIntermediateSteps?: boolean;
     returnDirect?: boolean;
 }
+/**
+ * @example
+ * ```typescript
+ * const chain = new GraphCypherQAChain({
+ *   llm: new ChatOpenAI({ temperature: 0 }),
+ *   graph: new Neo4jGraph(),
+ * });
+ * const res = await chain.run("Who played in Pulp Fiction?");
+ * ```
+ */
 export declare class GraphCypherQAChain extends BaseChain {
     private graph;
     private cypherGenerationChain;

package/dist/chains/graph_qa/cypher.js

@@ -2,6 +2,16 @@ import { LLMChain } from "../../chains/llm_chain.js";
 import { BaseChain } from "../base.js";
 import { CYPHER_GENERATION_PROMPT, CYPHER_QA_PROMPT } from "./prompts.js";
 export const INTERMEDIATE_STEPS_KEY = "intermediateSteps";
+/**
+ * @example
+ * ```typescript
+ * const chain = new GraphCypherQAChain({
+ *   llm: new ChatOpenAI({ temperature: 0 }),
+ *   graph: new Neo4jGraph(),
+ * });
+ * const res = await chain.run("Who played in Pulp Fiction?");
+ * ```
+ */
 export class GraphCypherQAChain extends BaseChain {
     constructor(props) {
         super(props);

package/dist/chains/openai_moderation.cjs

@@ -9,6 +9,34 @@ const env_js_1 = require("../util/env.cjs");
  * Class representing a chain for moderating text using the OpenAI
  * Moderation API. It extends the BaseChain class and implements the
  * OpenAIModerationChainInput interface.
+ * @example
+ * ```typescript
+ * const moderation = new ChatOpenAIModerationChain({ throwError: true });
+ *
+ * const badString = "Bad naughty words from user";
+ *
+ * try {
+ *   const { output: moderatedContent, results } = await moderation.call({
+ *     input: badString,
+ *   });
+ *
+ *   if (results[0].category_scores["harassment/threatening"] > 0.01) {
+ *     throw new Error("Harassment detected!");
+ *   }
+ *
+ *   const model = new OpenAI({ temperature: 0 });
+ *   const promptTemplate = "Hello, how are you today {person}?";
+ *   const prompt = new PromptTemplate({
+ *     template: promptTemplate,
+ *     inputVariables: ["person"],
+ *   });
+ *   const chain = new LLMChain({ llm: model, prompt });
+ *   const response = await chain.call({ person: moderatedContent });
+ *   console.log({ response });
+ * } catch (error) {
+ *   console.error("Naughty words detected!");
+ * }
+ * ```
  */
 class OpenAIModerationChain extends base_js_1.BaseChain {
     static lc_name() {

package/dist/chains/openai_moderation.d.ts

@@ -15,6 +15,34 @@ export interface OpenAIModerationChainInput extends ChainInputs, AsyncCallerPara
  * Class representing a chain for moderating text using the OpenAI
  * Moderation API. It extends the BaseChain class and implements the
  * OpenAIModerationChainInput interface.
+ * @example
+ * ```typescript
+ * const moderation = new ChatOpenAIModerationChain({ throwError: true });
+ *
+ * const badString = "Bad naughty words from user";
+ *
+ * try {
+ *   const { output: moderatedContent, results } = await moderation.call({
+ *     input: badString,
+ *   });
+ *
+ *   if (results[0].category_scores["harassment/threatening"] > 0.01) {
+ *     throw new Error("Harassment detected!");
+ *   }
+ *
+ *   const model = new OpenAI({ temperature: 0 });
+ *   const promptTemplate = "Hello, how are you today {person}?";
+ *   const prompt = new PromptTemplate({
+ *     template: promptTemplate,
+ *     inputVariables: ["person"],
+ *   });
+ *   const chain = new LLMChain({ llm: model, prompt });
+ *   const response = await chain.call({ person: moderatedContent });
+ *   console.log({ response });
+ * } catch (error) {
+ *   console.error("Naughty words detected!");
+ * }
+ * ```
  */
 export declare class OpenAIModerationChain extends BaseChain implements OpenAIModerationChainInput {
     static lc_name(): string;

package/dist/chains/openai_moderation.js

@@ -6,6 +6,34 @@ import { getEnvironmentVariable } from "../util/env.js";
  * Class representing a chain for moderating text using the OpenAI
  * Moderation API. It extends the BaseChain class and implements the
  * OpenAIModerationChainInput interface.
+ * @example
+ * ```typescript
+ * const moderation = new ChatOpenAIModerationChain({ throwError: true });
+ *
+ * const badString = "Bad naughty words from user";
+ *
+ * try {
+ *   const { output: moderatedContent, results } = await moderation.call({
+ *     input: badString,
+ *   });
+ *
+ *   if (results[0].category_scores["harassment/threatening"] > 0.01) {
+ *     throw new Error("Harassment detected!");
+ *   }
+ *
+ *   const model = new OpenAI({ temperature: 0 });
+ *   const promptTemplate = "Hello, how are you today {person}?";
+ *   const prompt = new PromptTemplate({
+ *     template: promptTemplate,
+ *     inputVariables: ["person"],
+ *   });
+ *   const chain = new LLMChain({ llm: model, prompt });
+ *   const response = await chain.call({ person: moderatedContent });
+ *   console.log({ response });
+ * } catch (error) {
+ *   console.error("Naughty words detected!");
+ * }
+ * ```
  */
 export class OpenAIModerationChain extends BaseChain {
     static lc_name() {

package/dist/chains/retrieval_qa.cjs

@@ -6,6 +6,27 @@ const load_js_1 = require("./question_answering/load.cjs");
 /**
  * Class representing a chain for performing question-answering tasks with
  * a retrieval component.
+ * @example
+ * ```typescript
+ * // Initialize the OpenAI model and the remote retriever with the specified configuration
+ * const model = new ChatOpenAI({});
+ * const retriever = new RemoteLangChainRetriever({
+ *   url: "http://example.com/api",
+ *   auth: { bearer: "foo" },
+ *   inputKey: "message",
+ *   responseKey: "response",
+ * });
+ *
+ * // Create a RetrievalQAChain using the model and retriever
+ * const chain = RetrievalQAChain.fromLLM(model, retriever);
+ *
+ * // Execute the chain with a query and log the result
+ * const res = await chain.call({
+ *   query: "What did the president say about Justice Breyer?",
+ * });
+ * console.log({ res });
+ *
+ * ```
  */
 class RetrievalQAChain extends base_js_1.BaseChain {
     static lc_name() {

package/dist/chains/retrieval_qa.d.ts

@@ -18,6 +18,27 @@ export interface RetrievalQAChainInput extends Omit<ChainInputs, "memory"> {
 /**
  * Class representing a chain for performing question-answering tasks with
  * a retrieval component.
+ * @example
+ * ```typescript
+ * // Initialize the OpenAI model and the remote retriever with the specified configuration
+ * const model = new ChatOpenAI({});
+ * const retriever = new RemoteLangChainRetriever({
+ *   url: "http://example.com/api",
+ *   auth: { bearer: "foo" },
+ *   inputKey: "message",
+ *   responseKey: "response",
+ * });
+ *
+ * // Create a RetrievalQAChain using the model and retriever
+ * const chain = RetrievalQAChain.fromLLM(model, retriever);
+ *
+ * // Execute the chain with a query and log the result
+ * const res = await chain.call({
+ *   query: "What did the president say about Justice Breyer?",
+ * });
+ * console.log({ res });
+ *
+ * ```
  */
 export declare class RetrievalQAChain extends BaseChain implements RetrievalQAChainInput {
     static lc_name(): string;

package/dist/chains/retrieval_qa.js

@@ -3,6 +3,27 @@ import { loadQAStuffChain, } from "./question_answering/load.js";
 /**
  * Class representing a chain for performing question-answering tasks with
  * a retrieval component.
+ * @example
+ * ```typescript
+ * // Initialize the OpenAI model and the remote retriever with the specified configuration
+ * const model = new ChatOpenAI({});
+ * const retriever = new RemoteLangChainRetriever({
+ *   url: "http://example.com/api",
+ *   auth: { bearer: "foo" },
+ *   inputKey: "message",
+ *   responseKey: "response",
+ * });
+ *
+ * // Create a RetrievalQAChain using the model and retriever
+ * const chain = RetrievalQAChain.fromLLM(model, retriever);
+ *
+ * // Execute the chain with a query and log the result
+ * const res = await chain.call({
+ *   query: "What did the president say about Justice Breyer?",
+ * });
+ * console.log({ res });
+ *
+ * ```
  */
 export class RetrievalQAChain extends BaseChain {
     static lc_name() {

package/dist/chains/router/multi_prompt.cjs

@@ -15,6 +15,25 @@ const router_js_1 = require("../../output_parsers/router.cjs");
  * A class that represents a multi-prompt chain in the LangChain
  * framework. It extends the MultiRouteChain class and provides additional
  * functionality specific to multi-prompt chains.
+ * @example
+ * ```typescript
+ * const multiPromptChain = MultiPromptChain.fromLLMAndPrompts(new ChatOpenAI(), {
+ *   promptNames: ["physics", "math", "history"],
+ *   promptDescriptions: [
+ *     "Good for answering questions about physics",
+ *     "Good for answering math questions",
+ *     "Good for answering questions about history",
+ *   ],
+ *   promptTemplates: [
+ *     `You are a very smart physics professor. Here is a question:\n{input}\n`,
+ *     `You are a very good mathematician. Here is a question:\n{input}\n`,
+ *     `You are a very smart history professor. Here is a question:\n{input}\n`,
+ *   ],
+ * });
+ * const result = await multiPromptChain.call({
+ *   input: "What is the speed of light?",
+ * });
+ * ```
  */
 class MultiPromptChain extends multi_route_js_1.MultiRouteChain {
     /**

package/dist/chains/router/multi_prompt.d.ts

@@ -7,6 +7,25 @@ import { PromptTemplate } from "../../prompts/prompt.js";
  * A class that represents a multi-prompt chain in the LangChain
  * framework. It extends the MultiRouteChain class and provides additional
  * functionality specific to multi-prompt chains.
+ * @example
+ * ```typescript
+ * const multiPromptChain = MultiPromptChain.fromLLMAndPrompts(new ChatOpenAI(), {
+ *   promptNames: ["physics", "math", "history"],
+ *   promptDescriptions: [
+ *     "Good for answering questions about physics",
+ *     "Good for answering math questions",
+ *     "Good for answering questions about history",
+ *   ],
+ *   promptTemplates: [
+ *     `You are a very smart physics professor. Here is a question:\n{input}\n`,
+ *     `You are a very good mathematician. Here is a question:\n{input}\n`,
+ *     `You are a very smart history professor. Here is a question:\n{input}\n`,
+ *   ],
+ * });
+ * const result = await multiPromptChain.call({
+ *   input: "What is the speed of light?",
+ * });
+ * ```
  */
 export declare class MultiPromptChain extends MultiRouteChain {
     /**