langchain 0.0.192 → 0.0.194

package/dist/llms/replicate.cjs

@@ -8,6 +8,17 @@ const base_js_1 = require("./base.cjs");
  * It handles the API key and model details, makes the actual API calls,
  * and converts the API response into a format usable by the rest of the
  * LangChain framework.
+ * @example
+ * ```typescript
+ * const model = new Replicate({
+ *   model: "replicate/flan-t5-xl:3ae0799123a1fe11f8c89fd99632f843fc5f7a761630160521c4253149754523",
+ * });
+ *
+ * const res = await model.call(
+ *   "Question: What would be a good company name for a company that makes colorful socks?\nAnswer:"
+ * );
+ * console.log({ res });
+ * ```
  */
 class Replicate extends base_js_1.LLM {
     static lc_name() {

package/dist/llms/replicate.d.ts

@@ -18,6 +18,17 @@ export interface ReplicateInput {
  * It handles the API key and model details, makes the actual API calls,
  * and converts the API response into a format usable by the rest of the
  * LangChain framework.
+ * @example
+ * ```typescript
+ * const model = new Replicate({
+ *   model: "replicate/flan-t5-xl:3ae0799123a1fe11f8c89fd99632f843fc5f7a761630160521c4253149754523",
+ * });
+ *
+ * const res = await model.call(
+ *   "Question: What would be a good company name for a company that makes colorful socks?\nAnswer:"
+ * );
+ * console.log({ res });
+ * ```
  */
 export declare class Replicate extends LLM implements ReplicateInput {
     static lc_name(): string;

package/dist/llms/replicate.js

@@ -5,6 +5,17 @@ import { LLM } from "./base.js";
  * It handles the API key and model details, makes the actual API calls,
  * and converts the API response into a format usable by the rest of the
  * LangChain framework.
+ * @example
+ * ```typescript
+ * const model = new Replicate({
+ *   model: "replicate/flan-t5-xl:3ae0799123a1fe11f8c89fd99632f843fc5f7a761630160521c4253149754523",
+ * });
+ *
+ * const res = await model.call(
+ *   "Question: What would be a good company name for a company that makes colorful socks?\nAnswer:"
+ * );
+ * console.log({ res });
+ * ```
  */
 export class Replicate extends LLM {
     static lc_name() {

package/dist/memory/buffer_memory.cjs

@@ -14,6 +14,30 @@ const chat_memory_js_1 = require("./chat_memory.cjs");
  * 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.
+ * @example
+ * ```typescript
+ * // Initialize the memory to store chat history and set up the language model with a specific temperature.
+ * const memory = new BufferMemory({ memoryKey: "chat_history" });
+ * const model = new ChatOpenAI({ temperature: 0.9 });
+ *
+ * // Create a prompt template for a friendly conversation between a human and an AI.
+ * const prompt =
+ *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+ *
+ * Current conversation:
+ * {chat_history}
+ * Human: {input}
+ * AI:`);
+ *
+ * // Set up the chain with the language model, prompt, and memory.
+ * const chain = new LLMChain({ llm: model, prompt, memory });
+ *
+ * // Example usage of the chain to continue the conversation.
+ * // The `call` method sends the input to the model and returns the AI's response.
+ * const res = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res });
+ *
+ * ```
  */
 class BufferMemory extends chat_memory_js_1.BaseChatMemory {
     constructor(fields) {

package/dist/memory/buffer_memory.d.ts

@@ -19,6 +19,30 @@ export interface BufferMemoryInput extends BaseChatMemoryInput {
  * 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.
+ * @example
+ * ```typescript
+ * // Initialize the memory to store chat history and set up the language model with a specific temperature.
+ * const memory = new BufferMemory({ memoryKey: "chat_history" });
+ * const model = new ChatOpenAI({ temperature: 0.9 });
+ *
+ * // Create a prompt template for a friendly conversation between a human and an AI.
+ * const prompt =
+ *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+ *
+ * Current conversation:
+ * {chat_history}
+ * Human: {input}
+ * AI:`);
+ *
+ * // Set up the chain with the language model, prompt, and memory.
+ * const chain = new LLMChain({ llm: model, prompt, memory });
+ *
+ * // Example usage of the chain to continue the conversation.
+ * // The `call` method sends the input to the model and returns the AI's response.
+ * const res = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res });
+ *
+ * ```
  */
 export declare class BufferMemory extends BaseChatMemory implements BufferMemoryInput {
     humanPrefix: string;

package/dist/memory/buffer_memory.js

@@ -11,6 +11,30 @@ import { BaseChatMemory } from "./chat_memory.js";
  * 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.
+ * @example
+ * ```typescript
+ * // Initialize the memory to store chat history and set up the language model with a specific temperature.
+ * const memory = new BufferMemory({ memoryKey: "chat_history" });
+ * const model = new ChatOpenAI({ temperature: 0.9 });
+ *
+ * // Create a prompt template for a friendly conversation between a human and an AI.
+ * const prompt =
+ *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+ *
+ * Current conversation:
+ * {chat_history}
+ * Human: {input}
+ * AI:`);
+ *
+ * // Set up the chain with the language model, prompt, and memory.
+ * const chain = new LLMChain({ llm: model, prompt, memory });
+ *
+ * // Example usage of the chain to continue the conversation.
+ * // The `call` method sends the input to the model and returns the AI's response.
+ * const res = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res });
+ *
+ * ```
  */
 export class BufferMemory extends BaseChatMemory {
     constructor(fields) {

package/dist/memory/buffer_token_memory.cjs

@@ -7,6 +7,21 @@ const chat_memory_js_1 = require("./chat_memory.cjs");
  * Class that represents a conversation chat memory with a token buffer.
  * It extends the `BaseChatMemory` class and implements the
  * `ConversationTokenBufferMemoryInput` interface.
+ * @example
+ * ```typescript
+ * const memory = new ConversationTokenBufferMemory({
+ *   llm: new ChatOpenAI({}),
+ *   maxTokenLimit: 10,
+ * });
+ *
+ * // Save conversation context
+ * await memory.saveContext({ input: "hi" }, { output: "whats up" });
+ * await memory.saveContext({ input: "not much you" }, { output: "not much" });
+ *
+ * // Load memory variables
+ * const result = await memory.loadMemoryVariables({});
+ * console.log(result);
+ * ```
  */
 class ConversationTokenBufferMemory extends chat_memory_js_1.BaseChatMemory {
     constructor(fields) {

package/dist/memory/buffer_token_memory.d.ts

@@ -15,6 +15,21 @@ export interface ConversationTokenBufferMemoryInput extends BaseChatMemoryInput
  * Class that represents a conversation chat memory with a token buffer.
  * It extends the `BaseChatMemory` class and implements the
  * `ConversationTokenBufferMemoryInput` interface.
+ * @example
+ * ```typescript
+ * const memory = new ConversationTokenBufferMemory({
+ *   llm: new ChatOpenAI({}),
+ *   maxTokenLimit: 10,
+ * });
+ *
+ * // Save conversation context
+ * await memory.saveContext({ input: "hi" }, { output: "whats up" });
+ * await memory.saveContext({ input: "not much you" }, { output: "not much" });
+ *
+ * // Load memory variables
+ * const result = await memory.loadMemoryVariables({});
+ * console.log(result);
+ * ```
  */
 export declare class ConversationTokenBufferMemory extends BaseChatMemory implements ConversationTokenBufferMemoryInput {
     humanPrefix: string;

package/dist/memory/buffer_token_memory.js

@@ -4,6 +4,21 @@ import { BaseChatMemory } from "./chat_memory.js";
  * Class that represents a conversation chat memory with a token buffer.
  * It extends the `BaseChatMemory` class and implements the
  * `ConversationTokenBufferMemoryInput` interface.
+ * @example
+ * ```typescript
+ * const memory = new ConversationTokenBufferMemory({
+ *   llm: new ChatOpenAI({}),
+ *   maxTokenLimit: 10,
+ * });
+ *
+ * // Save conversation context
+ * await memory.saveContext({ input: "hi" }, { output: "whats up" });
+ * await memory.saveContext({ input: "not much you" }, { output: "not much" });
+ *
+ * // Load memory variables
+ * const result = await memory.loadMemoryVariables({});
+ * console.log(result);
+ * ```
  */
 export class ConversationTokenBufferMemory extends BaseChatMemory {
     constructor(fields) {

package/dist/memory/buffer_window_memory.cjs

@@ -8,6 +8,29 @@ const chat_memory_js_1 = require("./chat_memory.cjs");
  * 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.
+ * @example
+ * ```typescript
+ * const prompt =
+ *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+ * Current conversation:
+ * {chat_history}
+ * Human: {input}
+ * AI:`);
+ *
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ *   memory: new BufferWindowMemory({ memoryKey: "chat_history", k: 1 }),
+ * });
+ *
+ * // Example of initiating a conversation with the AI
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Example of following up with another question
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2 });
+ * ```
  */
 class BufferWindowMemory extends chat_memory_js_1.BaseChatMemory {
     constructor(fields) {

package/dist/memory/buffer_window_memory.d.ts

@@ -14,6 +14,29 @@ export interface BufferWindowMemoryInput extends BaseChatMemoryInput {
  * 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.
+ * @example
+ * ```typescript
+ * const prompt =
+ *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+ * Current conversation:
+ * {chat_history}
+ * Human: {input}
+ * AI:`);
+ *
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ *   memory: new BufferWindowMemory({ memoryKey: "chat_history", k: 1 }),
+ * });
+ *
+ * // Example of initiating a conversation with the AI
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Example of following up with another question
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2 });
+ * ```
  */
 export declare class BufferWindowMemory extends BaseChatMemory implements BufferWindowMemoryInput {
     humanPrefix: string;

package/dist/memory/buffer_window_memory.js

@@ -5,6 +5,29 @@ import { BaseChatMemory } from "./chat_memory.js";
  * 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.
+ * @example
+ * ```typescript
+ * const prompt =
+ *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+ * Current conversation:
+ * {chat_history}
+ * Human: {input}
+ * AI:`);
+ *
+ * const chain = new LLMChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9 }),
+ *   prompt,
+ *   memory: new BufferWindowMemory({ memoryKey: "chat_history", k: 1 }),
+ * });
+ *
+ * // Example of initiating a conversation with the AI
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Example of following up with another question
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2 });
+ * ```
  */
 export class BufferWindowMemory extends BaseChatMemory {
     constructor(fields) {

package/dist/memory/entity_memory.cjs

@@ -11,6 +11,35 @@ const in_memory_js_1 = require("./stores/entity/in_memory.cjs");
  * Class for managing entity extraction and summarization to memory in
  * chatbot applications. Extends the BaseChatMemory class and implements
  * the EntityMemoryInput interface.
+ * @example
+ * ```typescript
+ * const memory = new EntityMemory({
+ *   llm: new ChatOpenAI({ temperature: 0 }),
+ *   chatHistoryKey: "history",
+ *   entitiesKey: "entities",
+ * });
+ * const model = new ChatOpenAI({ temperature: 0.9 });
+ * const chain = new LLMChain({
+ *   llm: model,
+ *   prompt: ENTITY_MEMORY_CONVERSATION_TEMPLATE,
+ *   memory,
+ * });
+ *
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({
+ *   res1,
+ *   memory: await memory.loadMemoryVariables({ input: "Who is Jim?" }),
+ * });
+ *
+ * const res2 = await chain.call({
+ *   input: "I work in construction. What about you?",
+ * });
+ * console.log({
+ *   res2,
+ *   memory: await memory.loadMemoryVariables({ input: "Who is Jim?" }),
+ * });
+ *
+ * ```
  */
 class EntityMemory extends chat_memory_js_1.BaseChatMemory {
     constructor(fields) {

package/dist/memory/entity_memory.d.ts

@@ -22,6 +22,35 @@ export interface EntityMemoryInput extends BaseChatMemoryInput {
  * Class for managing entity extraction and summarization to memory in
  * chatbot applications. Extends the BaseChatMemory class and implements
  * the EntityMemoryInput interface.
+ * @example
+ * ```typescript
+ * const memory = new EntityMemory({
+ *   llm: new ChatOpenAI({ temperature: 0 }),
+ *   chatHistoryKey: "history",
+ *   entitiesKey: "entities",
+ * });
+ * const model = new ChatOpenAI({ temperature: 0.9 });
+ * const chain = new LLMChain({
+ *   llm: model,
+ *   prompt: ENTITY_MEMORY_CONVERSATION_TEMPLATE,
+ *   memory,
+ * });
+ *
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({
+ *   res1,
+ *   memory: await memory.loadMemoryVariables({ input: "Who is Jim?" }),
+ * });
+ *
+ * const res2 = await chain.call({
+ *   input: "I work in construction. What about you?",
+ * });
+ * console.log({
+ *   res2,
+ *   memory: await memory.loadMemoryVariables({ input: "Who is Jim?" }),
+ * });
+ *
+ * ```
  */
 export declare class EntityMemory extends BaseChatMemory implements EntityMemoryInput {
     private entityExtractionChain;

package/dist/memory/entity_memory.js

@@ -8,6 +8,35 @@ import { InMemoryEntityStore } from "./stores/entity/in_memory.js";
  * Class for managing entity extraction and summarization to memory in
  * chatbot applications. Extends the BaseChatMemory class and implements
  * the EntityMemoryInput interface.
+ * @example
+ * ```typescript
+ * const memory = new EntityMemory({
+ *   llm: new ChatOpenAI({ temperature: 0 }),
+ *   chatHistoryKey: "history",
+ *   entitiesKey: "entities",
+ * });
+ * const model = new ChatOpenAI({ temperature: 0.9 });
+ * const chain = new LLMChain({
+ *   llm: model,
+ *   prompt: ENTITY_MEMORY_CONVERSATION_TEMPLATE,
+ *   memory,
+ * });
+ *
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({
+ *   res1,
+ *   memory: await memory.loadMemoryVariables({ input: "Who is Jim?" }),
+ * });
+ *
+ * const res2 = await chain.call({
+ *   input: "I work in construction. What about you?",
+ * });
+ * console.log({
+ *   res2,
+ *   memory: await memory.loadMemoryVariables({ input: "Who is Jim?" }),
+ * });
+ *
+ * ```
  */
 export class EntityMemory extends BaseChatMemory {
     constructor(fields) {

package/dist/memory/summary.cjs

@@ -80,6 +80,30 @@ exports.BaseConversationSummaryMemory = BaseConversationSummaryMemory;
  * Class that provides a concrete implementation of the conversation
  * memory. It includes methods for loading memory variables, saving
  * context, and clearing the memory.
+ * @example
+ * ```typescript
+ * const memory = new ConversationSummaryMemory({
+ *   memoryKey: "chat_history",
+ *   llm: new ChatOpenAI({ modelName: "gpt-3.5-turbo", temperature: 0 }),
+ * });
+ *
+ * const model = new ChatOpenAI();
+ * const prompt =
+ *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+ *
+ * Current conversation:
+ * {chat_history}
+ * Human: {input}
+ * AI:`);
+ * const chain = new LLMChain({ llm: model, prompt, memory });
+ *
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1, memory: await memory.loadMemoryVariables({}) });
+ *
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2, memory: await memory.loadMemoryVariables({}) });
+ *
+ * ```
  */
 class ConversationSummaryMemory extends BaseConversationSummaryMemory {
     constructor(fields) {

package/dist/memory/summary.d.ts

@@ -47,6 +47,30 @@ export declare abstract class BaseConversationSummaryMemory extends BaseChatMemo
  * Class that provides a concrete implementation of the conversation
  * memory. It includes methods for loading memory variables, saving
  * context, and clearing the memory.
+ * @example
+ * ```typescript
+ * const memory = new ConversationSummaryMemory({
+ *   memoryKey: "chat_history",
+ *   llm: new ChatOpenAI({ modelName: "gpt-3.5-turbo", temperature: 0 }),
+ * });
+ *
+ * const model = new ChatOpenAI();
+ * const prompt =
+ *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+ *
+ * Current conversation:
+ * {chat_history}
+ * Human: {input}
+ * AI:`);
+ * const chain = new LLMChain({ llm: model, prompt, memory });
+ *
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1, memory: await memory.loadMemoryVariables({}) });
+ *
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2, memory: await memory.loadMemoryVariables({}) });
+ *
+ * ```
  */
 export declare class ConversationSummaryMemory extends BaseConversationSummaryMemory {
     buffer: string;

package/dist/memory/summary.js

@@ -76,6 +76,30 @@ export class BaseConversationSummaryMemory extends BaseChatMemory {
  * Class that provides a concrete implementation of the conversation
  * memory. It includes methods for loading memory variables, saving
  * context, and clearing the memory.
+ * @example
+ * ```typescript
+ * const memory = new ConversationSummaryMemory({
+ *   memoryKey: "chat_history",
+ *   llm: new ChatOpenAI({ modelName: "gpt-3.5-turbo", temperature: 0 }),
+ * });
+ *
+ * const model = new ChatOpenAI();
+ * const prompt =
+ *   PromptTemplate.fromTemplate(`The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+ *
+ * Current conversation:
+ * {chat_history}
+ * Human: {input}
+ * AI:`);
+ * const chain = new LLMChain({ llm: model, prompt, memory });
+ *
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1, memory: await memory.loadMemoryVariables({}) });
+ *
+ * const res2 = await chain.call({ input: "What's my name?" });
+ * console.log({ res2, memory: await memory.loadMemoryVariables({}) });
+ *
+ * ```
  */
 export class ConversationSummaryMemory extends BaseConversationSummaryMemory {
     constructor(fields) {

package/dist/memory/summary_buffer.cjs

@@ -9,6 +9,38 @@ const summary_js_1 = require("./summary.cjs");
  * history in a LangChain application by maintaining a buffer of chat
  * messages and providing methods to load, save, prune, and clear the
  * memory.
+ * @example
+ * ```typescript
+ * // Initialize the memory with a specific model and token limit
+ * const memory = new ConversationSummaryBufferMemory({
+ *   llm: new ChatOpenAI({ modelName: "gpt-3.5-turbo-instruct", temperature: 0 }),
+ *   maxTokenLimit: 10,
+ * });
+ *
+ * // Save conversation context to memory
+ * await memory.saveContext({ input: "hi" }, { output: "whats up" });
+ * await memory.saveContext({ input: "not much you" }, { output: "not much" });
+ *
+ * // Load the conversation history from memory
+ * const history = await memory.loadMemoryVariables({});
+ * console.log({ history });
+ *
+ * // Create a chat prompt using the conversation history
+ * const chatPrompt = ChatPromptTemplate.fromMessages([
+ *   SystemMessagePromptTemplate.fromTemplate(
+ *     "The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.",
+ *   ),
+ *   new MessagesPlaceholder("history"),
+ *   HumanMessagePromptTemplate.fromTemplate("{input}"),
+ * ]);
+ *
+ * // Initialize the conversation chain with the model, memory, and prompt
+ * const chain = new ConversationChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9, verbose: true }),
+ *   memory: memory,
+ *   prompt: chatPrompt,
+ * });
+ * ```
  */
 class ConversationSummaryBufferMemory extends summary_js_1.BaseConversationSummaryMemory {
     constructor(fields) {

package/dist/memory/summary_buffer.d.ts

@@ -13,6 +13,38 @@ export interface ConversationSummaryBufferMemoryInput extends BaseConversationSu
  * history in a LangChain application by maintaining a buffer of chat
  * messages and providing methods to load, save, prune, and clear the
  * memory.
+ * @example
+ * ```typescript
+ * // Initialize the memory with a specific model and token limit
+ * const memory = new ConversationSummaryBufferMemory({
+ *   llm: new ChatOpenAI({ modelName: "gpt-3.5-turbo-instruct", temperature: 0 }),
+ *   maxTokenLimit: 10,
+ * });
+ *
+ * // Save conversation context to memory
+ * await memory.saveContext({ input: "hi" }, { output: "whats up" });
+ * await memory.saveContext({ input: "not much you" }, { output: "not much" });
+ *
+ * // Load the conversation history from memory
+ * const history = await memory.loadMemoryVariables({});
+ * console.log({ history });
+ *
+ * // Create a chat prompt using the conversation history
+ * const chatPrompt = ChatPromptTemplate.fromMessages([
+ *   SystemMessagePromptTemplate.fromTemplate(
+ *     "The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.",
+ *   ),
+ *   new MessagesPlaceholder("history"),
+ *   HumanMessagePromptTemplate.fromTemplate("{input}"),
+ * ]);
+ *
+ * // Initialize the conversation chain with the model, memory, and prompt
+ * const chain = new ConversationChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9, verbose: true }),
+ *   memory: memory,
+ *   prompt: chatPrompt,
+ * });
+ * ```
  */
 export declare class ConversationSummaryBufferMemory extends BaseConversationSummaryMemory implements ConversationSummaryBufferMemoryInput {
     movingSummaryBuffer: string;

package/dist/memory/summary_buffer.js

@@ -6,6 +6,38 @@ import { BaseConversationSummaryMemory, } from "./summary.js";
  * history in a LangChain application by maintaining a buffer of chat
  * messages and providing methods to load, save, prune, and clear the
  * memory.
+ * @example
+ * ```typescript
+ * // Initialize the memory with a specific model and token limit
+ * const memory = new ConversationSummaryBufferMemory({
+ *   llm: new ChatOpenAI({ modelName: "gpt-3.5-turbo-instruct", temperature: 0 }),
+ *   maxTokenLimit: 10,
+ * });
+ *
+ * // Save conversation context to memory
+ * await memory.saveContext({ input: "hi" }, { output: "whats up" });
+ * await memory.saveContext({ input: "not much you" }, { output: "not much" });
+ *
+ * // Load the conversation history from memory
+ * const history = await memory.loadMemoryVariables({});
+ * console.log({ history });
+ *
+ * // Create a chat prompt using the conversation history
+ * const chatPrompt = ChatPromptTemplate.fromMessages([
+ *   SystemMessagePromptTemplate.fromTemplate(
+ *     "The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.",
+ *   ),
+ *   new MessagesPlaceholder("history"),
+ *   HumanMessagePromptTemplate.fromTemplate("{input}"),
+ * ]);
+ *
+ * // Initialize the conversation chain with the model, memory, and prompt
+ * const chain = new ConversationChain({
+ *   llm: new ChatOpenAI({ temperature: 0.9, verbose: true }),
+ *   memory: memory,
+ *   prompt: chatPrompt,
+ * });
+ * ```
  */
 export class ConversationSummaryBufferMemory extends BaseConversationSummaryMemory {
     constructor(fields) {

package/dist/memory/vector_store.cjs

@@ -10,6 +10,30 @@ const base_js_1 = require("./base.cjs");
  * documents from a vector store database, which can be useful for
  * maintaining conversation history or other types of memory in an LLM
  * application.
+ * @example
+ * ```typescript
+ * const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());
+ * const memory = new VectorStoreRetrieverMemory({
+ *   vectorStoreRetriever: vectorStore.asRetriever(1),
+ *   memoryKey: "history",
+ * });
+ *
+ * // Saving context to memory
+ * await memory.saveContext(
+ *   { input: "My favorite food is pizza" },
+ *   { output: "thats good to know" },
+ * );
+ * await memory.saveContext(
+ *   { input: "My favorite sport is soccer" },
+ *   { output: "..." },
+ * );
+ * await memory.saveContext({ input: "I don't the Celtics" }, { output: "ok" });
+ *
+ * // Loading memory variables
+ * console.log(
+ *   await memory.loadMemoryVariables({ prompt: "what sport should i watch?" }),
+ * );
+ * ```
  */
 class VectorStoreRetrieverMemory extends base_js_1.BaseMemory {
     constructor(fields) {