langchain 0.0.130 → 0.0.132

package/dist/load/serializable.js

@@ -25,7 +25,45 @@ function replaceSecrets(root, secretsMap) {
     }
     return result;
 }
+/**
+ * Get a unique name for the module, rather than parent class implementations.
+ * Should not be subclassed, subclass lc_name above instead.
+ */
+export function get_lc_unique_name(
+// eslint-disable-next-line @typescript-eslint/no-use-before-define
+serializableClass) {
+    // "super" here would refer to the parent class of Serializable,
+    // when we want the parent class of the module actually calling this method.
+    const parentClass = Object.getPrototypeOf(serializableClass);
+    const lcNameIsSubclassed = typeof serializableClass.lc_name === "function" &&
+        (typeof parentClass.lc_name !== "function" ||
+            serializableClass.lc_name() !== parentClass.lc_name());
+    if (lcNameIsSubclassed) {
+        return serializableClass.lc_name();
+    }
+    else {
+        return serializableClass.name;
+    }
+}
 export class Serializable {
+    /**
+     * The name of the serializable. Override to provide an alias or
+     * to preserve the serialized module name in minified environments.
+     *
+     * Implemented as a static method to support loading logic.
+     */
+    static lc_name() {
+        return this.name;
+    }
+    /**
+     * The final serialized identifier for the module.
+     */
+    get lc_id() {
+        return [
+            ...this.lc_namespace,
+            get_lc_unique_name(this.constructor),
+        ];
+    }
     /**
      * A map of secrets, which will be omitted from serialization.
      * Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
@@ -104,7 +142,7 @@ export class Serializable {
         return {
             lc: 1,
             type: "constructor",
-            id: [...this.lc_namespace, this.constructor.name],
+            id: this.lc_id,
             kwargs: mapKeys(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, keyToJson, aliases),
         };
     }
@@ -112,7 +150,7 @@ export class Serializable {
         return {
             lc: 1,
             type: "not_implemented",
-            id: [...this.lc_namespace, this.constructor.name],
+            id: this.lc_id,
         };
     }
 }

package/dist/memory/base.cjs

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPromptInputKey = exports.getBufferString = exports.getOutputValue = exports.getInputValue = exports.BaseMemory = void 0;
+/**
+ * Abstract base class for memory in LangChain's Chains. Memory refers to
+ * the state in Chains. It can be used to store information about past
+ * executions of a Chain and inject that information into the inputs of
+ * future executions of the Chain.
+ */
 class BaseMemory {
 }
 exports.BaseMemory = BaseMemory;
@@ -74,6 +80,11 @@ function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI") {
     return string_messages.join("\n");
 }
 exports.getBufferString = getBufferString;
+/**
+ * Function used by memory classes to get the key of the prompt input,
+ * excluding any keys that are memory variables or the "stop" key. If
+ * there is not exactly one prompt input key, an error is thrown.
+ */
 function getPromptInputKey(inputs, memoryVariables) {
     const promptInputKeys = Object.keys(inputs).filter((key) => !memoryVariables.includes(key) && key !== "stop");
     if (promptInputKeys.length !== 1) {

package/dist/memory/base.d.ts

@@ -1,10 +1,45 @@
 import { BaseMessage } from "../schema/index.js";
+/**
+ * Type alias for a record where the keys are strings and the values can
+ * be any type. This is used to represent the input values for a Chain.
+ */
 export type InputValues = Record<string, any>;
+/**
+ * Type alias for a record where the keys are strings and the values can
+ * be any type. This is used to represent the output values from a Chain.
+ */
 export type OutputValues = Record<string, any>;
+/**
+ * Type alias for a record where the keys are strings and the values can
+ * be any type. This is used to represent the memory variables in a Chain.
+ */
 export type MemoryVariables = Record<string, any>;
+/**
+ * Abstract base class for memory in LangChain's Chains. Memory refers to
+ * the state in Chains. It can be used to store information about past
+ * executions of a Chain and inject that information into the inputs of
+ * future executions of the Chain.
+ */
 export declare abstract class BaseMemory {
     abstract get memoryKeys(): string[];
+    /**
+     * Abstract method that should take an object of input values and return a
+     * Promise that resolves with an object of memory variables. The
+     * implementation of this method should load the memory variables from the
+     * provided input values.
+     * @param values An object of input values.
+     * @returns Promise that resolves with an object of memory variables.
+     */
     abstract loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;
+    /**
+     * Abstract method that should take two objects, one of input values and
+     * one of output values, and return a Promise that resolves when the
+     * context has been saved. The implementation of this method should save
+     * the context based on the provided input and output values.
+     * @param inputValues An object of input values.
+     * @param outputValues An object of output values.
+     * @returns Promise that resolves when the context has been saved.
+     */
     abstract saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
 }
 /**
@@ -25,4 +60,9 @@ export declare const getOutputValue: (outputValues: OutputValues, outputKey?: st
  * of the chat message history, based on the message content and role.
  */
 export declare function getBufferString(messages: BaseMessage[], humanPrefix?: string, aiPrefix?: string): string;
+/**
+ * Function used by memory classes to get the key of the prompt input,
+ * excluding any keys that are memory variables or the "stop" key. If
+ * there is not exactly one prompt input key, an error is thrown.
+ */
 export declare function getPromptInputKey(inputs: Record<string, unknown>, memoryVariables: string[]): string;

package/dist/memory/base.js

@@ -1,3 +1,9 @@
+/**
+ * Abstract base class for memory in LangChain's Chains. Memory refers to
+ * the state in Chains. It can be used to store information about past
+ * executions of a Chain and inject that information into the inputs of
+ * future executions of the Chain.
+ */
 export class BaseMemory {
 }
 const getValue = (values, key) => {
@@ -67,6 +73,11 @@ export function getBufferString(messages, humanPrefix = "Human", aiPrefix = "AI"
     }
     return string_messages.join("\n");
 }
+/**
+ * Function used by memory classes to get the key of the prompt input,
+ * excluding any keys that are memory variables or the "stop" key. If
+ * there is not exactly one prompt input key, an error is thrown.
+ */
 export function getPromptInputKey(inputs, memoryVariables) {
     const promptInputKeys = Object.keys(inputs).filter((key) => !memoryVariables.includes(key) && key !== "stop");
     if (promptInputKeys.length !== 1) {

package/dist/memory/buffer_memory.cjs

@@ -3,6 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BufferMemory = void 0;
 const base_js_1 = require("./base.cjs");
 const chat_memory_js_1 = require("./chat_memory.cjs");
+/**
+ * The `BufferMemory` class is a type of memory component used for storing
+ * and managing previous chat messages. It is a wrapper around
+ * `ChatMessageHistory` that extracts the messages into an input variable.
+ * This class is particularly useful in applications like chatbots where
+ * it is essential to remember previous interactions. Note: The memory
+ * instance represents the history of a single conversation. Therefore, it
+ * is not recommended to share the same history or memory instance between
+ * two different chains. If you deploy your LangChain app on a serverless
+ * environment, do not store memory instances in a variable, as your
+ * hosting provider may reset it by the next time the function is called.
+ */
 class BufferMemory extends chat_memory_js_1.BaseChatMemory {
     constructor(fields) {
         super({
@@ -36,6 +48,13 @@ class BufferMemory extends chat_memory_js_1.BaseChatMemory {
     get memoryKeys() {
         return [this.memoryKey];
     }
+    /**
+     * Loads the memory variables. It takes an `InputValues` object as a
+     * parameter and returns a `Promise` that resolves with a
+     * `MemoryVariables` object.
+     * @param _values `InputValues` object.
+     * @returns A `Promise` that resolves with a `MemoryVariables` object.
+     */
     async loadMemoryVariables(_values) {
         const messages = await this.chatHistory.getMessages();
         if (this.returnMessages) {

package/dist/memory/buffer_memory.d.ts

@@ -1,15 +1,37 @@
 import { InputValues, MemoryVariables } from "./base.js";
 import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.js";
+/**
+ * Interface for the input parameters of the `BufferMemory` class.
+ */
 export interface BufferMemoryInput extends BaseChatMemoryInput {
     humanPrefix?: string;
     aiPrefix?: string;
     memoryKey?: string;
 }
+/**
+ * The `BufferMemory` class is a type of memory component used for storing
+ * and managing previous chat messages. It is a wrapper around
+ * `ChatMessageHistory` that extracts the messages into an input variable.
+ * This class is particularly useful in applications like chatbots where
+ * it is essential to remember previous interactions. Note: The memory
+ * instance represents the history of a single conversation. Therefore, it
+ * is not recommended to share the same history or memory instance between
+ * two different chains. If you deploy your LangChain app on a serverless
+ * environment, do not store memory instances in a variable, as your
+ * hosting provider may reset it by the next time the function is called.
+ */
 export declare class BufferMemory extends BaseChatMemory implements BufferMemoryInput {
     humanPrefix: string;
     aiPrefix: string;
     memoryKey: string;
     constructor(fields?: BufferMemoryInput);
     get memoryKeys(): string[];
+    /**
+     * Loads the memory variables. It takes an `InputValues` object as a
+     * parameter and returns a `Promise` that resolves with a
+     * `MemoryVariables` object.
+     * @param _values `InputValues` object.
+     * @returns A `Promise` that resolves with a `MemoryVariables` object.
+     */
     loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;
 }

package/dist/memory/buffer_memory.js

@@ -1,5 +1,17 @@
 import { getBufferString } from "./base.js";
 import { BaseChatMemory } from "./chat_memory.js";
+/**
+ * The `BufferMemory` class is a type of memory component used for storing
+ * and managing previous chat messages. It is a wrapper around
+ * `ChatMessageHistory` that extracts the messages into an input variable.
+ * This class is particularly useful in applications like chatbots where
+ * it is essential to remember previous interactions. Note: The memory
+ * instance represents the history of a single conversation. Therefore, it
+ * is not recommended to share the same history or memory instance between
+ * two different chains. If you deploy your LangChain app on a serverless
+ * environment, do not store memory instances in a variable, as your
+ * hosting provider may reset it by the next time the function is called.
+ */
 export class BufferMemory extends BaseChatMemory {
     constructor(fields) {
         super({
@@ -33,6 +45,13 @@ export class BufferMemory extends BaseChatMemory {
     get memoryKeys() {
         return [this.memoryKey];
     }
+    /**
+     * Loads the memory variables. It takes an `InputValues` object as a
+     * parameter and returns a `Promise` that resolves with a
+     * `MemoryVariables` object.
+     * @param _values `InputValues` object.
+     * @returns A `Promise` that resolves with a `MemoryVariables` object.
+     */
     async loadMemoryVariables(_values) {
         const messages = await this.chatHistory.getMessages();
         if (this.returnMessages) {

package/dist/memory/buffer_window_memory.cjs

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BufferWindowMemory = void 0;
 const base_js_1 = require("./base.cjs");
 const chat_memory_js_1 = require("./chat_memory.cjs");
+/**
+ * Class for managing and storing previous chat messages. It extends the
+ * BaseChatMemory class and implements the BufferWindowMemoryInput
+ * interface. This class is stateful and stores messages in a buffer. When
+ * called in a chain, it returns all of the messages it has stored.
+ */
 class BufferWindowMemory extends chat_memory_js_1.BaseChatMemory {
     constructor(fields) {
         super({
@@ -43,6 +49,15 @@ class BufferWindowMemory extends chat_memory_js_1.BaseChatMemory {
     get memoryKeys() {
         return [this.memoryKey];
     }
+    /**
+     * Method to load the memory variables. Retrieves the chat messages from
+     * the history, slices the last 'k' messages, and stores them in the
+     * memory under the memoryKey. If the returnMessages property is set to
+     * true, the method returns the messages as they are. Otherwise, it
+     * returns a string representation of the messages.
+     * @param _values InputValues object.
+     * @returns Promise that resolves to a MemoryVariables object.
+     */
     async loadMemoryVariables(_values) {
         const messages = await this.chatHistory.getMessages();
         if (this.returnMessages) {

package/dist/memory/buffer_window_memory.d.ts

@@ -1,11 +1,20 @@
 import { InputValues, MemoryVariables } from "./base.js";
 import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.js";
+/**
+ * Interface for the input parameters of the BufferWindowMemory class.
+ */
 export interface BufferWindowMemoryInput extends BaseChatMemoryInput {
     humanPrefix?: string;
     aiPrefix?: string;
     memoryKey?: string;
     k?: number;
 }
+/**
+ * Class for managing and storing previous chat messages. It extends the
+ * BaseChatMemory class and implements the BufferWindowMemoryInput
+ * interface. This class is stateful and stores messages in a buffer. When
+ * called in a chain, it returns all of the messages it has stored.
+ */
 export declare class BufferWindowMemory extends BaseChatMemory implements BufferWindowMemoryInput {
     humanPrefix: string;
     aiPrefix: string;
@@ -13,5 +22,14 @@ export declare class BufferWindowMemory extends BaseChatMemory implements Buffer
     k: number;
     constructor(fields?: BufferWindowMemoryInput);
     get memoryKeys(): string[];
+    /**
+     * Method to load the memory variables. Retrieves the chat messages from
+     * the history, slices the last 'k' messages, and stores them in the
+     * memory under the memoryKey. If the returnMessages property is set to
+     * true, the method returns the messages as they are. Otherwise, it
+     * returns a string representation of the messages.
+     * @param _values InputValues object.
+     * @returns Promise that resolves to a MemoryVariables object.
+     */
     loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;
 }

package/dist/memory/buffer_window_memory.js

@@ -1,5 +1,11 @@
 import { getBufferString } from "./base.js";
 import { BaseChatMemory } from "./chat_memory.js";
+/**
+ * Class for managing and storing previous chat messages. It extends the
+ * BaseChatMemory class and implements the BufferWindowMemoryInput
+ * interface. This class is stateful and stores messages in a buffer. When
+ * called in a chain, it returns all of the messages it has stored.
+ */
 export class BufferWindowMemory extends BaseChatMemory {
     constructor(fields) {
         super({
@@ -40,6 +46,15 @@ export class BufferWindowMemory extends BaseChatMemory {
     get memoryKeys() {
         return [this.memoryKey];
     }
+    /**
+     * Method to load the memory variables. Retrieves the chat messages from
+     * the history, slices the last 'k' messages, and stores them in the
+     * memory under the memoryKey. If the returnMessages property is set to
+     * true, the method returns the messages as they are. Otherwise, it
+     * returns a string representation of the messages.
+     * @param _values InputValues object.
+     * @returns Promise that resolves to a MemoryVariables object.
+     */
     async loadMemoryVariables(_values) {
         const messages = await this.chatHistory.getMessages();
         if (this.returnMessages) {

package/dist/memory/chat_memory.cjs

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseChatMemory = void 0;
 const base_js_1 = require("./base.cjs");
 const in_memory_js_1 = require("../stores/message/in_memory.cjs");
+/**
+ * Abstract class that provides a base for implementing different types of
+ * memory systems. It is designed to maintain the state of an application,
+ * specifically the history of a conversation. This class is typically
+ * extended by other classes to create specific types of memory systems.
+ */
 class BaseChatMemory extends base_js_1.BaseMemory {
     constructor(fields) {
         super();
@@ -35,11 +41,21 @@ class BaseChatMemory extends base_js_1.BaseMemory {
         this.inputKey = fields?.inputKey ?? this.inputKey;
         this.outputKey = fields?.outputKey ?? this.outputKey;
     }
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
     async saveContext(inputValues, outputValues) {
         // this is purposefully done in sequence so they're saved in order
         await this.chatHistory.addUserMessage((0, base_js_1.getInputValue)(inputValues, this.inputKey));
         await this.chatHistory.addAIChatMessage((0, base_js_1.getOutputValue)(outputValues, this.outputKey));
     }
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
     async clear() {
         await this.chatHistory.clear();
     }

package/dist/memory/chat_memory.d.ts

@@ -1,17 +1,36 @@
 import { BaseChatMessageHistory } from "../schema/index.js";
 import { BaseMemory, InputValues, OutputValues } from "./base.js";
+/**
+ * Interface for the input parameters of the BaseChatMemory class.
+ */
 export interface BaseChatMemoryInput {
     chatHistory?: BaseChatMessageHistory;
     returnMessages?: boolean;
     inputKey?: string;
     outputKey?: string;
 }
+/**
+ * Abstract class that provides a base for implementing different types of
+ * memory systems. It is designed to maintain the state of an application,
+ * specifically the history of a conversation. This class is typically
+ * extended by other classes to create specific types of memory systems.
+ */
 export declare abstract class BaseChatMemory extends BaseMemory {
     chatHistory: BaseChatMessageHistory;
     returnMessages: boolean;
     inputKey?: string;
     outputKey?: string;
     constructor(fields?: BaseChatMemoryInput);
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
     saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
     clear(): Promise<void>;
 }

package/dist/memory/chat_memory.js

@@ -1,5 +1,11 @@
 import { BaseMemory, getInputValue, getOutputValue, } from "./base.js";
 import { ChatMessageHistory } from "../stores/message/in_memory.js";
+/**
+ * Abstract class that provides a base for implementing different types of
+ * memory systems. It is designed to maintain the state of an application,
+ * specifically the history of a conversation. This class is typically
+ * extended by other classes to create specific types of memory systems.
+ */
 export class BaseChatMemory extends BaseMemory {
     constructor(fields) {
         super();
@@ -32,11 +38,21 @@ export class BaseChatMemory extends BaseMemory {
         this.inputKey = fields?.inputKey ?? this.inputKey;
         this.outputKey = fields?.outputKey ?? this.outputKey;
     }
+    /**
+     * Method to add user and AI messages to the chat history in sequence.
+     * @param inputValues The input values from the user.
+     * @param outputValues The output values from the AI.
+     * @returns Promise that resolves when the context has been saved.
+     */
     async saveContext(inputValues, outputValues) {
         // this is purposefully done in sequence so they're saved in order
         await this.chatHistory.addUserMessage(getInputValue(inputValues, this.inputKey));
         await this.chatHistory.addAIChatMessage(getOutputValue(outputValues, this.outputKey));
     }
+    /**
+     * Method to clear the chat history.
+     * @returns Promise that resolves when the chat history has been cleared.
+     */
     async clear() {
         await this.chatHistory.clear();
     }

package/dist/memory/combined_memory.cjs

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CombinedMemory = void 0;
 const chat_memory_js_1 = require("./chat_memory.cjs");
+/**
+ * Class that manages and manipulates previous chat messages. It extends
+ * from the BaseChatMemory class and implements the CombinedMemoryInput
+ * interface.
+ */
 class CombinedMemory extends chat_memory_js_1.BaseChatMemory {
     constructor(fields) {
         super({
@@ -41,6 +46,10 @@ class CombinedMemory extends chat_memory_js_1.BaseChatMemory {
         this.checkRepeatedMemoryVariable();
         this.checkInputKey();
     }
+    /**
+     * Checks for repeated memory variables across all memory objects. Throws
+     * an error if any are found.
+     */
     checkRepeatedMemoryVariable() {
         const allVariables = [];
         for (const memory of this.memories) {
@@ -53,6 +62,10 @@ class CombinedMemory extends chat_memory_js_1.BaseChatMemory {
             allVariables.push(...memory.memoryKeys);
         }
     }
+    /**
+     * Checks if input keys are set for all memory objects. Logs a warning if
+     * any are missing.
+     */
     checkInputKey() {
         for (const memory of this.memories) {
             if (memory.chatHistory !== undefined &&
@@ -61,6 +74,11 @@ class CombinedMemory extends chat_memory_js_1.BaseChatMemory {
             }
         }
     }
+    /**
+     * Loads memory variables from all memory objects.
+     * @param inputValues Input values to load memory variables from.
+     * @returns Promise that resolves with an object containing the loaded memory variables.
+     */
     async loadMemoryVariables(inputValues) {
         let memoryData = {};
         for (const memory of this.memories) {
@@ -72,11 +90,21 @@ class CombinedMemory extends chat_memory_js_1.BaseChatMemory {
         }
         return memoryData;
     }
+    /**
+     * Saves the context to all memory objects.
+     * @param inputValues Input values to save.
+     * @param outputValues Output values to save.
+     * @returns Promise that resolves when the context has been saved to all memory objects.
+     */
     async saveContext(inputValues, outputValues) {
         for (const memory of this.memories) {
             await memory.saveContext(inputValues, outputValues);
         }
     }
+    /**
+     * Clears all memory objects.
+     * @returns Promise that resolves when all memory objects have been cleared.
+     */
     async clear() {
         for (const memory of this.memories) {
             if (typeof memory.clear === "function") {

package/dist/memory/combined_memory.d.ts

@@ -1,21 +1,54 @@
 import { InputValues, MemoryVariables, BaseMemory, OutputValues } from "./base.js";
 import { BaseChatMemory, BaseChatMemoryInput } from "./chat_memory.js";
+/**
+ * Interface that defines the shape of the input object that the
+ * CombinedMemory constructor accepts. It extends the BaseChatMemoryInput
+ * interface and adds additional properties.
+ */
 export interface CombinedMemoryInput extends BaseChatMemoryInput {
     memories: BaseMemory[];
     humanPrefix?: string;
     aiPrefix?: string;
     memoryKey?: string;
 }
+/**
+ * Class that manages and manipulates previous chat messages. It extends
+ * from the BaseChatMemory class and implements the CombinedMemoryInput
+ * interface.
+ */
 export declare class CombinedMemory extends BaseChatMemory implements CombinedMemoryInput {
     humanPrefix: string;
     aiPrefix: string;
     memoryKey: string;
     memories: BaseMemory[];
     constructor(fields?: CombinedMemoryInput);
+    /**
+     * Checks for repeated memory variables across all memory objects. Throws
+     * an error if any are found.
+     */
     checkRepeatedMemoryVariable(): void;
+    /**
+     * Checks if input keys are set for all memory objects. Logs a warning if
+     * any are missing.
+     */
     checkInputKey(): void;
+    /**
+     * Loads memory variables from all memory objects.
+     * @param inputValues Input values to load memory variables from.
+     * @returns Promise that resolves with an object containing the loaded memory variables.
+     */
     loadMemoryVariables(inputValues: InputValues): Promise<MemoryVariables>;
+    /**
+     * Saves the context to all memory objects.
+     * @param inputValues Input values to save.
+     * @param outputValues Output values to save.
+     * @returns Promise that resolves when the context has been saved to all memory objects.
+     */
     saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
+    /**
+     * Clears all memory objects.
+     * @returns Promise that resolves when all memory objects have been cleared.
+     */
     clear(): Promise<void>;
     get memoryKeys(): string[];
 }

package/dist/memory/combined_memory.js

@@ -1,4 +1,9 @@
 import { BaseChatMemory } from "./chat_memory.js";
+/**
+ * Class that manages and manipulates previous chat messages. It extends
+ * from the BaseChatMemory class and implements the CombinedMemoryInput
+ * interface.
+ */
 export class CombinedMemory extends BaseChatMemory {
     constructor(fields) {
         super({
@@ -38,6 +43,10 @@ export class CombinedMemory extends BaseChatMemory {
         this.checkRepeatedMemoryVariable();
         this.checkInputKey();
     }
+    /**
+     * Checks for repeated memory variables across all memory objects. Throws
+     * an error if any are found.
+     */
     checkRepeatedMemoryVariable() {
         const allVariables = [];
         for (const memory of this.memories) {
@@ -50,6 +59,10 @@ export class CombinedMemory extends BaseChatMemory {
             allVariables.push(...memory.memoryKeys);
         }
     }
+    /**
+     * Checks if input keys are set for all memory objects. Logs a warning if
+     * any are missing.
+     */
     checkInputKey() {
         for (const memory of this.memories) {
             if (memory.chatHistory !== undefined &&
@@ -58,6 +71,11 @@ export class CombinedMemory extends BaseChatMemory {
             }
         }
     }
+    /**
+     * Loads memory variables from all memory objects.
+     * @param inputValues Input values to load memory variables from.
+     * @returns Promise that resolves with an object containing the loaded memory variables.
+     */
     async loadMemoryVariables(inputValues) {
         let memoryData = {};
         for (const memory of this.memories) {
@@ -69,11 +87,21 @@ export class CombinedMemory extends BaseChatMemory {
         }
         return memoryData;
     }
+    /**
+     * Saves the context to all memory objects.
+     * @param inputValues Input values to save.
+     * @param outputValues Output values to save.
+     * @returns Promise that resolves when the context has been saved to all memory objects.
+     */
     async saveContext(inputValues, outputValues) {
         for (const memory of this.memories) {
             await memory.saveContext(inputValues, outputValues);
         }
     }
+    /**
+     * Clears all memory objects.
+     * @returns Promise that resolves when all memory objects have been cleared.
+     */
     async clear() {
         for (const memory of this.memories) {
             if (typeof memory.clear === "function") {