Class BaseStore`Abstract`

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)

BaseStore
- AsyncBatchedStore
- InMemoryStore

Index

Constructors

Methods

batch delete get listNamespaces put search start stop

Constructors

constructor

new BaseStore(): BaseStore
Returns BaseStore

Methods

`Abstract`batch

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
- Op extends Operation[]
Parameters
- operations: Op
  Array of operations to execute
Returns Promise<OperationResults<Op>>
Promise resolving to results matching the operations
- Defined in store/base.ts:393

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>
- Defined in store/base.ts:492

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
- Defined in store/base.ts:404

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
- options: {
      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
});
```
- Defined in store/base.ts:516

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"]
);
```
- Defined in store/base.ts:476

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
- options: {
      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
});
```
- Defined in store/base.ts:430

start

start(): void | Promise<void>
Start the store. Override if initialization is needed.

Returns void | Promise<void>
- Defined in store/base.ts:550

stop

stop(): void | Promise<void>
Stop the store. Override if cleanup is needed.

Returns void | Promise<void>
- Defined in store/base.ts:555