LangGraph Python

https://reference.langchain.com/python/langgraph
Admin
LangGraph Python is a framework for building stateful, agentic applications with language models...
Tokens:413,806
Snippets:3,836
Trust Score:9.5
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Example output of get

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/assistants/SyncAssistantsClient/get

The printed output of the example usage, showing the assistant object with its fields such as `assistant_id`, `graph_id`, `created_at`, `updated_at`, `config`, `context`, and `metadata`.

```shell
----------------------------------------------------

{
    'assistant_id': 'my_assistant_id',
    'graph_id': 'agent',
    'created_at': '2024-06-25T17:10:33.109781+00:00',
    'updated_at': '2024-06-25T17:10:33.109781+00:00',
    'config': {},
    'context': {},
    'metadata': {'created_by': 'system'}
}
```

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

### Example usage of get

Source: https://reference.langchain.com/python/langgraph-sdk/_async/runs/RunsClient/get

Example showing how to use the `get` method with a client obtained from `get_client`. It retrieves a run by specifying the thread ID and run ID.

```python
client = get_client(url="http://localhost:2024")
run = await client.runs.get(
    thread_id="thread_id_to_delete",
    run_id="run_id_to_delete",
)
```

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

### Example usage of get

Source: https://reference.langchain.com/python/langgraph-sdk/_async/threads/ThreadsClient/get

Example usage of the get method. It creates a client, retrieves a thread by ID, and prints the thread object. The output shows the thread details including metadata.

```python
client = get_client(url="http://localhost:2024")
thread = await client.threads.get(
    thread_id="my_thread_id"
)
print(thread)
```

```shell
-----------------------------------------------------

{
    'thread_id': 'my_thread_id',
    'created_at': '2024-07-18T18:35:15.540834+00:00',
    'updated_at': '2024-07-18T18:35:15.540834+00:00',
    'metadata': {'graph_id': 'agent'}
}
```

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

### Example output of get

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/threads/SyncThreadsClient/get

Example output from the `get` method, showing the structure of the returned thread object. The output includes the thread ID, creation and update timestamps, and metadata.

```shell
-----------------------------------------------------

{
    'thread_id': 'my_thread_id',
    'created_at': '2024-07-18T18:35:15.540834+00:00',
    'updated_at': '2024-07-18T18:35:15.540834+00:00',
    'metadata': {'graph_id': 'agent'}
}
```

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

### Output of get assistant

Source: https://reference.langchain.com/python/langgraph-sdk/_async/assistants/AssistantsClient/get

Example output of the get method, showing the assistant object with its fields.

```shell
----------------------------------------------------

{
    'assistant_id': 'my_assistant_id',
    'graph_id': 'agent',
    'created_at': '2024-06-25T17:10:33.109781+00:00',
    'updated_at': '2024-06-25T17:10:33.109781+00:00',
    'config': {},
    'metadata': {'created_by': 'system'},
    'version': 1,
    'name': 'my_assistant'
}
```

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

### start

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/stream/SyncRunModule/start

Documentation for the `start` method in the `SyncRunModule` class of the `langgraph_sdk` Python package.

```APIDOC
## `start`

### Description
Sends a `run.start` message to the server and returns the result containing the run ID.

### Method
`start`

### Signature
```python
start(
    self,
    *,
    input: Any = None,
    config: dict[str, Any] | None = None,
    metadata: dict[str, Any] | None = None,
    langsmith_tracing: LangSmithTracing | None = None,
) -> dict[str, Any]
```

### Parameters
#### Keyword Arguments
- **input** (`Any`) - Optional - The input to the run.
- **config** (`dict[str, Any] | None`) - Optional - Configuration for the run.
- **metadata** (`dict[str, Any] | None`) - Optional - Metadata for the run.
- **langsmith_tracing** (`LangSmithTracing | None`) - Optional - LangSmith tracing configuration.

### Returns
- **dict[str, Any]** - The result containing the run ID, e.g., `{"run_id": ...}`.
```

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

### Example usage and output

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/store/SyncStoreClient/get_item

Example of retrieving an item from the store and printing it, followed by the expected output.

```python
client = get_sync_client(url="http://localhost:8123")
item = client.store.get_item(
    ["documents", "user123"],
    key="item456",
)
print(item)
```

```shell
----------------------------------------------------------------

{
    'namespace': ['documents', 'user123'],
    'key': 'item456',
    'value': {'title': 'My Document', 'content': 'Hello World'},
    'created_at': '2024-07-30T12:00:00Z',
    'updated_at': '2024-07-30T12:00:00Z'
}
```

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

### Get assistant by ID example

Source: https://reference.langchain.com/python/langgraph-sdk/_async/assistants/AssistantsClient/get

Example usage of the get method to retrieve an assistant by ID and print the result.

```python
assistant = await client.assistants.get(
    assistant_id="my_assistant_id"
)
print(assistant)
```

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

### langgraph.json configuration example

Source: https://reference.langchain.com/python/langgraph-sdk/auth/Auth

Example configuration file that sets up the Auth class by specifying the path to the auth file in the 'auth' key.

```json
{
  "dependencies": ["."],
  "graphs": {
    "agent": "./my_agent/agent.py:graph"
  },
  "env": ".env",
  "auth": {
    "path": "./auth.py:my_auth"
  }
}
```

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

### Example usage of client.assistants.get

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/assistants/SyncAssistantsClient/get

Example showing how to call `client.assistants.get` with an `assistant_id` and print the returned assistant object.

```python
assistant = client.assistants.get(
    assistant_id="my_assistant_id"
)
print(assistant)
```

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

### AssistantsCreate example payload

Source: https://reference.langchain.com/python/langgraph-sdk/auth/types/AssistantsCreate

Example payload for creating an assistant, showing all fields of the AssistantsCreate TypedDict.

```python
create_params = {
    "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
    "graph_id": "graph123",
    "config": {"tags": ["tag1", "tag2"]},
    "context": {"key": "value"},
    "metadata": {"owner": "user123"},
    "if_exists": "do_nothing",
    "name": "Assistant 1"
}
```

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

### Example usage of copy

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/threads/SyncThreadsClient/copy

Example of how to use the copy method with a sync client.

```python
client = get_sync_client(url="http://localhost:2024")
client.threads.copy(
    thread_id="my_thread_id"
)
```

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

### Example usage

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/cron/SyncCronClient/create_for_thread

Example of how to use create_for_thread to create a cron job for a thread.

```python
client = get_sync_client(url="http://localhost:8123")
cron_run = client.crons.create_for_thread(
    thread_id="my-thread-id",
    assistant_id="agent",
    schedule="27 15 * * *",
    input={"messages": [{"role": "user", "content": "hello!"}]},
    metadata={"name":"my_run"},
    context={"model_name": "openai"},
    interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
    interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
    webhook="https://my.fake.webhook.com",
    multitask_strategy="interrupt",
    enabled=True
)
```

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

### Example: Constructing CronsSearch parameters

Source: https://reference.langchain.com/python/langgraph-sdk/auth/types/CronsSearch

Shows how to build a search_params dictionary with assistant_id, thread_id, limit, and offset. The UUIDs are provided as examples.

```python
search_params = {
    "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
    "thread_id": UUID("123e4567-e89b-12d3-a456-426614174001"),
    "limit": 10,
    "offset": 0
}
```

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

### Example: allowed_json_modules True

Source: https://reference.langchain.com/python/langgraph-cli/schemas/SerdeConfig/allowed_json_modules

Configuration example showing how to allow any module to be deserialized by setting the attribute to True.

```json
{
    "serde": {
        "allowed_json_modules": True
    }
}
```

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

### Example output of search

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/cron/SyncCronClient/search

Example output from the `search` method, showing a list of cron job dictionaries.

```shell
----------------------------------------------------------

[
    {
        'cron_id': '1ef3cefa-4c09-6926-96d0-3dc97fd5e39b',
        'assistant_id': 'my_assistant_id',
        'thread_id': 'my_thread_id',
        'user_id': None,
        'payload':
            {
                'input': {'start_time': ''},
                'schedule': '4 * * * *',
                'assistant_id': 'my_assistant_id'
            },
        'schedule': '4 * * * *',
        'next_run_date': '2024-07-25T17:04:00+00:00',
        'end_time': None,
        'created_at': '2024-07-08T06:02:23.073257+00:00',
        'updated_at': '2024-07-08T06:02:23.073257+00:00'
    }
]
```

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

### Example: allowed_json_modules list

Source: https://reference.langchain.com/python/langgraph-cli/schemas/SerdeConfig/allowed_json_modules

Configuration example showing how to allow deserialization of a custom type from the module my_agent.my_file. Only the specified modules are allowed.

```json
{
    "serde": {
        "allowed_json_modules": [
            ["my_agent", "my_file", "SomeType"],
        ]
    }
}
```

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

### Example usage of join

Source: https://reference.langchain.com/python/langgraph-sdk/_async/runs/RunsClient/join

Example usage of the `join` method, showing how to call it with `thread_id` and `run_id` to block until the run completes.

```python
client = get_client(url="http://localhost:2024")
result =await client.runs.join(
    thread_id="thread_id_to_join",
    run_id="run_id_to_join"
)
```

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

### StoreClient usage example

Source: https://reference.langchain.com/python/langgraph-sdk/_async/store/StoreClient

Shows how to instantiate a client and store an item in the shared store. The example uses get_client to connect to a local server and put_item to persist a key-value pair with a namespace, key, and value.

```python
client = get_client(url="http://localhost:2024")
await client.store.put_item(["users", "user123"], "mem-123451342", {"name": "Alice", "score": 100})
```

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

### Example usage of get

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/runs/SyncRunsClient/get

Example usage of the get method to retrieve a run by thread ID and run ID.

```python
run = client.runs.get(
    thread_id="thread_id_to_delete",
    run_id="run_id_to_delete",
)
```

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

### Example usage of get

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/threads/SyncThreadsClient/get

Example of how to use the `get` method to retrieve a thread by its ID. The example creates a sync client and calls `threads.get` with a thread ID, then prints the returned thread object.

```python
client = get_sync_client(url="http://localhost:2024")
thread = client.threads.get(
    thread_id="my_thread_id"
)
print(thread)
```

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

### Example Usage: Creating an Assistant

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/assistants/SyncAssistantsClient/create

Example of how to create an assistant using the create method. It shows how to set the graph_id, context, metadata, assistant_id, if_exists, and name parameters. The client is obtained via get_sync_client.

```python
client = get_sync_client(url="http://localhost:2024")
assistant = client.assistants.create(
    graph_id="agent",
    context={"model_name": "openai"},
    metadata={"number":1},
    assistant_id="my-assistant-id",
    if_exists="do_nothing",
    name="my_name"
)
```

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

### Entrypoint.__init__

Source: https://reference.langchain.com/python/langgraph/func/entrypoint

Documentation for the Entrypoint class constructor and its properties.

```APIDOC
## Entrypoint

### Description
Creates a new Entrypoint instance with optional checkpointer, store, cache, context schema, cache policy, retry policy, and timeout settings.

### Constructor
```python
__init__(
    self,
    checkpointer: BaseCheckpointSaver | None = None,
    store: BaseStore | None = None,
    cache: BaseCache | None = None,
    context_schema: type[ContextT] | None = None,
    cache_policy: CachePolicy | None = None,
    retry_policy: RetryPolicy | Sequence[RetryPolicy] | None = None,
    timeout: float | timedelta | TimeoutPolicy | None = None,
    **kwargs: Unpack[DeprecatedKwargs] = {},
) -> None
```

### Parameters
- `checkpointer` (BaseCheckpointSaver | None) - Optional - Checkpoint saver for persistence.
- `store` (BaseStore | None) - Optional - Store for state management.
- `cache` (BaseCache | None) - Optional - Cache for memoization.
- `context_schema` (type[ContextT] | None) - Optional - Schema for context type.
- `cache_policy` (CachePolicy | None) - Optional - Policy for caching.
- `retry_policy` (RetryPolicy | Sequence[RetryPolicy] | None) - Optional - Policy for retries.
- `timeout` (float | timedelta | TimeoutPolicy | None) - Optional - Timeout for execution.

### Properties
- `checkpointer` - Returns the checkpointer.
- `store` - Returns the store.
- `cache` - Returns the cache.
- `cache_policy` - Returns the cache policy.
- `retry_policy` - Returns the retry policy.
- `timeout` - Returns the timeout.
- `context_schema` - Returns the context schema.
```

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

### Example usage of client.crons.create

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/cron/SyncCronClient/create

Example showing how to create a cron run using the sync client. It sets the assistant ID, schedule, input, metadata, context, and various options like checkpointing, interrupts, webhook, multitask strategy, and enabled flag.

```python
client = get_sync_client(url="http://localhost:8123")
cron_run = client.crons.create(
    assistant_id="agent",
    schedule="27 15 * * *",
    input={"messages": [{"role": "user", "content": "hello!"}]},
    metadata={"name":"my_run"},
    context={"model_name": "openai"},
    checkpoint_during=True,
    interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
    interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
    webhook="https://my.fake.webhook.com",
    multitask_strategy="interrupt",
    enabled=True
)
```

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

### Awaiting run.output()

Source: https://reference.langchain.com/python/langgraph/stream/run_stream/AsyncGraphRunStream/output

Example of awaiting the output() method to get the final state.

```python
output = await run.output()
```

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

### Example: Using SyncStoreClient to put an item

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/store/SyncStoreClient

Shows how to create a sync client and store an item in a namespaced hierarchy. The example uses get_sync_client with a local server URL and calls put_item with a namespace, key, and value.

```python
client = get_sync_client(url="http://localhost:2024"))
client.store.put_item(["users", "profiles"], "user123", {"name": "Alice", "age": 30})
```

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

### dockerfile_lines example

Source: https://reference.langchain.com/python/langgraph-cli/schemas/Config/dockerfile_lines

Example usage of the dockerfile_lines attribute in a LangGraph CLI configuration. It appends additional Docker instructions to the base Dockerfile, useful for installing OS packages or setting environment variables.

```python
dockerfile_lines=[
    "RUN apt-get update && apt-get install -y libmagic-dev",
    "ENV MY_CUSTOM_VAR=hello_world"
]
```

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

### Create and run a supervisor with two agents

Source: https://reference.langchain.com/python/langgraph-supervisor/supervisor/create_supervisor

Complete example of creating a supervisor workflow with two specialized agents (math and research) and running it. Shows how to define tools, create agents with create_react_agent, pass them to create_supervisor, compile, and invoke with a user message.

```python
from langchain_openai import ChatOpenAI

from langgraph_supervisor import create_supervisor
from langgraph.prebuilt import create_react_agent

# Create specialized agents

def add(a: float, b: float) -> float:
    '''Add two numbers.'''
    return a + b

def web_search(query: str) -> str:
    '''Search the web for information.'''
    return 'Here are the headcounts for each of the FAANG companies in 2024...'

math_agent = create_react_agent(
    model="openai:gpt-4o",
    tools=[add],
    name="math_expert",
)

research_agent = create_react_agent(
    model="openai:gpt-4o",
    tools=[web_search],
    name="research_expert",
)

# Create supervisor workflow
workflow = create_supervisor(
    [research_agent, math_agent],
    model=ChatOpenAI(model="gpt-4o"),
)

# Compile and run
app = workflow.compile()
result = app.invoke({
    "messages": [
        {
            "role": "user",
            "content": "what's the combined headcount of the FAANG companies in 2024?"
        }
    ]
})
```

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

### Stream a run with RunsClient.stream

Source: https://reference.langchain.com/python/langgraph-sdk/_async/runs/RunsClient/stream

Starts a run and asynchronously iterates over stream parts. The example passes a thread_id of None, an assistant_id, input messages, and configures stream_mode, metadata, context, interrupt_before/after, feedback_keys, webhook, and multitask_strategy. The output shows StreamPart objects for metadata, values, and end events.

```python
client = get_client(url="http://localhost:2024)
async for chunk in client.runs.stream(
    thread_id=None,
    assistant_id="agent",
    input={"messages": [{"role": "user", "content": "how are you?"}]},
    stream_mode=["values","debug"],
    metadata={"name":"my_run"},
    context={"model_name": "anthropic"},
    interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
    interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
    feedback_keys=["my_feedback_key_1","my_feedback_key_2"],
    webhook="https://my.fake.webhook.com",
    multitask_strategy="interrupt"
):
    print(chunk)
```

```shell

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

StreamPart(event='metadata', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2'})
StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}]})
StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}, {'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]})
StreamPart(event='end', data=None)
```

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

### Using entrypoint and tasks

Source: https://reference.langchain.com/python/langgraph/func/entrypoint

Complete example of using `@entrypoint` with a checkpointer and `@task`. It shows how to interrupt for human review, resume with `Command(resume=...)`, and stream results. The task result is cached by the checkpointer, so it is not re-executed on resume.

```python
import time

from langgraph.func import entrypoint, task
from langgraph.types import interrupt, Command
from langgraph.checkpoint.memory import InMemorySaver

@task
def compose_essay(topic: str) -> str:
    time.sleep(1.0)  # Simulate slow operation
    return f"An essay about {topic}"

@entrypoint(checkpointer=InMemorySaver())
def review_workflow(topic: str) -> dict:
    """Manages the workflow for generating and reviewing an essay.

    The workflow includes:
    1. Generating an essay about the given topic.
    2. Interrupting the workflow for human review of the generated essay.

    Upon resuming the workflow, compose_essay task will not be re-executed
    as its result is cached by the checkpointer.

    Args:
        topic: The subject of the essay.

    Returns:
        dict: A dictionary containing the generated essay and the human review.
    """
    essay_future = compose_essay(topic)
    essay = essay_future.result()
    human_review = interrupt({
        "question": "Please provide a review",
        "essay": essay
    })
    return {
        "essay": essay,
        "review": human_review,
    }

# Example configuration for the workflow
config = {
    "configurable": {
        "thread_id": "some_thread"
    }
}

# Topic for the essay
topic = "cats"

# Stream the workflow to generate the essay and await human review
for result in review_workflow.stream(topic, config):
    print(result)

# Example human review provided after the interrupt
human_review = "This essay is great."

# Resume the workflow with the provided human review
for result in review_workflow.stream(Command(resume=human_review), config):
    print(result)
```

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

### Python example: create a background run with common options

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/runs/SyncRunsClient/create

Shows a minimal client creation and a call to create with common options: input, metadata, context, interrupt nodes, webhook, and multitask strategy. Assumes a running LangGraph server at localhost:2024.

```python
client = get_sync_client(url="http://localhost:2024")
background_run = client.runs.create(
    thread_id="my_thread_id",
    assistant_id="my_assistant_id",
    input={"messages": [{"role": "user", "content": "hello!"}]},
    metadata={"name":"my_run"},
    context={"model_name": "openai"},
    interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
    interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
    webhook="https://my.fake.webhook.com",
    multitask_strategy="interrupt"
)
print(background_run)
```

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

### get

Source: https://reference.langchain.com/python/langgraph/channels/delta/DeltaChannel/get

Documentation for the get method of the DeltaChannel class.

```APIDOC
## get

### Description
Retrieves the current value of the DeltaChannel.

### Method
`get`

### Signature
```python
get(
    self,
) -> Any
```

### Parameters
- **self** - The instance of the DeltaChannel.

### Returns
- **Any** - The current value of the channel.
```

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

### Example usage of create()

Source: https://reference.langchain.com/python/langgraph-sdk/_async/threads/ThreadsClient/create

Example usage of the create method. It creates a client, then awaits the create call with metadata, a custom thread ID, and the if_exists behavior set to 'raise'.

```python
client = get_client(url="http://localhost:2024")
thread = await client.threads.create(
    metadata={"number":1},
    thread_id="my-thread-id",
    if_exists="raise"
)
```

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

### Example usage of delete

Source: https://reference.langchain.com/python/langgraph-sdk/_async/threads/ThreadsClient/delete

Example of deleting a thread by ID using the client. Note: the URL in the example appears to be missing a closing quote, but it is shown as-is.

```python
client = get_client(url="http://localhost2024)
await client.threads.delete(
    thread_id="my_thread_id"
)
```

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

### get

Source: https://reference.langchain.com/python/langgraph/managed/is_last_step/RemainingStepsManager/get

Documentation for the get method of the RemainingStepsManager class in langgraph.

```APIDOC
## get

### Description
Retrieves the remaining steps count from the scratchpad.

### Method
N/A (Python method)

### Endpoint
N/A (Python method)

### Parameters
#### Parameters
- **scratchpad** (PregelScratchpad) - Required - The scratchpad containing the remaining steps information.

### Request Example
N/A

### Response
#### Success Response
- **int** - The number of remaining steps.

#### Response Example
N/A
```

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

### Create sync client and get assistant

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/client/SyncLangGraphClient

Shows how to create a synchronous client and fetch an assistant by ID. The client is created with get_sync_client and the assistant is retrieved using the assistants.get method.

```python
client = get_sync_client(url="http://localhost:2024")
assistant = client.assistants.get("asst_123")
```

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

### get()

Source: https://reference.langchain.com/python/langgraph/channels/base/BaseChannel/get

Documentation for the get method of the BaseChannel class in langgraph.

```APIDOC
## get()

### Description
Returns the current value of the channel. Raises `EmptyChannelError` if the channel is empty (never updated yet).

### Method
`get`

### Signature
```python
get(
    self,
) -> Value
```

### Parameters
None

### Returns
- **Value** - The current value of the channel.

### Errors
- **EmptyChannelError** - Raised if the channel is empty (never updated yet).

```

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

### get

Source: https://reference.langchain.com/python/langgraph/channels/any_value/AnyValue/get

Documentation for the `get` method of the `AnyValue` channel in `langgraph`.

```APIDOC
## get()

### Description
Retrieves the current value stored in the channel. This method is part of the `AnyValue` channel implementation in `langgraph`.

### Method
`get`

### Signature
```python
get(
    self,
) -> Value
```

### Parameters
None

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

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

### Initialize StateGraph or entrypoint with store

Source: https://reference.langchain.com/python/langgraph/config/get_store

Shows how to initialize a StateGraph or an entrypoint with a store so that get_store() can be called inside nodes or tasks.

```python
# with StateGraph
graph = (
    StateGraph(...)
    ...
    .compile(store=store)
)

# or with entrypoint
@entrypoint(store=store)
def workflow(inputs):
    ...
```

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

### get

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/runs/SyncRunsClient/get

Get a run by thread ID and run ID.

```APIDOC
## get

### Description
Get a run.

### Method
SDK Method

### Endpoint
`client.runs.get(thread_id, run_id, *, headers=None, params=None)`

### Parameters
- `thread_id` (str) - Required - The thread ID to get.
- `run_id` (str) - Required - The run ID to get.
- `headers` (Mapping[str, str] | None) - Optional - Optional custom headers to include with the request. (default: `None`)
- `params` (QueryParamTypes | None) - Optional - Query parameters to include with the request. (default: `None`)

### Request Example
```python
run = client.runs.get(
    thread_id="thread_id_to_delete",
    run_id="run_id_to_delete",
)
```

### Response
#### Success Response
- `Run` - The `Run` object.

#### Response Example
```python
run  # Run object
```
```

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

### Create an assistant with configuration

Source: https://reference.langchain.com/python/langgraph-sdk/_async/assistants/AssistantsClient/create

Example usage of the create method. It creates an assistant with a graph_id, context, metadata, assistant_id, if_exists, and name. The if_exists parameter is set to 'do_nothing' to return the existing assistant if a duplicate is created.

```python
client = get_client(url="http://localhost:2024")
assistant = await client.assistants.create(
    graph_id="agent",
    context={"model_name": "openai"},
    metadata={"number":1},
    assistant_id="my-assistant-id",
    if_exists="do_nothing",
    name="my_name"
)
```

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

### get

Source: https://reference.langchain.com/python/langgraph-sdk/_async/http/HttpClient/get

Sends a GET request using the HTTP client.

```APIDOC
## GET

### Description
Sends a `GET` request to the specified path.

### Method
GET

### Endpoint
`/` (path is provided by the `path` parameter)

### Parameters
#### Path Parameters
- **path** (str) - Required - The URL path to send the GET request to.

#### Query Parameters
- **params** (QueryParamTypes | None) - Optional - Query parameters to include in the request.

#### Headers
- **headers** (Mapping[str, str] | None) - Optional - HTTP headers to include in the request.

#### Callback
- **on_response** (Callable[[httpx.Response], None] | None) - Optional - A callback function to invoke with the response object.

### Request Example
```python
client.get(
    path="/some/endpoint",
    params={"key": "value"},
    headers={"Authorization": "Bearer token"},
    on_response=lambda resp: print(resp.status_code)
)
```

### Response
#### Success Response (200)
- Returns the response data as `Any`.

#### Response Example
```json
{
  "data": "example response"
}
```
```

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

### PostgreSQL Checkpointer with PostgresSaver

Source: https://reference.langchain.com/python/langgraph/checkpoints

Use PostgresSaver for production. Connect using a connection string, call setup() to initialize the database, then compile the graph.

```python
from langgraph.checkpoint.postgres import PostgresSaver

with PostgresSaver.from_conn_string("postgresql://user:pass@localhost/db") as checkpointer:
    checkpointer.setup()
    graph = builder.compile(checkpointer=checkpointer)
```

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

### HostBackendClient.__init__

Source: https://reference.langchain.com/python/langgraph-cli/host_backend/HostBackendClient

Constructor for HostBackendClient. Initializes the client with base URL, API key, optional tenant ID, and optional transport.

```APIDOC
## HostBackendClient.__init__

### Description
Initializes a new HostBackendClient instance.

### Method
Constructor

### Signature
```python
HostBackendClient(
    self,
    base_url: str,
    api_key: str,
    tenant_id: str | None = None,
    *,
    transport: httpx.BaseTransport | None = None,
)
```

### Parameters
- **base_url** (str) - Required - The base URL of the host backend service.
- **api_key** (str) - Required - The API key for authentication.
- **tenant_id** (str | None) - Optional - The tenant ID.
- **transport** (httpx.BaseTransport | None) - Optional - Custom transport for HTTP requests.

### Response
No return value.
```

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

### get

Source: https://reference.langchain.com/python/langgraph/managed/base/ManagedValue/get

Documentation for the `get` method of the `ManagedValue` class in the `langgraph` library.

```APIDOC
## get

### Description
Retrieves the value from the scratchpad for the managed value.

### Method
N/A (Python method)

### Endpoint
N/A (Python method)

### Parameters
#### Arguments
- **scratchpad** (PregelScratchpad) - Required - The scratchpad from which to retrieve the value.

### Returns
- **V** - The value retrieved from the scratchpad.

### Example
```python
# Example usage (illustrative)
value = get(scratchpad)
```
```

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

### get

Source: https://reference.langchain.com/python/langgraph/channels/untracked_value/UntrackedValue/get

Documentation for the `get` method of the `UntrackedValue` class in the `langgraph` library.

```APIDOC
## get

### Description
Retrieves the current value of the untracked value channel.

### Method
`get`

### Signature
```python
get(
    self,
) -> Value
```

### Parameters
- **self** - The instance of the `UntrackedValue` channel.

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

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

### get()

Source: https://reference.langchain.com/python/langgraph/channels/named_barrier_value/NamedBarrierValue/get

Documentation for the get method of the NamedBarrierValue class in the langgraph library.

```APIDOC
## get()

### Description
Retrieves the current value of the NamedBarrierValue channel.

### Method
`get`

### Signature
```python
get(
    self,
) -> Value
```

### Parameters
None

### Returns
- **Value** - The current value of the channel.
```

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

### get

Source: https://reference.langchain.com/python/langgraph/channels/last_value/LastValueAfterFinish/get

Documentation for the `get` method of the `LastValueAfterFinish` channel in the `langgraph` library.

```APIDOC
## get

### Description
Retrieves the current value of the channel. This method is part of the `LastValueAfterFinish` channel in the `langgraph` library.

### Method
`get`

### Signature
```python
get(
    self,
) -> Value
```

### Parameters
No parameters.

### Returns
- **Value** - The current value of the channel.
```

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

### Example usage of create

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/threads/SyncThreadsClient/create

Example usage of the create method, creating a thread with metadata, a custom thread ID, and setting if_exists to 'raise' to handle duplicate creation.

```python
client = get_sync_client(url="http://localhost:2024")
thread = client.threads.create(
    metadata={"number":1},
    thread_id="my-thread-id",
    if_exists="raise"
)
```

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

### Example usage of update

Source: https://reference.langchain.com/python/langgraph-sdk/_async/threads/ThreadsClient/update

Example of updating a thread with metadata and TTL.

```python
client = get_client(url="http://localhost:2024")
thread = await client.threads.update(
    thread_id="my-thread-id",
    metadata={"number":1},
    ttl=43_200,
)
```

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

### Example output of get_state

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/threads/SyncThreadsClient/get_state

Example output of the get_state call, showing the thread state including values, next, checkpoint, metadata, and other fields. This is the printed result from the previous example.

```shell
----------------------------------------------------------------------------------------------------------------------------------------------------------------------

{
    'values': {
        'messages': [
            {
                'content': 'how are you?',
                'additional_kwargs': {},
                'response_metadata': {},
                'type': 'human',
                'name': None,
                'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10',
                'example': False
            },
            {
                'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.",
                'additional_kwargs': {},
                'response_metadata': {},
                'type': 'ai',
                'name': None,
                'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b',
                'example': False,
                'tool_calls': [],
                'invalid_tool_calls': [],
                'usage_metadata': None
            }
        ]
    },
    'next': [],
    'checkpoint':
        {
            'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
            'checkpoint_ns': '',
            'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1'
        }
    'metadata':
        {
            'step': 1,
            'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2',
            'source': 'loop',
            'writes':
                {
                    'agent':
                        {
                            'messages': [
                                {
                                    'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b',
                                    'name': None,
                                    'type': 'ai',
                                    'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.",
                                    'example': False,
                                    'tool_calls': [],
                                    'usage_metadata': None,
                                    'additional_kwargs': {},
                                    'response_metadata': {},
                                    'invalid_tool_calls': []
                                }
                            ]
                        }
                },
    'user_id': None,
    'graph_id': 'agent',
    'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
    'created_by': 'system',
    'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'},
    'created_at': '2024-07-25T15:35:44.184703+00:00',
    'parent_config':
        {
            'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
            'checkpoint_ns': '',
            'checkpoint_id': '1ef4a9b8-d80d-6fa7-8000-9300467fad0f'
        }
}
```

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

### Create a run with SyncRunsClient

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/runs/SyncRunsClient

Shows how to instantiate a synchronous client and create a run. The client is obtained via get_sync_client with a local server URL, then runs.create is called with a thread ID and assistant ID.

```python
client = get_sync_client(url="http://localhost:2024")
run = client.runs.create(thread_id="thread_123", assistant_id="asst_456")
```

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

### get()

Source: https://reference.langchain.com/python/langgraph/channels/ephemeral_value/EphemeralValue/get

Documentation for the `get` method of the `EphemeralValue` channel class in the `langgraph` library.

```APIDOC
## get()

### Description
Retrieves the current value of the channel. This method is part of the `EphemeralValue` channel class in the `langgraph` library.

### Method
`get(self) -> Value`

### Parameters
None

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

### Example
```python
# Assuming 'channel' is an instance of EphemeralValue
value = channel.get()
```
```

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

### SyncStoreClient.__init__

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/store/SyncStoreClient

Constructs a new SyncStoreClient instance with the provided HTTP client.

```APIDOC
## SyncStoreClient.__init__

### Description
Initializes a new SyncStoreClient instance with the given HTTP client.

### Method
Constructor

### Signature
```python
__init__(
    self,
    http: SyncHttpClient,
) -> None
```

### Parameters
- **http** (SyncHttpClient) - Required - The HTTP client used for making synchronous requests.

### Request Example
```python
client = SyncStoreClient(http)
```

### Response
No return value.
```

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

### Example usage of search

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/cron/SyncCronClient/search

Example of calling `client.crons.search` with several parameters and printing the results.

```python
client = get_sync_client(url="http://localhost:8123")
cron_jobs = client.crons.search(
    assistant_id="my_assistant_id",
    thread_id="my_thread_id",
    enabled=True,
    limit=5,
    offset=5,
)
print(cron_jobs)
```

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

### Example: Creating a multi-agent swarm with handoff tools

Source: https://reference.langchain.com/python/langgraph-swarm/swarm/create_swarm

Example usage of create_swarm with two agents (Alice and Bob) that can hand off to each other. It shows how to create agents with tools, compile the workflow with a checkpointer, and invoke the app with a thread ID.

```python
from langgraph.checkpoint.memory import InMemorySaver
from langchain.agents import create_agent
from langgraph_swarm import create_handoff_tool, create_swarm

def add(a: int, b: int) -> int:
    '''Add two numbers'''
    return a + b

alice = create_agent(
    "openai:gpt-4o",
    tools=[
        add,
        create_handoff_tool(
            agent_name="Bob",
            description="Transfer to Bob",
        ),
    ],
    system_prompt="You are Alice, an addition expert.",
    name="Alice",
)

bob = create_agent(
    "openai:gpt-4o",
    tools=[
        create_handoff_tool(
            agent_name="Alice",
            description="Transfer to Alice, she can help with math",
        ),
    ],
    system_prompt="You are Bob, you speak like a pirate.",
    name="Bob",
)

checkpointer = InMemorySaver()
workflow = create_swarm(
    [alice, bob],
    default_active_agent="Alice"
)
app = workflow.compile(checkpointer=checkpointer)

config = {"configurable": {"thread_id": "1"}}
turn_1 = app.invoke(
    {"messages": [{"role": "user", "content": "i'd like to speak to Bob"}]},
    config,
)
turn_2 = app.invoke(
    {"messages": [{"role": "user", "content": "what's 5 + 7?"}]},
    config,
)
```

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

### DeployOutcome.__init__

Source: https://reference.langchain.com/python/langgraph-cli/deploy/DeployOutcome

Constructs a new DeployOutcome instance with the given deployment ID and build result.

```APIDOC
## DeployOutcome.__init__

### Description
Constructs a new DeployOutcome instance with the given deployment ID and build result.

### Signature
```python
__init__(
    self,
    deployment_id: str,
    build_result: BuildResult,
) -> None
```

### Parameters
- **deployment_id** (str) - Required - The deployment ID.
- **build_result** (BuildResult) - Required - The build result.

### Returns
None
```

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

### get

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/http/SyncHttpClient/get

Sends a GET request to the specified path with optional query parameters, headers, and a response callback.

```APIDOC
## [GET] /{path}

### Description
Sends a GET request to the specified path.

### Method
GET

### Endpoint
/{path}

### Parameters
#### Path Parameters
- **path** (string) - Required - The path to send the GET request to.

#### Query Parameters
- **params** (QueryParamTypes) - Optional - Query parameters to include in the request.

#### Headers
- **headers** (Mapping[str, str]) - Optional - HTTP headers to include in the request.

#### Request Body
- **on_response** (Callable[[httpx.Response], None]) - Optional - Callback function to handle the response.

### Request Example
```
GET /path?param=value
Headers: {"Authorization": "Bearer token"}
```

### Response
#### Success Response (200)
- **response** (Any) - The response data.

#### Response Example
```
{"status": "success"}
```
```

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

### Example usage of cancel

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/runs/SyncRunsClient/cancel

Example showing how to cancel a run using the `cancel` method with `wait=True` and `action='interrupt'`.

```python
client = get_sync_client(url="http://localhost:2024")
client.runs.cancel(
    thread_id="thread_id_to_cancel",
    run_id="run_id_to_cancel",
    wait=True,
    action="interrupt"
)
```

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

### AssistantsClient __init__ signature

Source: https://reference.langchain.com/python/langgraph-sdk/_async/assistants/AssistantsClient

Initialization method for AssistantsClient. Accepts an HttpClient and returns None.

```python
__init__(
    self,
    http: HttpClient,
) -> None
```

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

### Example Usage: client.runs.stream()

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/runs/SyncRunsClient/stream

Creates a synchronous client and streams run events by calling client.runs.stream() with various parameters such as thread_id, assistant_id, input, stream_mode, metadata, context, interrupt_before, interrupt_after, feedback_keys, webhook, and multitask_strategy. The example iterates over the returned chunks and prints each one.

```python
client = get_sync_client(url="http://localhost:2024")
async for chunk in client.runs.stream(
    thread_id=None,
    assistant_id="agent",
    input={"messages": [{"role": "user", "content": "how are you?"}]},
    stream_mode=["values","debug"],
    metadata={"name":"my_run"},
    context={"model_name": "anthropic"},
    interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
    interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
    feedback_keys=["my_feedback_key_1","my_feedback_key_2"],
    webhook="https://my.fake.webhook.com",
    multitask_strategy="interrupt"
):
    print(chunk)
```

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

### RunsCreate payload example

Source: https://reference.langchain.com/python/langgraph-sdk/auth/types/RunsCreate

Example of constructing a RunsCreate payload with all fields, including UUIDs for assistant, thread, and run IDs, and various configuration options.

```python
create_params = {
    "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
    "thread_id": UUID("123e4567-e89b-12d3-a456-426614174001"),
    "run_id": UUID("123e4567-e89b-12d3-a456-426614174002"),
    "status": "pending",
    "metadata": {"owner": "user123"},
    "prevent_insert_if_inflight": True,
    "multitask_strategy": "reject",
    "if_not_exists": "create",
    "after_seconds": 10,
    "kwargs": {"key": "value"},
    "action": "interrupt"
}
```

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

### Example usage of prune

Source: https://reference.langchain.com/python/langgraph-sdk/_async/threads/ThreadsClient/prune

Example showing how to call `prune` with a list of thread IDs and print the result.

```python
client = get_client(url="http://localhost:2024")
result = await client.threads.prune(
    thread_ids=["thread_1", "thread_2"],
)
print(result)  # {'pruned_count': 2}
```

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

### SyncAssistantsClient __init__ method

Source: https://reference.langchain.com/python/langgraph-sdk/_sync/assistants/SyncAssistantsClient

Initializes the client with the provided SyncHttpClient. The http parameter is required.

```python
__init__(
    self,
    http: SyncHttpClient,
) -> None
```
Tokens:
Raw