langchain 0.0.191 → 0.0.193

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

package/dist/memory/vector_store.d.ts

@@ -17,6 +17,30 @@ export interface VectorStoreRetrieverMemoryParams {
  * 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?" }),
+ * );
+ * ```
  */
 export declare class VectorStoreRetrieverMemory extends BaseMemory implements VectorStoreRetrieverMemoryParams {
     vectorStoreRetriever: VectorStoreRetriever;

package/dist/memory/vector_store.js

@@ -7,6 +7,30 @@ import { BaseMemory, getInputValue, } from "./base.js";
  * 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?" }),
+ * );
+ * ```
  */
 export class VectorStoreRetrieverMemory extends BaseMemory {
     constructor(fields) {

package/dist/memory/zep.cjs

@@ -10,6 +10,40 @@ const index_js_1 = require("../schema/index.cjs");
  * and saving the chat history, and clearing the memory when needed. It
  * uses the ZepClient to interact with the Zep service for managing the
  * chat session's memory.
+ * @example
+ * ```typescript
+ * const sessionId = randomUUID();
+ * const zepURL = "http://your-zep-url";
+ *
+ * // Initialize ZepMemory with session ID, base URL, and API key
+ * const memory = new ZepMemory({
+ *   sessionId,
+ *   baseURL: zepURL,
+ *   apiKey: "change_this_key",
+ * });
+ *
+ * // Create a ChatOpenAI model instance with specific parameters
+ * const model = new ChatOpenAI({
+ *   modelName: "gpt-3.5-turbo",
+ *   temperature: 0,
+ * });
+ *
+ * // Create a ConversationChain with the model and memory
+ * const chain = new ConversationChain({ llm: model, memory });
+ *
+ * // Example of calling the chain with an input
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Follow-up call to the chain to demonstrate memory usage
+ * const res2 = await chain.call({ input: "What did I just say my name was?" });
+ * console.log({ res2 });
+ *
+ * // Output the session ID and the current state of memory
+ * console.log("Session ID: ", sessionId);
+ * console.log("Memory: ", await memory.loadMemoryVariables({}));
+ *
+ * ```
  */
 class ZepMemory extends chat_memory_js_1.BaseChatMemory {
     constructor(fields) {

package/dist/memory/zep.d.ts

@@ -19,6 +19,40 @@ export interface ZepMemoryInput extends BaseChatMemoryInput {
  * and saving the chat history, and clearing the memory when needed. It
  * uses the ZepClient to interact with the Zep service for managing the
  * chat session's memory.
+ * @example
+ * ```typescript
+ * const sessionId = randomUUID();
+ * const zepURL = "http://your-zep-url";
+ *
+ * // Initialize ZepMemory with session ID, base URL, and API key
+ * const memory = new ZepMemory({
+ *   sessionId,
+ *   baseURL: zepURL,
+ *   apiKey: "change_this_key",
+ * });
+ *
+ * // Create a ChatOpenAI model instance with specific parameters
+ * const model = new ChatOpenAI({
+ *   modelName: "gpt-3.5-turbo",
+ *   temperature: 0,
+ * });
+ *
+ * // Create a ConversationChain with the model and memory
+ * const chain = new ConversationChain({ llm: model, memory });
+ *
+ * // Example of calling the chain with an input
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Follow-up call to the chain to demonstrate memory usage
+ * const res2 = await chain.call({ input: "What did I just say my name was?" });
+ * console.log({ res2 });
+ *
+ * // Output the session ID and the current state of memory
+ * console.log("Session ID: ", sessionId);
+ * console.log("Memory: ", await memory.loadMemoryVariables({}));
+ *
+ * ```
  */
 export declare class ZepMemory extends BaseChatMemory implements ZepMemoryInput {
     humanPrefix: string;

package/dist/memory/zep.js

@@ -7,6 +7,40 @@ import { AIMessage, ChatMessage, HumanMessage, SystemMessage, } from "../schema/
  * and saving the chat history, and clearing the memory when needed. It
  * uses the ZepClient to interact with the Zep service for managing the
  * chat session's memory.
+ * @example
+ * ```typescript
+ * const sessionId = randomUUID();
+ * const zepURL = "http://your-zep-url";
+ *
+ * // Initialize ZepMemory with session ID, base URL, and API key
+ * const memory = new ZepMemory({
+ *   sessionId,
+ *   baseURL: zepURL,
+ *   apiKey: "change_this_key",
+ * });
+ *
+ * // Create a ChatOpenAI model instance with specific parameters
+ * const model = new ChatOpenAI({
+ *   modelName: "gpt-3.5-turbo",
+ *   temperature: 0,
+ * });
+ *
+ * // Create a ConversationChain with the model and memory
+ * const chain = new ConversationChain({ llm: model, memory });
+ *
+ * // Example of calling the chain with an input
+ * const res1 = await chain.call({ input: "Hi! I'm Jim." });
+ * console.log({ res1 });
+ *
+ * // Follow-up call to the chain to demonstrate memory usage
+ * const res2 = await chain.call({ input: "What did I just say my name was?" });
+ * console.log({ res2 });
+ *
+ * // Output the session ID and the current state of memory
+ * console.log("Session ID: ", sessionId);
+ * console.log("Memory: ", await memory.loadMemoryVariables({}));
+ *
+ * ```
  */
 export class ZepMemory extends BaseChatMemory {
     constructor(fields) {