Class RedisStore

A Redis-based key-value store for LangGraph state.

This store persists data in Redis, providing durable storage for graph state. It can be used as a standalone key-value store or with LangGraph's checkpointing.

Example

// Basic key-value storage
const store = new RedisStore();
await store.put(["users", "123"], "prefs", { theme: "dark" });
const item = await store.get(["users", "123"], "prefs");

Example

// Vector search with embeddings
import { OpenAIEmbeddings } from "@langchain/openai";
const store = new RedisStore({
  index: {
    dims: 1536,
    embeddings: new OpenAIEmbeddings({ modelName: "text-embedding-3-small" }),
  }
});

// Store documents
await store.put(["docs"], "doc1", { text: "Python tutorial" });
await store.put(["docs"], "doc2", { text: "TypeScript guide" });

// Search by similarity
const results = await store.search(["docs"], { query: "python programming" });

Example

// Custom Redis configuration
const store = new RedisStore({
  url: "redis://username:[email protected]:6379",
  ttl: 86400, // 1 day TTL
  keyPrefix: "myapp:store:"
});

Example

// Using with IORedis client
import IORedis from "ioredis";

const redisClient = new IORedis("redis://localhost:6379");
const store = new RedisStore({
  client: redisClient,
  ttl: 3600 // 1 hour TTL
});

Example

// Advanced filtering with MongoDB-style operators
const store = new RedisStore();

// Add some items
await store.put(["products"], "p1", { name: "Widget", price: 10, inStock: true });
await store.put(["products"], "p2", { name: "Gadget", price: 20, inStock: true });
await store.put(["products"], "p3", { name: "Tool", price: 15, inStock: false });

// Search with filters
const expensiveProducts = await store.search(["products"], {
  filter: { price: { $gt: 12 } }
});

const inStockProducts = await store.search(["products"], {
  filter: { inStock: true }
});

const specificProducts = await store.search(["products"], {
  filter: { name: { $in: ["Widget", "Tool"] } }
});

Example

// Batching operations for efficiency
const store = new RedisStore();

const results = await store.batch([
  // Get operation 
  { namespace: ["users"], key: "user1" },
  // Put operation
  { namespace: ["users"], key: "user2", value: { name: "Alice" } },
  // Search operation
  { namespacePrefix: ["products"], filter: { category: "electronics" }, limit: 5 }
]);

// results[0] = Get result
// results[1] = null (put operations return null)
// results[2] = Search results

Example

// Using the legacy key-value API
const store = new RedisStore();

// Set a value
await store.set("session:user123", { authenticated: true });

// Get a value
const session = await store.getLegacy("session:user123");

// Check if key exists
const exists = await store.has("session:user123");

// Set TTL for a key
await store.setTTL("session:user123", 1800); // 30 minutes

// Get remaining TTL
const remainingTtl = await store.getTTL("session:user123");

// List all keys
const allKeys = await store.keys();

// Clear all data
await store.clear();

Example

// Properly starting and stopping the store
import { createGraph } from "@langchain/langgraph";

const store = new RedisStore();

// Register for proper lifecycle management with a graph
const builder = createGraph();
builder.addPersistenceOptions({ 
  stateStore: store
});

// Or manually control the lifecycle
store.start(); // Connect to Redis

try {
  // Use the store...
} finally {
  store.stop(); // Disconnect when done
}

Hierarchy

BaseStore
- RedisStore

Constructors

constructor

new RedisStore(options?): RedisStore
Creates a new Redis store.
Parameters
- options: RedisStoreOptions = {}
  Configuration options for the Redis store.
Returns RedisStore
Overrides BaseStore.constructor
- Defined in src/providers/redis/store/redis_store.ts:470

Properties

`Private` `Optional` _redisConfig

_redisConfig?: IndexConfig & {
__tokenizedFields?: [string, string[]][];
}

Type declaration

Optional __tokenizedFields?: [string, string[]][]

client

client: RedisAdapter

`Private` clientOwned

clientOwned: boolean = false

`Private` connectionPromise

connectionPromise: null | Promise<unknown> = null

`Private` data

data: Map<string, Map<string, Item>> = ...

`Private` isConnecting

isConnecting: boolean = false

keyPrefix

keyPrefix: string

`Optional` ttl

ttl?: number

`Private` vectors

vectors: Map<string, Map<string, Map<string, number[]>>> = ...

Accessors

indexConfig

get indexConfig(): undefined | IndexConfig
Returns the store's index configuration

Returns undefined | IndexConfig
- Defined in src/providers/redis/store/redis_store.ts:1172

Methods

batch

batch<Op>(operations): Promise<OperationResults<Op>>
Execute multiple operations in a single batch. Implementation of BaseStore abstract method.
Type Parameters
- Op extends readonly Operation[]
Parameters
- operations: Op
  Array of operations to execute
Returns Promise<OperationResults<Op>>
Promise resolving to results matching the operations
Overrides BaseStore.batch
- Defined in src/providers/redis/store/redis_store.ts:687

clear

clear(): Promise<void>
Legacy method for clearing all keys

Returns Promise<void>
- Defined in src/providers/redis/store/redis_store.ts:1245

connect

connect(): Promise<void>
Ensures the Redis client is connected. This method handles concurrent connection attempts by using a promise.

Returns Promise<void>
- Defined in src/providers/redis/store/redis_store.ts:641

`Private` cosineSimilarity

cosineSimilarity(vec1, vec2): number
Calculate cosine similarity between two vectors
Parameters
- vec1: number[]
- vec2: number[]
Returns number
- Defined in src/providers/redis/store/redis_store.ts:1355

`Private` createItem

createItem(namespace, key, value, metadata?): Item
Creates a standardized item from Redis data.
Parameters
- namespace: string[]
- key: string
- value: Record<string, any>
- Optional metadata: Record<string, any>
Returns Item
- Defined in src/providers/redis/store/redis_store.ts:854

delete

delete(namespace, key): Promise<void>
Delete an item from storage. Implementation of the BaseStore abstract method.
Parameters
- namespace: string[]
- key: string
Returns Promise<void>
Overrides BaseStore.delete
- Defined in src/providers/redis/store/redis_store.ts:785

disconnect

disconnect(): Promise<void>
Disconnects the Redis client if it was created by this store.

Returns Promise<void>
- Defined in src/providers/redis/store/redis_store.ts:670

`Private` doesMatch

doesMatch(namespace, pattern, matchType): boolean
Check if a namespace matches a pattern
Parameters
- namespace: string[]
- pattern: string[]
- matchType: "prefix" | "suffix"
Returns boolean
- Defined in src/providers/redis/store/redis_store.ts:1379

`Private` extractTexts

extractTexts(ops): [string[], [string[], string, string][]]
Extract texts for embedding from put operations Used internally by batch method
Parameters
- ops: PutOperation[]
Returns [string[], [string[], string, string][]]
- Defined in src/providers/redis/store/redis_store.ts:1313

filterItems

filterItems(items, filter?): Item[]
Filter items based on a filter condition
Parameters
- items: Item[]
  Items to filter
- Optional filter: Record<string, any>
  Filter condition
Returns Item[]
Filtered items
- Defined in src/providers/redis/store/redis_store.ts:512

get

get(namespace, key): Promise<null | Item>
Get an item by namespace and key. Implementation of the BaseStore abstract method.
Parameters
- namespace: string[]
- key: string
Returns Promise<null | Item>
Overrides BaseStore.get
- Defined in src/providers/redis/store/redis_store.ts:724

getLegacy

getLegacy<T>(key): Promise<undefined | T>
Legacy method for direct key-value access
Type Parameters
- T
Parameters
- key: string
Returns Promise<undefined | T>
- Defined in src/providers/redis/store/redis_store.ts:1179

`Private` getNamespacePrefix

getNamespacePrefix(namespacePrefix): string
Gets a namespaced key prefix for use with pattern matching.
Parameters
- namespacePrefix: string[]
Returns string
- Defined in src/providers/redis/store/redis_store.ts:840

`Private` getOperation

getOperation(op): Promise<null | Item>
Redis Get operation implementation
Parameters
- op: GetOperation
Returns Promise<null | Item>
- Defined in src/providers/redis/store/redis_store.ts:931

`Private` getRedisKey

getRedisKey(namespace, key): string
Generates a Redis key from namespace and item key
Parameters
- namespace: string[]
- key: string
Returns string
- Defined in src/providers/redis/store/redis_store.ts:847

getTTL

getTTL(key): Promise<number>
Retrieves the time-to-live (TTL) for a key.
Parameters
- key: string
Returns Promise<number>
- Defined in src/providers/redis/store/redis_store.ts:1282

`Private` getVectors

getVectors(item): Promise<number[][]>
Retrieves vector embeddings for an item
Parameters
- item: Item
Returns Promise<number[][]>
- Defined in src/providers/redis/store/redis_store.ts:914

has

has(key): Promise<boolean>
Legacy method for checking key existence
Parameters
- key: string
Returns Promise<boolean>
- Defined in src/providers/redis/store/redis_store.ts:1230

insertVectors

insertVectors(texts, items, embeddings?): Promise<void>
Insert vector embeddings
Parameters
- texts: string[]
  The texts to embed
- items: [string[], string, string][]
  The items containing the texts
- Optional embeddings: number[][]
  Optional pre-computed embeddings
Returns Promise<void>
Promise that resolves when vectors are inserted
- Defined in src/providers/redis/store/redis_store.ts:593

keys

keys(): Promise<string[]>
Legacy method for listing keys

Returns Promise<string[]>
- Defined in src/providers/redis/store/redis_store.ts:1265

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
});
```
Inherited from BaseStore.listNamespaces
- Defined in node_modules/@langchain/langgraph-checkpoint/dist/store/base.d.ts:373

`Private` listNamespacesOperation

listNamespacesOperation(op): Promise<string[][]>
List namespaces with filtering based on match conditions.
Parameters
- op: ListNamespacesOperation
Returns Promise<string[][]>
- Defined in src/providers/redis/store/redis_store.ts:1125

paginateResults

paginateResults(items, offset?, limit?): SearchItem[]
Paginate results
Parameters
- items: SearchItem[]
  Items to paginate
- offset: number = 0
  Offset to start from
- limit: number = 10
  Maximum number of items to return
Returns SearchItem[]
Paginated items
- Defined in src/providers/redis/store/redis_store.ts:578

put

put(namespace, key, value, index?): Promise<void>
Put an item into storage. Implementation of the BaseStore abstract method.
Parameters
- namespace: string[]
- key: string
- value: Record<string, any>
- Optional index: string[]
Returns Promise<void>
Overrides BaseStore.put
- Defined in src/providers/redis/store/redis_store.ts:748

`Private` putOperation

putOperation(op): Promise<void>
Redis Put operation implementation
Parameters
- op: PutOperation
Returns Promise<void>
- Defined in src/providers/redis/store/redis_store.ts:975

`Private` redisSearchOperation

redisSearchOperation(op): Promise<SearchItem[]>
Execute search on Redis keys.
Parameters
- op: SearchOperation
Returns Promise<SearchItem[]>
- Defined in src/providers/redis/store/redis_store.ts:1049

scoreResults

scoreResults(items, queryEmbedding): Promise<SearchItem[]>
Score results based on similarity to a query embedding
Parameters
- items: Item[]
  Items to score
- queryEmbedding: number[]
  The query embedding to compare against
Returns Promise<SearchItem[]>
Scored items
- Defined in src/providers/redis/store/redis_store.ts:538

search

search(namespacePrefix, options?): Promise<SearchItem[]>
Search for items. Implementation of the BaseStore abstract method.
Parameters
- namespacePrefix: string[]
- options: {
      filter?: Record<string, any>;
      limit?: number;
      offset?: number;
      query?: string;
  } = {}
  - Optional filter?: Record<string, any>
  - Optional limit?: number
  - Optional offset?: number
  - Optional query?: string
Returns Promise<SearchItem[]>
Overrides BaseStore.search
- Defined in src/providers/redis/store/redis_store.ts:797

set

set<T>(key, value): Promise<void>
Legacy method for direct key-value setting
Type Parameters
- T
Parameters
- key: string
- value: T
Returns Promise<void>
- Defined in src/providers/redis/store/redis_store.ts:1200

setTTL

setTTL(key, ttl): Promise<boolean>
Sets the time-to-live (TTL) for a key.
Parameters
- key: string
- ttl: number
Returns Promise<boolean>
- Defined in src/providers/redis/store/redis_store.ts:1297

start

start(): void
Start the store - connect to Redis. Implementation of the BaseStore abstract method.

Returns void
Overrides BaseStore.start
- Defined in src/providers/redis/store/redis_store.ts:819

stop

stop(): void
Stop the store - disconnect from Redis. Implementation of the BaseStore abstract method.

Returns void
Overrides BaseStore.stop
- Defined in src/providers/redis/store/redis_store.ts:830

`Private` storeVectors

storeVectors(texts, embeddings): Promise<void>
Stores vector embeddings in Redis
Parameters
- texts: Record<string, [string[], string, string][]>
- embeddings: number[][]
Returns Promise<void>
- Defined in src/providers/redis/store/redis_store.ts:883

Class RedisStore

Example

Example

Example

Example

Example

Example

Example

Example

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns RedisStore

Properties

Private Optional _redisConfig

Type declaration

Optional __tokenizedFields?: [string, string[]][]

client

Private clientOwned

Private connectionPromise

Private data

Private isConnecting

keyPrefix

Optional ttl

Private vectors

Accessors

indexConfig

Returns undefined | IndexConfig

Methods

batch

Type Parameters

Parameters

Returns Promise<OperationResults<Op>>

clear

Returns Promise<void>

connect

Returns Promise<void>

Private cosineSimilarity

Parameters

Returns number

Private createItem

Parameters

Returns Item

delete

Parameters

Returns Promise<void>

disconnect

Returns Promise<void>

Private doesMatch

Parameters

Returns boolean

Private extractTexts

Parameters

Returns [string[], [string[], string, string][]]

filterItems

Parameters

Returns Item[]

get

Parameters

Returns Promise<null | Item>

getLegacy

Type Parameters

Parameters

Returns Promise<undefined | T>

Private getNamespacePrefix

Parameters

Returns string

Private getOperation

Parameters

Returns Promise<null | Item>

Private getRedisKey

Parameters

Returns string

getTTL

`Private` `Optional` _redisConfig

`Optional` __tokenizedFields?: [string, string[]][]

`Private` clientOwned

`Private` connectionPromise

`Private` data

`Private` isConnecting

`Optional` ttl

`Private` vectors

`Private` cosineSimilarity

`Private` createItem

`Private` doesMatch

`Private` extractTexts

`Private` getNamespacePrefix

`Private` getOperation

`Private` getRedisKey

`Private` getVectors

`Optional` limit?: number

`Optional` maxDepth?: number

`Optional` offset?: number

`Optional` prefix?: string[]

`Optional` suffix?: string[]

`Private` listNamespacesOperation

`Private` putOperation

`Private` redisSearchOperation

`Optional` filter?: Record<string, any>

`Optional` limit?: number

`Optional` offset?: number

`Optional` query?: string

`Private` storeVectors