LangGraph

https://reference.langchain.com/javascript/langchain-langgraph
Admin
LangGraph is a Python and JavaScript library for building stateful, multi-step computational graphs...
Tokens:64,881
Snippets:856
Trust Score:9.5
Update:3 months ago
Show doc for...
Tokens:
Raw
### setup()

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/setup

Initializes the Redis store instance. This method returns a promise that resolves when the setup is complete.

```APIDOC
## setup()

### Description
Initializes the Redis store. This method prepares the store for operations.

### Signature
`setup(): Promise<void>`

### Returns
- **Promise<void>** - A promise that resolves when the setup process is finished.
```

--------------------------------

### PostgresSaver setup method signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-postgres/index/PostgresSaver/setup

Defines the asynchronous setup method for initializing the database.

```javascript
setup(): Promise<void>
```

--------------------------------

### Example usage of namespace

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/store/Item/namespace

An example showing a namespace path for a user profile.

```ts
// Get a user profile
namespace: ["users", "profiles"]
```

--------------------------------

### Call setup method

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-sqlite/SqliteSaver/setup

Initializes the database structure for the SqliteSaver instance.

```javascript
setup()
```

--------------------------------

### start()

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/index/AsyncBatchedStore/start

Initializes the store. This method can be overridden if custom initialization logic is needed.

```APIDOC
## start()

### Description
Starts the store. This method is intended to be overridden if specific initialization logic is required for the store instance.

### Signature
`start(): void`

### Returns
- **void** - This method does not return a value.
```

--------------------------------

### Usage examples for key

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/store/Item/key

Illustrates common string values used for the key property.

```ts
key: "user123"  // For a user profile
key: "doc456"   // For a document
```

--------------------------------

### setup()

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-sqlite/SqliteSaver/setup

Initializes the necessary database tables for the SqliteSaver. This method must be called to ensure the database is ready for checkpoint operations.

```APIDOC
## setup()

### Description
Initializes the SQLite database schema required for checkpoint storage. This method should be called to prepare the database environment.

### Signature
`setup(): void`

### Returns
- **void** - This method does not return a value.
```

--------------------------------

### Initialize AsyncBatchedStore

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/index/AsyncBatchedStore/start

Invoke this method to start the store. It returns void and is intended for initialization tasks.

```javascript
start()
```

--------------------------------

### setup()

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-postgres/index/PostgresSaver/setup

Initializes the checkpoint database by creating necessary tables and running migrations. This method must be called by the user before the first use of the checkpointer.

```APIDOC
## setup()

### Description
Asynchronously sets up the checkpoint database. This method creates the required tables if they do not exist and executes necessary database migrations.

### Signature
`setup(): Promise<void>`

### Returns
- **Promise<void>** - A promise that resolves when the database setup is complete.
```

--------------------------------

### Initialize PostgresSaver from connection string

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-postgres/index/PostgresSaver/fromConnString

Creates a checkpointer instance and initializes the database schema. Ensure the setup method is called after instantiation.

```typescript
const connString = "postgresql://user:password@localhost:5432/db";
const checkpointer = PostgresSaver.fromConnString(connString, {
 schema: "custom_schema" // defaults to "public"
});
await checkpointer.setup();
```

--------------------------------

### get(namespace: string[], key: string)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/index/AsyncBatchedStore/get

Retrieves a single item by its namespace and key.

```APIDOC
## get(namespace: string[], key: string)

### Description
Retrieve a single item by its namespace and key.

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

### Parameters
- **namespace** (string[]) - Required - Hierarchical path for the item
- **key** (string) - Required - Unique identifier within the namespace

### Returns
- **Promise<Item | null>** - Promise resolving to the item or null if not found
```

--------------------------------

### get(config: RunnableConfig)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/cache/InMemoryCache/get

Retrieves a checkpoint associated with the provided configuration.

```APIDOC
## get(config: RunnableConfig)

### Description
Retrieves a checkpoint from the checkpoint saver based on the provided configuration.

### Signature
`get(config: RunnableConfig): Promise<Checkpoint<string, string> | undefined>`

### Parameters
- **config** (RunnableConfig) - Required - The configuration object used to identify the checkpoint.

### Returns
- **Promise<Checkpoint<string, string> | undefined>** - A promise that resolves to the checkpoint if found, or undefined if no checkpoint exists for the given configuration.
```

--------------------------------

### get(config: RunnableConfig)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/cache/BaseCache/get

Retrieves a checkpoint associated with the provided configuration.

```APIDOC
## get(config: RunnableConfig)

### Description
Retrieves a checkpoint from the store based on the provided configuration.

### Signature
`get(config: RunnableConfig): Promise<Checkpoint<string, string> | undefined>`

### Parameters
- **config** (RunnableConfig) - Required - The configuration object used to identify the checkpoint.

### Returns
- **Promise<Checkpoint<string, string> | undefined>** - A promise that resolves to the checkpoint if found, or undefined if no checkpoint exists for the given config.
```

--------------------------------

### get(config: RunnableConfig)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/base/BaseCheckpointSaver/get

Retrieves a checkpoint associated with the provided configuration.

```APIDOC
## get(config: RunnableConfig)

### Description
Retrieves a checkpoint from the saver based on the provided configuration.

### Signature
`get(config: RunnableConfig): Promise<Checkpoint<string, string> | undefined>`

### Parameters
- **config** (RunnableConfig) - Required - The configuration object used to identify the checkpoint.

### Returns
- **Promise<Checkpoint<string, string> | undefined>** - A promise that resolves to the checkpoint if found, or undefined if no checkpoint exists for the given configuration.
```

--------------------------------

### get(assistantId: string, options?: __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/AssistantsClient/get

Retrieves an assistant by its ID.

```APIDOC
## get(assistantId: string, options?: __type)

### Description
Retrieves an assistant by its unique ID.

### Signature
`get(assistantId: string, options?: __type): Promise<Assistant>`

### Parameters
- **assistantId** (string) - Required - The ID of the assistant.
- **options** (__type) - Optional - Additional configuration options.

### Returns
- **Promise<Assistant>** - A promise that resolves to the Assistant object.
```

--------------------------------

### get(namespace: string[], key: string, options?: __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/get

Retrieves an item from the Redis store using the provided namespace and key.

```APIDOC
## get(namespace: string[], key: string, options?: __type)

### Description
Retrieves an item from the Redis store based on the provided namespace and key.

### Signature
`get(namespace: string[], key: string, options?: __type): Promise<Item | null>`

### Parameters
- **namespace** (string[]) - Required - The namespace path for the item.
- **key** (string) - Required - The key of the item to retrieve.
- **options** (__type) - Optional - Additional configuration options.

### Returns
- **Promise<Item | null>** - A promise that resolves to the retrieved item or null if not found.
```

--------------------------------

### get()

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/index/ChannelProtocol/get

Retrieves the current value of the channel.

```APIDOC
## get()

### Description
Returns the current value of the channel.

### Signature
`get(): ValueType`

### Returns
- **ValueType** - The current value stored in the channel.
```

--------------------------------

### Usage with additional type configuration

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/useStream

Example of configuring interrupts and configurable types within the useStream hook.

```typescript
// With additional type configuration (interrupts, configurable)
interface MyGraphState {
  messages: Message<MyToolCalls>[];
}

function Chat() {
  const stream = useStream<MyGraphState, {
    InterruptType: { question: string };
    ConfigurableType: { userId: string };
  }>({
    assistantId: "my-graph",
    apiUrl: "http://localhost:2024",
  });

  // stream.interrupt is typed as { question: string } | undefined
}
```

--------------------------------

### Usage with createAgent

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/useStream

Example of using useStream with an agent created via createAgent, allowing for automatic inference of tool call types.

```typescript
// In your agent file (e.g., agent.ts)
import { createAgent, tool } from "langchain";
import { z } from "zod";

const getWeather = tool(
  async ({ location }) => `Weather in ${location}`,
  { name: "get_weather", schema: z.object({ location: z.string() }) }
);

export const agent = createAgent({
  model: "openai:gpt-4o",
  tools: [getWeather],
});

// In your React component
import { agent } from "./agent";

function Chat() {
  // Tool calls are automatically typed from the agent's tools!
  const stream = useStream<typeof agent>({
    assistantId: "agent",
    apiUrl: "http://localhost:2024",
  });

  // stream.toolCalls[0].call.name is typed as "get_weather"
  // stream.toolCalls[0].call.args is typed as { location: string }
}
```

--------------------------------

### prepareFetchOptions(path, options)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/AssistantsClient/prepareFetchOptions

Prepares the fetch options by combining the provided path and request initialization parameters into a tuple containing the URL and RequestInit objects.

```APIDOC
## prepareFetchOptions

### Description
Constructs the URL and RequestInit configuration required for network requests.

### Signature
`prepareFetchOptions(path: string, options?: RequestInit & __type): [URL, RequestInit]`

### Parameters
- **path** (string) - Required - The path for the request.
- **options** (RequestInit & __type) - Optional - Additional request initialization options.

### Returns
- **[URL, RequestInit]** - A tuple containing the constructed URL and the RequestInit object.
```

--------------------------------

### Initialize and use PostgresSaver with a LangGraph agent

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-postgres/index/PostgresSaver

Demonstrates connecting to a Postgres database using a connection string and integrating the checkpointer into a React agent. Ensure .setup() is called before the first use.

```typescript
import { ChatOpenAI } from "@langchain/openai";
import { PostgresSaver } from "@langchain/langgraph-checkpoint-postgres";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const checkpointer = PostgresSaver.fromConnString(
  "postgresql://user:password@localhost:5432/db",
  // optional configuration object
  {
    schema: "custom_schema" // defaults to "public"
  }
);

// NOTE: you need to call .setup() the first time you're using your checkpointer
await checkpointer.setup();

const graph = createReactAgent({
  tools: [getWeather],
  llm: new ChatOpenAI({
    model: "gpt-4o-mini",
  }),
  checkpointSaver: checkpointer,
});
const config = { configurable: { thread_id: "1" } };

await graph.invoke({
  messages: [{
    role: "user",
    content: "what's the weather in sf"
  }],
}, config);
```

--------------------------------

### get(threadId: string, options?: __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/ThreadsClient/get

Retrieves a thread by its ID using the ThreadsClient.

```APIDOC
## get(threadId: string, options?: __type)

### Description
Retrieves a thread by its ID. Returns a promise that resolves to the thread object.

### Parameters
#### Path Parameters
- **threadId** (string) - Required - ID of the thread.

#### Optional Parameters
- **options** (__type) - Optional - Additional configuration options.

### Returns
- **Promise<Thread<ValuesType, unknown>>** - The requested thread object.
```

--------------------------------

### fromConnString(connString: string, config?: StoreConfig)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/fromConnString

Initializes a new RedisStore instance from a provided connection string.

```APIDOC
## fromConnString

### Description
Creates and returns a new instance of `RedisStore` using the specified Redis connection string and optional configuration.

### Signature
`fromConnString(connString: string, config?: StoreConfig): Promise<RedisStore>`

### Parameters
- **connString** (string) - Required - The Redis connection string.
- **config** (StoreConfig) - Optional - Configuration options for the store.

### Returns
- **Promise<RedisStore>** - A promise that resolves to the initialized RedisStore instance.
```

--------------------------------

### Get RedisStore statistics signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/getStatistics

The method returns a promise that resolves to store statistics.

```javascript
getStatistics(): Promise<__type>
```

--------------------------------

### fetch<T>(path: string, options: RequestInit & __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/AssistantsClient/fetch

Performs a fetch request using the AssistantsClient.

```APIDOC
## fetch<T>(path: string, options: RequestInit & __type)

### Description
Performs an HTTP request using the AssistantsClient. This method is generic and returns a promise that resolves to a tuple containing the response data and the raw Response object.

### Signature
`fetch<T>(path: string, options: RequestInit & __type): Promise<[T, Response]>`

### Parameters
- **path** (string) - Required - The request path.
- **options** (RequestInit & __type) - Required - The request configuration options.

### Returns
- **Promise<[T, Response]>** - A promise that resolves to a tuple containing the parsed response body of type T and the raw Response object.
```

--------------------------------

### get(keys: CacheFullKey[]): Promise<__type[]>

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/index/BaseCache/get

Retrieves the cached values for the specified keys.

```APIDOC
## get(keys: CacheFullKey[]): Promise<__type[]>

### Description
Retrieves the cached values for the given keys.

### Parameters
- **keys** (CacheFullKey[]) - Required - The keys to get.

### Returns
- **Promise<__type[]>** - A promise that resolves to the cached values.
```

--------------------------------

### fetch<T>(path: string, options: RequestInit & __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/StoreClient/fetch

Performs a fetch request using the StoreClient.

```APIDOC
## fetch<T>(path: string, options: RequestInit & __type)

### Description
Performs a network request to the specified path using the provided options. This method is part of the StoreClient in the @langchain/langgraph-sdk.

### Signature
`fetch<T>(path: string, options: RequestInit & __type): Promise<[T, Response]>`

### Parameters
- **path** (string) - Required - The request path.
- **options** (RequestInit & __type) - Required - Configuration options for the request.

### Returns
- **Promise<[T, Response]>** - A promise that resolves to a tuple containing the response data of type T and the raw Response object.
```

--------------------------------

### get method signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/cache/InMemoryCache/get

Defines the method signature for retrieving a checkpoint using a RunnableConfig.

```javascript
get(config: RunnableConfig): Promise<Checkpoint<string, string> | undefined>
```

--------------------------------

### beforeAll()

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-validation/index/CheckpointSaverTestInitializer/beforeAll

Initializes the test environment before any tests are executed.

```APIDOC
## beforeAll()

### Description
Called once before any tests are run. Use this to perform any setup that your checkpoint checkpointer may require, like starting docker containers.

### Signature
`beforeAll(): void | Promise<void>`

### Returns
- **void | Promise<void>** - The method returns void or a promise that resolves to void.
```

--------------------------------

### Usage with subagent streaming

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/useStream

Example of using useStream to handle subagent streams and filtering messages.

```typescript
import { useStream, SubagentStream } from "@langchain/langgraph-sdk/react";
import type { agent } from "./agent";

function DeepAgentChat() {
  const stream = useStream<typeof agent>({
    assistantId: "deepagent",
    apiUrl: "http://localhost:2024",
    // Filter subagent messages from main stream
    filterSubagentMessages: true,
  });

  const handleSubmit = (content: string) => {
    stream.submit(
      { messages: [{ content, type: "human" }] },
      { streamSubgraphs: true } // Enable subgraph streaming
    );
  };

  // Access subagent streams via stream.subagents (Map<string, SubagentStream>)
  const subagentList = [...stream.subagents.values()];

  return (
    <div>
      {stream.messages.map((msg) => <Message key={msg.id} message={msg} />)}

      {subagentList.map((subagent) => (
        <SubagentCard
          key={subagent.id}
          status={subagent.status} // "pending" | "running" | "complete" | "error"
          messages={subagent.messages}
          toolCalls={subagent.toolCalls}
        />
      ))}
    </div>
  );
}
```

--------------------------------

### RedisSaver.fromUrl(url, ttlConfig)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/index/RedisSaver/fromUrl

Initializes a new RedisSaver instance using the provided Redis connection URL.

```APIDOC
## fromUrl(url, ttlConfig)

### Description
Creates and returns a new RedisSaver instance connected to the specified Redis URL.

### Signature
`fromUrl(url: string, ttlConfig?: TTLConfig): Promise<RedisSaver>`

### Parameters
- **url** (string) - Required - The Redis connection URL.
- **ttlConfig** (TTLConfig) - Optional - Configuration for time-to-live settings.

### Returns
- **Promise<RedisSaver>** - A promise that resolves to a RedisSaver instance.
```

--------------------------------

### Initialize and use InMemoryStore

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/index/InMemoryStore

Demonstrates basic key-value storage operations and configuring the store for vector search using OpenAI embeddings.

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

// Vector search with embeddings
import { OpenAIEmbeddings } from "@langchain/openai";
const store = new InMemoryStore({
  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" });
```

--------------------------------

### createSwarm()

Source: https://reference.langchain.com/javascript/langchain-langgraph-swarm

Initializes a new swarm configuration.

```APIDOC
## createSwarm()

### Description
Initializes a swarm instance using the provided parameters.

### Parameters
- **params** (CreateSwarmParams) - Required - Configuration object for the swarm.
```

--------------------------------

### InferAgentToolCalls Usage Example

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/InferAgentToolCalls

Extracts the tool call union type from an agent created with specific tools.

```ts
const agent = createAgent({ tools: [getWeather, search], ... });
type ToolCalls = InferAgentToolCalls<typeof agent>;
// ToolCalls is:
// | { name: "get_weather"; args: { location: string }; id?: string }
// | { name: "search"; args: { query: string }; id?: string }
```

--------------------------------

### List Namespaces with Filtering

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/index/AsyncBatchedStore/listNamespaces

Demonstrates how to list namespaces using prefix and suffix filters along with depth and limit options.

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

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

--------------------------------

### get(threadId: string, runId: string, options?: __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/RunsClient/get

Retrieves a run by its ID from the specified thread.

```APIDOC
## get(threadId: string, runId: string, options?: __type)

### Description
Retrieves a run by its ID from the specified thread.

### Parameters
- **threadId** (string) - Required - The ID of the thread.
- **runId** (string) - Required - The ID of the run.
- **options** (__type) - Optional - Additional options for the request.

### Returns
- **Promise<Run>** - The run object.
```

--------------------------------

### fromCluster(rootNodes, config)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/fromCluster

Initializes a new RedisStore instance using a Redis cluster configuration.

```APIDOC
## fromCluster

### Description
Initializes a RedisStore instance for use with a Redis cluster.

### Signature
`fromCluster(rootNodes: __type[], config?: StoreConfig): Promise<RedisStore>`

### Parameters
- **rootNodes** (__type[]) - Required - The root nodes for the cluster configuration.
- **config** (StoreConfig) - Optional - Configuration options for the Redis store.

### Returns
- **Promise<RedisStore>** - A promise that resolves to the initialized RedisStore instance.
```

--------------------------------

### createCua()

Source: https://reference.langchain.com/javascript/langchain-langgraph-cua/index

Initializes a new computer use agent instance.

```APIDOC
## createCua()

### Description
Initializes and returns a new instance of a computer use agent (CUA).
```

--------------------------------

### ResolveStreamInterface Usage

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/index/ResolveStreamInterface

Examples demonstrating how ResolveStreamInterface automatically detects the stream type based on the provided agent or graph.

```typescript
// Automatic detection based on agent type
type GraphStream = ResolveStreamInterface<typeof compiledGraph, BagTemplate>;
// → UseGraphStream (with typed node names)

type AgentStream = ResolveStreamInterface<typeof reactAgent, BagTemplate>;
// → UseAgentStream (has toolCalls)

type DeepStream = ResolveStreamInterface<typeof deepAgent, BagTemplate>;
// → UseDeepAgentStream (has toolCalls AND subagents)
```

--------------------------------

### SubagentStream Usage

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/SubagentStream

Examples of how to define a SubagentStream using either automatic agent type inference or explicit generic types.

```APIDOC
## SubagentStream

### Description
Represents a single subagent stream within the LangGraph SDK. It can be used with automatic type inference from an agent or by manually specifying state and tool call types.

### Usage
#### Agent type inference (Recommended)
```typescript
import type { agent } from "./agent";

// Automatically infers state and tool call types from the agent
const subagent: SubagentStream<typeof agent> = ...;
```

#### Explicit generics
```typescript
type ResearcherState = { research_notes: string };
const researcher: SubagentStream<ResearcherState, MyToolCall> = ...;
```
```

--------------------------------

### Import the react module

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react

The entry point for the react module in the LangGraph SDK.

```javascript
react
```

--------------------------------

### fetch<T>(path: string, options: RequestInit & __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/ThreadsClient/fetch

Performs a fetch request using the provided path and options, returning the response data and the raw Response object.

```APIDOC
## fetch<T>(path: string, options: RequestInit & __type)

### Description
Performs an HTTP request using the specified path and request options. This method is part of the ThreadsClient and returns a promise that resolves to a tuple containing the typed response data and the raw Response object.

### Signature
`fetch<T>(path: string, options: RequestInit & __type): Promise<[T, Response]>`

### Parameters
- **path** (string) - Required - The path for the request.
- **options** (RequestInit & __type) - Required - The request configuration options.

### Returns
- **Promise<[T, Response]>** - A promise that resolves to a tuple containing the response body of type T and the Response object.
```

--------------------------------

### Inferring Subagent State

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/InferSubagentState

Example usage of InferSubagentState to extract the state type of a subagent defined within a deep agent.

```ts
const agent = createDeepAgent({
  subagents: [
    { name: "researcher", middleware: [ResearchMiddleware] }
  ] as const,
});

type ResearcherState = InferSubagentState<typeof agent, "researcher">;
// ResearcherState includes { messages: Message<ToolCall>[], ...ResearchMiddleware state }
```

--------------------------------

### PostgresSaver.list(config, options)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-postgres/index/PostgresSaver/list

Retrieves a list of checkpoint tuples from the Postgres database based on the provided configuration.

```APIDOC
## list(config, options)

### Description
Retrieves a list of checkpoint tuples from the Postgres database based on the provided config. The checkpoints are returned as an AsyncGenerator and are ordered by checkpoint ID in descending order (newest first).

### Signature
`list(config: RunnableConfig, options?: any): AsyncGenerator<CheckpointTuple>`

### Parameters
- **config** (RunnableConfig) - Required - The configuration object used to filter or identify the checkpoints.
- **options** (any) - Optional - Additional options for the retrieval process.

### Returns
- **AsyncGenerator<CheckpointTuple>** - An asynchronous generator yielding checkpoint tuples.
```

--------------------------------

### getInstance()

Source: https://reference.langchain.com/javascript/langchain-langgraph-cua/utils

Retrieves the current instance.

```APIDOC
## getInstance()

### Description
Retrieves the current instance used by the module.
```

--------------------------------

### Get thread by ID signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/ThreadsClient/get

Defines the method signature for retrieving a thread, supporting optional state type parameters.

```javascript
get<ValuesType = TStateType>(threadId: string, options?: __type): Promise<Thread<ValuesType, unknown>>
```

--------------------------------

### RedisStore Constructor Signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/constructor

Initializes the RedisStore with a required Redis connection and optional configuration object.

```javascript
constructor(client: RedisConnection, config?: StoreConfig): RedisStore
```

--------------------------------

### List namespaces with prefix and depth constraints

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/index/BaseStore/listNamespaces

Filters namespaces starting with a specific prefix while limiting the depth of the returned hierarchy.

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

--------------------------------

### Usage with custom state and tool calls

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/useStream

Example of using useStream with a custom state interface and a discriminated union for tool calls.

```typescript
import { Message } from "@langchain/langgraph-sdk";

// Define your tool call types as a discriminated union
type MyToolCalls =
  | { name: "search"; args: { query: string }; id?: string }
  | { name: "calculate"; args: { expression: string }; id?: string };

// Embed tool call types in your state's messages
interface MyGraphState {
  messages: Message<MyToolCalls>[];
  context?: string;
}

function Chat() {
  const stream = useStream<MyGraphState>({
    assistantId: "my-graph",
    apiUrl: "http://localhost:2024",
  });

  // stream.values is typed as MyGraphState
  // stream.toolCalls[0].call.name is typed as "search" | "calculate"
}
```

--------------------------------

### createBatch(payloads, options)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/RunsClient/createBatch

Creates a batch of stateless background runs.

```APIDOC
## createBatch

### Description
Creates a batch of stateless background runs.

### Signature
`createBatch(payloads: Omit<RunsCreatePayload, "signal"> & __type[], options?: __type): Promise<Run[]>`

### Parameters
- **payloads** (Omit<RunsCreatePayload, "signal"> & __type[]) - Required - An array of payloads for creating runs.
- **options** (__type) - Optional - Configuration options for the batch creation.

### Returns
- **Promise<Run[]>** - An array of created runs.
```

--------------------------------

### RedisStore.fromConnString method signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/fromConnString

Defines the method signature for initializing a RedisStore from a connection string.

```javascript
fromConnString(connString: string, config?: StoreConfig): Promise<RedisStore>
```

--------------------------------

### Method Signature for prepareFetchOptions

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/AssistantsClient/prepareFetchOptions

Defines the input parameters and return type for the prepareFetchOptions method.

```javascript
prepareFetchOptions(path: string, options?: RequestInit & __type): [URL, RequestInit]
```

--------------------------------

### Configure Deep Agent Stream

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/index/UseDeepAgentStreamOptions

Demonstrates initializing a stream with DeepAgent-specific options like subagent tool names and message filtering.

```typescript
const stream = useStream<typeof agent>({
  assistantId: "deep-agent",
  apiUrl: "http://localhost:2024",

  // DeepAgent-specific options
  subagentToolNames: ["task", "delegate"],
  filterSubagentMessages: true,

  onError: (error) => console.error(error),
});
```

--------------------------------

### Accessing the client signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client

The client object serves as the main entry point for the SDK.

```javascript
client
```

--------------------------------

### GetToolCallsType<StateType>

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/GetToolCallsType

Extracts the tool call type from a StateType's messages property. This is the canonical way to get typed tool calls in useStream.

```APIDOC
## GetToolCallsType<StateType>

### Description
Extracts the tool call type from a StateType's messages property. This is the canonical way to get typed tool calls in useStream.

### Signature
`GetToolCallsType: ExtractToolCallsFromState<StateType> extends never ? DefaultToolCall : ExtractToolCallsFromState<StateType>`

### Example
```ts
type MyToolCalls =
  | { name: "get_weather"; args: { location: string }; id?: string }
  | { name: "search"; args: { query: string }; id?: string };

interface MyState {
  messages: Message<MyToolCalls>[];
}

// GetToolCallsType<MyState> = MyToolCalls
```
```

--------------------------------

### extractToolCallIdFromNamespace(namespace)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/extractToolCallIdFromNamespace

Extracts the tool call ID from a namespace path array. It looks for the first segment starting with 'tools:' and returns the ID portion.

```APIDOC
## extractToolCallIdFromNamespace

### Description
Extracts the tool call ID from a namespace path. Namespaces follow the pattern: ["tools:call_abc123", "model_request:xyz", ...]. This function extracts "call_abc123" from the first "tools:" segment.

### Signature
`extractToolCallIdFromNamespace(namespace: string[] | undefined): string | undefined`

### Parameters
- **namespace** (string[] | undefined) - Required - The namespace array from stream events.

### Returns
- **string | undefined** - The tool call ID, or undefined if not found.
```

--------------------------------

### fromCluster(rootNodes, ttlConfig)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/index/RedisSaver/fromCluster

Initializes a new RedisSaver instance using a Redis cluster configuration.

```APIDOC
## fromCluster

### Description
Initializes a RedisSaver instance for use with a Redis cluster.

### Signature
`fromCluster(rootNodes: __type[], ttlConfig?: TTLConfig): Promise<RedisSaver>`

### Parameters
- **rootNodes** (__type[]) - Required - The root nodes for the Redis cluster configuration.
- **ttlConfig** (TTLConfig) - Optional - Configuration for Time-To-Live settings.

### Returns
- **Promise<RedisSaver>** - A promise that resolves to an instance of RedisSaver.
```

--------------------------------

### list(config, options)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/index/RedisSaver/list

Retrieves a list of checkpoints from the Redis store.

```APIDOC
## list(config, options)

### Description
Retrieves a list of checkpoints from the Redis store as an asynchronous generator.

### Signature
`list(config: RunnableConfig<Record<string, any>> | null, options?: CheckpointListOptions & __type): AsyncGenerator<CheckpointTuple>`

### Parameters
- **config** (RunnableConfig<Record<string, any>> | null) - Required - The configuration for the retrieval.
- **options** (CheckpointListOptions & __type) - Optional - Additional options for listing checkpoints.

### Returns
- **AsyncGenerator<CheckpointTuple>** - An asynchronous generator yielding checkpoint tuples.
```

--------------------------------

### Rendering Tool Calls in React

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/UseAgentStream/getToolCalls

Example of using getToolCalls within a map function to render tool calls alongside AI messages in a React component.

```typescript
messages.map(message => {
  if (message.type === "ai") {
    const calls = stream.getToolCalls(message);
    return (
      <>
        <MessageBubble message={message} />
        {calls.map(tc => <ToolCallCard key={tc.call.id} {...tc} />)}
      </>
    );
  }
  return <MessageBubble message={message} />;
});
```

--------------------------------

### fromUrl(url: string, ttlConfig?: TTLConfig)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/shallow/ShallowRedisSaver/fromUrl

Initializes a new ShallowRedisSaver instance using the provided Redis URL and optional TTL configuration.

```APIDOC
## fromUrl

### Description
Initializes a new `ShallowRedisSaver` instance from a Redis connection URL.

### Signature
`fromUrl(url: string, ttlConfig?: TTLConfig): Promise<ShallowRedisSaver>`

### Parameters
- **url** (string) - Required - The Redis connection URL.
- **ttlConfig** (TTLConfig) - Optional - Configuration for time-to-live settings.

### Returns
- **Promise<ShallowRedisSaver>** - A promise that resolves to an instance of `ShallowRedisSaver`.
```

--------------------------------

### RedisStore.fromCluster Method Signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/fromCluster

Defines the static method signature for initializing a RedisStore from a cluster configuration.

```javascript
fromCluster(rootNodes: __type[], config?: StoreConfig): Promise<RedisStore>
```

--------------------------------

### experimental_loadShare(name: string, module: unknown)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react-ui/experimental_loadShare

Loads a shared module by name.

```APIDOC
## experimental_loadShare

### Description
Loads a shared module into the application context.

### Signature
`experimental_loadShare(name: string, module: unknown): void`

### Parameters
- **name** (string) - Required - The name of the module to load.
- **module** (unknown) - Required - The module object to be loaded.

### Returns
- **void** - This function does not return a value.
```

--------------------------------

### constructor()

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/react/FetchStreamTransport

Initializes a new instance of the FetchStreamTransport class.

```APIDOC
## constructor()

### Description
Creates an instance of FetchStreamTransport for handling thread event streams.

### Signature
`new FetchStreamTransport()`
```

--------------------------------

### Initialize BaseCache

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint/index/BaseCache/constructor

The constructor accepts an optional SerializerProtocol to handle data serialization.

```javascript
constructor<V = unknown>(serde?: SerializerProtocol): BaseCache<V>
```

--------------------------------

### Initialize ShallowRedisSaver from URL

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/shallow/ShallowRedisSaver/fromUrl

Creates a ShallowRedisSaver instance using a connection string and optional TTL configuration.

```javascript
fromUrl(url: string, ttlConfig?: TTLConfig): Promise<ShallowRedisSaver>
```

--------------------------------

### listTests<T>(initializer)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-validation/index/listTests

Exercises the list method of the checkpointer. This test relies on the getTuple method functioning properly.

```APIDOC
## listTests

### Description
Exercises the `list` method of the checkpointer. Note that this test relies on the `getTuple` method of the checkpointer functioning properly.

### Signature
`listTests<T extends BaseCheckpointSaver<number>>(initializer: CheckpointSaverTestInitializer<T>)`

### Parameters
- **initializer** (CheckpointSaverTestInitializer<T>) - Required - The initializer for the checkpointer.

### Returns
- **void**
```

--------------------------------

### list(config: RunnableConfig, options?: any)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-sqlite/SqliteSaver/list

Retrieves checkpoints from the SQLite database based on the provided configuration.

```APIDOC
## list(config: RunnableConfig, options?: any)

### Description
Retrieves a list of checkpoints from the SQLite database as an asynchronous generator.

### Signature
`list(config: RunnableConfig, options?: any): AsyncGenerator<CheckpointTuple>`

### Parameters
- **config** (RunnableConfig) - Required - The configuration for the retrieval.
- **options** (any) - Optional - Additional options for the operation.

### Returns
- **AsyncGenerator<CheckpointTuple>** - An asynchronous generator yielding checkpoint tuples.
```

--------------------------------

### getScrapybaraClient(apiKey: string)

Source: https://reference.langchain.com/javascript/langchain-langgraph-cua/utils/getScrapybaraClient

Initializes a Scrapybara client using the provided API key.

```APIDOC
## getScrapybaraClient(apiKey: string)

### Description
Retrieves a Scrapybara client instance using the provided API key from the configuration.

### Signature
`getScrapybaraClient(apiKey: string): ScrapybaraClient`

### Parameters
- **apiKey** (string) - Required - The API key for Scrapybara.

### Returns
- **ScrapybaraClient** - The initialized Scrapybara client.
```

--------------------------------

### getVersions(assistantId: string, payload?: __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/AssistantsClient/getVersions

Retrieves a list of all versions for a given assistant.

```APIDOC
## getVersions

### Description
List all versions of an assistant.

### Signature
`getVersions(assistantId: string, payload?: __type): Promise<AssistantVersion[]>`

### Parameters
- **assistantId** (string) - Required - ID of the assistant.
- **payload** (__type) - Optional

### Returns
- **Promise<AssistantVersion[]>** - List of assistant versions.
```

--------------------------------

### PostgresSaver.fromConnString(connString, options)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-postgres/index/PostgresSaver/fromConnString

Creates a new instance of PostgresSaver from a connection string.

```APIDOC
## PostgresSaver.fromConnString

### Description
Creates a new instance of PostgresSaver from a connection string.

### Signature
`fromConnString(connString: string, options?: Partial<PostgresSaverOptions>): PostgresSaver`

### Parameters
- **connString** (string) - Required - The connection string to connect to the Postgres database.
- **options** (Partial<PostgresSaverOptions>) - Optional - Optional configuration object.

### Returns
- **PostgresSaver** - A new instance of PostgresSaver.

### Example
```ts
const connString = "postgresql://user:password@localhost:5432/db";
const checkpointer = PostgresSaver.fromConnString(connString, {
 schema: "custom_schema" // defaults to "public"
});
await checkpointer.setup();
```
```

--------------------------------

### SqliteSaver.fromConnString(connStringOrLocalPath: string)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-sqlite/SqliteSaver/fromConnString

Initializes a new SqliteSaver instance from a provided connection string or local file path.

```APIDOC
## fromConnString

### Description
Initializes a SqliteSaver instance using a connection string or a local file path.

### Signature
`fromConnString(connStringOrLocalPath: string): SqliteSaver`

### Parameters
- **connStringOrLocalPath** (string) - Required - The connection string or local path to the SQLite database.

### Returns
- **SqliteSaver** - An instance of the SqliteSaver class.
```

--------------------------------

### CLI Signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-validation/cli

The entry point signature for the CLI module.

```javascript
cli
```

--------------------------------

### getItem(namespace: string[], key: string, options?: __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/StoreClient/getItem

Retrieves a single item from the store based on the provided namespace and key.

```APIDOC
## getItem

### Description
Retrieve a single item from the store.

### Signature
`getItem(namespace: string[], key: string, options?: __type): Promise<Item | null>`

### Parameters
- **namespace** (string[]) - Required - A list of strings representing the namespace path.
- **key** (string) - Required - The unique identifier for the item.
- **options** (__type) - Optional - Additional configuration options.

### Returns
- **Promise<Item | null>** - A promise that resolves to the requested item or null if not found.

### Example
```typescript
const item = await client.store.getItem(
  ["documents", "user123"],
  "item456",
  { refreshTtl: true }
);
console.log(item);
```
```

--------------------------------

### create(threadId, assistantId, payload)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/RunsClient/create

Creates a new run for a specified thread and assistant.

```APIDOC
## create(threadId, assistantId, payload)

### Description
Creates a new run. This method initiates a run process associated with a specific thread and assistant.

### Signature
`create(threadId: string | null, assistantId: string, payload?: RunsCreatePayload): Promise<Run>`

### Parameters
- **threadId** (string | null) - Required - The ID of the thread.
- **assistantId** (string) - Required - Assistant ID to use for this run.
- **payload** (RunsCreatePayload) - Optional - Payload for creating a run.

### Returns
- **Promise<Run>** - The created run object.
```

--------------------------------

### createSwarm<AnnotationRootT>(agents)

Source: https://reference.langchain.com/javascript/langchain-langgraph-swarm/index/createSwarm

Initializes a multi-agent swarm using the provided agent parameters.

```APIDOC
## createSwarm

### Description
Creates a multi-agent swarm based on the provided configuration.

### Signature
`createSwarm<AnnotationRootT extends AnnotationRoot<any> = any>(agents: CreateSwarmParams<AnnotationRootT>): StateGraph<...>`

### Parameters
- **agents** (CreateSwarmParams<AnnotationRootT>) - Required - List of agents to add to the swarm.

### Returns
- **StateGraph** - A multi-agent swarm StateGraph.
```

--------------------------------

### AssistantsClient Methods

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/AssistantsClient

The AssistantsClient provides various methods to interact with assistants, including creation, deletion, searching, and fetching details or schemas.

```APIDOC
## AssistantsClient Methods

### count()
Returns the count of assistants.

### create()
Creates a new assistant.

### delete()
Deletes an existing assistant.

### fetch()
Fetches a list of assistants.

### get()
Retrieves details for a specific assistant.

### getGraph()
Retrieves the graph definition for an assistant.

### getSchemas()
Retrieves the schemas associated with an assistant.

### getSubgraphs()
Retrieves subgraphs associated with an assistant.

### getVersions()
Retrieves version history for an assistant.

### search()
Searches for assistants based on criteria.

### setLatest()
Sets a specific version as the latest for an assistant.

### update()
Updates an existing assistant.
```

--------------------------------

### getConfigurationWithDefaults(config: LangGraphRunnableConfig)

Source: https://reference.langchain.com/javascript/langchain-langgraph-cua/types/getConfigurationWithDefaults

Retrieves the configuration with default values applied.

```APIDOC
## getConfigurationWithDefaults

### Description
Gets the configuration with default values applied based on the provided input.

### Signature
`getConfigurationWithDefaults(config: LangGraphRunnableConfig): any`

### Parameters
- **config** (LangGraphRunnableConfig) - Required - The configuration to use.

### Returns
- **any** - The configuration with default values.
```

--------------------------------

### PostgresSaver Constructor Signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-postgres/index/PostgresSaver/constructor

Defines the initialization parameters for the PostgresSaver class.

```javascript
constructor(pool: Pool, serde?: any, options?: Partial<PostgresSaverOptions>): PostgresSaver
```

--------------------------------

### RedisSaver.fromCluster Method Signature

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/index/RedisSaver/fromCluster

Defines the method signature for initializing a RedisSaver from a cluster configuration.

```javascript
fromCluster(rootNodes: __type[], ttlConfig?: TTLConfig): Promise<RedisSaver>
```

--------------------------------

### search(namespacePrefix: string[], options?: __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/search

Searches for items in the Redis store using a specified namespace prefix.

```APIDOC
## search(namespacePrefix: string[], options?: __type)

### Description
Searches for items in the Redis store based on a provided namespace prefix.

### Signature
`search(namespacePrefix: string[], options?: __type): Promise<SearchItem[]>`

### Parameters
- **namespacePrefix** (string[]) - Required - The prefix of the namespace to search within.
- **options** (__type) - Optional - Additional search options.

### Returns
- **Promise<SearchItem[]>** - A promise that resolves to an array of search results.
```

--------------------------------

### createHandoffBackMessages(agentName: string, supervisorName: string)

Source: https://reference.langchain.com/javascript/langchain-langgraph-supervisor/handoff/createHandoffBackMessages

Creates the necessary messages to signal a handoff back to the supervisor.

```APIDOC
## createHandoffBackMessages

### Description
Generates an AIMessage and a ToolMessage to handle the transition of control back to a supervisor agent.

### Signature
`createHandoffBackMessages(agentName: string, supervisorName: string): [AIMessage, ToolMessage]`

### Parameters
- **agentName** (string) - Required - The name of the agent performing the handoff.
- **supervisorName** (string) - Required - The name of the supervisor agent receiving the handoff.

### Returns
- **[AIMessage, ToolMessage]** - A tuple containing the AI message and the tool message for the handoff.
```

--------------------------------

### create(payload: __type): Promise<Assistant>

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/AssistantsClient/create

Creates a new assistant using the provided payload.

```APIDOC
## create(payload: __type)

### Description
Creates a new assistant.

### Parameters
- **payload** (__type) - Required - Payload for creating an assistant.

### Returns
- **Promise<Assistant>** - The created assistant.
```

--------------------------------

### listNamespaces(options?: __type): Promise<string[][]>

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-redis/store/RedisStore/listNamespaces

Retrieves a list of namespaces from the Redis store.

```APIDOC
## listNamespaces

### Description
Retrieves a list of namespaces from the Redis store.

### Signature
`listNamespaces(options?: __type): Promise<string[][]>`

### Parameters
- **options** (__type) - Optional - Configuration options for the request.

### Returns
- **Promise<string[][]>** - A promise that resolves to an array of namespace arrays.
```

--------------------------------

### put(config, checkpoint, metadata, newVersions)

Source: https://reference.langchain.com/javascript/langchain-langgraph-checkpoint-postgres/index/PostgresSaver/put

Saves a checkpoint to the Postgres database.

```APIDOC
## put(config, checkpoint, metadata, newVersions)

### Description
Saves a checkpoint to the Postgres database. The checkpoint is associated with the provided config and its parent config (if any).

### Signature
`put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata, newVersions: ChannelVersions): Promise<RunnableConfig<Record<string, any>>>`

### Parameters
- **config** (RunnableConfig) - Required
- **checkpoint** (Checkpoint) - Required
- **metadata** (CheckpointMetadata) - Required
- **newVersions** (ChannelVersions) - Required

### Returns
- **Promise<RunnableConfig<Record<string, any>>>**
```

--------------------------------

### searchItems(namespacePrefix: string[], options?: __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/StoreClient/searchItems

Searches for items within a namespace prefix. Returns a promise that resolves to a SearchItemsResponse.

```APIDOC
## searchItems

### Description
Search for items within a namespace prefix.

### Signature
`searchItems(namespacePrefix: string[], options?: __type): Promise<SearchItemsResponse>`

### Parameters
- **namespacePrefix** (string[]) - Required - List of strings representing the namespace prefix.
- **options** (__type) - Optional - Configuration options for the search.

### Returns
- **Promise<SearchItemsResponse>** - A promise that resolves to the search results.

### Example
```typescript
const results = await client.store.searchItems(
  ["documents"],
  {
    filter: { author: "John Doe" },
    limit: 5,
    refreshTtl: true
  }
);
```
```

--------------------------------

### listNamespaces(options?: __type)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/StoreClient/listNamespaces

Retrieves a list of namespaces from the store. This method returns a promise that resolves to a ListNamespaceResponse.

```APIDOC
## listNamespaces

### Description
List namespaces with optional match conditions.

### Signature
`listNamespaces(options?: __type): Promise<ListNamespaceResponse>`

### Parameters
- **options** (__type) - Optional - Configuration options for listing namespaces.

### Returns
- **Promise<ListNamespaceResponse>** - A promise that resolves to the list of namespaces.
```

--------------------------------

### putItem(namespace, key, value, options)

Source: https://reference.langchain.com/javascript/langchain-langgraph-sdk/client/StoreClient/putItem

Stores or updates an item in the store using a namespace path, a unique key, and the item data.

```APIDOC
## putItem(namespace: string[], key: string, value: Record<string, unknown>, options?: __type)

### Description
Stores or updates an item within the store. This method is part of the StoreClient in the @langchain/langgraph-sdk.

### Parameters
- **namespace** (string[]) - Required - A list of strings representing the namespace path.
- **key** (string) - Required - The unique identifier for the item within the namespace.
- **value** (Record<string, unknown>) - Required - A dictionary containing the item's data.
- **options** (__type) - Optional - Additional configuration options.

### Returns
- **Promise<void>** - A promise that resolves when the operation is complete.

### Example
```typescript
await client.store.putItem(
  ["documents", "user123"],
  "item456",
  { title: "My Document", content: "Hello World" },
  { ttl: 60 } // expires in 60 minutes
);
```
```
Tokens:
Raw