langchain 0.0.191 → 0.0.193

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

package/dist/storage/upstash_redis.cjs

@@ -7,6 +7,25 @@ const storage_js_1 = require("../schema/storage.cjs");
  * Class that extends the BaseStore class to interact with an Upstash Redis
  * database. It provides methods for getting, setting, and deleting data,
  * as well as yielding keys from the database.
+ * @example
+ * ```typescript
+ * const store = new UpstashRedisStore({
+ *   client: new Redis({
+ *     url: "your-upstash-redis-url",
+ *     token: "your-upstash-redis-token",
+ *   }),
+ * });
+ * await store.mset([
+ *   ["message:id:0", "encoded-ai-message"],
+ *   ["message:id:1", "encoded-human-message"],
+ * ]);
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * const yieldedKeys = [];
+ * for await (const key of store.yieldKeys("message:id")) {
+ *   yieldedKeys.push(key);
+ * }
+ * await store.mdelete(yieldedKeys);
+ * ```
  */
 class UpstashRedisStore extends storage_js_1.BaseStore {
     constructor(fields) {

package/dist/storage/upstash_redis.d.ts

@@ -22,6 +22,25 @@ export interface UpstashRedisStoreInput {
  * Class that extends the BaseStore class to interact with an Upstash Redis
  * database. It provides methods for getting, setting, and deleting data,
  * as well as yielding keys from the database.
+ * @example
+ * ```typescript
+ * const store = new UpstashRedisStore({
+ *   client: new Redis({
+ *     url: "your-upstash-redis-url",
+ *     token: "your-upstash-redis-token",
+ *   }),
+ * });
+ * await store.mset([
+ *   ["message:id:0", "encoded-ai-message"],
+ *   ["message:id:1", "encoded-human-message"],
+ * ]);
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * const yieldedKeys = [];
+ * for await (const key of store.yieldKeys("message:id")) {
+ *   yieldedKeys.push(key);
+ * }
+ * await store.mdelete(yieldedKeys);
+ * ```
  */
 export declare class UpstashRedisStore extends BaseStore<string, Uint8Array> {
     lc_namespace: string[];

package/dist/storage/upstash_redis.js

@@ -4,6 +4,25 @@ import { BaseStore } from "../schema/storage.js";
  * Class that extends the BaseStore class to interact with an Upstash Redis
  * database. It provides methods for getting, setting, and deleting data,
  * as well as yielding keys from the database.
+ * @example
+ * ```typescript
+ * const store = new UpstashRedisStore({
+ *   client: new Redis({
+ *     url: "your-upstash-redis-url",
+ *     token: "your-upstash-redis-token",
+ *   }),
+ * });
+ * await store.mset([
+ *   ["message:id:0", "encoded-ai-message"],
+ *   ["message:id:1", "encoded-human-message"],
+ * ]);
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * const yieldedKeys = [];
+ * for await (const key of store.yieldKeys("message:id")) {
+ *   yieldedKeys.push(key);
+ * }
+ * await store.mdelete(yieldedKeys);
+ * ```
  */
 export class UpstashRedisStore extends BaseStore {
     constructor(fields) {

package/dist/storage/vercel_kv.cjs

@@ -7,6 +7,22 @@ const storage_js_1 = require("../schema/storage.cjs");
  * Class that extends the BaseStore class to interact with a Vercel KV
  * database. It provides methods for getting, setting, and deleting data,
  * as well as yielding keys from the database.
+ * @example
+ * ```typescript
+ * const store = new VercelKVStore({
+ *   client: getClient(),
+ * });
+ * await store.mset([
+ *   { key: "message:id:0", value: "encoded message 0" },
+ *   { key: "message:id:1", value: "encoded message 1" },
+ * ]);
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * const yieldedKeys = [];
+ * for await (const key of store.yieldKeys("message:id:")) {
+ *   yieldedKeys.push(key);
+ * }
+ * await store.mdelete(yieldedKeys);
+ * ```
  */
 class VercelKVStore extends storage_js_1.BaseStore {
     constructor(fields) {

package/dist/storage/vercel_kv.d.ts

@@ -4,6 +4,22 @@ import { BaseStore } from "../schema/storage.js";
  * Class that extends the BaseStore class to interact with a Vercel KV
  * database. It provides methods for getting, setting, and deleting data,
  * as well as yielding keys from the database.
+ * @example
+ * ```typescript
+ * const store = new VercelKVStore({
+ *   client: getClient(),
+ * });
+ * await store.mset([
+ *   { key: "message:id:0", value: "encoded message 0" },
+ *   { key: "message:id:1", value: "encoded message 1" },
+ * ]);
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * const yieldedKeys = [];
+ * for await (const key of store.yieldKeys("message:id:")) {
+ *   yieldedKeys.push(key);
+ * }
+ * await store.mdelete(yieldedKeys);
+ * ```
  */
 export declare class VercelKVStore extends BaseStore<string, Uint8Array> {
     lc_namespace: string[];

package/dist/storage/vercel_kv.js

@@ -4,6 +4,22 @@ import { BaseStore } from "../schema/storage.js";
  * Class that extends the BaseStore class to interact with a Vercel KV
  * database. It provides methods for getting, setting, and deleting data,
  * as well as yielding keys from the database.
+ * @example
+ * ```typescript
+ * const store = new VercelKVStore({
+ *   client: getClient(),
+ * });
+ * await store.mset([
+ *   { key: "message:id:0", value: "encoded message 0" },
+ *   { key: "message:id:1", value: "encoded message 1" },
+ * ]);
+ * const retrievedMessages = await store.mget(["message:id:0", "message:id:1"]);
+ * const yieldedKeys = [];
+ * for await (const key of store.yieldKeys("message:id:")) {
+ *   yieldedKeys.push(key);
+ * }
+ * await store.mdelete(yieldedKeys);
+ * ```
  */
 export class VercelKVStore extends BaseStore {
     constructor(fields) {