langchain 0.0.192 → 0.0.193

package/dist/retrievers/vespa.cjs

@@ -7,6 +7,21 @@ const base_js_1 = require("./remote/base.cjs");
  * Class responsible for retrieving data from Vespa. It extends the
  * `RemoteRetriever` class and includes methods for creating the JSON body
  * for a query and processing the JSON response from Vespa.
+ * @example
+ * ```typescript
+ * const retriever = new VespaRetriever({
+ *   url: "https:
+ *   auth: false,
+ *   query_body: {
+ *     yql: "select content from paragraph where userQuery()",
+ *     hits: 5,
+ *     ranking: "documentation",
+ *     locale: "en-us",
+ *   },
+ *   content_field: "content",
+ * });
+ * const result = await retriever.getRelevantDocuments("what is vespa?");
+ * ```
  */
 class VespaRetriever extends base_js_1.RemoteRetriever {
     static lc_name() {

package/dist/retrievers/vespa.d.ts

@@ -14,6 +14,21 @@ export interface VespaRetrieverParams extends RemoteRetrieverParams {
  * Class responsible for retrieving data from Vespa. It extends the
  * `RemoteRetriever` class and includes methods for creating the JSON body
  * for a query and processing the JSON response from Vespa.
+ * @example
+ * ```typescript
+ * const retriever = new VespaRetriever({
+ *   url: "https:
+ *   auth: false,
+ *   query_body: {
+ *     yql: "select content from paragraph where userQuery()",
+ *     hits: 5,
+ *     ranking: "documentation",
+ *     locale: "en-us",
+ *   },
+ *   content_field: "content",
+ * });
+ * const result = await retriever.getRelevantDocuments("what is vespa?");
+ * ```
  */
 export declare class VespaRetriever extends RemoteRetriever {
     static lc_name(): string;

package/dist/retrievers/vespa.js

@@ -4,6 +4,21 @@ import { RemoteRetriever, } from "./remote/base.js";
  * Class responsible for retrieving data from Vespa. It extends the
  * `RemoteRetriever` class and includes methods for creating the JSON body
  * for a query and processing the JSON response from Vespa.
+ * @example
+ * ```typescript
+ * const retriever = new VespaRetriever({
+ *   url: "https:
+ *   auth: false,
+ *   query_body: {
+ *     yql: "select content from paragraph where userQuery()",
+ *     hits: 5,
+ *     ranking: "documentation",
+ *     locale: "en-us",
+ *   },
+ *   content_field: "content",
+ * });
+ * const result = await retriever.getRelevantDocuments("what is vespa?");
+ * ```
  */
 export class VespaRetriever extends RemoteRetriever {
     static lc_name() {

package/dist/retrievers/zep.cjs

@@ -7,6 +7,16 @@ const document_js_1 = require("../document.cjs");
 /**
  * Class for retrieving information from a Zep long-term memory store.
  * Extends the BaseRetriever class.
+ * @example
+ * ```typescript
+ * const retriever = new ZepRetriever({
+ *   url: "http:
+ *   sessionId: "session_exampleUUID",
+ *   topK: 3,
+ * });
+ * const query = "Can I drive red cars in France?";
+ * const docs = await retriever.getRelevantDocuments(query);
+ * ```
  */
 class ZepRetriever extends retriever_js_1.BaseRetriever {
     static lc_name() {

package/dist/retrievers/zep.d.ts

@@ -27,6 +27,16 @@ export interface ZepRetrieverConfig extends BaseRetrieverInput {
 /**
  * Class for retrieving information from a Zep long-term memory store.
  * Extends the BaseRetriever class.
+ * @example
+ * ```typescript
+ * const retriever = new ZepRetriever({
+ *   url: "http:
+ *   sessionId: "session_exampleUUID",
+ *   topK: 3,
+ * });
+ * const query = "Can I drive red cars in France?";
+ * const docs = await retriever.getRelevantDocuments(query);
+ * ```
  */
 export declare class ZepRetriever extends BaseRetriever {
     static lc_name(): string;

package/dist/retrievers/zep.js

@@ -4,6 +4,16 @@ import { Document } from "../document.js";
 /**
  * Class for retrieving information from a Zep long-term memory store.
  * Extends the BaseRetriever class.
+ * @example
+ * ```typescript
+ * const retriever = new ZepRetriever({
+ *   url: "http:
+ *   sessionId: "session_exampleUUID",
+ *   topK: 3,
+ * });
+ * const query = "Can I drive red cars in France?";
+ * const docs = await retriever.getRelevantDocuments(query);
+ * ```
  */
 export class ZepRetriever extends BaseRetriever {
     static lc_name() {

package/dist/schema/index.d.ts

@@ -66,14 +66,16 @@ export interface StoredGeneration {
     message?: StoredMessage;
 }
 export type MessageType = "human" | "ai" | "generic" | "system" | "function" | "tool";
-export type MessageContent = string | {
-    type: "text" | "image_url";
-    text?: string;
-    image_url?: string | {
+export type MessageContent = string | ({
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    image_url: string | {
         url: string;
-        detail?: "low" | "high";
+        detail?: "auto" | "low" | "high";
     };
-}[];
+})[];
 export interface BaseMessageFields {
     content: MessageContent;
     name?: string;

package/dist/schema/output_parser.cjs

@@ -171,6 +171,21 @@ class BaseCumulativeTransformOutputParser extends BaseTransformOutputParser {
 exports.BaseCumulativeTransformOutputParser = BaseCumulativeTransformOutputParser;
 /**
  * OutputParser that parses LLMResult into the top likely string.
+ * @example
+ * ```typescript
+ * const promptTemplate = PromptTemplate.fromTemplate(
+ *   "Tell me a joke about {topic}",
+ * );
+ *
+ * const chain = RunnableSequence.from([
+ *   promptTemplate,
+ *   new ChatOpenAI({}),
+ *   new StringOutputParser(),
+ * ]);
+ *
+ * const result = await chain.invoke({ topic: "bears" });
+ * console.log("What do you call a bear with no teeth? A gummy bear!");
+ * ```
  */
 class StringOutputParser extends BaseTransformOutputParser {
     constructor() {

package/dist/schema/output_parser.d.ts

@@ -104,6 +104,21 @@ export declare abstract class BaseCumulativeTransformOutputParser<T = unknown> e
 }
 /**
  * OutputParser that parses LLMResult into the top likely string.
+ * @example
+ * ```typescript
+ * const promptTemplate = PromptTemplate.fromTemplate(
+ *   "Tell me a joke about {topic}",
+ * );
+ *
+ * const chain = RunnableSequence.from([
+ *   promptTemplate,
+ *   new ChatOpenAI({}),
+ *   new StringOutputParser(),
+ * ]);
+ *
+ * const result = await chain.invoke({ topic: "bears" });
+ * console.log("What do you call a bear with no teeth? A gummy bear!");
+ * ```
  */
 export declare class StringOutputParser extends BaseTransformOutputParser<string> {
     static lc_name(): string;

package/dist/schema/output_parser.js

@@ -164,6 +164,21 @@ export class BaseCumulativeTransformOutputParser extends BaseTransformOutputPars
 }
 /**
  * OutputParser that parses LLMResult into the top likely string.
+ * @example
+ * ```typescript
+ * const promptTemplate = PromptTemplate.fromTemplate(
+ *   "Tell me a joke about {topic}",
+ * );
+ *
+ * const chain = RunnableSequence.from([
+ *   promptTemplate,
+ *   new ChatOpenAI({}),
+ *   new StringOutputParser(),
+ * ]);
+ *
+ * const result = await chain.invoke({ topic: "bears" });
+ * console.log("What do you call a bear with no teeth? A gummy bear!");
+ * ```
  */
 export class StringOutputParser extends BaseTransformOutputParser {
     constructor() {

package/dist/schema/runnable/base.cjs

@@ -654,6 +654,14 @@ class RunnableRetry extends RunnableBinding {
 exports.RunnableRetry = RunnableRetry;
 /**
  * A sequence of runnables, where the output of each is the input of the next.
+ * @example
+ * ```typescript
+ * const promptTemplate = PromptTemplate.fromTemplate(
+ *   "Tell me a joke about {topic}",
+ * );
+ * const chain = RunnableSequence.from([promptTemplate, new ChatOpenAI({})]);
+ * const result = await chain.invoke({ topic: "bears" });
+ * ```
  */
 class RunnableSequence extends Runnable {
     static lc_name() {
@@ -839,6 +847,18 @@ exports.RunnableSequence = RunnableSequence;
 /**
  * A runnable that runs a mapping of runnables in parallel,
  * and returns a mapping of their outputs.
+ * @example
+ * ```typescript
+ * const mapChain = RunnableMap.from({
+ *   joke: PromptTemplate.fromTemplate("Tell me a joke about {topic}").pipe(
+ *     new ChatAnthropic({}),
+ *   ),
+ *   poem: PromptTemplate.fromTemplate("write a 2-line poem about {topic}").pipe(
+ *     new ChatAnthropic({}),
+ *   ),
+ * });
+ * const result = await mapChain.invoke({ topic: "bear" });
+ * ```
  */
 class RunnableMap extends Runnable {
     static lc_name() {

package/dist/schema/runnable/base.d.ts

@@ -249,6 +249,14 @@ export declare class RunnableRetry<RunInput = any, RunOutput = any, CallOptions
 }
 /**
  * A sequence of runnables, where the output of each is the input of the next.
+ * @example
+ * ```typescript
+ * const promptTemplate = PromptTemplate.fromTemplate(
+ *   "Tell me a joke about {topic}",
+ * );
+ * const chain = RunnableSequence.from([promptTemplate, new ChatOpenAI({})]);
+ * const result = await chain.invoke({ topic: "bears" });
+ * ```
  */
 export declare class RunnableSequence<RunInput = any, RunOutput = any> extends Runnable<RunInput, RunOutput> {
     static lc_name(): string;
@@ -283,6 +291,18 @@ export declare class RunnableSequence<RunInput = any, RunOutput = any> extends R
 /**
  * A runnable that runs a mapping of runnables in parallel,
  * and returns a mapping of their outputs.
+ * @example
+ * ```typescript
+ * const mapChain = RunnableMap.from({
+ *   joke: PromptTemplate.fromTemplate("Tell me a joke about {topic}").pipe(
+ *     new ChatAnthropic({}),
+ *   ),
+ *   poem: PromptTemplate.fromTemplate("write a 2-line poem about {topic}").pipe(
+ *     new ChatAnthropic({}),
+ *   ),
+ * });
+ * const result = await mapChain.invoke({ topic: "bear" });
+ * ```
  */
 export declare class RunnableMap<RunInput> extends Runnable<RunInput, Record<string, any>> {
     static lc_name(): string;

package/dist/schema/runnable/base.js

@@ -644,6 +644,14 @@ export class RunnableRetry extends RunnableBinding {
 }
 /**
  * A sequence of runnables, where the output of each is the input of the next.
+ * @example
+ * ```typescript
+ * const promptTemplate = PromptTemplate.fromTemplate(
+ *   "Tell me a joke about {topic}",
+ * );
+ * const chain = RunnableSequence.from([promptTemplate, new ChatOpenAI({})]);
+ * const result = await chain.invoke({ topic: "bears" });
+ * ```
  */
 export class RunnableSequence extends Runnable {
     static lc_name() {
@@ -828,6 +836,18 @@ export class RunnableSequence extends Runnable {
 /**
  * A runnable that runs a mapping of runnables in parallel,
  * and returns a mapping of their outputs.
+ * @example
+ * ```typescript
+ * const mapChain = RunnableMap.from({
+ *   joke: PromptTemplate.fromTemplate("Tell me a joke about {topic}").pipe(
+ *     new ChatAnthropic({}),
+ *   ),
+ *   poem: PromptTemplate.fromTemplate("write a 2-line poem about {topic}").pipe(
+ *     new ChatAnthropic({}),
+ *   ),
+ * });
+ * const result = await mapChain.invoke({ topic: "bear" });
+ * ```
  */
 export class RunnableMap extends Runnable {
     static lc_name() {

package/dist/schema/runnable/branch.cjs

@@ -8,6 +8,34 @@ const base_js_1 = require("./base.cjs");
  * it evaluates the condition of each branch in order and executes the
  * corresponding branch if the condition is true. If none of the conditions
  * are true, it executes the default branch.
+ * @example
+ * ```typescript
+ * const branch = RunnableBranch.from([
+ *   [
+ *     (x: { topic: string; question: string }) =>
+ *       x.topic.toLowerCase().includes("anthropic"),
+ *     anthropicChain,
+ *   ],
+ *   [
+ *     (x: { topic: string; question: string }) =>
+ *       x.topic.toLowerCase().includes("langchain"),
+ *     langChainChain,
+ *   ],
+ *   generalChain,
+ * ]);
+ *
+ * const fullChain = RunnableSequence.from([
+ *   {
+ *     topic: classificationChain,
+ *     question: (input: { question: string }) => input.question,
+ *   },
+ *   branch,
+ * ]);
+ *
+ * const result = await fullChain.invoke({
+ *   question: "how do I use LangChain?",
+ * });
+ * ```
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 class RunnableBranch extends base_js_1.Runnable {

package/dist/schema/runnable/branch.d.ts

@@ -21,6 +21,34 @@ export type BranchLike<RunInput, RunOutput> = [
  * it evaluates the condition of each branch in order and executes the
  * corresponding branch if the condition is true. If none of the conditions
  * are true, it executes the default branch.
+ * @example
+ * ```typescript
+ * const branch = RunnableBranch.from([
+ *   [
+ *     (x: { topic: string; question: string }) =>
+ *       x.topic.toLowerCase().includes("anthropic"),
+ *     anthropicChain,
+ *   ],
+ *   [
+ *     (x: { topic: string; question: string }) =>
+ *       x.topic.toLowerCase().includes("langchain"),
+ *     langChainChain,
+ *   ],
+ *   generalChain,
+ * ]);
+ *
+ * const fullChain = RunnableSequence.from([
+ *   {
+ *     topic: classificationChain,
+ *     question: (input: { question: string }) => input.question,
+ *   },
+ *   branch,
+ * ]);
+ *
+ * const result = await fullChain.invoke({
+ *   question: "how do I use LangChain?",
+ * });
+ * ```
  */
 export declare class RunnableBranch<RunInput = any, RunOutput = any> extends Runnable<RunInput, RunOutput> {
     static lc_name(): string;

package/dist/schema/runnable/branch.js

@@ -5,6 +5,34 @@ import { Runnable, _coerceToRunnable } from "./base.js";
  * it evaluates the condition of each branch in order and executes the
  * corresponding branch if the condition is true. If none of the conditions
  * are true, it executes the default branch.
+ * @example
+ * ```typescript
+ * const branch = RunnableBranch.from([
+ *   [
+ *     (x: { topic: string; question: string }) =>
+ *       x.topic.toLowerCase().includes("anthropic"),
+ *     anthropicChain,
+ *   ],
+ *   [
+ *     (x: { topic: string; question: string }) =>
+ *       x.topic.toLowerCase().includes("langchain"),
+ *     langChainChain,
+ *   ],
+ *   generalChain,
+ * ]);
+ *
+ * const fullChain = RunnableSequence.from([
+ *   {
+ *     topic: classificationChain,
+ *     question: (input: { question: string }) => input.question,
+ *   },
+ *   branch,
+ * ]);
+ *
+ * const result = await fullChain.invoke({
+ *   question: "how do I use LangChain?",
+ * });
+ * ```
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class RunnableBranch extends Runnable {

package/dist/storage/file_system.cjs

@@ -30,6 +30,27 @@ const storage_js_1 = require("../schema/storage.cjs");
 /**
  * File system implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in the file system.
+ * @example
+ * ```typescript
+ * const store = await LocalFileStore.fromPath("./messages");
+ * await store.mset(
+ *   Array.from({ length: 5 }).map((_, index) => [
+ *     `message:id:${index}`,
+ *     new TextEncoder().encode(
+ *       JSON.stringify(
+ *         index % 2 === 0
+ *           ? new AIMessage("ai stuff...")
+ *           : new HumanMessage("human stuff..."),
+ *       ),
+ *     ),
+ *   ]),
+ * );
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));
+ * for await (const key of store.yieldKeys("message:id:")) {
+ *   await store.mdelete([key]);
+ * }
+ * ```
  */
 class LocalFileStore extends storage_js_1.BaseStore {
     constructor(fields) {

package/dist/storage/file_system.d.ts

@@ -2,6 +2,27 @@ import { BaseStore } from "../schema/storage.js";
 /**
  * File system implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in the file system.
+ * @example
+ * ```typescript
+ * const store = await LocalFileStore.fromPath("./messages");
+ * await store.mset(
+ *   Array.from({ length: 5 }).map((_, index) => [
+ *     `message:id:${index}`,
+ *     new TextEncoder().encode(
+ *       JSON.stringify(
+ *         index % 2 === 0
+ *           ? new AIMessage("ai stuff...")
+ *           : new HumanMessage("human stuff..."),
+ *       ),
+ *     ),
+ *   ]),
+ * );
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));
+ * for await (const key of store.yieldKeys("message:id:")) {
+ *   await store.mdelete([key]);
+ * }
+ * ```
  */
 export declare class LocalFileStore extends BaseStore<string, Uint8Array> {
     lc_namespace: string[];

package/dist/storage/file_system.js

@@ -4,6 +4,27 @@ import { BaseStore } from "../schema/storage.js";
 /**
  * File system implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in the file system.
+ * @example
+ * ```typescript
+ * const store = await LocalFileStore.fromPath("./messages");
+ * await store.mset(
+ *   Array.from({ length: 5 }).map((_, index) => [
+ *     `message:id:${index}`,
+ *     new TextEncoder().encode(
+ *       JSON.stringify(
+ *         index % 2 === 0
+ *           ? new AIMessage("ai stuff...")
+ *           : new HumanMessage("human stuff..."),
+ *       ),
+ *     ),
+ *   ]),
+ * );
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));
+ * for await (const key of store.yieldKeys("message:id:")) {
+ *   await store.mdelete([key]);
+ * }
+ * ```
  */
 export class LocalFileStore extends BaseStore {
     constructor(fields) {

package/dist/storage/in_memory.cjs

@@ -5,6 +5,21 @@ const storage_js_1 = require("../schema/storage.cjs");
 /**
  * In-memory implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in memory.
+ * @example
+ * ```typescript
+ * const store = new InMemoryStore<BaseMessage>();
+ * await store.mset(
+ *   Array.from({ length: 5 }).map((_, index) => [
+ *     `message:id:${index}`,
+ *     index % 2 === 0
+ *       ? new AIMessage("ai stuff...")
+ *       : new HumanMessage("human stuff..."),
+ *   ]),
+ * );
+ *
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * await store.mdelete(await store.yieldKeys("message:id:").toArray());
+ * ```
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 class InMemoryStore extends storage_js_1.BaseStore {

package/dist/storage/in_memory.d.ts

@@ -2,6 +2,21 @@ import { BaseStore } from "../schema/storage.js";
 /**
  * In-memory implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in memory.
+ * @example
+ * ```typescript
+ * const store = new InMemoryStore<BaseMessage>();
+ * await store.mset(
+ *   Array.from({ length: 5 }).map((_, index) => [
+ *     `message:id:${index}`,
+ *     index % 2 === 0
+ *       ? new AIMessage("ai stuff...")
+ *       : new HumanMessage("human stuff..."),
+ *   ]),
+ * );
+ *
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * await store.mdelete(await store.yieldKeys("message:id:").toArray());
+ * ```
  */
 export declare class InMemoryStore<T = any> extends BaseStore<string, T> {
     lc_namespace: string[];

package/dist/storage/in_memory.js

@@ -2,6 +2,21 @@ import { BaseStore } from "../schema/storage.js";
 /**
  * In-memory implementation of the BaseStore using a dictionary. Used for
  * storing key-value pairs in memory.
+ * @example
+ * ```typescript
+ * const store = new InMemoryStore<BaseMessage>();
+ * await store.mset(
+ *   Array.from({ length: 5 }).map((_, index) => [
+ *     `message:id:${index}`,
+ *     index % 2 === 0
+ *       ? new AIMessage("ai stuff...")
+ *       : new HumanMessage("human stuff..."),
+ *   ]),
+ * );
+ *
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * await store.mdelete(await store.yieldKeys("message:id:").toArray());
+ * ```
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class InMemoryStore extends BaseStore {

package/dist/storage/ioredis.cjs

@@ -6,6 +6,30 @@ const storage_js_1 = require("../schema/storage.cjs");
  * Class that extends the BaseStore class to interact with a Redis
  * database. It provides methods for getting, setting, and deleting data,
  * as well as yielding keys from the database.
+ * @example
+ * ```typescript
+ * const store = new RedisByteStore({ client: new Redis({}) });
+ * await store.mset([
+ *   [
+ *     "message:id:0",
+ *     new TextEncoder().encode(JSON.stringify(new AIMessage("ai stuff..."))),
+ *   ],
+ *   [
+ *     "message:id:1",
+ *     new TextEncoder().encode(
+ *       JSON.stringify(new HumanMessage("human stuff...")),
+ *     ),
+ *   ],
+ * ]);
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));
+ * const yieldedKeys = [];
+ * for await (const key of store.yieldKeys("message:id:")) {
+ *   yieldedKeys.push(key);
+ * }
+ * console.log(yieldedKeys);
+ * await store.mdelete(yieldedKeys);
+ * ```
  */
 class RedisByteStore extends storage_js_1.BaseStore {
     constructor(fields) {

package/dist/storage/ioredis.d.ts

@@ -5,6 +5,30 @@ import { BaseStore } from "../schema/storage.js";
  * Class that extends the BaseStore class to interact with a Redis
  * database. It provides methods for getting, setting, and deleting data,
  * as well as yielding keys from the database.
+ * @example
+ * ```typescript
+ * const store = new RedisByteStore({ client: new Redis({}) });
+ * await store.mset([
+ *   [
+ *     "message:id:0",
+ *     new TextEncoder().encode(JSON.stringify(new AIMessage("ai stuff..."))),
+ *   ],
+ *   [
+ *     "message:id:1",
+ *     new TextEncoder().encode(
+ *       JSON.stringify(new HumanMessage("human stuff...")),
+ *     ),
+ *   ],
+ * ]);
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));
+ * const yieldedKeys = [];
+ * for await (const key of store.yieldKeys("message:id:")) {
+ *   yieldedKeys.push(key);
+ * }
+ * console.log(yieldedKeys);
+ * await store.mdelete(yieldedKeys);
+ * ```
  */
 export declare class RedisByteStore extends BaseStore<string, Uint8Array> {
     lc_namespace: string[];

package/dist/storage/ioredis.js

@@ -3,6 +3,30 @@ import { BaseStore } from "../schema/storage.js";
  * Class that extends the BaseStore class to interact with a Redis
  * database. It provides methods for getting, setting, and deleting data,
  * as well as yielding keys from the database.
+ * @example
+ * ```typescript
+ * const store = new RedisByteStore({ client: new Redis({}) });
+ * await store.mset([
+ *   [
+ *     "message:id:0",
+ *     new TextEncoder().encode(JSON.stringify(new AIMessage("ai stuff..."))),
+ *   ],
+ *   [
+ *     "message:id:1",
+ *     new TextEncoder().encode(
+ *       JSON.stringify(new HumanMessage("human stuff...")),
+ *     ),
+ *   ],
+ * ]);
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * console.log(retrievedMessages.map((v) => new TextDecoder().decode(v)));
+ * const yieldedKeys = [];
+ * for await (const key of store.yieldKeys("message:id:")) {
+ *   yieldedKeys.push(key);
+ * }
+ * console.log(yieldedKeys);
+ * await store.mdelete(yieldedKeys);
+ * ```
  */
 export class RedisByteStore extends BaseStore {
     constructor(fields) {