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

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, key): 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, key): 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?): Promise<string[][]>

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

    Parameters

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

      Options for listing namespaces

      • Optional limit?: number
      • Optional maxDepth?: number
      • Optional offset?: number
      • Optional prefix?: string[]
      • Optional suffix?: string[]

    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, key, value): 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, options?): 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

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

      Search options for filtering and pagination

      • Optional filter?: Record<string, any>
      • Optional limit?: number
      • Optional offset?: number
      • Optional query?: string

    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?) => void);
            resolve: ((value) => void);
        }>;
        running: boolean;
        store: string;
    }

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

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

Settings

Member Visibility

Theme

On This Page

constructorisRunningdeletegetlistNamespacesputsearchstartstoptoJSON