langchain 0.0.192 → 0.0.194

package/dist/embeddings/llama_cpp.js

@@ -1,5 +1,21 @@
 import { createLlamaModel, createLlamaContext, } from "../util/llama_cpp.js";
 import { Embeddings } from "./base.js";
+/**
+ * @example
+ * ```typescript
+ * // Initialize LlamaCppEmbeddings with the path to the model file
+ * const embeddings = new LlamaCppEmbeddings({
+ *   modelPath: "/Replace/with/path/to/your/model/gguf-llama2-q4_0.bin",
+ * });
+ *
+ * // Embed a query string using the Llama embeddings
+ * const res = embeddings.embedQuery("Hello Llama!");
+ *
+ * // Output the resulting embeddings
+ * console.log(res);
+ *
+ * ```
+ */
 export class LlamaCppEmbeddings extends Embeddings {
     constructor(inputs) {
         super(inputs);

package/dist/embeddings/minimax.cjs

@@ -7,6 +7,21 @@ const base_js_1 = require("./base.cjs");
 /**
  * Class for generating embeddings using the Minimax API. Extends the
  * Embeddings class and implements MinimaxEmbeddingsParams
+ * @example
+ * ```typescript
+ * const embeddings = new MinimaxEmbeddings();
+ *
+ * // Embed a single query
+ * const queryEmbedding = await embeddings.embedQuery("Hello world");
+ * console.log(queryEmbedding);
+ *
+ * // Embed multiple documents
+ * const documentsEmbedding = await embeddings.embedDocuments([
+ *   "Hello world",
+ *   "Bye bye",
+ * ]);
+ * console.log(documentsEmbedding);
+ * ```
  */
 class MinimaxEmbeddings extends base_js_1.Embeddings {
     constructor(fields) {

package/dist/embeddings/minimax.d.ts

@@ -64,6 +64,21 @@ export interface CreateMinimaxEmbeddingRequest {
 /**
  * Class for generating embeddings using the Minimax API. Extends the
  * Embeddings class and implements MinimaxEmbeddingsParams
+ * @example
+ * ```typescript
+ * const embeddings = new MinimaxEmbeddings();
+ *
+ * // Embed a single query
+ * const queryEmbedding = await embeddings.embedQuery("Hello world");
+ * console.log(queryEmbedding);
+ *
+ * // Embed multiple documents
+ * const documentsEmbedding = await embeddings.embedDocuments([
+ *   "Hello world",
+ *   "Bye bye",
+ * ]);
+ * console.log(documentsEmbedding);
+ * ```
  */
 export declare class MinimaxEmbeddings extends Embeddings implements MinimaxEmbeddingsParams {
     modelName: string;

package/dist/embeddings/minimax.js

@@ -4,6 +4,21 @@ import { Embeddings } from "./base.js";
 /**
  * Class for generating embeddings using the Minimax API. Extends the
  * Embeddings class and implements MinimaxEmbeddingsParams
+ * @example
+ * ```typescript
+ * const embeddings = new MinimaxEmbeddings();
+ *
+ * // Embed a single query
+ * const queryEmbedding = await embeddings.embedQuery("Hello world");
+ * console.log(queryEmbedding);
+ *
+ * // Embed multiple documents
+ * const documentsEmbedding = await embeddings.embedDocuments([
+ *   "Hello world",
+ *   "Bye bye",
+ * ]);
+ * console.log(documentsEmbedding);
+ * ```
  */
 export class MinimaxEmbeddings extends Embeddings {
     constructor(fields) {

package/dist/embeddings/openai.cjs

@@ -11,6 +11,16 @@ const openai_js_1 = require("../util/openai.cjs");
  * Class for generating embeddings using the OpenAI API. Extends the
  * Embeddings class and implements OpenAIEmbeddingsParams and
  * AzureOpenAIInput.
+ * @example
+ * ```typescript
+ * // Embed a query using OpenAIEmbeddings to generate embeddings for a given text
+ * const model = new OpenAIEmbeddings();
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?",
+ * );
+ * console.log({ res });
+ *
+ * ```
  */
 class OpenAIEmbeddings extends base_js_1.Embeddings {
     constructor(fields, configuration) {

package/dist/embeddings/openai.d.ts

@@ -27,6 +27,16 @@ export interface OpenAIEmbeddingsParams extends EmbeddingsParams {
  * Class for generating embeddings using the OpenAI API. Extends the
  * Embeddings class and implements OpenAIEmbeddingsParams and
  * AzureOpenAIInput.
+ * @example
+ * ```typescript
+ * // Embed a query using OpenAIEmbeddings to generate embeddings for a given text
+ * const model = new OpenAIEmbeddings();
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?",
+ * );
+ * console.log({ res });
+ *
+ * ```
  */
 export declare class OpenAIEmbeddings extends Embeddings implements OpenAIEmbeddingsParams, AzureOpenAIInput {
     modelName: string;

package/dist/embeddings/openai.js

@@ -8,6 +8,16 @@ import { wrapOpenAIClientError } from "../util/openai.js";
  * Class for generating embeddings using the OpenAI API. Extends the
  * Embeddings class and implements OpenAIEmbeddingsParams and
  * AzureOpenAIInput.
+ * @example
+ * ```typescript
+ * // Embed a query using OpenAIEmbeddings to generate embeddings for a given text
+ * const model = new OpenAIEmbeddings();
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?",
+ * );
+ * console.log({ res });
+ *
+ * ```
  */
 export class OpenAIEmbeddings extends Embeddings {
     constructor(fields, configuration) {

package/dist/embeddings/tensorflow.cjs

@@ -31,6 +31,22 @@ const base_js_1 = require("./base.cjs");
  * Class that extends the Embeddings class and provides methods for
  * generating embeddings using the Universal Sentence Encoder model from
  * TensorFlow.js.
+ * @example
+ * ```typescript
+ * const embeddings = new TensorFlowEmbeddings();
+ * const store = new MemoryVectorStore(embeddings);
+ *
+ * const documents = [
+ *   "A document",
+ *   "Some other piece of text",
+ *   "One more",
+ *   "And another",
+ * ];
+ *
+ * await store.addDocuments(
+ *   documents.map((pageContent) => new Document({ pageContent }))
+ * );
+ * ```
  */
 class TensorFlowEmbeddings extends base_js_1.Embeddings {
     constructor(fields) {

package/dist/embeddings/tensorflow.d.ts

@@ -10,6 +10,22 @@ export interface TensorFlowEmbeddingsParams extends EmbeddingsParams {
  * Class that extends the Embeddings class and provides methods for
  * generating embeddings using the Universal Sentence Encoder model from
  * TensorFlow.js.
+ * @example
+ * ```typescript
+ * const embeddings = new TensorFlowEmbeddings();
+ * const store = new MemoryVectorStore(embeddings);
+ *
+ * const documents = [
+ *   "A document",
+ *   "Some other piece of text",
+ *   "One more",
+ *   "And another",
+ * ];
+ *
+ * await store.addDocuments(
+ *   documents.map((pageContent) => new Document({ pageContent }))
+ * );
+ * ```
  */
 export declare class TensorFlowEmbeddings extends Embeddings {
     constructor(fields?: TensorFlowEmbeddingsParams);

package/dist/embeddings/tensorflow.js

@@ -5,6 +5,22 @@ import { Embeddings } from "./base.js";
  * Class that extends the Embeddings class and provides methods for
  * generating embeddings using the Universal Sentence Encoder model from
  * TensorFlow.js.
+ * @example
+ * ```typescript
+ * const embeddings = new TensorFlowEmbeddings();
+ * const store = new MemoryVectorStore(embeddings);
+ *
+ * const documents = [
+ *   "A document",
+ *   "Some other piece of text",
+ *   "One more",
+ *   "And another",
+ * ];
+ *
+ * await store.addDocuments(
+ *   documents.map((pageContent) => new Document({ pageContent }))
+ * );
+ * ```
  */
 export class TensorFlowEmbeddings extends Embeddings {
     constructor(fields) {

package/dist/experimental/autogpt/agent.cjs

@@ -13,6 +13,27 @@ const count_tokens_js_1 = require("../../base_language/count_tokens.cjs");
  * Class representing the AutoGPT concept with LangChain primitives. It is
  * designed to be used with a set of tools such as a search tool,
  * write-file tool, and a read-file tool.
+ * @example
+ * ```typescript
+ * const autogpt = AutoGPT.fromLLMAndTools(
+ *   new ChatOpenAI({ temperature: 0 }),
+ *   [
+ *     new ReadFileTool({ store: new InMemoryFileStore() }),
+ *     new WriteFileTool({ store: new InMemoryFileStore() }),
+ *     new SerpAPI("YOUR_SERPAPI_API_KEY", {
+ *       location: "San Francisco,California,United States",
+ *       hl: "en",
+ *       gl: "us",
+ *     }),
+ *   ],
+ *   {
+ *     memory: new MemoryVectorStore(new OpenAIEmbeddings()).asRetriever(),
+ *     aiName: "Tom",
+ *     aiRole: "Assistant",
+ *   },
+ * );
+ * const result = await autogpt.run(["write a weather report for SF today"]);
+ * ```
  */
 class AutoGPT {
     constructor({ aiName, memory, chain, outputParser, tools, feedbackTool, maxIterations, }) {

package/dist/experimental/autogpt/agent.d.ts

@@ -21,6 +21,27 @@ export interface AutoGPTInput {
  * Class representing the AutoGPT concept with LangChain primitives. It is
  * designed to be used with a set of tools such as a search tool,
  * write-file tool, and a read-file tool.
+ * @example
+ * ```typescript
+ * const autogpt = AutoGPT.fromLLMAndTools(
+ *   new ChatOpenAI({ temperature: 0 }),
+ *   [
+ *     new ReadFileTool({ store: new InMemoryFileStore() }),
+ *     new WriteFileTool({ store: new InMemoryFileStore() }),
+ *     new SerpAPI("YOUR_SERPAPI_API_KEY", {
+ *       location: "San Francisco,California,United States",
+ *       hl: "en",
+ *       gl: "us",
+ *     }),
+ *   ],
+ *   {
+ *     memory: new MemoryVectorStore(new OpenAIEmbeddings()).asRetriever(),
+ *     aiName: "Tom",
+ *     aiRole: "Assistant",
+ *   },
+ * );
+ * const result = await autogpt.run(["write a weather report for SF today"]);
+ * ```
  */
 export declare class AutoGPT {
     aiName: string;

package/dist/experimental/autogpt/agent.js

@@ -10,6 +10,27 @@ import { getEmbeddingContextSize, getModelContextSize, } from "../../base_langua
  * Class representing the AutoGPT concept with LangChain primitives. It is
  * designed to be used with a set of tools such as a search tool,
  * write-file tool, and a read-file tool.
+ * @example
+ * ```typescript
+ * const autogpt = AutoGPT.fromLLMAndTools(
+ *   new ChatOpenAI({ temperature: 0 }),
+ *   [
+ *     new ReadFileTool({ store: new InMemoryFileStore() }),
+ *     new WriteFileTool({ store: new InMemoryFileStore() }),
+ *     new SerpAPI("YOUR_SERPAPI_API_KEY", {
+ *       location: "San Francisco,California,United States",
+ *       hl: "en",
+ *       gl: "us",
+ *     }),
+ *   ],
+ *   {
+ *     memory: new MemoryVectorStore(new OpenAIEmbeddings()).asRetriever(),
+ *     aiName: "Tom",
+ *     aiRole: "Assistant",
+ *   },
+ * );
+ * const result = await autogpt.run(["write a weather report for SF today"]);
+ * ```
  */
 export class AutoGPT {
     constructor({ aiName, memory, chain, outputParser, tools, feedbackTool, maxIterations, }) {

package/dist/experimental/babyagi/agent.cjs

@@ -11,6 +11,18 @@ const task_prioritization_js_1 = require("./task_prioritization.cjs");
  * prioritization, and execution. It uses three chains for these
  * operations: `creationChain`, `prioritizationChain`, and
  * `executionChain`.
+ * @example
+ * ```typescript
+ * const babyAGI = BabyAGI.fromLLM({
+ *   llm: new OpenAI({ temperature: 0 }),
+ *   vectorstore: new MemoryVectorStore(new OpenAIEmbeddings()),
+ *   maxIterations: 3,
+ * });
+ *
+ * const result = await babyAGI.call({
+ *   objective: "Write a weather report for SF today",
+ * });
+ * ```
  */
 class BabyAGI extends base_js_1.BaseChain {
     static lc_name() {

package/dist/experimental/babyagi/agent.d.ts

@@ -31,6 +31,18 @@ export interface BabyAGIInputs extends Omit<ChainInputs, "memory" | "callbackMan
  * prioritization, and execution. It uses three chains for these
  * operations: `creationChain`, `prioritizationChain`, and
  * `executionChain`.
+ * @example
+ * ```typescript
+ * const babyAGI = BabyAGI.fromLLM({
+ *   llm: new OpenAI({ temperature: 0 }),
+ *   vectorstore: new MemoryVectorStore(new OpenAIEmbeddings()),
+ *   maxIterations: 3,
+ * });
+ *
+ * const result = await babyAGI.call({
+ *   objective: "Write a weather report for SF today",
+ * });
+ * ```
  */
 export declare class BabyAGI extends BaseChain implements BabyAGIInputs {
     static lc_name(): string;

package/dist/experimental/babyagi/agent.js

@@ -8,6 +8,18 @@ import { TaskPrioritizationChain } from "./task_prioritization.js";
  * prioritization, and execution. It uses three chains for these
  * operations: `creationChain`, `prioritizationChain`, and
  * `executionChain`.
+ * @example
+ * ```typescript
+ * const babyAGI = BabyAGI.fromLLM({
+ *   llm: new OpenAI({ temperature: 0 }),
+ *   vectorstore: new MemoryVectorStore(new OpenAIEmbeddings()),
+ *   maxIterations: 3,
+ * });
+ *
+ * const result = await babyAGI.call({
+ *   objective: "Write a weather report for SF today",
+ * });
+ * ```
  */
 export class BabyAGI extends BaseChain {
     static lc_name() {

package/dist/experimental/chat_models/ollama_functions.cjs

@@ -4,18 +4,14 @@ exports.OllamaFunctions = void 0;
 const base_js_1 = require("../../chat_models/base.cjs");
 const index_js_1 = require("../../schema/index.cjs");
 const ollama_js_1 = require("../../chat_models/ollama.cjs");
-const prompt_js_1 = require("../../prompts/prompt.cjs");
-const TOOL_SYSTEM_PROMPT = 
-/* #__PURE__ */
-prompt_js_1.PromptTemplate.fromTemplate(`You have access to the following tools:
-
+const chat_js_1 = require("../../prompts/chat.cjs");
+const DEFAULT_TOOL_SYSTEM_TEMPLATE = `You have access to the following tools:
 {tools}
-
-To use a tool, respond with a JSON object with the following structure:
+You must always select one of the above tools and respond with only a JSON object matching the following schema:
 {{
-  "tool": <name of the called tool>,
-  "tool_input": <parameters for the tool matching the above JSON schema>
-}}`);
+  "tool": <name of the selected tool>,
+  "tool_input": <parameters for the selected tool, matching the tool's JSON schema>
+}}`;
 class OllamaFunctions extends base_js_1.BaseChatModel {
     static lc_name() {
         return "OllamaFunctions";
@@ -28,11 +24,11 @@ class OllamaFunctions extends base_js_1.BaseChatModel {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "toolSystemPrompt", {
+        Object.defineProperty(this, "toolSystemPromptTemplate", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: TOOL_SYSTEM_PROMPT
+            value: DEFAULT_TOOL_SYSTEM_TEMPLATE
         });
         Object.defineProperty(this, "defaultResponseFunction", {
             enumerable: true,
@@ -60,7 +56,8 @@ class OllamaFunctions extends base_js_1.BaseChatModel {
             value: ["langchain", "experimental", "chat_models"]
         });
         this.llm = fields?.llm ?? new ollama_js_1.ChatOllama({ ...fields, format: "json" });
-        this.toolSystemPrompt = fields?.toolSystemPrompt ?? this.toolSystemPrompt;
+        this.toolSystemPromptTemplate =
+            fields?.toolSystemPromptTemplate ?? this.toolSystemPromptTemplate;
     }
     invocationParams() {
         return this.llm.invocationParams();
@@ -80,10 +77,10 @@ class OllamaFunctions extends base_js_1.BaseChatModel {
         else if (functions.length === 0) {
             functions.push(this.defaultResponseFunction);
         }
-        const defaultContent = await this.toolSystemPrompt.format({
+        const systemPromptTemplate = chat_js_1.SystemMessagePromptTemplate.fromTemplate(this.toolSystemPromptTemplate);
+        const systemMessage = await systemPromptTemplate.format({
             tools: JSON.stringify(functions, null, 2),
         });
-        const systemMessage = new index_js_1.SystemMessage({ content: defaultContent });
         const chatResult = await this.llm._generate([systemMessage, ...messages], options, runManager);
         const chatGenerationContent = chatResult.generations[0].message.content;
         if (typeof chatGenerationContent !== "string") {

package/dist/experimental/chat_models/ollama_functions.d.ts

@@ -4,16 +4,15 @@ import { BaseMessage, ChatResult } from "../../schema/index.js";
 import { ChatOllama } from "../../chat_models/ollama.js";
 import { OllamaInput } from "../../util/ollama.js";
 import { BaseFunctionCallOptions } from "../../base_language/index.js";
-import type { BasePromptTemplate } from "../../prompts/base.js";
 export interface ChatOllamaFunctionsCallOptions extends BaseFunctionCallOptions {
 }
 export type OllamaFunctionsInput = Partial<OllamaInput> & BaseChatModelParams & {
     llm?: ChatOllama;
-    toolSystemPrompt?: BasePromptTemplate;
+    toolSystemPromptTemplate?: string;
 };
 export declare class OllamaFunctions extends BaseChatModel<ChatOllamaFunctionsCallOptions> {
     llm: ChatOllama;
-    toolSystemPrompt: BasePromptTemplate;
+    toolSystemPromptTemplate: string;
     protected defaultResponseFunction: {
         name: string;
         description: string;
@@ -61,7 +60,7 @@ export declare class OllamaFunctions extends BaseChatModel<ChatOllamaFunctionsCa
             tfs_z: number | undefined;
             top_k: number | undefined;
             top_p: number | undefined;
-            typical_p: number | undefined; /** @ignore */
+            typical_p: number | undefined;
             use_mlock: boolean | undefined;
             use_mmap: boolean | undefined;
             vocab_only: boolean | undefined;

package/dist/experimental/chat_models/ollama_functions.js

@@ -1,18 +1,14 @@
 import { BaseChatModel } from "../../chat_models/base.js";
-import { AIMessage, SystemMessage, } from "../../schema/index.js";
+import { AIMessage } from "../../schema/index.js";
 import { ChatOllama } from "../../chat_models/ollama.js";
-import { PromptTemplate } from "../../prompts/prompt.js";
-const TOOL_SYSTEM_PROMPT = 
-/* #__PURE__ */
-PromptTemplate.fromTemplate(`You have access to the following tools:
-
+import { SystemMessagePromptTemplate } from "../../prompts/chat.js";
+const DEFAULT_TOOL_SYSTEM_TEMPLATE = `You have access to the following tools:
 {tools}
-
-To use a tool, respond with a JSON object with the following structure:
+You must always select one of the above tools and respond with only a JSON object matching the following schema:
 {{
-  "tool": <name of the called tool>,
-  "tool_input": <parameters for the tool matching the above JSON schema>
-}}`);
+  "tool": <name of the selected tool>,
+  "tool_input": <parameters for the selected tool, matching the tool's JSON schema>
+}}`;
 export class OllamaFunctions extends BaseChatModel {
     static lc_name() {
         return "OllamaFunctions";
@@ -25,11 +21,11 @@ export class OllamaFunctions extends BaseChatModel {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "toolSystemPrompt", {
+        Object.defineProperty(this, "toolSystemPromptTemplate", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: TOOL_SYSTEM_PROMPT
+            value: DEFAULT_TOOL_SYSTEM_TEMPLATE
         });
         Object.defineProperty(this, "defaultResponseFunction", {
             enumerable: true,
@@ -57,7 +53,8 @@ export class OllamaFunctions extends BaseChatModel {
             value: ["langchain", "experimental", "chat_models"]
         });
         this.llm = fields?.llm ?? new ChatOllama({ ...fields, format: "json" });
-        this.toolSystemPrompt = fields?.toolSystemPrompt ?? this.toolSystemPrompt;
+        this.toolSystemPromptTemplate =
+            fields?.toolSystemPromptTemplate ?? this.toolSystemPromptTemplate;
     }
     invocationParams() {
         return this.llm.invocationParams();
@@ -77,10 +74,10 @@ export class OllamaFunctions extends BaseChatModel {
         else if (functions.length === 0) {
             functions.push(this.defaultResponseFunction);
         }
-        const defaultContent = await this.toolSystemPrompt.format({
+        const systemPromptTemplate = SystemMessagePromptTemplate.fromTemplate(this.toolSystemPromptTemplate);
+        const systemMessage = await systemPromptTemplate.format({
             tools: JSON.stringify(functions, null, 2),
         });
-        const systemMessage = new SystemMessage({ content: defaultContent });
         const chatResult = await this.llm._generate([systemMessage, ...messages], options, runManager);
         const chatGenerationContent = chatResult.generations[0].message.content;
         if (typeof chatGenerationContent !== "string") {

package/dist/experimental/generative_agents/generative_agent.cjs

@@ -8,6 +8,36 @@ const base_js_1 = require("../../chains/base.cjs");
  * Implementation of a generative agent that can learn and form new memories over
  * time. It extends the BaseChain class, which is a generic
  * sequence of calls to components, including other chains.
+ * @example
+ * ```typescript
+ * const tommie: GenerativeAgent = new GenerativeAgent(
+ *   new OpenAI({ temperature: 0.9, maxTokens: 1500 }),
+ *   new GenerativeAgentMemory(
+ *     new ChatOpenAI(),
+ *     new TimeWeightedVectorStoreRetriever({
+ *       vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),
+ *       otherScoreKeys: ["importance"],
+ *       k: 15,
+ *     }),
+ *     { reflectionThreshold: 8 },
+ *   ),
+ *   {
+ *     name: "Tommie",
+ *     age: 25,
+ *     traits: "anxious, likes design, talkative",
+ *     status: "looking for a job",
+ *   },
+ * );
+ *
+ * await tommie.addMemory(
+ *   "Tommie remembers his dog, Bruno, from when he was a kid",
+ *   new Date(),
+ * );
+ * const summary = await tommie.getSummary({ forceRefresh: true });
+ * const response = await tommie.generateDialogueResponse(
+ *   "USER says Hello Tommie, how are you today?",
+ * );
+ * ```
  */
 class GenerativeAgent extends base_js_1.BaseChain {
     static lc_name() {

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

@@ -22,6 +22,36 @@ export type GenerativeAgentConfig = {
  * Implementation of a generative agent that can learn and form new memories over
  * time. It extends the BaseChain class, which is a generic
  * sequence of calls to components, including other chains.
+ * @example
+ * ```typescript
+ * const tommie: GenerativeAgent = new GenerativeAgent(
+ *   new OpenAI({ temperature: 0.9, maxTokens: 1500 }),
+ *   new GenerativeAgentMemory(
+ *     new ChatOpenAI(),
+ *     new TimeWeightedVectorStoreRetriever({
+ *       vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),
+ *       otherScoreKeys: ["importance"],
+ *       k: 15,
+ *     }),
+ *     { reflectionThreshold: 8 },
+ *   ),
+ *   {
+ *     name: "Tommie",
+ *     age: 25,
+ *     traits: "anxious, likes design, talkative",
+ *     status: "looking for a job",
+ *   },
+ * );
+ *
+ * await tommie.addMemory(
+ *   "Tommie remembers his dog, Bruno, from when he was a kid",
+ *   new Date(),
+ * );
+ * const summary = await tommie.getSummary({ forceRefresh: true });
+ * const response = await tommie.generateDialogueResponse(
+ *   "USER says Hello Tommie, how are you today?",
+ * );
+ * ```
  */
 export declare class GenerativeAgent extends BaseChain {
     static lc_name(): string;

package/dist/experimental/generative_agents/generative_agent.js

@@ -5,6 +5,36 @@ import { BaseChain } from "../../chains/base.js";
  * Implementation of a generative agent that can learn and form new memories over
  * time. It extends the BaseChain class, which is a generic
  * sequence of calls to components, including other chains.
+ * @example
+ * ```typescript
+ * const tommie: GenerativeAgent = new GenerativeAgent(
+ *   new OpenAI({ temperature: 0.9, maxTokens: 1500 }),
+ *   new GenerativeAgentMemory(
+ *     new ChatOpenAI(),
+ *     new TimeWeightedVectorStoreRetriever({
+ *       vectorStore: new MemoryVectorStore(new OpenAIEmbeddings()),
+ *       otherScoreKeys: ["importance"],
+ *       k: 15,
+ *     }),
+ *     { reflectionThreshold: 8 },
+ *   ),
+ *   {
+ *     name: "Tommie",
+ *     age: 25,
+ *     traits: "anxious, likes design, talkative",
+ *     status: "looking for a job",
+ *   },
+ * );
+ *
+ * await tommie.addMemory(
+ *   "Tommie remembers his dog, Bruno, from when he was a kid",
+ *   new Date(),
+ * );
+ * const summary = await tommie.getSummary({ forceRefresh: true });
+ * const response = await tommie.generateDialogueResponse(
+ *   "USER says Hello Tommie, how are you today?",
+ * );
+ * ```
  */
 export class GenerativeAgent extends BaseChain {
     static lc_name() {

package/dist/experimental/generative_agents/generative_agent_memory.cjs

@@ -246,6 +246,24 @@ class GenerativeAgentMemoryChain extends base_js_1.BaseChain {
  * 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();
+ * ```
  */
 class GenerativeAgentMemory extends base_js_2.BaseMemory {
     constructor(llm, memoryRetriever, config) {