Class AsyncBatchedStore

Abstract base class for persistent key-value stores.

Stores enable persistence and memory that can be shared across threads, scoped to user IDs, assistant IDs, or other arbitrary namespaces.

Features:

  • Hierarchical namespaces for organization
  • Key-value storage with metadata
  • Vector similarity search (if configured)
  • Filtering and pagination

Hierarchy (View Summary)

Constructors

constructor

Accessors

isRunning

Methods

delete get listNamespaces put search start stop toJSON

Constructors

constructor

Accessors

isRunning

  • get isRunning(): boolean

    Returns boolean

Methods

delete

  • delete(namespace: string[], key: string): Promise<void>

    Delete an item from the store.

    Parameters

    • namespace: string[]

      Hierarchical path for the item

    • key: string

      Unique identifier within the namespace

    Returns Promise<void>

get

  • get(namespace: string[], key: string): Promise<null | Item>

    Retrieve a single item by its namespace and key.

    Parameters

    • namespace: string[]

      Hierarchical path for the item

    • key: string

      Unique identifier within the namespace

    Returns Promise<null | Item>

    Promise resolving to the item or null if not found

listNamespaces

  • listNamespaces(
        options?: {
            limit?: number;
            maxDepth?: number;
            offset?: number;
            prefix?: string[];
            suffix?: string[];
        },
    ): Promise<string[][]>

    List and filter namespaces in the store. Used to explore data organization and navigate the namespace hierarchy.

    Parameters

    • Optionaloptions: {
          limit?: number;
          maxDepth?: number;
          offset?: number;
          prefix?: string[];
          suffix?: string[];
      }

      Options for listing namespaces

    Returns Promise<string[][]>

    Promise resolving to list of namespace paths

    Example

    // List all namespaces under "documents"
    await store.listNamespaces({
      prefix: ["documents"],
      maxDepth: 2
    });

    // List namespaces ending with "v1"
    await store.listNamespaces({
      suffix: ["v1"],
      limit: 50
    });

put

  • put(namespace: string[], key: string, value: Record<string, any>): Promise<void>

    Store or update an item.

    Parameters

    • namespace: string[]

      Hierarchical path for the item

    • key: string

      Unique identifier within the namespace

    • value: Record<string, any>

      Object containing the item's data

    Returns Promise<void>

    Example

    // Simple storage
    await store.put(["docs"], "report", { title: "Annual Report" });

    // With specific field indexing
    await store.put(
      ["docs"],
      "report",
      {
        title: "Q4 Report",
        chapters: [{ content: "..." }, { content: "..." }]
      },
      ["title", "chapters[*].content"]
    );

search

  • search(
        namespacePrefix: string[],
        options?: { filter?: Record<string, any>; limit?: number; offset?: number },
    ): Promise<Item[]>

    Search for items within a namespace prefix. Supports both metadata filtering and vector similarity search.

    Parameters

    • namespacePrefix: string[]

      Hierarchical path prefix to search within

    • Optionaloptions: { filter?: Record<string, any>; limit?: number; offset?: number }

      Search options for filtering and pagination

    Returns Promise<Item[]>

    Promise resolving to list of matching items with relevance scores

    Example

    // Search with filters
    await store.search(["documents"], {
      filter: { type: "report", status: "active" },
      limit: 5,
      offset: 10
    });

    // Vector similarity search
    await store.search(["users", "content"], {
      query: "technical documentation about APIs",
      limit: 20
    });

start

  • start(): void

    Start the store. Override if initialization is needed.

    Returns void

stop

  • stop(): Promise<void>

    Stop the store. Override if cleanup is needed.

    Returns Promise<void>

toJSON

  • toJSON(): {
        nextKey: number;
        queue: Map<
            number,
            {
                operation: Operation;
                reject: (reason?: any) => void;
                resolve: (value: any) => void;
            },
        >;
        running: boolean;
        store: string;
    }

    Returns {
        nextKey: number;
        queue: Map<
            number,
            {
                operation: Operation;
                reject: (reason?: any) => void;
                resolve: (value: any) => void;
            },
        >;
        running: boolean;
        store: string;
    }

Settings

Member Visibility

On This Page

Constructors
Accessors
Methods