langchain 1.0.0-alpha.6 → 1.0.0-alpha.8

package/dist/memory/summary_buffer.d.cts

@@ -1,90 +0,0 @@
-import { BaseConversationSummaryMemory, BaseConversationSummaryMemoryInput } from "./summary.cjs";
-import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-
-//#region src/memory/summary_buffer.d.ts
-
-/**
- * Interface for the input parameters of the
- * ConversationSummaryBufferMemory class.
- */
-interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {
-  maxTokenLimit?: number;
-}
-/**
- * Class that extends BaseConversationSummaryMemory and implements
- * ConversationSummaryBufferMemoryInput. It manages the conversation
- * 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({ model: "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({ model: "gpt-4o-mini", temperature: 0.9, verbose: true }),
- *   memory: memory,
- *   prompt: chatPrompt,
- * });
- * ```
- */
-declare class ConversationSummaryBufferMemory extends BaseConversationSummaryMemory implements ConversationSummaryBufferMemoryInput {
-  movingSummaryBuffer: string;
-  maxTokenLimit: number;
-  constructor(fields: ConversationSummaryBufferMemoryInput);
-  get memoryKeys(): string[];
-  /**
-   * Method that loads the chat messages from the memory and returns them as
-   * a string or as a list of messages, depending on the returnMessages
-   * property.
-   * @param _ InputValues object, not used in this method.
-   * @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.
-   */
-  loadMemoryVariables(_?: InputValues): Promise<MemoryVariables>;
-  /**
-   * Method that saves the context of the conversation, including the input
-   * and output values, and prunes the memory if it exceeds the maximum
-   * token limit.
-   * @param inputValues InputValues object containing the input values of the conversation.
-   * @param outputValues OutputValues object containing the output values of the conversation.
-   * @returns Promise that resolves when the context is saved and the memory is pruned.
-   */
-  saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
-  /**
-   * Method that prunes the memory if the total number of tokens in the
-   * buffer exceeds the maxTokenLimit. It removes messages from the
-   * beginning of the buffer until the total number of tokens is within the
-   * limit.
-   * @returns Promise that resolves when the memory is pruned.
-   */
-  prune(): Promise<void>;
-  /**
-   * Method that clears the memory and resets the movingSummaryBuffer.
-   * @returns Promise that resolves when the memory is cleared.
-   */
-  clear(): Promise<void>;
-}
-//#endregion
-export { ConversationSummaryBufferMemory, ConversationSummaryBufferMemoryInput };
-//# sourceMappingURL=summary_buffer.d.cts.map

package/dist/memory/summary_buffer.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"summary_buffer.d.cts","names":["InputValues","MemoryVariables","OutputValues","BaseConversationSummaryMemory","BaseConversationSummaryMemoryInput","ConversationSummaryBufferMemoryInput","ConversationSummaryBufferMemory","Promise"],"sources":["../../src/memory/summary_buffer.d.ts"],"sourcesContent":["import { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseConversationSummaryMemory, BaseConversationSummaryMemoryInput } from \"./summary.js\";\n/**\n * Interface for the input parameters of the\n * ConversationSummaryBufferMemory class.\n */\nexport interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {\n    maxTokenLimit?: number;\n}\n/**\n * Class that extends BaseConversationSummaryMemory and implements\n * ConversationSummaryBufferMemoryInput. It manages the conversation\n * history in a LangChain application by maintaining a buffer of chat\n * messages and providing methods to load, save, prune, and clear the\n * memory.\n * @example\n * ```typescript\n * // Initialize the memory with a specific model and token limit\n * const memory = new ConversationSummaryBufferMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo-instruct\", temperature: 0 }),\n *   maxTokenLimit: 10,\n * });\n *\n * // Save conversation context to memory\n * await memory.saveContext({ input: \"hi\" }, { output: \"whats up\" });\n * await memory.saveContext({ input: \"not much you\" }, { output: \"not much\" });\n *\n * // Load the conversation history from memory\n * const history = await memory.loadMemoryVariables({});\n * console.log({ history });\n *\n * // Create a chat prompt using the conversation history\n * const chatPrompt = ChatPromptTemplate.fromMessages([\n *   SystemMessagePromptTemplate.fromTemplate(\n *     \"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.\",\n *   ),\n *   new MessagesPlaceholder(\"history\"),\n *   HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n * ]);\n *\n * // Initialize the conversation chain with the model, memory, and prompt\n * const chain = new ConversationChain({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9, verbose: true }),\n *   memory: memory,\n *   prompt: chatPrompt,\n * });\n * ```\n */\nexport declare class ConversationSummaryBufferMemory extends BaseConversationSummaryMemory implements ConversationSummaryBufferMemoryInput {\n    movingSummaryBuffer: string;\n    maxTokenLimit: number;\n    constructor(fields: ConversationSummaryBufferMemoryInput);\n    get memoryKeys(): string[];\n    /**\n     * Method that loads the chat messages from the memory and returns them as\n     * a string or as a list of messages, depending on the returnMessages\n     * property.\n     * @param _ InputValues object, not used in this method.\n     * @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.\n     */\n    loadMemoryVariables(_?: InputValues): Promise<MemoryVariables>;\n    /**\n     * Method that saves the context of the conversation, including the input\n     * and output values, and prunes the memory if it exceeds the maximum\n     * token limit.\n     * @param inputValues InputValues object containing the input values of the conversation.\n     * @param outputValues OutputValues object containing the output values of the conversation.\n     * @returns Promise that resolves when the context is saved and the memory is pruned.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n    /**\n     * Method that prunes the memory if the total number of tokens in the\n     * buffer exceeds the maxTokenLimit. It removes messages from the\n     * beginning of the buffer until the total number of tokens is within the\n     * limit.\n     * @returns Promise that resolves when the memory is pruned.\n     */\n    prune(): Promise<void>;\n    /**\n     * Method that clears the memory and resets the movingSummaryBuffer.\n     * @returns Promise that resolves when the memory is cleared.\n     */\n    clear(): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA;AA0CA;AAAoD,UA1CnCK,oCAAAA,SAA6CD,kCA0CV,CAAA;EAAA,aAG5BC,CAAAA,EAAAA,MAAAA;;;;;;;;;;;AAHkH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArHC,+BAAAA,SAAwCH,6BAAAA,YAAyCE;;;sBAG9EA;;;;;;;;;0BASIL,cAAcO,QAAQN;;;;;;;;;2BASrBD,2BAA2BE,eAAeK;;;;;;;;WAQ1DA;;;;;WAKAA"}

package/dist/memory/summary_buffer.d.ts

@@ -1,90 +0,0 @@
-import { BaseConversationSummaryMemory, BaseConversationSummaryMemoryInput } from "./summary.js";
-import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-
-//#region src/memory/summary_buffer.d.ts
-
-/**
- * Interface for the input parameters of the
- * ConversationSummaryBufferMemory class.
- */
-interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {
-  maxTokenLimit?: number;
-}
-/**
- * Class that extends BaseConversationSummaryMemory and implements
- * ConversationSummaryBufferMemoryInput. It manages the conversation
- * 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({ model: "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({ model: "gpt-4o-mini", temperature: 0.9, verbose: true }),
- *   memory: memory,
- *   prompt: chatPrompt,
- * });
- * ```
- */
-declare class ConversationSummaryBufferMemory extends BaseConversationSummaryMemory implements ConversationSummaryBufferMemoryInput {
-  movingSummaryBuffer: string;
-  maxTokenLimit: number;
-  constructor(fields: ConversationSummaryBufferMemoryInput);
-  get memoryKeys(): string[];
-  /**
-   * Method that loads the chat messages from the memory and returns them as
-   * a string or as a list of messages, depending on the returnMessages
-   * property.
-   * @param _ InputValues object, not used in this method.
-   * @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.
-   */
-  loadMemoryVariables(_?: InputValues): Promise<MemoryVariables>;
-  /**
-   * Method that saves the context of the conversation, including the input
-   * and output values, and prunes the memory if it exceeds the maximum
-   * token limit.
-   * @param inputValues InputValues object containing the input values of the conversation.
-   * @param outputValues OutputValues object containing the output values of the conversation.
-   * @returns Promise that resolves when the context is saved and the memory is pruned.
-   */
-  saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
-  /**
-   * Method that prunes the memory if the total number of tokens in the
-   * buffer exceeds the maxTokenLimit. It removes messages from the
-   * beginning of the buffer until the total number of tokens is within the
-   * limit.
-   * @returns Promise that resolves when the memory is pruned.
-   */
-  prune(): Promise<void>;
-  /**
-   * Method that clears the memory and resets the movingSummaryBuffer.
-   * @returns Promise that resolves when the memory is cleared.
-   */
-  clear(): Promise<void>;
-}
-//#endregion
-export { ConversationSummaryBufferMemory, ConversationSummaryBufferMemoryInput };
-//# sourceMappingURL=summary_buffer.d.ts.map

package/dist/memory/summary_buffer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"summary_buffer.d.ts","names":["InputValues","MemoryVariables","OutputValues","BaseConversationSummaryMemory","BaseConversationSummaryMemoryInput","ConversationSummaryBufferMemoryInput","ConversationSummaryBufferMemory","Promise"],"sources":["../../src/memory/summary_buffer.d.ts"],"sourcesContent":["import { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseConversationSummaryMemory, BaseConversationSummaryMemoryInput } from \"./summary.js\";\n/**\n * Interface for the input parameters of the\n * ConversationSummaryBufferMemory class.\n */\nexport interface ConversationSummaryBufferMemoryInput extends BaseConversationSummaryMemoryInput {\n    maxTokenLimit?: number;\n}\n/**\n * Class that extends BaseConversationSummaryMemory and implements\n * ConversationSummaryBufferMemoryInput. It manages the conversation\n * history in a LangChain application by maintaining a buffer of chat\n * messages and providing methods to load, save, prune, and clear the\n * memory.\n * @example\n * ```typescript\n * // Initialize the memory with a specific model and token limit\n * const memory = new ConversationSummaryBufferMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo-instruct\", temperature: 0 }),\n *   maxTokenLimit: 10,\n * });\n *\n * // Save conversation context to memory\n * await memory.saveContext({ input: \"hi\" }, { output: \"whats up\" });\n * await memory.saveContext({ input: \"not much you\" }, { output: \"not much\" });\n *\n * // Load the conversation history from memory\n * const history = await memory.loadMemoryVariables({});\n * console.log({ history });\n *\n * // Create a chat prompt using the conversation history\n * const chatPrompt = ChatPromptTemplate.fromMessages([\n *   SystemMessagePromptTemplate.fromTemplate(\n *     \"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.\",\n *   ),\n *   new MessagesPlaceholder(\"history\"),\n *   HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n * ]);\n *\n * // Initialize the conversation chain with the model, memory, and prompt\n * const chain = new ConversationChain({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9, verbose: true }),\n *   memory: memory,\n *   prompt: chatPrompt,\n * });\n * ```\n */\nexport declare class ConversationSummaryBufferMemory extends BaseConversationSummaryMemory implements ConversationSummaryBufferMemoryInput {\n    movingSummaryBuffer: string;\n    maxTokenLimit: number;\n    constructor(fields: ConversationSummaryBufferMemoryInput);\n    get memoryKeys(): string[];\n    /**\n     * Method that loads the chat messages from the memory and returns them as\n     * a string or as a list of messages, depending on the returnMessages\n     * property.\n     * @param _ InputValues object, not used in this method.\n     * @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.\n     */\n    loadMemoryVariables(_?: InputValues): Promise<MemoryVariables>;\n    /**\n     * Method that saves the context of the conversation, including the input\n     * and output values, and prunes the memory if it exceeds the maximum\n     * token limit.\n     * @param inputValues InputValues object containing the input values of the conversation.\n     * @param outputValues OutputValues object containing the output values of the conversation.\n     * @returns Promise that resolves when the context is saved and the memory is pruned.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n    /**\n     * Method that prunes the memory if the total number of tokens in the\n     * buffer exceeds the maxTokenLimit. It removes messages from the\n     * beginning of the buffer until the total number of tokens is within the\n     * limit.\n     * @returns Promise that resolves when the memory is pruned.\n     */\n    prune(): Promise<void>;\n    /**\n     * Method that clears the memory and resets the movingSummaryBuffer.\n     * @returns Promise that resolves when the memory is cleared.\n     */\n    clear(): Promise<void>;\n}\n"],"mappings":";;;;;;;AAMA;AA0CA;AAAoD,UA1CnCK,oCAAAA,SAA6CD,kCA0CV,CAAA;EAAA,aAG5BC,CAAAA,EAAAA,MAAAA;;;;;;;;;;;AAHkH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAArHC,+BAAAA,SAAwCH,6BAAAA,YAAyCE;;;sBAG9EA;;;;;;;;;0BASIL,cAAcO,QAAQN;;;;;;;;;2BASrBD,2BAA2BE,eAAeK;;;;;;;;WAQ1DA;;;;;WAKAA"}

package/dist/memory/summary_buffer.js

@@ -1,116 +0,0 @@
-import { BaseConversationSummaryMemory } from "./summary.js";
-import { getBufferString } from "@langchain/core/messages";
-
-//#region src/memory/summary_buffer.ts
-/**
-* Class that extends BaseConversationSummaryMemory and implements
-* ConversationSummaryBufferMemoryInput. It manages the conversation
-* 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({ model: "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({ model: "gpt-4o-mini", temperature: 0.9, verbose: true }),
-*   memory: memory,
-*   prompt: chatPrompt,
-* });
-* ```
-*/
-var ConversationSummaryBufferMemory = class extends BaseConversationSummaryMemory {
-	movingSummaryBuffer = "";
-	maxTokenLimit = 2e3;
-	constructor(fields) {
-		super(fields);
-		this.maxTokenLimit = fields?.maxTokenLimit ?? this.maxTokenLimit;
-	}
-	get memoryKeys() {
-		return [this.memoryKey];
-	}
-	/**
-	* Method that loads the chat messages from the memory and returns them as
-	* a string or as a list of messages, depending on the returnMessages
-	* property.
-	* @param _ InputValues object, not used in this method.
-	* @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.
-	*/
-	async loadMemoryVariables(_) {
-		let buffer = await this.chatHistory.getMessages();
-		if (this.movingSummaryBuffer) buffer = [new this.summaryChatMessageClass(this.movingSummaryBuffer), ...buffer];
-		let finalBuffer;
-		if (this.returnMessages) finalBuffer = buffer;
-		else finalBuffer = getBufferString(buffer, this.humanPrefix, this.aiPrefix);
-		return { [this.memoryKey]: finalBuffer };
-	}
-	/**
-	* Method that saves the context of the conversation, including the input
-	* and output values, and prunes the memory if it exceeds the maximum
-	* token limit.
-	* @param inputValues InputValues object containing the input values of the conversation.
-	* @param outputValues OutputValues object containing the output values of the conversation.
-	* @returns Promise that resolves when the context is saved and the memory is pruned.
-	*/
-	async saveContext(inputValues, outputValues) {
-		await super.saveContext(inputValues, outputValues);
-		await this.prune();
-	}
-	/**
-	* Method that prunes the memory if the total number of tokens in the
-	* buffer exceeds the maxTokenLimit. It removes messages from the
-	* beginning of the buffer until the total number of tokens is within the
-	* limit.
-	* @returns Promise that resolves when the memory is pruned.
-	*/
-	async prune() {
-		let buffer = await this.chatHistory.getMessages();
-		if (this.movingSummaryBuffer) buffer = [new this.summaryChatMessageClass(this.movingSummaryBuffer), ...buffer];
-		let currBufferLength = await this.llm.getNumTokens(getBufferString(buffer, this.humanPrefix, this.aiPrefix));
-		if (currBufferLength > this.maxTokenLimit) {
-			const prunedMemory = [];
-			while (currBufferLength > this.maxTokenLimit) {
-				const poppedMessage = buffer.shift();
-				if (poppedMessage) {
-					prunedMemory.push(poppedMessage);
-					currBufferLength = await this.llm.getNumTokens(getBufferString(buffer, this.humanPrefix, this.aiPrefix));
-				}
-			}
-			this.movingSummaryBuffer = await this.predictNewSummary(prunedMemory, this.movingSummaryBuffer);
-		}
-	}
-	/**
-	* Method that clears the memory and resets the movingSummaryBuffer.
-	* @returns Promise that resolves when the memory is cleared.
-	*/
-	async clear() {
-		await super.clear();
-		this.movingSummaryBuffer = "";
-	}
-};
-
-//#endregion
-export { ConversationSummaryBufferMemory };
-//# sourceMappingURL=summary_buffer.js.map

package/dist/memory/summary_buffer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"summary_buffer.js","names":["fields: ConversationSummaryBufferMemoryInput","_?: InputValues","inputValues: InputValues","outputValues: OutputValues"],"sources":["../../src/memory/summary_buffer.ts"],"sourcesContent":["import { getBufferString } from \"@langchain/core/messages\";\nimport {\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport {\n  BaseConversationSummaryMemory,\n  BaseConversationSummaryMemoryInput,\n} from \"./summary.js\";\n\n/**\n * Interface for the input parameters of the\n * ConversationSummaryBufferMemory class.\n */\nexport interface ConversationSummaryBufferMemoryInput\n  extends BaseConversationSummaryMemoryInput {\n  maxTokenLimit?: number;\n}\n\n/**\n * Class that extends BaseConversationSummaryMemory and implements\n * ConversationSummaryBufferMemoryInput. It manages the conversation\n * history in a LangChain application by maintaining a buffer of chat\n * messages and providing methods to load, save, prune, and clear the\n * memory.\n * @example\n * ```typescript\n * // Initialize the memory with a specific model and token limit\n * const memory = new ConversationSummaryBufferMemory({\n *   llm: new ChatOpenAI({ model: \"gpt-3.5-turbo-instruct\", temperature: 0 }),\n *   maxTokenLimit: 10,\n * });\n *\n * // Save conversation context to memory\n * await memory.saveContext({ input: \"hi\" }, { output: \"whats up\" });\n * await memory.saveContext({ input: \"not much you\" }, { output: \"not much\" });\n *\n * // Load the conversation history from memory\n * const history = await memory.loadMemoryVariables({});\n * console.log({ history });\n *\n * // Create a chat prompt using the conversation history\n * const chatPrompt = ChatPromptTemplate.fromMessages([\n *   SystemMessagePromptTemplate.fromTemplate(\n *     \"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.\",\n *   ),\n *   new MessagesPlaceholder(\"history\"),\n *   HumanMessagePromptTemplate.fromTemplate(\"{input}\"),\n * ]);\n *\n * // Initialize the conversation chain with the model, memory, and prompt\n * const chain = new ConversationChain({\n *   llm: new ChatOpenAI({ model: \"gpt-4o-mini\", temperature: 0.9, verbose: true }),\n *   memory: memory,\n *   prompt: chatPrompt,\n * });\n * ```\n */\nexport class ConversationSummaryBufferMemory\n  extends BaseConversationSummaryMemory\n  implements ConversationSummaryBufferMemoryInput\n{\n  movingSummaryBuffer = \"\";\n\n  maxTokenLimit = 2000;\n\n  constructor(fields: ConversationSummaryBufferMemoryInput) {\n    super(fields);\n\n    this.maxTokenLimit = fields?.maxTokenLimit ?? this.maxTokenLimit;\n  }\n\n  get memoryKeys() {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method that loads the chat messages from the memory and returns them as\n   * a string or as a list of messages, depending on the returnMessages\n   * property.\n   * @param _ InputValues object, not used in this method.\n   * @returns Promise that resolves with MemoryVariables object containing the loaded chat messages.\n   */\n  async loadMemoryVariables(_?: InputValues): Promise<MemoryVariables> {\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\n    let finalBuffer;\n    if (this.returnMessages) {\n      finalBuffer = buffer;\n    } else {\n      finalBuffer = getBufferString(buffer, this.humanPrefix, this.aiPrefix);\n    }\n\n    return { [this.memoryKey]: finalBuffer };\n  }\n\n  /**\n   * Method that saves the context of the conversation, including the input\n   * and output values, and prunes the memory if it exceeds the maximum\n   * token limit.\n   * @param inputValues InputValues object containing the input values of the conversation.\n   * @param outputValues OutputValues object containing the output values of the conversation.\n   * @returns Promise that resolves when the context is saved and the memory is pruned.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    await super.saveContext(inputValues, outputValues);\n    await this.prune();\n  }\n\n  /**\n   * Method that prunes the memory if the total number of tokens in the\n   * buffer exceeds the maxTokenLimit. It removes messages from the\n   * beginning of the buffer until the total number of tokens is within the\n   * limit.\n   * @returns Promise that resolves when the memory is pruned.\n   */\n  async prune() {\n    // Prune buffer if it exceeds max token limit\n    let buffer = await this.chatHistory.getMessages();\n    if (this.movingSummaryBuffer) {\n      buffer = [\n        new this.summaryChatMessageClass(this.movingSummaryBuffer),\n        ...buffer,\n      ];\n    }\n\n    let currBufferLength = await this.llm.getNumTokens(\n      getBufferString(buffer, this.humanPrefix, this.aiPrefix)\n    );\n\n    if (currBufferLength > this.maxTokenLimit) {\n      const prunedMemory = [];\n      while (currBufferLength > this.maxTokenLimit) {\n        const poppedMessage = buffer.shift();\n        if (poppedMessage) {\n          prunedMemory.push(poppedMessage);\n          currBufferLength = await this.llm.getNumTokens(\n            getBufferString(buffer, this.humanPrefix, this.aiPrefix)\n          );\n        }\n      }\n      this.movingSummaryBuffer = await this.predictNewSummary(\n        prunedMemory,\n        this.movingSummaryBuffer\n      );\n    }\n  }\n\n  /**\n   * Method that clears the memory and resets the movingSummaryBuffer.\n   * @returns Promise that resolves when the memory is cleared.\n   */\n  async clear() {\n    await super.clear();\n    this.movingSummaryBuffer = \"\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,IAAa,kCAAb,cACU,8BAEV;CACE,sBAAsB;CAEtB,gBAAgB;CAEhB,YAAYA,QAA8C;EACxD,MAAM,OAAO;EAEb,KAAK,gBAAgB,QAAQ,iBAAiB,KAAK;CACpD;CAED,IAAI,aAAa;AACf,SAAO,CAAC,KAAK,SAAU;CACxB;;;;;;;;CASD,MAAM,oBAAoBC,GAA2C;EACnE,IAAI,SAAS,MAAM,KAAK,YAAY,aAAa;AACjD,MAAI,KAAK,qBACP,SAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,sBACtC,GAAG,MACJ;EAGH,IAAI;AACJ,MAAI,KAAK,gBACP,cAAc;OAEd,cAAc,gBAAgB,QAAQ,KAAK,aAAa,KAAK,SAAS;AAGxE,SAAO,GAAG,KAAK,YAAY,YAAa;CACzC;;;;;;;;;CAUD,MAAM,YACJC,aACAC,cACe;EACf,MAAM,MAAM,YAAY,aAAa,aAAa;EAClD,MAAM,KAAK,OAAO;CACnB;;;;;;;;CASD,MAAM,QAAQ;EAEZ,IAAI,SAAS,MAAM,KAAK,YAAY,aAAa;AACjD,MAAI,KAAK,qBACP,SAAS,CACP,IAAI,KAAK,wBAAwB,KAAK,sBACtC,GAAG,MACJ;EAGH,IAAI,mBAAmB,MAAM,KAAK,IAAI,aACpC,gBAAgB,QAAQ,KAAK,aAAa,KAAK,SAAS,CACzD;AAED,MAAI,mBAAmB,KAAK,eAAe;GACzC,MAAM,eAAe,CAAE;AACvB,UAAO,mBAAmB,KAAK,eAAe;IAC5C,MAAM,gBAAgB,OAAO,OAAO;AACpC,QAAI,eAAe;KACjB,aAAa,KAAK,cAAc;KAChC,mBAAmB,MAAM,KAAK,IAAI,aAChC,gBAAgB,QAAQ,KAAK,aAAa,KAAK,SAAS,CACzD;IACF;GACF;GACD,KAAK,sBAAsB,MAAM,KAAK,kBACpC,cACA,KAAK,oBACN;EACF;CACF;;;;;CAMD,MAAM,QAAQ;EACZ,MAAM,MAAM,OAAO;EACnB,KAAK,sBAAsB;CAC5B;AACF"}

package/dist/memory/vector_store.cjs

@@ -1,87 +0,0 @@
-const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
-const require_util_document = require('../util/document.cjs');
-const __langchain_core_documents = require_rolldown_runtime.__toESM(require("@langchain/core/documents"));
-const __langchain_core_memory = require_rolldown_runtime.__toESM(require("@langchain/core/memory"));
-
-//#region src/memory/vector_store.ts
-/**
-* Class for managing long-term memory in Large Language Model (LLM)
-* applications. It provides a way to persist and retrieve relevant
-* 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?" }),
-* );
-* ```
-*/
-var VectorStoreRetrieverMemory = class extends __langchain_core_memory.BaseMemory {
-	vectorStoreRetriever;
-	inputKey;
-	memoryKey;
-	returnDocs;
-	metadata;
-	constructor(fields) {
-		super();
-		this.vectorStoreRetriever = fields.vectorStoreRetriever;
-		this.inputKey = fields.inputKey;
-		this.memoryKey = fields.memoryKey ?? "memory";
-		this.returnDocs = fields.returnDocs ?? false;
-		this.metadata = fields.metadata;
-	}
-	get memoryKeys() {
-		return [this.memoryKey];
-	}
-	/**
-	* Method to load memory variables. It uses the vectorStoreRetriever to
-	* get relevant documents based on the query obtained from the input
-	* values.
-	* @param values An InputValues object.
-	* @returns A Promise that resolves to a MemoryVariables object.
-	*/
-	async loadMemoryVariables(values) {
-		const query = (0, __langchain_core_memory.getInputValue)(values, this.inputKey);
-		const results = await this.vectorStoreRetriever.getRelevantDocuments(query);
-		return { [this.memoryKey]: this.returnDocs ? results : require_util_document.formatDocumentsAsString(results) };
-	}
-	/**
-	* Method to save context. It constructs a document from the input and
-	* output values (excluding the memory key) and adds it to the vector
-	* store database using the vectorStoreRetriever.
-	* @param inputValues An InputValues object.
-	* @param outputValues An OutputValues object.
-	* @returns A Promise that resolves to void.
-	*/
-	async saveContext(inputValues, outputValues) {
-		const metadata = typeof this.metadata === "function" ? this.metadata(inputValues, outputValues) : this.metadata;
-		const text = Object.entries(inputValues).filter(([k]) => k !== this.memoryKey).concat(Object.entries(outputValues)).map(([k, v]) => `${k}: ${v}`).join("\n");
-		await this.vectorStoreRetriever.addDocuments([new __langchain_core_documents.Document({
-			pageContent: text,
-			metadata
-		})]);
-	}
-};
-
-//#endregion
-exports.VectorStoreRetrieverMemory = VectorStoreRetrieverMemory;
-//# sourceMappingURL=vector_store.cjs.map

package/dist/memory/vector_store.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"vector_store.cjs","names":["BaseMemory","fields: VectorStoreRetrieverMemoryParams","values: InputValues","formatDocumentsAsString","inputValues: InputValues","outputValues: OutputValues","Document"],"sources":["../../src/memory/vector_store.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { Document } from \"@langchain/core/documents\";\nimport {\n  BaseMemory,\n  getInputValue,\n  InputValues,\n  MemoryVariables,\n  OutputValues,\n} from \"@langchain/core/memory\";\nimport { formatDocumentsAsString } from \"../util/document.js\";\n\ntype Metadata = Record<string, unknown>;\ntype MetadataFunction = (\n  inputValues?: InputValues,\n  outputValues?: OutputValues\n) => Metadata;\n\n/**\n * Interface for the parameters required to initialize a\n * VectorStoreRetrieverMemory instance.\n */\nexport interface VectorStoreRetrieverMemoryParams {\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n  inputKey?: string;\n  outputKey?: string;\n  memoryKey?: string;\n  returnDocs?: boolean;\n  /**\n   * Metadata to be added to the document when saving context.\n   */\n  metadata?: Metadata | MetadataFunction;\n}\n\n/**\n * Class for managing long-term memory in Large Language Model (LLM)\n * applications. It provides a way to persist and retrieve relevant\n * documents from a vector store database, which can be useful for\n * maintaining conversation history or other types of memory in an LLM\n * application.\n * @example\n * ```typescript\n * const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n * const memory = new VectorStoreRetrieverMemory({\n *   vectorStoreRetriever: vectorStore.asRetriever(1),\n *   memoryKey: \"history\",\n * });\n *\n * // Saving context to memory\n * await memory.saveContext(\n *   { input: \"My favorite food is pizza\" },\n *   { output: \"thats good to know\" },\n * );\n * await memory.saveContext(\n *   { input: \"My favorite sport is soccer\" },\n *   { output: \"...\" },\n * );\n * await memory.saveContext({ input: \"I don't the Celtics\" }, { output: \"ok\" });\n *\n * // Loading memory variables\n * console.log(\n *   await memory.loadMemoryVariables({ prompt: \"what sport should i watch?\" }),\n * );\n * ```\n */\nexport class VectorStoreRetrieverMemory\n  extends BaseMemory\n  implements VectorStoreRetrieverMemoryParams\n{\n  vectorStoreRetriever: VectorStoreRetrieverInterface;\n\n  inputKey?: string;\n\n  memoryKey: string;\n\n  returnDocs: boolean;\n\n  metadata?: Metadata | MetadataFunction;\n\n  constructor(fields: VectorStoreRetrieverMemoryParams) {\n    super();\n    this.vectorStoreRetriever = fields.vectorStoreRetriever;\n    this.inputKey = fields.inputKey;\n    this.memoryKey = fields.memoryKey ?? \"memory\";\n    this.returnDocs = fields.returnDocs ?? false;\n    this.metadata = fields.metadata;\n  }\n\n  get memoryKeys(): string[] {\n    return [this.memoryKey];\n  }\n\n  /**\n   * Method to load memory variables. It uses the vectorStoreRetriever to\n   * get relevant documents based on the query obtained from the input\n   * values.\n   * @param values An InputValues object.\n   * @returns A Promise that resolves to a MemoryVariables object.\n   */\n  async loadMemoryVariables(values: InputValues): Promise<MemoryVariables> {\n    const query = getInputValue(values, this.inputKey);\n    const results = await this.vectorStoreRetriever.getRelevantDocuments(query);\n    return {\n      [this.memoryKey]: this.returnDocs\n        ? results\n        : formatDocumentsAsString(results),\n    };\n  }\n\n  /**\n   * Method to save context. It constructs a document from the input and\n   * output values (excluding the memory key) and adds it to the vector\n   * store database using the vectorStoreRetriever.\n   * @param inputValues An InputValues object.\n   * @param outputValues An OutputValues object.\n   * @returns A Promise that resolves to void.\n   */\n  async saveContext(\n    inputValues: InputValues,\n    outputValues: OutputValues\n  ): Promise<void> {\n    const metadata =\n      typeof this.metadata === \"function\"\n        ? this.metadata(inputValues, outputValues)\n        : this.metadata;\n    const text = Object.entries(inputValues)\n      .filter(([k]) => k !== this.memoryKey)\n      .concat(Object.entries(outputValues))\n      .map(([k, v]) => `${k}: ${v}`)\n      .join(\"\\n\");\n    await this.vectorStoreRetriever.addDocuments([\n      new Document({ pageContent: text, metadata }),\n    ]);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgEA,IAAa,6BAAb,cACUA,mCAEV;CACE;CAEA;CAEA;CAEA;CAEA;CAEA,YAAYC,QAA0C;EACpD,OAAO;EACP,KAAK,uBAAuB,OAAO;EACnC,KAAK,WAAW,OAAO;EACvB,KAAK,YAAY,OAAO,aAAa;EACrC,KAAK,aAAa,OAAO,cAAc;EACvC,KAAK,WAAW,OAAO;CACxB;CAED,IAAI,aAAuB;AACzB,SAAO,CAAC,KAAK,SAAU;CACxB;;;;;;;;CASD,MAAM,oBAAoBC,QAA+C;EACvE,MAAM,mDAAsB,QAAQ,KAAK,SAAS;EAClD,MAAM,UAAU,MAAM,KAAK,qBAAqB,qBAAqB,MAAM;AAC3E,SAAO,GACJ,KAAK,YAAY,KAAK,aACnB,UACAC,8CAAwB,QAAQ,CACrC;CACF;;;;;;;;;CAUD,MAAM,YACJC,aACAC,cACe;EACf,MAAM,WACJ,OAAO,KAAK,aAAa,aACrB,KAAK,SAAS,aAAa,aAAa,GACxC,KAAK;EACX,MAAM,OAAO,OAAO,QAAQ,YAAY,CACrC,OAAO,CAAC,CAAC,EAAE,KAAK,MAAM,KAAK,UAAU,CACrC,OAAO,OAAO,QAAQ,aAAa,CAAC,CACpC,IAAI,CAAC,CAAC,GAAG,EAAE,KAAK,GAAG,EAAE,EAAE,EAAE,GAAG,CAAC,CAC7B,KAAK,KAAK;EACb,MAAM,KAAK,qBAAqB,aAAa,CAC3C,IAAIC,oCAAS;GAAE,aAAa;GAAM;EAAU,EAC7C,EAAC;CACH;AACF"}

package/dist/memory/vector_store.d.cts

@@ -1,81 +0,0 @@
-import { BaseMemory, InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-import { VectorStoreRetrieverInterface } from "@langchain/core/vectorstores";
-
-//#region src/memory/vector_store.d.ts
-type Metadata = Record<string, unknown>;
-type MetadataFunction = (inputValues?: InputValues, outputValues?: OutputValues) => Metadata;
-/**
- * Interface for the parameters required to initialize a
- * VectorStoreRetrieverMemory instance.
- */
-interface VectorStoreRetrieverMemoryParams {
-  vectorStoreRetriever: VectorStoreRetrieverInterface;
-  inputKey?: string;
-  outputKey?: string;
-  memoryKey?: string;
-  returnDocs?: boolean;
-  /**
-   * Metadata to be added to the document when saving context.
-   */
-  metadata?: Metadata | MetadataFunction;
-}
-/**
- * Class for managing long-term memory in Large Language Model (LLM)
- * applications. It provides a way to persist and retrieve relevant
- * 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?" }),
- * );
- * ```
- */
-declare class VectorStoreRetrieverMemory extends BaseMemory implements VectorStoreRetrieverMemoryParams {
-  vectorStoreRetriever: VectorStoreRetrieverInterface;
-  inputKey?: string;
-  memoryKey: string;
-  returnDocs: boolean;
-  metadata?: Metadata | MetadataFunction;
-  constructor(fields: VectorStoreRetrieverMemoryParams);
-  get memoryKeys(): string[];
-  /**
-   * Method to load memory variables. It uses the vectorStoreRetriever to
-   * get relevant documents based on the query obtained from the input
-   * values.
-   * @param values An InputValues object.
-   * @returns A Promise that resolves to a MemoryVariables object.
-   */
-  loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;
-  /**
-   * Method to save context. It constructs a document from the input and
-   * output values (excluding the memory key) and adds it to the vector
-   * store database using the vectorStoreRetriever.
-   * @param inputValues An InputValues object.
-   * @param outputValues An OutputValues object.
-   * @returns A Promise that resolves to void.
-   */
-  saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
-}
-//#endregion
-export { VectorStoreRetrieverMemory, VectorStoreRetrieverMemoryParams };
-//# sourceMappingURL=vector_store.d.cts.map

package/dist/memory/vector_store.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vector_store.d.cts","names":["VectorStoreRetrieverInterface","BaseMemory","InputValues","MemoryVariables","OutputValues","Metadata","Record","MetadataFunction","VectorStoreRetrieverMemoryParams","VectorStoreRetrieverMemory","Promise"],"sources":["../../src/memory/vector_store.d.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { BaseMemory, InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\ntype Metadata = Record<string, unknown>;\ntype MetadataFunction = (inputValues?: InputValues, outputValues?: OutputValues) => Metadata;\n/**\n * Interface for the parameters required to initialize a\n * VectorStoreRetrieverMemory instance.\n */\nexport interface VectorStoreRetrieverMemoryParams {\n    vectorStoreRetriever: VectorStoreRetrieverInterface;\n    inputKey?: string;\n    outputKey?: string;\n    memoryKey?: string;\n    returnDocs?: boolean;\n    /**\n     * Metadata to be added to the document when saving context.\n     */\n    metadata?: Metadata | MetadataFunction;\n}\n/**\n * Class for managing long-term memory in Large Language Model (LLM)\n * applications. It provides a way to persist and retrieve relevant\n * documents from a vector store database, which can be useful for\n * maintaining conversation history or other types of memory in an LLM\n * application.\n * @example\n * ```typescript\n * const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n * const memory = new VectorStoreRetrieverMemory({\n *   vectorStoreRetriever: vectorStore.asRetriever(1),\n *   memoryKey: \"history\",\n * });\n *\n * // Saving context to memory\n * await memory.saveContext(\n *   { input: \"My favorite food is pizza\" },\n *   { output: \"thats good to know\" },\n * );\n * await memory.saveContext(\n *   { input: \"My favorite sport is soccer\" },\n *   { output: \"...\" },\n * );\n * await memory.saveContext({ input: \"I don't the Celtics\" }, { output: \"ok\" });\n *\n * // Loading memory variables\n * console.log(\n *   await memory.loadMemoryVariables({ prompt: \"what sport should i watch?\" }),\n * );\n * ```\n */\nexport declare class VectorStoreRetrieverMemory extends BaseMemory implements VectorStoreRetrieverMemoryParams {\n    vectorStoreRetriever: VectorStoreRetrieverInterface;\n    inputKey?: string;\n    memoryKey: string;\n    returnDocs: boolean;\n    metadata?: Metadata | MetadataFunction;\n    constructor(fields: VectorStoreRetrieverMemoryParams);\n    get memoryKeys(): string[];\n    /**\n     * Method to load memory variables. It uses the vectorStoreRetriever to\n     * get relevant documents based on the query obtained from the input\n     * values.\n     * @param values An InputValues object.\n     * @returns A Promise that resolves to a MemoryVariables object.\n     */\n    loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Method to save context. It constructs a document from the input and\n     * output values (excluding the memory key) and adds it to the vector\n     * store database using the vectorStoreRetriever.\n     * @param inputValues An InputValues object.\n     * @param outputValues An OutputValues object.\n     * @returns A Promise that resolves to void.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\nexport {};\n"],"mappings":";;;;KAEKK,QAAAA,GAAWC;KACXC,gBAAAA,kBAAkCL,4BAA4BE,iBAAiBC;AAFY;AAC1E;;;AAC6CD,UAKlDI,gCAAAA,CALkDJ;EAAY,oBAAKC,EAM1DL,6BAN0DK;EAAQ,QAAA,CAAA,EAAA,MAAA;EAK3EG,SAAAA,CAAAA,EAAAA,MAAAA;EAAgC,SAAA,CAAA,EAAA,MAAA;EAAA,UACvBR,CAAAA,EAAAA,OAAAA;EAA6B;;AAQb;EAiCrBS,QAAAA,CAAAA,EAjCNJ,QAiCMI,GAjCKF,gBAiCqB;;;;;;;;;;;;;;AAA+D;;;;;;;;;;;;;;;;;;;cAAzFE,0BAAAA,SAAmCR,UAAAA,YAAsBO;wBACpDR;;;;aAIXK,WAAWE;sBACFC;;;;;;;;;8BASQN,cAAcQ,QAAQP;;;;;;;;;2BASzBD,2BAA2BE,eAAeM"}

package/dist/memory/vector_store.d.ts

@@ -1,81 +0,0 @@
-import { BaseMemory, InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
-import { VectorStoreRetrieverInterface } from "@langchain/core/vectorstores";
-
-//#region src/memory/vector_store.d.ts
-type Metadata = Record<string, unknown>;
-type MetadataFunction = (inputValues?: InputValues, outputValues?: OutputValues) => Metadata;
-/**
- * Interface for the parameters required to initialize a
- * VectorStoreRetrieverMemory instance.
- */
-interface VectorStoreRetrieverMemoryParams {
-  vectorStoreRetriever: VectorStoreRetrieverInterface;
-  inputKey?: string;
-  outputKey?: string;
-  memoryKey?: string;
-  returnDocs?: boolean;
-  /**
-   * Metadata to be added to the document when saving context.
-   */
-  metadata?: Metadata | MetadataFunction;
-}
-/**
- * Class for managing long-term memory in Large Language Model (LLM)
- * applications. It provides a way to persist and retrieve relevant
- * 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?" }),
- * );
- * ```
- */
-declare class VectorStoreRetrieverMemory extends BaseMemory implements VectorStoreRetrieverMemoryParams {
-  vectorStoreRetriever: VectorStoreRetrieverInterface;
-  inputKey?: string;
-  memoryKey: string;
-  returnDocs: boolean;
-  metadata?: Metadata | MetadataFunction;
-  constructor(fields: VectorStoreRetrieverMemoryParams);
-  get memoryKeys(): string[];
-  /**
-   * Method to load memory variables. It uses the vectorStoreRetriever to
-   * get relevant documents based on the query obtained from the input
-   * values.
-   * @param values An InputValues object.
-   * @returns A Promise that resolves to a MemoryVariables object.
-   */
-  loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;
-  /**
-   * Method to save context. It constructs a document from the input and
-   * output values (excluding the memory key) and adds it to the vector
-   * store database using the vectorStoreRetriever.
-   * @param inputValues An InputValues object.
-   * @param outputValues An OutputValues object.
-   * @returns A Promise that resolves to void.
-   */
-  saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;
-}
-//#endregion
-export { VectorStoreRetrieverMemory, VectorStoreRetrieverMemoryParams };
-//# sourceMappingURL=vector_store.d.ts.map

package/dist/memory/vector_store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vector_store.d.ts","names":["VectorStoreRetrieverInterface","BaseMemory","InputValues","MemoryVariables","OutputValues","Metadata","Record","MetadataFunction","VectorStoreRetrieverMemoryParams","VectorStoreRetrieverMemory","Promise"],"sources":["../../src/memory/vector_store.d.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { BaseMemory, InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\ntype Metadata = Record<string, unknown>;\ntype MetadataFunction = (inputValues?: InputValues, outputValues?: OutputValues) => Metadata;\n/**\n * Interface for the parameters required to initialize a\n * VectorStoreRetrieverMemory instance.\n */\nexport interface VectorStoreRetrieverMemoryParams {\n    vectorStoreRetriever: VectorStoreRetrieverInterface;\n    inputKey?: string;\n    outputKey?: string;\n    memoryKey?: string;\n    returnDocs?: boolean;\n    /**\n     * Metadata to be added to the document when saving context.\n     */\n    metadata?: Metadata | MetadataFunction;\n}\n/**\n * Class for managing long-term memory in Large Language Model (LLM)\n * applications. It provides a way to persist and retrieve relevant\n * documents from a vector store database, which can be useful for\n * maintaining conversation history or other types of memory in an LLM\n * application.\n * @example\n * ```typescript\n * const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n * const memory = new VectorStoreRetrieverMemory({\n *   vectorStoreRetriever: vectorStore.asRetriever(1),\n *   memoryKey: \"history\",\n * });\n *\n * // Saving context to memory\n * await memory.saveContext(\n *   { input: \"My favorite food is pizza\" },\n *   { output: \"thats good to know\" },\n * );\n * await memory.saveContext(\n *   { input: \"My favorite sport is soccer\" },\n *   { output: \"...\" },\n * );\n * await memory.saveContext({ input: \"I don't the Celtics\" }, { output: \"ok\" });\n *\n * // Loading memory variables\n * console.log(\n *   await memory.loadMemoryVariables({ prompt: \"what sport should i watch?\" }),\n * );\n * ```\n */\nexport declare class VectorStoreRetrieverMemory extends BaseMemory implements VectorStoreRetrieverMemoryParams {\n    vectorStoreRetriever: VectorStoreRetrieverInterface;\n    inputKey?: string;\n    memoryKey: string;\n    returnDocs: boolean;\n    metadata?: Metadata | MetadataFunction;\n    constructor(fields: VectorStoreRetrieverMemoryParams);\n    get memoryKeys(): string[];\n    /**\n     * Method to load memory variables. It uses the vectorStoreRetriever to\n     * get relevant documents based on the query obtained from the input\n     * values.\n     * @param values An InputValues object.\n     * @returns A Promise that resolves to a MemoryVariables object.\n     */\n    loadMemoryVariables(values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Method to save context. It constructs a document from the input and\n     * output values (excluding the memory key) and adds it to the vector\n     * store database using the vectorStoreRetriever.\n     * @param inputValues An InputValues object.\n     * @param outputValues An OutputValues object.\n     * @returns A Promise that resolves to void.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\nexport {};\n"],"mappings":";;;;KAEKK,QAAAA,GAAWC;KACXC,gBAAAA,kBAAkCL,4BAA4BE,iBAAiBC;AAFY;AAC1E;;;AAC6CD,UAKlDI,gCAAAA,CALkDJ;EAAY,oBAAKC,EAM1DL,6BAN0DK;EAAQ,QAAA,CAAA,EAAA,MAAA;EAK3EG,SAAAA,CAAAA,EAAAA,MAAAA;EAAgC,SAAA,CAAA,EAAA,MAAA;EAAA,UACvBR,CAAAA,EAAAA,OAAAA;EAA6B;;AAQb;EAiCrBS,QAAAA,CAAAA,EAjCNJ,QAiCMI,GAjCKF,gBAiCqB;;;;;;;;;;;;;;AAA+D;;;;;;;;;;;;;;;;;;;cAAzFE,0BAAAA,SAAmCR,UAAAA,YAAsBO;wBACpDR;;;;aAIXK,WAAWE;sBACFC;;;;;;;;;8BASQN,cAAcQ,QAAQP;;;;;;;;;2BASzBD,2BAA2BE,eAAeM"}