@langchain/classic 1.0.0-alpha.1

package/dist/experimental/generative_agents/generative_agent_memory.d.ts

@@ -0,0 +1,205 @@
+import { BaseChain } from "../../chains/base.js";
+import { LLMChain } from "../../chains/llm_chain.js";
+import { TimeWeightedVectorStoreRetriever } from "../../retrievers/time_weighted.js";
+import { Document } from "@langchain/core/documents";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
+import { CallbackManagerForChainRun, Callbacks } from "@langchain/core/callbacks/manager";
+import { BaseMemory, InputValues, OutputValues } from "@langchain/core/memory";
+import { ChainValues } from "@langchain/core/utils/types";
+
+//#region src/experimental/generative_agents/generative_agent_memory.d.ts
+type GenerativeAgentMemoryConfig = {
+  reflectionThreshold?: number;
+  importanceWeight?: number;
+  verbose?: boolean;
+  maxTokensLimit?: number;
+};
+/**
+ * Class that manages the memory of a generative agent in LangChain. It
+ * extends the `BaseChain` class and has methods for adding observations
+ * or memories to the agent's memory, scoring the importance of a memory,
+ * reflecting on recent events to add synthesized memories, and generating
+ * insights on a topic of reflection based on pertinent memories.
+ */
+declare class GenerativeAgentMemoryChain extends BaseChain {
+  static lc_name(): string;
+  reflecting: boolean;
+  reflectionThreshold?: number;
+  importanceWeight: number;
+  memoryRetriever: TimeWeightedVectorStoreRetriever;
+  llm: BaseLanguageModelInterface;
+  verbose: boolean;
+  private aggregateImportance;
+  constructor(llm: BaseLanguageModelInterface, memoryRetriever: TimeWeightedVectorStoreRetriever, config: Omit<GenerativeAgentMemoryConfig, "maxTokensLimit">);
+  _chainType(): string;
+  get inputKeys(): string[];
+  get outputKeys(): string[];
+  /**
+   * Method that creates a new LLMChain with the given prompt.
+   * @param prompt The PromptTemplate to use for the new LLMChain.
+   * @returns A new LLMChain instance.
+   */
+  chain(prompt: PromptTemplate): LLMChain;
+  _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<{
+    output: number;
+  }>;
+  /**
+   * Method that pauses the agent to reflect on recent events and generate
+   * new insights.
+   * @param now The current date.
+   * @param runManager The CallbackManagerForChainRun to use for the reflection.
+   * @returns An array of new insights as strings.
+   */
+  pauseToReflect(now?: Date, runManager?: CallbackManagerForChainRun): Promise<string[]>;
+  /**
+   * Method that scores the importance of a given memory.
+   * @param memoryContent The content of the memory to score.
+   * @param runManager The CallbackManagerForChainRun to use for scoring.
+   * @returns The importance score of the memory as a number.
+   */
+  scoreMemoryImportance(memoryContent: string, runManager?: CallbackManagerForChainRun): Promise<number>;
+  /**
+   * Method that retrieves the topics of reflection based on the last K
+   * memories.
+   * @param lastK The number of most recent memories to consider for generating topics.
+   * @param runManager The CallbackManagerForChainRun to use for retrieving topics.
+   * @returns An array of topics of reflection as strings.
+   */
+  getTopicsOfReflection(lastK: number, runManager?: CallbackManagerForChainRun): Promise<string[]>;
+  /**
+   * Method that generates insights on a given topic of reflection based on
+   * pertinent memories.
+   * @param topic The topic of reflection.
+   * @param now The current date.
+   * @param runManager The CallbackManagerForChainRun to use for generating insights.
+   * @returns An array of insights as strings.
+   */
+  getInsightsOnTopic(topic: string, now?: Date, runManager?: CallbackManagerForChainRun): Promise<string[]>;
+  /**
+   * Method that parses a newline-separated string into a list of strings.
+   * @param text The newline-separated string to parse.
+   * @returns An array of strings.
+   */
+  static parseList(text: string): string[];
+  // TODO: Mock "now" to simulate different times
+  /**
+   * Method that fetches memories related to a given observation.
+   * @param observation The observation to fetch memories for.
+   * @param _now The current date.
+   * @param runManager The CallbackManagerForChainRun to use for fetching memories.
+   * @returns An array of Document instances representing the fetched memories.
+   */
+  fetchMemories(observation: string, _now?: Date, runManager?: CallbackManagerForChainRun): Promise<Document[]>;
+}
+/**
+ * Class that manages the memory of a generative agent in LangChain. It
+ * extends the `BaseMemory` class and has methods for adding a memory,
+ * formatting memories, getting memories until a token limit is reached,
+ * loading memory variables, saving the context of a model run to memory,
+ * and clearing memory contents.
+ * @example
+ * ```typescript
+ * const createNewMemoryRetriever = async () => {
+ *   const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());
+ *   const retriever = new TimeWeightedVectorStoreRetriever({
+ *     vectorStore,
+ *     otherScoreKeys: ["importance"],
+ *     k: 15,
+ *   });
+ *   return retriever;
+ * };
+ * const tommiesMemory = new GenerativeAgentMemory(
+ *   llm,
+ *   await createNewMemoryRetriever(),
+ *   { reflectionThreshold: 8 },
+ * );
+ * const summary = await tommiesMemory.getSummary();
+ * ```
+ */
+declare class GenerativeAgentMemory extends BaseMemory {
+  llm: BaseLanguageModelInterface;
+  memoryRetriever: TimeWeightedVectorStoreRetriever;
+  verbose: boolean;
+  reflectionThreshold?: number;
+  private maxTokensLimit;
+  queriesKey: string;
+  mostRecentMemoriesTokenKey: string;
+  addMemoryKey: string;
+  relevantMemoriesKey: string;
+  relevantMemoriesSimpleKey: string;
+  mostRecentMemoriesKey: string;
+  nowKey: string;
+  memoryChain: GenerativeAgentMemoryChain;
+  constructor(llm: BaseLanguageModelInterface, memoryRetriever: TimeWeightedVectorStoreRetriever, config?: GenerativeAgentMemoryConfig);
+  /**
+   * Method that returns the key for relevant memories.
+   * @returns The key for relevant memories as a string.
+   */
+  getRelevantMemoriesKey(): string;
+  /**
+   * Method that returns the key for the most recent memories token.
+   * @returns The key for the most recent memories token as a string.
+   */
+  getMostRecentMemoriesTokenKey(): string;
+  /**
+   * Method that returns the key for adding a memory.
+   * @returns The key for adding a memory as a string.
+   */
+  getAddMemoryKey(): string;
+  /**
+   * Method that returns the key for the current time.
+   * @returns The key for the current time as a string.
+   */
+  getCurrentTimeKey(): string;
+  get memoryKeys(): string[];
+  /**
+   * Method that adds a memory to the agent's memory.
+   * @param memoryContent The content of the memory to add.
+   * @param now The current date.
+   * @param metadata The metadata for the memory.
+   * @param callbacks The Callbacks to use for adding the memory.
+   * @returns The result of the memory addition.
+   */
+  addMemory(memoryContent: string, now?: Date, metadata?: Record<string, unknown>, callbacks?: Callbacks): Promise<ChainValues>;
+  /**
+   * Method that formats the given relevant memories in detail.
+   * @param relevantMemories The relevant memories to format.
+   * @returns The formatted memories as a string.
+   */
+  formatMemoriesDetail(relevantMemories: Document[]): string;
+  /**
+   * Method that formats the given relevant memories in a simple manner.
+   * @param relevantMemories The relevant memories to format.
+   * @returns The formatted memories as a string.
+   */
+  formatMemoriesSimple(relevantMemories: Document[]): string;
+  /**
+   * Method that retrieves memories until a token limit is reached.
+   * @param consumedTokens The number of tokens consumed so far.
+   * @returns The memories as a string.
+   */
+  getMemoriesUntilLimit(consumedTokens: number): Promise<string>;
+  get memoryVariables(): string[];
+  /**
+   * Method that loads memory variables based on the given inputs.
+   * @param inputs The inputs to use for loading memory variables.
+   * @returns An object containing the loaded memory variables.
+   */
+  loadMemoryVariables(inputs: InputValues): Promise<Record<string, string>>;
+  /**
+   * Method that saves the context of a model run to memory.
+   * @param _inputs The inputs of the model run.
+   * @param outputs The outputs of the model run.
+   * @returns Nothing.
+   */
+  saveContext(_inputs: InputValues, outputs: OutputValues): Promise<void>;
+  /**
+   * Method that clears the memory contents.
+   * @returns Nothing.
+   */
+  clear(): void;
+}
+//#endregion
+export { GenerativeAgentMemory };
+//# sourceMappingURL=generative_agent_memory.d.ts.map

package/dist/experimental/generative_agents/generative_agent_memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generative_agent_memory.d.ts","names":["BaseLanguageModelInterface","PromptTemplate","Document","ChainValues","BaseMemory","InputValues","OutputValues","CallbackManagerForChainRun","Callbacks","TimeWeightedVectorStoreRetriever","BaseChain","LLMChain","GenerativeAgentMemoryConfig","GenerativeAgentMemoryChain","Omit","Promise","Date","GenerativeAgentMemory","Record"],"sources":["../../../src/experimental/generative_agents/generative_agent_memory.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { Document } from \"@langchain/core/documents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { BaseMemory, InputValues, OutputValues } from \"@langchain/core/memory\";\nimport { CallbackManagerForChainRun, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { TimeWeightedVectorStoreRetriever } from \"../../retrievers/time_weighted.js\";\nimport { BaseChain } from \"../../chains/base.js\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\nexport type GenerativeAgentMemoryConfig = {\n    reflectionThreshold?: number;\n    importanceWeight?: number;\n    verbose?: boolean;\n    maxTokensLimit?: number;\n};\n/**\n * Class that manages the memory of a generative agent in LangChain. It\n * extends the `BaseChain` class and has methods for adding observations\n * or memories to the agent's memory, scoring the importance of a memory,\n * reflecting on recent events to add synthesized memories, and generating\n * insights on a topic of reflection based on pertinent memories.\n */\ndeclare class GenerativeAgentMemoryChain extends BaseChain {\n    static lc_name(): string;\n    reflecting: boolean;\n    reflectionThreshold?: number;\n    importanceWeight: number;\n    memoryRetriever: TimeWeightedVectorStoreRetriever;\n    llm: BaseLanguageModelInterface;\n    verbose: boolean;\n    private aggregateImportance;\n    constructor(llm: BaseLanguageModelInterface, memoryRetriever: TimeWeightedVectorStoreRetriever, config: Omit<GenerativeAgentMemoryConfig, \"maxTokensLimit\">);\n    _chainType(): string;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    /**\n     * Method that creates a new LLMChain with the given prompt.\n     * @param prompt The PromptTemplate to use for the new LLMChain.\n     * @returns A new LLMChain instance.\n     */\n    chain(prompt: PromptTemplate): LLMChain;\n    _call(values: ChainValues, runManager?: CallbackManagerForChainRun): Promise<{\n        output: number;\n    }>;\n    /**\n     * Method that pauses the agent to reflect on recent events and generate\n     * new insights.\n     * @param now The current date.\n     * @param runManager The CallbackManagerForChainRun to use for the reflection.\n     * @returns An array of new insights as strings.\n     */\n    pauseToReflect(now?: Date, runManager?: CallbackManagerForChainRun): Promise<string[]>;\n    /**\n     * Method that scores the importance of a given memory.\n     * @param memoryContent The content of the memory to score.\n     * @param runManager The CallbackManagerForChainRun to use for scoring.\n     * @returns The importance score of the memory as a number.\n     */\n    scoreMemoryImportance(memoryContent: string, runManager?: CallbackManagerForChainRun): Promise<number>;\n    /**\n     * Method that retrieves the topics of reflection based on the last K\n     * memories.\n     * @param lastK The number of most recent memories to consider for generating topics.\n     * @param runManager The CallbackManagerForChainRun to use for retrieving topics.\n     * @returns An array of topics of reflection as strings.\n     */\n    getTopicsOfReflection(lastK: number, runManager?: CallbackManagerForChainRun): Promise<string[]>;\n    /**\n     * Method that generates insights on a given topic of reflection based on\n     * pertinent memories.\n     * @param topic The topic of reflection.\n     * @param now The current date.\n     * @param runManager The CallbackManagerForChainRun to use for generating insights.\n     * @returns An array of insights as strings.\n     */\n    getInsightsOnTopic(topic: string, now?: Date, runManager?: CallbackManagerForChainRun): Promise<string[]>;\n    /**\n     * Method that parses a newline-separated string into a list of strings.\n     * @param text The newline-separated string to parse.\n     * @returns An array of strings.\n     */\n    static parseList(text: string): string[];\n    // TODO: Mock \"now\" to simulate different times\n    /**\n     * Method that fetches memories related to a given observation.\n     * @param observation The observation to fetch memories for.\n     * @param _now The current date.\n     * @param runManager The CallbackManagerForChainRun to use for fetching memories.\n     * @returns An array of Document instances representing the fetched memories.\n     */\n    fetchMemories(observation: string, _now?: Date, runManager?: CallbackManagerForChainRun): Promise<Document[]>;\n}\n/**\n * Class that manages the memory of a generative agent in LangChain. It\n * extends the `BaseMemory` class and has methods for adding a memory,\n * formatting memories, getting memories until a token limit is reached,\n * loading memory variables, saving the context of a model run to memory,\n * and clearing memory contents.\n * @example\n * ```typescript\n * const createNewMemoryRetriever = async () => {\n *   const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n *   const retriever = new TimeWeightedVectorStoreRetriever({\n *     vectorStore,\n *     otherScoreKeys: [\"importance\"],\n *     k: 15,\n *   });\n *   return retriever;\n * };\n * const tommiesMemory = new GenerativeAgentMemory(\n *   llm,\n *   await createNewMemoryRetriever(),\n *   { reflectionThreshold: 8 },\n * );\n * const summary = await tommiesMemory.getSummary();\n * ```\n */\nexport declare class GenerativeAgentMemory extends BaseMemory {\n    llm: BaseLanguageModelInterface;\n    memoryRetriever: TimeWeightedVectorStoreRetriever;\n    verbose: boolean;\n    reflectionThreshold?: number;\n    private maxTokensLimit;\n    queriesKey: string;\n    mostRecentMemoriesTokenKey: string;\n    addMemoryKey: string;\n    relevantMemoriesKey: string;\n    relevantMemoriesSimpleKey: string;\n    mostRecentMemoriesKey: string;\n    nowKey: string;\n    memoryChain: GenerativeAgentMemoryChain;\n    constructor(llm: BaseLanguageModelInterface, memoryRetriever: TimeWeightedVectorStoreRetriever, config?: GenerativeAgentMemoryConfig);\n    /**\n     * Method that returns the key for relevant memories.\n     * @returns The key for relevant memories as a string.\n     */\n    getRelevantMemoriesKey(): string;\n    /**\n     * Method that returns the key for the most recent memories token.\n     * @returns The key for the most recent memories token as a string.\n     */\n    getMostRecentMemoriesTokenKey(): string;\n    /**\n     * Method that returns the key for adding a memory.\n     * @returns The key for adding a memory as a string.\n     */\n    getAddMemoryKey(): string;\n    /**\n     * Method that returns the key for the current time.\n     * @returns The key for the current time as a string.\n     */\n    getCurrentTimeKey(): string;\n    get memoryKeys(): string[];\n    /**\n     * Method that adds a memory to the agent's memory.\n     * @param memoryContent The content of the memory to add.\n     * @param now The current date.\n     * @param metadata The metadata for the memory.\n     * @param callbacks The Callbacks to use for adding the memory.\n     * @returns The result of the memory addition.\n     */\n    addMemory(memoryContent: string, now?: Date, metadata?: Record<string, unknown>, callbacks?: Callbacks): Promise<ChainValues>;\n    /**\n     * Method that formats the given relevant memories in detail.\n     * @param relevantMemories The relevant memories to format.\n     * @returns The formatted memories as a string.\n     */\n    formatMemoriesDetail(relevantMemories: Document[]): string;\n    /**\n     * Method that formats the given relevant memories in a simple manner.\n     * @param relevantMemories The relevant memories to format.\n     * @returns The formatted memories as a string.\n     */\n    formatMemoriesSimple(relevantMemories: Document[]): string;\n    /**\n     * Method that retrieves memories until a token limit is reached.\n     * @param consumedTokens The number of tokens consumed so far.\n     * @returns The memories as a string.\n     */\n    getMemoriesUntilLimit(consumedTokens: number): Promise<string>;\n    get memoryVariables(): string[];\n    /**\n     * Method that loads memory variables based on the given inputs.\n     * @param inputs The inputs to use for loading memory variables.\n     * @returns An object containing the loaded memory variables.\n     */\n    loadMemoryVariables(inputs: InputValues): Promise<Record<string, string>>;\n    /**\n     * Method that saves the context of a model run to memory.\n     * @param _inputs The inputs of the model run.\n     * @param outputs The outputs of the model run.\n     * @returns Nothing.\n     */\n    saveContext(_inputs: InputValues, outputs: OutputValues): Promise<void>;\n    /**\n     * Method that clears the memory contents.\n     * @returns Nothing.\n     */\n    clear(): void;\n}\nexport {};\n"],"mappings":";;;;;;;;;;;KASYY,2BAAAA;;EAAAA,gBAAAA,CAAAA,EAAAA,MAAAA;EAaEC,OAAAA,CAAAA,EAAAA,OAAAA;EAA0B,cAAA,CAAA,EAAA,MAAA;CAAA;;;;;;;;cAA1BA,0BAAAA,SAAmCH,SAAAA,CAmB/BP;EAAW,OAAeI,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA0B,UAAGQ,EAAAA,OAAAA;EAAO,mBAUvDC,CAAAA,EAAAA,MAAAA;EAAI,gBAAeT,EAAAA,MAAAA;EAA0B,eAAGQ,EAxBpDN,gCAwBoDM;EAAO,GAOlBR,EA9BrDP,0BA8BqDO;EAA0B,OAAGQ,EAAAA,OAAAA;EAAO,QAQ5CR,mBAAAA;EAA0B,WAAGQ,CAAAA,GAAAA,EAnC9Df,0BAmC8De,EAAAA,eAAAA,EAnCjBN,gCAmCiBM,EAAAA,MAAAA,EAnCyBD,IAmCzBC,CAnC8BH,2BAmC9BG,EAAAA,gBAAAA,CAAAA;EAAO,UAS9CC,CAAAA,CAAAA,EAAAA,MAAAA;EAAI,IAAeT,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAA0B,IAAGQ,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAO;;;;;EArDzC,KAAA,CAAA,MAAA,EAkBxCd,cAlBwC,CAAA,EAkBvBU,QAlBuB;EA+FrCM,KAAAA,CAAAA,MAAAA,EA5EHd,WA4EwB,EAAA,UAAA,CAAA,EA5EEI,0BA4EF,CAAA,EA5E+BQ,OA4E/B,CAAA;IAAA,MAAA,EAAA,MAAA;EAAA,CAAA,CAAA;EACP;;;;;;;EA2C+B,cAA+BP,CAAAA,GAAAA,CAAAA,EA9GxEQ,IA8GwER,EAAAA,UAAAA,CAAAA,EA9GrDD,0BA8GqDC,CAAAA,EA9GxBO,OA8GwBP,CAAAA,MAAAA,EAAAA,CAAAA;EAAS;;;;;;EAyB/D,qBAAWU,CAAAA,aAAAA,EAAAA,MAAAA,EAAAA,UAAAA,CAAAA,EAhIQX,0BAgIRW,CAAAA,EAhIqCH,OAgIrCG,CAAAA,MAAAA,CAAAA;EAAM;;;;;AArEC;;oDAnDPX,6BAA6BQ;;;;;;;;;0CASvCC,mBAAmBT,6BAA6BQ;;;;;;;;;;;;;;;4CAe9CC,mBAAmBT,6BAA6BQ,QAAQb;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BjFe,qBAAAA,SAA8Bb,UAAAA;OAC1CJ;mBACYS;;;;;;;;;;;eAWJI;mBACIb,6CAA6CS,2CAA2CG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCA8BlEI,iBAAiBE,qCAAqCV,YAAYO,QAAQZ;;;;;;yCAM1ED;;;;;;yCAMAA;;;;;;iDAMQa;;;;;;;8BAOnBV,cAAcU,QAAQG;;;;;;;uBAO7Bb,sBAAsBC,eAAeS"}

package/dist/experimental/generative_agents/generative_agent_memory.js

@@ -0,0 +1,363 @@
+import { BaseChain } from "../../chains/base.js";
+import { LLMChain } from "../../chains/llm_chain.js";
+import { Document } from "@langchain/core/documents";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { BaseMemory } from "@langchain/core/memory";
+
+//#region src/experimental/generative_agents/generative_agent_memory.ts
+/**
+* Class that manages the memory of a generative agent in LangChain. It
+* extends the `BaseChain` class and has methods for adding observations
+* or memories to the agent's memory, scoring the importance of a memory,
+* reflecting on recent events to add synthesized memories, and generating
+* insights on a topic of reflection based on pertinent memories.
+*/
+var GenerativeAgentMemoryChain = class GenerativeAgentMemoryChain extends BaseChain {
+	static lc_name() {
+		return "GenerativeAgentMemoryChain";
+	}
+	reflecting = false;
+	reflectionThreshold;
+	importanceWeight = .15;
+	memoryRetriever;
+	llm;
+	verbose = false;
+	aggregateImportance = 0;
+	constructor(llm, memoryRetriever, config) {
+		super();
+		this.llm = llm;
+		this.memoryRetriever = memoryRetriever;
+		this.reflectionThreshold = config.reflectionThreshold;
+		this.importanceWeight = config.importanceWeight ?? this.importanceWeight;
+		this.verbose = config.verbose ?? this.verbose;
+	}
+	_chainType() {
+		return "generative_agent_memory";
+	}
+	get inputKeys() {
+		return [
+			"memory_content",
+			"now",
+			"memory_metadata"
+		];
+	}
+	get outputKeys() {
+		return ["output"];
+	}
+	/**
+	* Method that creates a new LLMChain with the given prompt.
+	* @param prompt The PromptTemplate to use for the new LLMChain.
+	* @returns A new LLMChain instance.
+	*/
+	chain(prompt) {
+		const chain = new LLMChain({
+			llm: this.llm,
+			prompt,
+			verbose: this.verbose,
+			outputKey: "output"
+		});
+		return chain;
+	}
+	async _call(values, runManager) {
+		const { memory_content: memoryContent, now } = values;
+		const importanceScore = await this.scoreMemoryImportance(memoryContent, runManager);
+		this.aggregateImportance += importanceScore;
+		const document = new Document({
+			pageContent: memoryContent,
+			metadata: {
+				importance: importanceScore,
+				...values.memory_metadata
+			}
+		});
+		await this.memoryRetriever.addDocuments([document]);
+		if (this.reflectionThreshold !== void 0 && this.aggregateImportance > this.reflectionThreshold && !this.reflecting) {
+			console.log("Reflecting on current memories...");
+			this.reflecting = true;
+			await this.pauseToReflect(now, runManager);
+			this.aggregateImportance = 0;
+			this.reflecting = false;
+		}
+		return { output: importanceScore };
+	}
+	/**
+	* Method that pauses the agent to reflect on recent events and generate
+	* new insights.
+	* @param now The current date.
+	* @param runManager The CallbackManagerForChainRun to use for the reflection.
+	* @returns An array of new insights as strings.
+	*/
+	async pauseToReflect(now, runManager) {
+		if (this.verbose) console.log("Pausing to reflect...");
+		const newInsights = [];
+		const topics = await this.getTopicsOfReflection(50, runManager);
+		for (const topic of topics) {
+			const insights = await this.getInsightsOnTopic(topic, now, runManager);
+			for (const insight of insights) await this.call({
+				memory_content: insight,
+				now,
+				memory_metadata: { source: "reflection_insight" }
+			}, runManager?.getChild("reflection_insight_memory"));
+			newInsights.push(...insights);
+		}
+		return newInsights;
+	}
+	/**
+	* Method that scores the importance of a given memory.
+	* @param memoryContent The content of the memory to score.
+	* @param runManager The CallbackManagerForChainRun to use for scoring.
+	* @returns The importance score of the memory as a number.
+	*/
+	async scoreMemoryImportance(memoryContent, runManager) {
+		const prompt = PromptTemplate.fromTemplate("On the scale of 1 to 10, where 1 is purely mundane (e.g., brushing teeth, making bed) and 10 is extremely poignant (e.g., a break up, college acceptance), rate the likely poignancy of the following piece of memory. Respond with a single integer.\nMemory: {memory_content}\nRating: ");
+		const score = await this.chain(prompt).run(memoryContent, runManager?.getChild("determine_importance"));
+		const strippedScore = score.trim();
+		if (this.verbose) console.log("Importance score:", strippedScore);
+		const match = strippedScore.match(/^\D*(\d+)/);
+		if (match) {
+			const capturedNumber = parseFloat(match[1]);
+			const result = capturedNumber / 10 * this.importanceWeight;
+			return result;
+		} else return 0;
+	}
+	/**
+	* Method that retrieves the topics of reflection based on the last K
+	* memories.
+	* @param lastK The number of most recent memories to consider for generating topics.
+	* @param runManager The CallbackManagerForChainRun to use for retrieving topics.
+	* @returns An array of topics of reflection as strings.
+	*/
+	async getTopicsOfReflection(lastK, runManager) {
+		const prompt = PromptTemplate.fromTemplate("{observations}\n\nGiven only the information above, what are the 3 most salient high-level questions we can answer about the subjects in the statements? Provide each question on a new line.\n\n");
+		const observations = this.memoryRetriever.getMemoryStream().slice(-lastK);
+		const observationStr = observations.map((o) => o.pageContent).join("\n");
+		const result = await this.chain(prompt).run(observationStr, runManager?.getChild("reflection_topics"));
+		return GenerativeAgentMemoryChain.parseList(result);
+	}
+	/**
+	* Method that generates insights on a given topic of reflection based on
+	* pertinent memories.
+	* @param topic The topic of reflection.
+	* @param now The current date.
+	* @param runManager The CallbackManagerForChainRun to use for generating insights.
+	* @returns An array of insights as strings.
+	*/
+	async getInsightsOnTopic(topic, now, runManager) {
+		const prompt = PromptTemplate.fromTemplate("Statements about {topic}\n{related_statements}\n\nWhat 5 high-level insights can you infer from the above statements? (example format: insight (because of 1, 5, 3))");
+		const relatedMemories = await this.fetchMemories(topic, now, runManager);
+		const relatedStatements = relatedMemories.map((memory, index) => `${index + 1}. ${memory.pageContent}`).join("\n");
+		const result = await this.chain(prompt).call({
+			topic,
+			related_statements: relatedStatements
+		}, runManager?.getChild("reflection_insights"));
+		return GenerativeAgentMemoryChain.parseList(result.output);
+	}
+	/**
+	* Method that parses a newline-separated string into a list of strings.
+	* @param text The newline-separated string to parse.
+	* @returns An array of strings.
+	*/
+	static parseList(text) {
+		return text.split("\n").map((s) => s.trim());
+	}
+	/**
+	* Method that fetches memories related to a given observation.
+	* @param observation The observation to fetch memories for.
+	* @param _now The current date.
+	* @param runManager The CallbackManagerForChainRun to use for fetching memories.
+	* @returns An array of Document instances representing the fetched memories.
+	*/
+	async fetchMemories(observation, _now, runManager) {
+		return this.memoryRetriever.invoke(observation, runManager?.getChild("memory_retriever"));
+	}
+};
+/**
+* Class that manages the memory of a generative agent in LangChain. It
+* extends the `BaseMemory` class and has methods for adding a memory,
+* formatting memories, getting memories until a token limit is reached,
+* loading memory variables, saving the context of a model run to memory,
+* and clearing memory contents.
+* @example
+* ```typescript
+* const createNewMemoryRetriever = async () => {
+*   const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());
+*   const retriever = new TimeWeightedVectorStoreRetriever({
+*     vectorStore,
+*     otherScoreKeys: ["importance"],
+*     k: 15,
+*   });
+*   return retriever;
+* };
+* const tommiesMemory = new GenerativeAgentMemory(
+*   llm,
+*   await createNewMemoryRetriever(),
+*   { reflectionThreshold: 8 },
+* );
+* const summary = await tommiesMemory.getSummary();
+* ```
+*/
+var GenerativeAgentMemory = class extends BaseMemory {
+	llm;
+	memoryRetriever;
+	verbose;
+	reflectionThreshold;
+	maxTokensLimit = 1200;
+	queriesKey = "queries";
+	mostRecentMemoriesTokenKey = "recent_memories_token";
+	addMemoryKey = "addMemory";
+	relevantMemoriesKey = "relevant_memories";
+	relevantMemoriesSimpleKey = "relevant_memories_simple";
+	mostRecentMemoriesKey = "most_recent_memories";
+	nowKey = "now";
+	memoryChain;
+	constructor(llm, memoryRetriever, config) {
+		super();
+		this.llm = llm;
+		this.memoryRetriever = memoryRetriever;
+		this.verbose = config?.verbose ?? this.verbose;
+		this.reflectionThreshold = config?.reflectionThreshold ?? this.reflectionThreshold;
+		this.maxTokensLimit = config?.maxTokensLimit ?? this.maxTokensLimit;
+		this.memoryChain = new GenerativeAgentMemoryChain(llm, memoryRetriever, {
+			reflectionThreshold: config?.reflectionThreshold,
+			importanceWeight: config?.importanceWeight
+		});
+	}
+	/**
+	* Method that returns the key for relevant memories.
+	* @returns The key for relevant memories as a string.
+	*/
+	getRelevantMemoriesKey() {
+		return this.relevantMemoriesKey;
+	}
+	/**
+	* Method that returns the key for the most recent memories token.
+	* @returns The key for the most recent memories token as a string.
+	*/
+	getMostRecentMemoriesTokenKey() {
+		return this.mostRecentMemoriesTokenKey;
+	}
+	/**
+	* Method that returns the key for adding a memory.
+	* @returns The key for adding a memory as a string.
+	*/
+	getAddMemoryKey() {
+		return this.addMemoryKey;
+	}
+	/**
+	* Method that returns the key for the current time.
+	* @returns The key for the current time as a string.
+	*/
+	getCurrentTimeKey() {
+		return this.nowKey;
+	}
+	get memoryKeys() {
+		return [this.relevantMemoriesKey, this.mostRecentMemoriesKey];
+	}
+	/**
+	* Method that adds a memory to the agent's memory.
+	* @param memoryContent The content of the memory to add.
+	* @param now The current date.
+	* @param metadata The metadata for the memory.
+	* @param callbacks The Callbacks to use for adding the memory.
+	* @returns The result of the memory addition.
+	*/
+	async addMemory(memoryContent, now, metadata, callbacks) {
+		return this.memoryChain.call({
+			memory_content: memoryContent,
+			now,
+			memory_metadata: metadata
+		}, callbacks);
+	}
+	/**
+	* Method that formats the given relevant memories in detail.
+	* @param relevantMemories The relevant memories to format.
+	* @returns The formatted memories as a string.
+	*/
+	formatMemoriesDetail(relevantMemories) {
+		if (!relevantMemories.length) return "No relevant information.";
+		const contentStrings = /* @__PURE__ */ new Set();
+		const content = [];
+		for (const memory of relevantMemories) {
+			if (memory.pageContent in contentStrings) continue;
+			contentStrings.add(memory.pageContent);
+			const createdTime = memory.metadata.created_at.toLocaleString("en-US", {
+				month: "long",
+				day: "numeric",
+				year: "numeric",
+				hour: "numeric",
+				minute: "numeric",
+				hour12: true
+			});
+			content.push(`${createdTime}: ${memory.pageContent.trim()}`);
+		}
+		const joinedContent = content.map((mem) => `${mem}`).join("\n");
+		return joinedContent;
+	}
+	/**
+	* Method that formats the given relevant memories in a simple manner.
+	* @param relevantMemories The relevant memories to format.
+	* @returns The formatted memories as a string.
+	*/
+	formatMemoriesSimple(relevantMemories) {
+		const joinedContent = relevantMemories.map((mem) => `${mem.pageContent}`).join("; ");
+		return joinedContent;
+	}
+	/**
+	* Method that retrieves memories until a token limit is reached.
+	* @param consumedTokens The number of tokens consumed so far.
+	* @returns The memories as a string.
+	*/
+	async getMemoriesUntilLimit(consumedTokens) {
+		const result = [];
+		for (const doc of this.memoryRetriever.getMemoryStream().slice().reverse()) {
+			if (consumedTokens >= this.maxTokensLimit) {
+				if (this.verbose) console.log("Exceeding max tokens for LLM, filtering memories");
+				break;
+			}
+			consumedTokens += await this.llm.getNumTokens(doc.pageContent);
+			if (consumedTokens < this.maxTokensLimit) result.push(doc);
+		}
+		return this.formatMemoriesSimple(result);
+	}
+	get memoryVariables() {
+		return [];
+	}
+	/**
+	* Method that loads memory variables based on the given inputs.
+	* @param inputs The inputs to use for loading memory variables.
+	* @returns An object containing the loaded memory variables.
+	*/
+	async loadMemoryVariables(inputs) {
+		const queries = inputs[this.queriesKey];
+		const now = inputs[this.nowKey];
+		if (queries !== void 0) {
+			const relevantMemories = (await Promise.all(queries.map((query) => this.memoryChain.fetchMemories(query, now)))).flat();
+			return {
+				[this.relevantMemoriesKey]: this.formatMemoriesDetail(relevantMemories),
+				[this.relevantMemoriesSimpleKey]: this.formatMemoriesSimple(relevantMemories)
+			};
+		}
+		const mostRecentMemoriesToken = inputs[this.mostRecentMemoriesTokenKey];
+		if (mostRecentMemoriesToken !== void 0) return { [this.mostRecentMemoriesKey]: await this.getMemoriesUntilLimit(mostRecentMemoriesToken) };
+		return {};
+	}
+	/**
+	* Method that saves the context of a model run to memory.
+	* @param _inputs The inputs of the model run.
+	* @param outputs The outputs of the model run.
+	* @returns Nothing.
+	*/
+	async saveContext(_inputs, outputs) {
+		const mem = outputs[this.addMemoryKey];
+		const now = outputs[this.nowKey];
+		if (mem) await this.addMemory(mem, now, {});
+	}
+	/**
+	* Method that clears the memory contents.
+	* @returns Nothing.
+	*/
+	clear() {}
+};
+
+//#endregion
+export { GenerativeAgentMemory };
+//# sourceMappingURL=generative_agent_memory.js.map

package/dist/experimental/generative_agents/generative_agent_memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generative_agent_memory.js","names":["llm: BaseLanguageModelInterface","memoryRetriever: TimeWeightedVectorStoreRetriever","config: Omit<GenerativeAgentMemoryConfig, \"maxTokensLimit\">","prompt: PromptTemplate","values: ChainValues","runManager?: CallbackManagerForChainRun","now?: Date","newInsights: string[]","memoryContent: string","lastK: number","o: { pageContent: string }","topic: string","relatedStatements: string","text: string","observation: string","_now?: Date","config?: GenerativeAgentMemoryConfig","metadata?: Record<string, unknown>","callbacks?: Callbacks","relevantMemories: Document[]","consumedTokens: number","inputs: InputValues","query: string","_inputs: InputValues","outputs: OutputValues"],"sources":["../../../src/experimental/generative_agents/generative_agent_memory.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { PromptTemplate } from \"@langchain/core/prompts\";\nimport { Document } from \"@langchain/core/documents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { BaseMemory, InputValues, OutputValues } from \"@langchain/core/memory\";\nimport {\n  CallbackManagerForChainRun,\n  Callbacks,\n} from \"@langchain/core/callbacks/manager\";\nimport { TimeWeightedVectorStoreRetriever } from \"../../retrievers/time_weighted.js\";\nimport { BaseChain } from \"../../chains/base.js\";\nimport { LLMChain } from \"../../chains/llm_chain.js\";\n\nexport type GenerativeAgentMemoryConfig = {\n  reflectionThreshold?: number;\n  importanceWeight?: number;\n  verbose?: boolean;\n  maxTokensLimit?: number;\n};\n\n/**\n * Class that manages the memory of a generative agent in LangChain. It\n * extends the `BaseChain` class and has methods for adding observations\n * or memories to the agent's memory, scoring the importance of a memory,\n * reflecting on recent events to add synthesized memories, and generating\n * insights on a topic of reflection based on pertinent memories.\n */\nclass GenerativeAgentMemoryChain extends BaseChain {\n  static lc_name() {\n    return \"GenerativeAgentMemoryChain\";\n  }\n\n  reflecting = false;\n\n  reflectionThreshold?: number;\n\n  importanceWeight = 0.15;\n\n  memoryRetriever: TimeWeightedVectorStoreRetriever;\n\n  llm: BaseLanguageModelInterface;\n\n  verbose = false;\n\n  private aggregateImportance = 0.0;\n\n  constructor(\n    llm: BaseLanguageModelInterface,\n    memoryRetriever: TimeWeightedVectorStoreRetriever,\n    config: Omit<GenerativeAgentMemoryConfig, \"maxTokensLimit\">\n  ) {\n    super();\n    this.llm = llm;\n    this.memoryRetriever = memoryRetriever;\n    this.reflectionThreshold = config.reflectionThreshold;\n    this.importanceWeight = config.importanceWeight ?? this.importanceWeight;\n    this.verbose = config.verbose ?? this.verbose;\n  }\n\n  _chainType(): string {\n    return \"generative_agent_memory\";\n  }\n\n  get inputKeys(): string[] {\n    return [\"memory_content\", \"now\", \"memory_metadata\"];\n  }\n\n  get outputKeys(): string[] {\n    return [\"output\"];\n  }\n\n  /**\n   * Method that creates a new LLMChain with the given prompt.\n   * @param prompt The PromptTemplate to use for the new LLMChain.\n   * @returns A new LLMChain instance.\n   */\n  chain(prompt: PromptTemplate): LLMChain {\n    const chain = new LLMChain({\n      llm: this.llm,\n      prompt,\n      verbose: this.verbose,\n      outputKey: \"output\",\n    });\n    return chain;\n  }\n\n  async _call(values: ChainValues, runManager?: CallbackManagerForChainRun) {\n    const { memory_content: memoryContent, now } = values;\n    // add an observation or memory to the agent's memory\n    const importanceScore = await this.scoreMemoryImportance(\n      memoryContent,\n      runManager\n    );\n    this.aggregateImportance += importanceScore;\n    const document = new Document({\n      pageContent: memoryContent,\n      metadata: {\n        importance: importanceScore,\n        ...values.memory_metadata,\n      },\n    });\n    await this.memoryRetriever.addDocuments([document]);\n    // after an agent has processed a certain amount of memories (as measured by aggregate importance),\n    // it is time to pause and reflect on recent events to add more synthesized memories to the agent's\n    // memory stream.\n    if (\n      this.reflectionThreshold !== undefined &&\n      this.aggregateImportance > this.reflectionThreshold &&\n      !this.reflecting\n    ) {\n      console.log(\"Reflecting on current memories...\");\n      this.reflecting = true;\n      await this.pauseToReflect(now, runManager);\n      this.aggregateImportance = 0.0;\n      this.reflecting = false;\n    }\n    return { output: importanceScore };\n  }\n\n  /**\n   * Method that pauses the agent to reflect on recent events and generate\n   * new insights.\n   * @param now The current date.\n   * @param runManager The CallbackManagerForChainRun to use for the reflection.\n   * @returns An array of new insights as strings.\n   */\n  async pauseToReflect(\n    now?: Date,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<string[]> {\n    if (this.verbose) {\n      console.log(\"Pausing to reflect...\");\n    }\n    const newInsights: string[] = [];\n    const topics = await this.getTopicsOfReflection(50, runManager);\n    for (const topic of topics) {\n      const insights = await this.getInsightsOnTopic(topic, now, runManager);\n      for (const insight of insights) {\n        // add memory\n        await this.call(\n          {\n            memory_content: insight,\n            now,\n            memory_metadata: {\n              source: \"reflection_insight\",\n            },\n          },\n          runManager?.getChild(\"reflection_insight_memory\")\n        );\n      }\n      newInsights.push(...insights);\n    }\n    return newInsights;\n  }\n\n  /**\n   * Method that scores the importance of a given memory.\n   * @param memoryContent The content of the memory to score.\n   * @param runManager The CallbackManagerForChainRun to use for scoring.\n   * @returns The importance score of the memory as a number.\n   */\n  async scoreMemoryImportance(\n    memoryContent: string,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<number> {\n    // score the absolute importance of a given memory\n    const prompt = PromptTemplate.fromTemplate(\n      \"On the scale of 1 to 10, where 1 is purely mundane\" +\n        \" (e.g., brushing teeth, making bed) and 10 is\" +\n        \" extremely poignant (e.g., a break up, college\" +\n        \" acceptance), rate the likely poignancy of the\" +\n        \" following piece of memory. Respond with a single integer.\" +\n        \"\\nMemory: {memory_content}\" +\n        \"\\nRating: \"\n    );\n    const score = await this.chain(prompt).run(\n      memoryContent,\n      runManager?.getChild(\"determine_importance\")\n    );\n\n    const strippedScore = score.trim();\n\n    if (this.verbose) {\n      console.log(\"Importance score:\", strippedScore);\n    }\n    const match = strippedScore.match(/^\\D*(\\d+)/);\n    if (match) {\n      const capturedNumber = parseFloat(match[1]);\n      const result = (capturedNumber / 10) * this.importanceWeight;\n      return result;\n    } else {\n      return 0.0;\n    }\n  }\n\n  /**\n   * Method that retrieves the topics of reflection based on the last K\n   * memories.\n   * @param lastK The number of most recent memories to consider for generating topics.\n   * @param runManager The CallbackManagerForChainRun to use for retrieving topics.\n   * @returns An array of topics of reflection as strings.\n   */\n  async getTopicsOfReflection(\n    lastK: number,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<string[]> {\n    const prompt = PromptTemplate.fromTemplate(\n      \"{observations}\\n\\n\" +\n        \"Given only the information above, what are the 3 most salient\" +\n        \" high-level questions we can answer about the subjects in\" +\n        \" the statements? Provide each question on a new line.\\n\\n\"\n    );\n\n    const observations = this.memoryRetriever.getMemoryStream().slice(-lastK);\n    const observationStr = observations\n      .map((o: { pageContent: string }) => o.pageContent)\n      .join(\"\\n\");\n    const result = await this.chain(prompt).run(\n      observationStr,\n      runManager?.getChild(\"reflection_topics\")\n    );\n    return GenerativeAgentMemoryChain.parseList(result);\n  }\n\n  /**\n   * Method that generates insights on a given topic of reflection based on\n   * pertinent memories.\n   * @param topic The topic of reflection.\n   * @param now The current date.\n   * @param runManager The CallbackManagerForChainRun to use for generating insights.\n   * @returns An array of insights as strings.\n   */\n  async getInsightsOnTopic(\n    topic: string,\n    now?: Date,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<string[]> {\n    // generate insights on a topic of reflection, based on pertinent memories\n    const prompt = PromptTemplate.fromTemplate(\n      \"Statements about {topic}\\n\" +\n        \"{related_statements}\\n\\n\" +\n        \"What 5 high-level insights can you infer from the above statements?\" +\n        \" (example format: insight (because of 1, 5, 3))\"\n    );\n\n    const relatedMemories = await this.fetchMemories(topic, now, runManager);\n    const relatedStatements: string = relatedMemories\n      .map((memory, index) => `${index + 1}. ${memory.pageContent}`)\n      .join(\"\\n\");\n    const result = await this.chain(prompt).call(\n      {\n        topic,\n        related_statements: relatedStatements,\n      },\n      runManager?.getChild(\"reflection_insights\")\n    );\n    return GenerativeAgentMemoryChain.parseList(result.output); // added output\n  }\n\n  /**\n   * Method that parses a newline-separated string into a list of strings.\n   * @param text The newline-separated string to parse.\n   * @returns An array of strings.\n   */\n  static parseList(text: string): string[] {\n    // parse a newine seperates string into a list of strings\n    return text.split(\"\\n\").map((s) => s.trim());\n  }\n\n  // TODO: Mock \"now\" to simulate different times\n  /**\n   * Method that fetches memories related to a given observation.\n   * @param observation The observation to fetch memories for.\n   * @param _now The current date.\n   * @param runManager The CallbackManagerForChainRun to use for fetching memories.\n   * @returns An array of Document instances representing the fetched memories.\n   */\n  async fetchMemories(\n    observation: string,\n    _now?: Date,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<Document[]> {\n    return this.memoryRetriever.invoke(\n      observation,\n      runManager?.getChild(\"memory_retriever\")\n    );\n  }\n}\n\n/**\n * Class that manages the memory of a generative agent in LangChain. It\n * extends the `BaseMemory` class and has methods for adding a memory,\n * formatting memories, getting memories until a token limit is reached,\n * loading memory variables, saving the context of a model run to memory,\n * and clearing memory contents.\n * @example\n * ```typescript\n * const createNewMemoryRetriever = async () => {\n *   const vectorStore = new MemoryVectorStore(new OpenAIEmbeddings());\n *   const retriever = new TimeWeightedVectorStoreRetriever({\n *     vectorStore,\n *     otherScoreKeys: [\"importance\"],\n *     k: 15,\n *   });\n *   return retriever;\n * };\n * const tommiesMemory = new GenerativeAgentMemory(\n *   llm,\n *   await createNewMemoryRetriever(),\n *   { reflectionThreshold: 8 },\n * );\n * const summary = await tommiesMemory.getSummary();\n * ```\n */\nexport class GenerativeAgentMemory extends BaseMemory {\n  llm: BaseLanguageModelInterface;\n\n  memoryRetriever: TimeWeightedVectorStoreRetriever;\n\n  verbose: boolean;\n\n  reflectionThreshold?: number;\n\n  private maxTokensLimit = 1200;\n\n  queriesKey = \"queries\";\n\n  mostRecentMemoriesTokenKey = \"recent_memories_token\";\n\n  addMemoryKey = \"addMemory\";\n\n  relevantMemoriesKey = \"relevant_memories\";\n\n  relevantMemoriesSimpleKey = \"relevant_memories_simple\";\n\n  mostRecentMemoriesKey = \"most_recent_memories\";\n\n  nowKey = \"now\";\n\n  memoryChain: GenerativeAgentMemoryChain;\n\n  constructor(\n    llm: BaseLanguageModelInterface,\n    memoryRetriever: TimeWeightedVectorStoreRetriever,\n    config?: GenerativeAgentMemoryConfig\n  ) {\n    super();\n    this.llm = llm;\n    this.memoryRetriever = memoryRetriever;\n    this.verbose = config?.verbose ?? this.verbose;\n    this.reflectionThreshold =\n      config?.reflectionThreshold ?? this.reflectionThreshold;\n    this.maxTokensLimit = config?.maxTokensLimit ?? this.maxTokensLimit;\n    this.memoryChain = new GenerativeAgentMemoryChain(llm, memoryRetriever, {\n      reflectionThreshold: config?.reflectionThreshold,\n      importanceWeight: config?.importanceWeight,\n    });\n  }\n\n  /**\n   * Method that returns the key for relevant memories.\n   * @returns The key for relevant memories as a string.\n   */\n  getRelevantMemoriesKey(): string {\n    return this.relevantMemoriesKey;\n  }\n\n  /**\n   * Method that returns the key for the most recent memories token.\n   * @returns The key for the most recent memories token as a string.\n   */\n  getMostRecentMemoriesTokenKey(): string {\n    return this.mostRecentMemoriesTokenKey;\n  }\n\n  /**\n   * Method that returns the key for adding a memory.\n   * @returns The key for adding a memory as a string.\n   */\n  getAddMemoryKey(): string {\n    return this.addMemoryKey;\n  }\n\n  /**\n   * Method that returns the key for the current time.\n   * @returns The key for the current time as a string.\n   */\n  getCurrentTimeKey(): string {\n    return this.nowKey;\n  }\n\n  get memoryKeys(): string[] {\n    // Return an array of memory keys\n    return [this.relevantMemoriesKey, this.mostRecentMemoriesKey];\n  }\n\n  /**\n   * Method that adds a memory to the agent's memory.\n   * @param memoryContent The content of the memory to add.\n   * @param now The current date.\n   * @param metadata The metadata for the memory.\n   * @param callbacks The Callbacks to use for adding the memory.\n   * @returns The result of the memory addition.\n   */\n  async addMemory(\n    memoryContent: string,\n    now?: Date,\n    metadata?: Record<string, unknown>,\n    callbacks?: Callbacks\n  ) {\n    return this.memoryChain.call(\n      { memory_content: memoryContent, now, memory_metadata: metadata },\n      callbacks\n    );\n  }\n\n  /**\n   * Method that formats the given relevant memories in detail.\n   * @param relevantMemories The relevant memories to format.\n   * @returns The formatted memories as a string.\n   */\n  formatMemoriesDetail(relevantMemories: Document[]): string {\n    if (!relevantMemories.length) {\n      return \"No relevant information.\";\n    }\n    const contentStrings = new Set();\n    const content = [];\n    for (const memory of relevantMemories) {\n      if (memory.pageContent in contentStrings) {\n        continue;\n      }\n      contentStrings.add(memory.pageContent);\n      const createdTime = memory.metadata.created_at.toLocaleString(\"en-US\", {\n        month: \"long\",\n        day: \"numeric\",\n        year: \"numeric\",\n        hour: \"numeric\",\n        minute: \"numeric\",\n        hour12: true,\n      });\n      content.push(`${createdTime}: ${memory.pageContent.trim()}`);\n    }\n    const joinedContent = content.map((mem) => `${mem}`).join(\"\\n\");\n    return joinedContent;\n  }\n\n  /**\n   * Method that formats the given relevant memories in a simple manner.\n   * @param relevantMemories The relevant memories to format.\n   * @returns The formatted memories as a string.\n   */\n  formatMemoriesSimple(relevantMemories: Document[]): string {\n    const joinedContent = relevantMemories\n      .map((mem) => `${mem.pageContent}`)\n      .join(\"; \");\n    return joinedContent;\n  }\n\n  /**\n   * Method that retrieves memories until a token limit is reached.\n   * @param consumedTokens The number of tokens consumed so far.\n   * @returns The memories as a string.\n   */\n  async getMemoriesUntilLimit(consumedTokens: number): Promise<string> {\n    // reduce the number of tokens in the documents\n    const result = [];\n    for (const doc of this.memoryRetriever\n      .getMemoryStream()\n      .slice()\n      .reverse()) {\n      if (consumedTokens >= this.maxTokensLimit) {\n        if (this.verbose) {\n          console.log(\"Exceeding max tokens for LLM, filtering memories\");\n        }\n        break;\n      }\n      // eslint-disable-next-line no-param-reassign\n      consumedTokens += await this.llm.getNumTokens(doc.pageContent);\n      if (consumedTokens < this.maxTokensLimit) {\n        result.push(doc);\n      }\n    }\n    return this.formatMemoriesSimple(result);\n  }\n\n  get memoryVariables(): string[] {\n    // input keys this memory class will load dynamically\n    return [];\n  }\n\n  /**\n   * Method that loads memory variables based on the given inputs.\n   * @param inputs The inputs to use for loading memory variables.\n   * @returns An object containing the loaded memory variables.\n   */\n  async loadMemoryVariables(\n    inputs: InputValues\n  ): Promise<Record<string, string>> {\n    const queries = inputs[this.queriesKey];\n    const now = inputs[this.nowKey];\n    if (queries !== undefined) {\n      const relevantMemories = (\n        await Promise.all(\n          queries.map((query: string) =>\n            this.memoryChain.fetchMemories(query, now)\n          )\n        )\n      ).flat();\n      return {\n        [this.relevantMemoriesKey]: this.formatMemoriesDetail(relevantMemories),\n        [this.relevantMemoriesSimpleKey]:\n          this.formatMemoriesSimple(relevantMemories),\n      };\n    }\n    const mostRecentMemoriesToken = inputs[this.mostRecentMemoriesTokenKey];\n    if (mostRecentMemoriesToken !== undefined) {\n      return {\n        [this.mostRecentMemoriesKey]: await this.getMemoriesUntilLimit(\n          mostRecentMemoriesToken\n        ),\n      };\n    }\n    return {};\n  }\n\n  /**\n   * Method that saves the context of a model run to memory.\n   * @param _inputs The inputs of the model run.\n   * @param outputs The outputs of the model run.\n   * @returns Nothing.\n   */\n  async saveContext(\n    _inputs: InputValues,\n    outputs: OutputValues\n  ): Promise<void> {\n    // save the context of this model run to memory\n    const mem = outputs[this.addMemoryKey];\n    const now = outputs[this.nowKey];\n    if (mem) {\n      await this.addMemory(mem, now, {});\n    }\n  }\n\n  /**\n   * Method that clears the memory contents.\n   * @returns Nothing.\n   */\n  clear(): void {\n    // TODO: clear memory contents\n  }\n}\n"],"mappings":"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"}

package/dist/experimental/generative_agents/index.cjs

@@ -0,0 +1,21 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_generative_agent_memory = require('./generative_agent_memory.cjs');
+const require_generative_agent = require('./generative_agent.cjs');
+
+//#region src/experimental/generative_agents/index.ts
+var generative_agents_exports = {};
+require_rolldown_runtime.__export(generative_agents_exports, {
+	GenerativeAgent: () => require_generative_agent.GenerativeAgent,
+	GenerativeAgentMemory: () => require_generative_agent_memory.GenerativeAgentMemory
+});
+
+//#endregion
+exports.GenerativeAgent = require_generative_agent.GenerativeAgent;
+exports.GenerativeAgentMemory = require_generative_agent_memory.GenerativeAgentMemory;
+Object.defineProperty(exports, 'generative_agents_exports', {
+  enumerable: true,
+  get: function () {
+    return generative_agents_exports;
+  }
+});
+//# sourceMappingURL=index.cjs.map