langchain 0.0.192 → 0.0.194

package/dist/cache/momento.d.ts

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

package/dist/cache/momento.js

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

package/dist/cache/redis.cjs

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

package/dist/cache/redis.d.ts

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

package/dist/cache/redis.js

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

package/dist/cache/upstash_redis.cjs

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

package/dist/cache/upstash_redis.d.ts

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

package/dist/cache/upstash_redis.js

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

package/dist/callbacks/handlers/console.cjs

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

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

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

package/dist/callbacks/handlers/console.js

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

package/dist/callbacks/manager.cjs

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

package/dist/callbacks/manager.d.ts

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

package/dist/callbacks/manager.js

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

package/dist/chains/analyze_documents_chain.cjs

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

package/dist/chains/analyze_documents_chain.d.ts

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

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, }) {