Class BaseStoreAbstract

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

Methods

batch delete get listNamespaces put search start stop

Constructors

constructor

Methods

Abstractbatch

  • batch<Op extends Operation[]>(operations: Op): Promise<OperationResults<Op>>

    Execute multiple operations in a single batch. This is more efficient than executing operations individually.

    Type Parameters

    Parameters

    • operations: Op

      Array of operations to execute

    Returns Promise<OperationResults<Op>>

    Promise resolving to results matching the operations

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>,
        index?: false | string[],
    ): 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

    • Optionalindex: false | string[]

      Optional indexing configuration

    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;
            query?: string;
        },
    ): Promise<SearchItem[]>

    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;
          query?: string;
      }

      Search options for filtering and pagination

    Returns Promise<SearchItem[]>

    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(): void

    Stop the store. Override if cleanup is needed.

    Returns void

Settings

Member Visibility

On This Page

Constructors
Methods