Python SDK 参考¶

LangGraph 客户端实现连接到 LangGraph API。

此模块提供异步（get_client(url="http://localhost:2024")) 或 LangGraphClient）和同步（get_sync_client(url="http://localhost:2024")) 或 SyncLanggraphClient）客户端，用于与 LangGraph API 的核心资源（如助手、线程、运行和定时任务）以及其持久文档存储进行交互。

类

名称	描述
`LangGraphClient`	LangGraph API 的顶层客户端。
`HttpClient`	处理对 LangGraph API 的异步请求。
`AssistantsClient`	用于在 LangGraph 中管理助手的客户端。
`ThreadsClient`	用于在 LangGraph 中管理线程的客户端。
`RunsClient`	用于在 LangGraph 中管理运行的客户端。
`CronClient`	用于在 LangGraph 中管理重复运行（定时任务）的客户端。
`StoreClient`	用于与图的共享存储交互的客户端。
`SyncLangGraphClient`	用于与 LangGraph API 交互的同步客户端。
`SyncHttpClient`	处理对 LangGraph API 的同步请求。
`SyncAssistantsClient`	用于在 LangGraph 中同步管理助手的客户端。
`SyncThreadsClient`	用于在 LangGraph 中管理线程的同步客户端。
`SyncRunsClient`	用于在 LangGraph 中管理运行的同步客户端。
`SyncCronClient`	用于在 LangGraph 中管理定时任务的同步客户端。
`SyncStoreClient`	用于对键值存储进行同步操作的客户端。

函数

名称	描述
`get_client`	获取 LangGraphClient 实例。
`get_sync_client`	获取同步 LangGraphClient 实例。

LangGraphClient ¶

LangGraph API 的顶层客户端。

属性

名称	类型	描述
`assistants`		管理图的版本化配置。
`threads`		处理（可能）多轮交互，例如对话线程。
`runs`		控制图的单个调用。
`crons`		管理计划操作。
`store`		与持久的共享数据存储接口。

HttpClient ¶

处理对 LangGraph API 的异步请求。

在提供的 httpx 客户端之上添加了额外的错误消息和内容处理。

属性

名称	类型	描述
`client`	`AsyncClient`	底层 HTTPX 异步客户端。

方法

名称	描述
`get`	发送 GET 请求。
`post`	发送 POST 请求。
`put`	发送 PUT 请求。
`patch`	发送 PATCH 请求。
`delete`	发送 DELETE 请求。
`stream`	使用 SSE 流式传输结果。

get `async` ¶

get(
    path: str,
    *,
    params: Optional[QueryParamTypes] = None,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> Any

发送 GET 请求。

post `async` ¶

post(
    path: str,
    *,
    json: Optional[dict],
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> Any

发送 POST 请求。

put `async` ¶

put(
    path: str,
    *,
    json: dict,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> Any

发送 PUT 请求。

patch `async` ¶

patch(
    path: str,
    *,
    json: dict,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> Any

发送 PATCH 请求。

delete `async` ¶

delete(
    path: str,
    *,
    json: Optional[Any] = None,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> None

发送 DELETE 请求。

stream `async` ¶

stream(
    path: str,
    method: str,
    *,
    json: Optional[dict] = None,
    params: Optional[QueryParamTypes] = None,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> AsyncIterator[StreamPart]

使用 SSE 流式传输结果。

AssistantsClient ¶

用于在 LangGraph 中管理助手的客户端。

此类提供与助手交互的方法，助手是图的版本化配置。

示例

client = get_client(url="http://localhost:2024")
assistant = await client.assistants.get("assistant_id_123")

方法

名称	描述
`get`	通过 ID 获取助手。
`get_graph`	通过 ID 获取助手的图。
`get_schemas`	通过 ID 获取助手的模式。
`get_subgraphs`	通过 ID 获取助手的模式。
`create`	创建新助手。
`update`	更新助手。
`delete`	删除助手。
`search`	搜索助手。
`get_versions`	列出助手的所有版本。
`set_latest`	更改助手的版本。

get `async` ¶

get(
    assistant_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> Assistant

通过 ID 获取助手。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要获取的助手的 ID。	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`Assistant`	`Assistant`	助手对象。

用法示例

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

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

{
    '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'
}

get_graph `async` ¶

get_graph(
    assistant_id: str,
    *,
    xray: Union[int, bool] = False,
    headers: Optional[dict[str, str]] = None
) -> dict[str, list[dict[str, Any]]]

通过 ID 获取助手的图。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要获取其图的助手的 ID。	必需
`xray`	`联合[int, bool]`	包含子图的图表示。如果提供了整数值，则只包含深度小于或等于该值的子图。	`False`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`Graph`	`dict[str, list[dict[str, Any]]]`	助手的图信息，JSON 格式。

用法示例

client = get_client(url="http://localhost:2024")
graph_info = await client.assistants.get_graph(
    assistant_id="my_assistant_id"
)
print(graph_info)

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

{
    'nodes':
        [
            {'id': '__start__', 'type': 'schema', 'data': '__start__'},
            {'id': '__end__', 'type': 'schema', 'data': '__end__'},
            {'id': 'agent','type': 'runnable','data': {'id': ['langgraph', 'utils', 'RunnableCallable'],'name': 'agent'}},
        ],
    'edges':
        [
            {'source': '__start__', 'target': 'agent'},
            {'source': 'agent','target': '__end__'}
        ]
}

get_schemas `async` ¶

get_schemas(
    assistant_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> GraphSchema

通过 ID 获取助手的模式。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要获取其模式的助手的 ID。	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`GraphSchema`	`GraphSchema`	助手的图模式。

用法示例

client = get_client(url="http://localhost:2024")
schema = await client.assistants.get_schemas(
    assistant_id="my_assistant_id"
)
print(schema)

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

{
    'graph_id': 'agent',
    'state_schema':
        {
            'title': 'LangGraphInput',
            '$ref': '#/definitions/AgentState',
            'definitions':
                {
                    'BaseMessage':
                        {
                            'title': 'BaseMessage',
                            'description': 'Base abstract Message class. Messages are the inputs and outputs of ChatModels.',
                            'type': 'object',
                            'properties':
                                {
                                 'content':
                                    {
                                        'title': 'Content',
                                        'anyOf': [
                                            {'type': 'string'},
                                            {'type': 'array','items': {'anyOf': [{'type': 'string'}, {'type': 'object'}]}}
                                        ]
                                    },
                                'additional_kwargs':
                                    {
                                        'title': 'Additional Kwargs',
                                        'type': 'object'
                                    },
                                'response_metadata':
                                    {
                                        'title': 'Response Metadata',
                                        'type': 'object'
                                    },
                                'type':
                                    {
                                        'title': 'Type',
                                        'type': 'string'
                                    },
                                'name':
                                    {
                                        'title': 'Name',
                                        'type': 'string'
                                    },
                                'id':
                                    {
                                        'title': 'Id',
                                        'type': 'string'
                                    }
                                },
                            'required': ['content', 'type']
                        },
                    'AgentState':
                        {
                            'title': 'AgentState',
                            'type': 'object',
                            'properties':
                                {
                                    'messages':
                                        {
                                            'title': 'Messages',
                                            'type': 'array',
                                            'items': {'$ref': '#/definitions/BaseMessage'}
                                        }
                                },
                            'required': ['messages']
                        }
                }
        },
    'config_schema':
        {
            'title': 'Configurable',
            'type': 'object',
            'properties':
                {
                    'model_name':
                        {
                            'title': 'Model Name',
                            'enum': ['anthropic', 'openai'],
                            'type': 'string'
                        }
                }
        }
}

get_subgraphs `async` ¶

get_subgraphs(
    assistant_id: str,
    namespace: Optional[str] = None,
    recurse: bool = False,
    *,
    headers: Optional[dict[str, str]] = None
) -> Subgraphs

通过 ID 获取助手的模式。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要获取其模式的助手的 ID。	必需
`namespace`	`可选[str]`	可选的命名空间进行过滤。	`无`
`recurse`	`bool`	是否递归获取子图。	`False`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`Subgraphs`	`Subgraphs`	助手的图模式。

create `async` ¶

create(
    graph_id: Optional[str],
    config: Optional[Config] = None,
    *,
    metadata: Json = None,
    assistant_id: Optional[str] = None,
    if_exists: Optional[OnConflictBehavior] = None,
    name: Optional[str] = None,
    headers: Optional[dict[str, str]] = None,
    description: Optional[str] = None
) -> Assistant

创建新助手。

当图是可配置的且您希望基于不同配置创建不同助手时很有用。

参数

名称	类型	描述	默认
`graph_id`	`可选[str]`	助手应使用的图的 ID。图 ID 通常在 langgraph.json 配置中设置。	必需
`config`	`可选[Config]`	用于图的配置。	`无`
`metadata`	`Json`	要添加到助手的元数据。	`无`
`assistant_id`	`可选[str]`	要使用的助手 ID，如果未提供，将默认为随机 UUID。	`无`
`if_exists`	`可选[OnConflictBehavior]`	如何处理重复创建。默认在底层为 'raise'。必须是 'raise'（如果重复则抛出错误）或 'do_nothing'（返回现有助手）。	`无`
`name`	`可选[str]`	助手的名称。默认在底层为 'Untitled'。	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`
`description`	`可选[str]`	助手的可选描述。 description 字段适用于 langgraph-api server 版本 >=0.0.45	`无`

返回

名称	类型	描述
`Assistant`	`Assistant`	创建的助手。

用法示例

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

update `async` ¶

update(
    assistant_id: str,
    *,
    graph_id: Optional[str] = None,
    config: Optional[Config] = None,
    metadata: Json = None,
    name: Optional[str] = None,
    headers: Optional[dict[str, str]] = None,
    description: Optional[str] = None
) -> Assistant

更新助手。

使用此方法指向不同的图、更新配置或更改助手的元数据。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要更新的助手。	必需
`graph_id`	`可选[str]`	助手应使用的图的 ID。图 ID 通常在 langgraph.json 配置中设置。如果为 None，助手将继续指向相同的图。	`无`
`config`	`可选[Config]`	用于图的配置。	`无`
`metadata`	`Json`	要与现有助手元数据合并的元数据。	`无`
`name`	`可选[str]`	助手的新名称。	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`
`description`	`可选[str]`	助手的可选描述。 description 字段适用于 langgraph-api server 版本 >=0.0.45	`无`

返回

名称	类型	描述
`Assistant`	`Assistant`	已更新的助手。

用法示例

client = get_client(url="http://localhost:2024")
assistant = await client.assistants.update(
    assistant_id='e280dad7-8618-443f-87f1-8e41841c180f',
    graph_id="other-graph",
    config={"configurable": {"model_name": "anthropic"}},
    metadata={"number":2}
)

delete `async` ¶

delete(
    assistant_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> None

删除助手。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要删除的助手 ID。	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_client(url="http://localhost:2024")
await client.assistants.delete(
    assistant_id="my_assistant_id"
)

search `async` ¶

search(
    *,
    metadata: Json = None,
    graph_id: Optional[str] = None,
    limit: int = 10,
    offset: int = 0,
    sort_by: Optional[AssistantSortBy] = None,
    sort_order: Optional[SortOrder] = None,
    headers: Optional[dict[str, str]] = None
) -> list[Assistant]

搜索助手。

参数

名称	类型	描述	默认
`metadata`	`Json`	要过滤的元数据。每个键值对的精确匹配过滤。	`无`
`graph_id`	`可选[str]`	要过滤的图的 ID。图 ID 通常在 langgraph.json 配置中设置。	`无`
`limit`	`int`	要返回的最大结果数。	`10`
`offset`	`int`	要跳过的结果数。	`0`
`sort_by`	`可选[AssistantSortBy]`	要排序的字段。	`无`
`sort_order`	`可选[SortOrder]`	排序顺序。	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Assistant]`	list[Assistant]: 助手列表。

用法示例

client = get_client(url="http://localhost:2024")
assistants = await client.assistants.search(
    metadata = {"name":"my_name"},
    graph_id="my_graph_id",
    limit=5,
    offset=5
)

get_versions `async` ¶

get_versions(
    assistant_id: str,
    metadata: Json = None,
    limit: int = 10,
    offset: int = 0,
    *,
    headers: Optional[dict[str, str]] = None
) -> list[AssistantVersion]

列出助手的所有版本。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要获取版本的助手 ID。	必需
`metadata`	`Json`	用于过滤版本的元数据。每个键值对的精确匹配过滤。	`无`
`limit`	`int`	要返回的最大版本数。	`10`
`offset`	`int`	要跳过的版本数。	`0`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[AssistantVersion]`	list[AssistantVersion]: 助手版本列表。

用法示例

client = get_client(url="http://localhost:2024")
assistant_versions = await client.assistants.get_versions(
    assistant_id="my_assistant_id"
)

set_latest `async` ¶

set_latest(
    assistant_id: str,
    version: int,
    *,
    headers: Optional[dict[str, str]] = None
) -> Assistant

更改助手的版本。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要删除的助手 ID。	必需
`要更改到的版本。`	`int`	ThreadsClient ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`Assistant`	`Assistant`	助手对象。

用法示例

client = get_client(url="http://localhost:2024")
new_version_assistant = await client.assistants.set_latest(
    assistant_id="my_assistant_id",
    version=3
)

线程维护图在多次交互/调用（又称运行）中的状态。它累积并持久化图的状态，允许在图的不同调用之间保持连续性。

用于在 LangGraph 中管理线程的客户端。

通过 ID 获取线程。

示例

client = get_client(url="http://localhost:2024"))
new_thread = await client.threads.create(metadata={"user_id": "123"})

方法

名称	描述
`get`	创建新线程。
`create`	更新线程。
`update`	删除线程。
`delete`	搜索线程。
`search`	copy
`复制线程。`	get_state
`获取线程状态。`	update_state
`更新线程状态。`	get_history
`获取线程状态历史。`	get `async` ¶

thread_id

get(
    thread_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> Thread

创建新线程。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	Thread	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`线程对象。`	`线程对象。`	create `async` ¶

用法示例

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

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

{
    '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'}
}

要添加到线程的元数据。

create(
    *,
    metadata: Json = None,
    thread_id: Optional[str] = None,
    if_exists: Optional[OnConflictBehavior] = None,
    supersteps: Optional[
        Sequence[dict[str, Sequence[dict[str, Any]]]]
    ] = None,
    graph_id: Optional[str] = None,
    headers: Optional[dict[str, str]] = None
) -> Thread

更新线程。

参数

名称	类型	描述	默认
`metadata`	`Json`	线程 ID。如果为 None，ID 将是随机生成的 UUID。	`无`
`要获取的线程 ID。`	`可选[str]`	如何处理重复创建。默认在底层为 'raise'。必须是 'raise'（如果重复则抛出错误）或 'do_nothing'（返回现有线程）。	`无`
`if_exists`	`可选[OnConflictBehavior]`	supersteps	`无`
`可选[序列[dict[str, 序列[dict[str, Any]]]]]`	`创建线程时应用超步列表，每个超步包含一系列更新。每次更新都有 values 或 command 和 as_node。用于在部署之间复制线程。`	与线程关联的可选图 ID。	`无`
`graph_id`	`可选[str]`	创建的线程。	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`线程对象。`	`线程对象。`	update `async` ¶

用法示例

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

要更新的线程 ID。

update(
    thread_id: str,
    *,
    metadata: dict[str, Any],
    headers: Optional[dict[str, str]] = None
) -> Thread

删除线程。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	dict[str, Any]	必需
`metadata`	`要与现有线程元数据合并的元数据。`	delete `async` ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`线程对象。`	`线程对象。`	update `async` ¶

用法示例

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

要删除的线程 ID。

delete(
    thread_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> None

搜索线程。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	search `async` ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

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

要过滤的线程元数据。

search(
    *,
    metadata: Json = None,
    values: Json = None,
    status: Optional[ThreadStatus] = None,
    limit: int = 10,
    offset: int = 0,
    sort_by: Optional[ThreadSortBy] = None,
    sort_order: Optional[SortOrder] = None,
    headers: Optional[dict[str, str]] = None
) -> list[Thread]

copy

参数

名称	类型	描述	默认
`metadata`	`Json`	values	`无`
`要过滤的状态值。`	`Json`	status	`无`
`可选[ThreadStatus]`	`要过滤的线程状态。必须是 'idle'、'busy'、'interrupted' 或 'error' 之一。`	要返回的线程数量限制。	`无`
`limit`	`int`	在线程表中开始搜索的偏移量。	`10`
`offset`	`int`	可选[ThreadSortBy]	`0`
`sort_by`	`排序字段。`	排序顺序。	`无`
`sort_order`	`可选[SortOrder]`	list[Thread]	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Thread]: 匹配搜索参数的线程列表。`	copy `async` ¶

用法示例

client = get_client(url="http://localhost:2024")
threads = await client.threads.search(
    metadata={"number":1},
    status="interrupted",
    limit=15,
    offset=5
)

要复制的线程 ID。

copy(
    thread_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> None

get_state

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	get_state `async` ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_client(url="http://localhost:2024)
await client.threads.copy(
    thread_id="my_thread_id"
)

要获取状态的线程 ID。

get_state(
    thread_id: str,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    *,
    subgraphs: bool = False,
    headers: Optional[dict[str, str]] = None
) -> ThreadState

update_state

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	checkpoint	必需
`可选[Checkpoint]`	`要获取状态的检查点。`	checkpoint_id	`无`
`(已弃用) 要获取状态的检查点 ID。`	`可选[str]`	subgraphs	`无`
`包含子图状态。`	`bool`	ThreadState	`False`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`线程的状态。`	`线程的状态。`	update_state `async` ¶

用法示例

client = get_client(url="http://localhost:2024)
thread_state = await client.threads.get_state(
    thread_id="my_thread_id",
    checkpoint_id="my_checkpoint_id"
)
print(thread_state)

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

{
    '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'
        }
}

要更新的线程 ID。

update_state(
    thread_id: str,
    values: Optional[Union[dict, Sequence[dict]]],
    *,
    as_node: Optional[str] = None,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    headers: Optional[dict[str, str]] = None
) -> ThreadUpdateStateResponse

get_history

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	可选[联合[dict, 序列[dict]]]	必需
`要过滤的状态值。`	`用于更新状态的值。`	as_node	必需
`更新状态，就好像这个节点刚刚执行过一样。`	`可选[str]`	要更新状态的检查点。	`无`
`可选[Checkpoint]`	`要获取状态的检查点。`	(已弃用) 要更新状态的检查点 ID。	`无`
`(已弃用) 要获取状态的检查点 ID。`	`可选[str]`	ThreadUpdateStateResponse	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`更新线程状态后的响应。`	`更新线程状态后的响应。`	get_history `async` ¶

用法示例

client = get_client(url="http://localhost:2024)
response = await client.threads.update_state(
    thread_id="my_thread_id",
    values={"messages":[{"role": "user", "content": "hello!"}]},
    as_node="my_node",
)
print(response)

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

{
    'checkpoint': {
        'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
        'checkpoint_ns': '',
        'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1',
        'checkpoint_map': {}
    }
}

要获取状态历史的线程 ID。

get_history(
    thread_id: str,
    *,
    limit: int = 10,
    before: Optional[str | Checkpoint] = None,
    metadata: Optional[dict] = None,
    checkpoint: Optional[Checkpoint] = None,
    headers: Optional[dict[str, str]] = None
) -> list[ThreadState]

get async ¶

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	返回此子图的状态。如果为空，则默认为根。	必需
`可选[Checkpoint]`	`要获取状态的检查点。`	要返回的最大状态数。	`无`
`limit`	`int`	before	`10`
`可选[str \| Checkpoint]`	`在此检查点之前返回状态。`	可选[dict]	`无`
`metadata`	`按元数据键值对过滤状态。`	list[ThreadState]	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[ThreadState]: 线程的状态历史。`	RunsClient ¶

用法示例

client = get_client(url="http://localhost:2024)
thread_state = await client.threads.get_history(
    thread_id="my_thread_id",
    limit=5,
)

运行是助手的单个调用，带有可选的输入、配置和元数据。此客户端管理运行，可以是有状态的（在线程上）或无状态的。

用于在 LangGraph 中管理运行的客户端。

创建运行并流式传输结果。

示例

client = get_client(url="http://localhost:2024")
run = await client.runs.create(assistant_id="asst_123", thread_id="thread_456", input={"query": "Hello"})

方法

名称	描述
`stream`	创建后台运行。
`create`	create_batch
`创建一批无状态后台运行。`	wait
`创建运行，等待其完成并返回最终状态。`	list
`列出运行。`	获取运行。
`get`	cancel
`join`	cancel
`阻塞直到运行完成。返回线程的最终状态。`	join_stream
`实时流式传输运行输出，直到运行完成。`	删除运行。
`delete`	stream ¶

要分配给线程的线程 ID。如果为 None，将创建无状态运行。

stream(
    thread_id: Optional[str],
    assistant_id: str,
    *,
    input: Optional[dict] = None,
    command: Optional[Command] = None,
    stream_mode: Union[
        StreamMode, Sequence[StreamMode]
    ] = "values",
    stream_subgraphs: bool = False,
    stream_resumable: bool = False,
    metadata: Optional[dict] = None,
    config: Optional[Config] = None,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    checkpoint_during: Optional[bool] = None,
    interrupt_before: Optional[
        Union[All, Sequence[str]]
    ] = None,
    interrupt_after: Optional[
        Union[All, Sequence[str]]
    ] = None,
    feedback_keys: Optional[Sequence[str]] = None,
    on_disconnect: Optional[DisconnectMode] = None,
    on_completion: Optional[OnCompletionBehavior] = None,
    webhook: Optional[str] = None,
    multitask_strategy: Optional[MultitaskStrategy] = None,
    if_not_exists: Optional[IfNotExists] = None,
    after_seconds: Optional[int] = None,
    headers: Optional[dict[str, str]] = None,
    on_run_created: Optional[
        Callable[[RunCreateMetadata], None]
    ] = None
) -> AsyncIterator[StreamPart]

创建后台运行。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`可选[str]`	要从中流式传输的助手 ID 或图名称。如果使用图名称，将默认为从该图创建的第一个助手。	必需
`assistant_id`	`str`	input	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`可选[Command]`	`要执行的命令。不能与输入组合使用。`	stream_mode	`无`
`联合[StreamMode, 序列[StreamMode]]`	`要使用的流模式。`	'values'	`stream_subgraphs`
`是否流式传输子图的输出。`	`bool`	stream_resumable	`False`
`流是否可恢复。如果为 True，即使断开连接后，也可以完全恢复和重播流。`	`bool`	分配给运行的元数据。	`False`
`metadata`	`按元数据键值对过滤状态。`	助手的配置。	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[Checkpoint]`	`要获取状态的检查点。`	checkpoint_during	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`在执行前立即中断的节点。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`在执行前立即中断的节点。`	feedback_keys	`无`
`可选[序列[str]]`	`分配给运行的反馈键。`	on_disconnect	`无`
`可选[DisconnectMode]`	`要使用的断开连接模式。必须是 'cancel' 或 'continue' 之一。`	on_completion	`无`
`可选[OnCompletionBehavior]`	`是否删除或保留为无状态运行创建的线程。必须是 'delete' 或 'keep' 之一。`	webhook	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[MultitaskStrategy]`	`要使用的多任务策略。必须是 'reject'、'interrupt'、'rollback' 或 'enqueue' 之一。`	if_not_exists	`无`
`可选[IfNotExists]`	`如何处理缺失的线程。默认为 'reject'。必须是 'reject'（如果缺失则抛出错误）或 'create'（创建新线程）。`	after_seconds	`无`
`可选[int]`	`运行开始前等待的秒数。用于安排未来的运行。`	on_run_created	`无`
`可选[可调用[[RunCreateMetadata], None]]`	`运行创建时的回调。`	AsyncIterator[StreamPart]	`无`

返回

类型	描述
`AsyncIterator[StreamPart]: 流结果的异步迭代器。`	create `async` ¶

用法示例

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"},
    config={"configurable": {"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)

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

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)

运行创建时可选的回调。

create(
    thread_id: Optional[str],
    assistant_id: str,
    *,
    input: Optional[dict] = None,
    command: Optional[Command] = None,
    stream_mode: Union[
        StreamMode, Sequence[StreamMode]
    ] = "values",
    stream_subgraphs: bool = False,
    stream_resumable: bool = False,
    metadata: Optional[dict] = None,
    config: Optional[Config] = None,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    checkpoint_during: Optional[bool] = None,
    interrupt_before: Optional[
        Union[All, Sequence[str]]
    ] = None,
    interrupt_after: Optional[
        Union[All, Sequence[str]]
    ] = None,
    webhook: Optional[str] = None,
    multitask_strategy: Optional[MultitaskStrategy] = None,
    if_not_exists: Optional[IfNotExists] = None,
    on_completion: Optional[OnCompletionBehavior] = None,
    after_seconds: Optional[int] = None,
    headers: Optional[dict[str, str]] = None,
    on_run_created: Optional[
        Callable[[RunCreateMetadata], None]
    ] = None
) -> Run

create_batch

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`可选[str]`	要从中流式传输的助手 ID 或图名称。如果使用图名称，将默认为从该图创建的第一个助手。	必需
`assistant_id`	`str`	input	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`可选[Command]`	`要执行的命令。不能与输入组合使用。`	stream_mode	`无`
`联合[StreamMode, 序列[StreamMode]]`	`要使用的流模式。`	'values'	`stream_subgraphs`
`是否流式传输子图的输出。`	`bool`	stream_resumable	`False`
`流是否可恢复。如果为 True，即使断开连接后，也可以完全恢复和重播流。`	`bool`	分配给运行的元数据。	`False`
`metadata`	`按元数据键值对过滤状态。`	助手的配置。	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[Checkpoint]`	`要获取状态的检查点。`	checkpoint_during	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`在执行前立即中断的节点。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`在执行前立即中断的节点。`	feedback_keys	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[MultitaskStrategy]`	`要使用的多任务策略。必须是 'reject'、'interrupt'、'rollback' 或 'enqueue' 之一。`	if_not_exists	`无`
`可选[OnCompletionBehavior]`	`是否删除或保留为无状态运行创建的线程。必须是 'delete' 或 'keep' 之一。`	webhook	`无`
`可选[IfNotExists]`	`如何处理缺失的线程。默认为 'reject'。必须是 'reject'（如果缺失则抛出错误）或 'create'（创建新线程）。`	after_seconds	`无`
`可选[int]`	`运行开始前等待的秒数。用于安排未来的运行。`	on_run_created	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`
`可选[可调用[[RunCreateMetadata], None]]`	`运行创建时的回调。`	Run	`无`

返回

名称	类型	描述
`创建的后台运行。`	`创建的后台运行。`	create_batch `async` ¶

用法示例

background_run = await client.runs.create(
    thread_id="my_thread_id",
    assistant_id="my_assistant_id",
    input={"messages": [{"role": "user", "content": "hello!"}]},
    metadata={"name":"my_run"},
    config={"configurable": {"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)

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

{
    'run_id': 'my_run_id',
    'thread_id': 'my_thread_id',
    'assistant_id': 'my_assistant_id',
    'created_at': '2024-07-25T15:35:42.598503+00:00',
    'updated_at': '2024-07-25T15:35:42.598503+00:00',
    'metadata': {},
    'status': 'pending',
    'kwargs':
        {
            'input':
                {
                    'messages': [
                        {
                            'role': 'user',
                            'content': 'how are you?'
                        }
                    ]
                },
            'config':
                {
                    'metadata':
                        {
                            'created_by': 'system'
                        },
                    'configurable':
                        {
                            'run_id': 'my_run_id',
                            'user_id': None,
                            'graph_id': 'agent',
                            'thread_id': 'my_thread_id',
                            'checkpoint_id': None,
                            'model_name': "openai",
                            'assistant_id': 'my_assistant_id'
                        }
                },
            'webhook': "https://my.fake.webhook.com",
            'temporary': False,
            'stream_mode': ['values'],
            'feedback_keys': None,
            'interrupt_after': ["node_to_stop_after_1","node_to_stop_after_2"],
            'interrupt_before': ["node_to_stop_before_1","node_to_stop_before_2"]
        },
    'multitask_strategy': 'interrupt'
}

wait `async` ¶

create_batch(payloads: list[RunCreate]) -> list[Run]

wait

要在其上创建运行的线程 ID。如果为 None，将创建无状态运行。

wait(
    thread_id: Optional[str],
    assistant_id: str,
    *,
    input: Optional[dict] = None,
    command: Optional[Command] = None,
    metadata: Optional[dict] = None,
    config: Optional[Config] = None,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    checkpoint_during: Optional[bool] = None,
    interrupt_before: Optional[
        Union[All, Sequence[str]]
    ] = None,
    interrupt_after: Optional[
        Union[All, Sequence[str]]
    ] = None,
    webhook: Optional[str] = None,
    on_disconnect: Optional[DisconnectMode] = None,
    on_completion: Optional[OnCompletionBehavior] = None,
    multitask_strategy: Optional[MultitaskStrategy] = None,
    if_not_exists: Optional[IfNotExists] = None,
    after_seconds: Optional[int] = None,
    raise_error: bool = True,
    headers: Optional[dict[str, str]] = None,
    on_run_created: Optional[
        Callable[[RunCreateMetadata], None]
    ] = None
) -> Union[list[dict], dict[str, Any]]

list

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`可选[str]`	要运行的助手 ID 或图名称。如果使用图名称，将默认为从该图创建的第一个助手。	必需
`assistant_id`	`str`	联合[list[dict], dict[str, Any]]	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`可选[Command]`	`要执行的命令。不能与输入组合使用。`	stream_mode	`无`
`metadata`	`按元数据键值对过滤状态。`	助手的配置。	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[Checkpoint]`	`要获取状态的检查点。`	checkpoint_during	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`在执行前立即中断的节点。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`在执行前立即中断的节点。`	feedback_keys	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[DisconnectMode]`	`要使用的断开连接模式。必须是 'cancel' 或 'continue' 之一。`	on_completion	`无`
`可选[OnCompletionBehavior]`	`是否删除或保留为无状态运行创建的线程。必须是 'delete' 或 'keep' 之一。`	webhook	`无`
`可选[MultitaskStrategy]`	`要使用的多任务策略。必须是 'reject'、'interrupt'、'rollback' 或 'enqueue' 之一。`	if_not_exists	`无`
`可选[IfNotExists]`	`如何处理缺失的线程。默认为 'reject'。必须是 'reject'（如果缺失则抛出错误）或 'create'（创建新线程）。`	after_seconds	`无`
`可选[int]`	`运行开始前等待的秒数。用于安排未来的运行。`	on_run_created	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`
`可选[可调用[[RunCreateMetadata], None]]`	`运行创建时的回调。`	Run	`无`

返回

类型	描述
`Union[list[dict], dict[str, Any]]: 运行的输出。`	list `async` ¶

用法示例

client = get_client(url="http://localhost:2024")
final_state_of_run = await client.runs.wait(
    thread_id=None,
    assistant_id="agent",
    input={"messages": [{"role": "user", "content": "how are you?"}]},
    metadata={"name":"my_run"},
    config={"configurable": {"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"],
    webhook="https://my.fake.webhook.com",
    multitask_strategy="interrupt"
)
print(final_state_of_run)

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

{
    'messages': [
        {
            'content': 'how are you?',
            'additional_kwargs': {},
            'response_metadata': {},
            'type': 'human',
            'name': None,
            'id': 'f51a862c-62fe-4866-863b-b0863e8ad78a',
            '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-bf1cd3c6-768f-4c16-b62d-ba6f17ad8b36',
            'example': False,
            'tool_calls': [],
            'invalid_tool_calls': [],
            'usage_metadata': None
        }
    ]
}

要列出运行的线程 ID。

list(
    thread_id: str,
    *,
    limit: int = 10,
    offset: int = 0,
    status: Optional[RunStatus] = None,
    headers: Optional[dict[str, str]] = None
) -> list[Run]

获取运行。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	可选[RunStatus]	必需
`limit`	`int`	要返回的最大结果数。	`10`
`offset`	`int`	要跳过的结果数。	`0`
`可选[ThreadStatus]`	`要过滤的运行状态。`	list[Run]	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Run]: 线程的运行列表。`	get `async` ¶

用法示例

client = get_client(url="http://localhost:2024")
await client.runs.list(
    thread_id="thread_id",
    limit=5,
    offset=5,
)

要获取的线程 ID。

get(
    thread_id: str,
    run_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> Run

cancel

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	run_id	必需
`要获取的运行 ID。`	`str`	运行对象。	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`创建的后台运行。`	`创建的后台运行。`	cancel `async` ¶

用法示例

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

要取消的线程 ID。

cancel(
    thread_id: str,
    run_id: str,
    *,
    wait: bool = False,
    action: CancelAction = "interrupt",
    headers: Optional[dict[str, str]] = None
) -> None

cancel

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	要取消的运行 ID。	必需
`要获取的运行 ID。`	`str`	是否等待运行完成。	必需
`创建运行，等待其完成并返回最终状态。`	`bool`	action	`False`
`CancelAction`	`取消运行时要执行的操作。可能的值为 interrupt 或 rollback。默认为 interrupt。`	'interrupt'	`join async ¶`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

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

要加入的线程 ID。

join(
    thread_id: str,
    run_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> dict

join_stream

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	要加入的运行 ID。	必需
`要获取的运行 ID。`	`str`	dict	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`join_stream ¶`	无

用法示例

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

实时流式传输运行输出，直到运行完成。输出不缓冲，因此在此调用之前产生的任何输出都不会在此处接收。

join_stream(
    thread_id: str,
    run_id: str,
    *,
    cancel_on_disconnect: bool = False,
    stream_mode: Optional[
        Union[StreamMode, Sequence[StreamMode]]
    ] = None,
    headers: Optional[dict[str, str]] = None,
    last_event_id: Optional[str] = None
) -> AsyncIterator[StreamPart]

cancel_on_disconnect

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	要加入的运行 ID。	必需
`要获取的运行 ID。`	`str`	dict	必需
`流断开连接时是否取消运行。`	`bool`	可选[联合[StreamMode, 序列[StreamMode]]]	`False`
`联合[StreamMode, 序列[StreamMode]]`	`要使用的流模式。必须是创建运行时传递的流模式的子集。后台运行默认包含所有流模式的并集。`	delete `async` ¶	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`AsyncIterator[StreamPart]: 流结果的异步迭代器。`	无

用法示例

client = get_client(url="http://localhost:2024")
async for part in client.runs.join_stream(
    thread_id="thread_id_to_join",
    run_id="run_id_to_join",
    stream_mode=["values", "debug"]
):
    print(part)

要删除的线程 ID。

delete(
    thread_id: str,
    run_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> None

stream ¶

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	要删除的运行 ID。	必需
`要获取的运行 ID。`	`str`	CronClient ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

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

运行是助手对可选输入和配置的单次调用。此客户端允许安排定期运行以自动发生。

用于在 LangGraph 中管理重复运行（定时任务）的客户端。

功能可用性

用法示例

client = get_client(url="http://localhost:2024"))
cron_job = await client.crons.create_for_thread(
    thread_id="thread_123",
    assistant_id="asst_456",
    schedule="0 9 * * *",
    input={"message": "Daily update"}
)

cron 客户端功能并非所有许可证都支持。请查阅相关许可证文档以获取最新功能可用性详情。

create_for_thread

方法

名称	描述
`为线程创建定时任务。`	创建定时运行。
`create`	删除定时任务。
`delete`	获取定时任务列表。
`search`	create_for_thread `async` ¶

要运行定时任务的线程 ID。

create_for_thread(
    thread_id: str,
    assistant_id: str,
    *,
    schedule: str,
    input: Optional[dict] = None,
    metadata: Optional[dict] = None,
    config: Optional[Config] = None,
    checkpoint_during: Optional[bool] = None,
    interrupt_before: Optional[
        Union[All, list[str]]
    ] = None,
    interrupt_after: Optional[Union[All, list[str]]] = None,
    webhook: Optional[str] = None,
    multitask_strategy: Optional[str] = None,
    headers: Optional[dict[str, str]] = None
) -> Run

创建定时运行。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	用于定时任务的助手 ID 或图名称。如果使用图名称，将默认为从该图创建的第一个助手。	必需
`assistant_id`	`str`	schedule	必需
`执行此任务的 cron 调度。`	`str`	分配给定时任务运行的元数据。	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`metadata`	`按元数据键值对过滤状态。`	可选[联合[All, list[str]]]	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`定时任务运行。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`定时任务运行。`	feedback_keys	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[MultitaskStrategy]`	`可选[str]`	if_not_exists	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`创建的后台运行。`	`创建的后台运行。`	create `async` ¶

用法示例

client = get_client(url="http://localhost:2024")
cron_run = await 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"},
    config={"configurable": {"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"
)

delete `async` ¶

create(
    assistant_id: str,
    *,
    schedule: str,
    input: Optional[dict] = None,
    metadata: Optional[dict] = None,
    config: Optional[Config] = None,
    checkpoint_during: Optional[bool] = None,
    interrupt_before: Optional[
        Union[All, list[str]]
    ] = None,
    interrupt_after: Optional[Union[All, list[str]]] = None,
    webhook: Optional[str] = None,
    multitask_strategy: Optional[str] = None,
    headers: Optional[dict[str, str]] = None
) -> Run

删除定时任务。

参数

名称	类型	描述	默认
`assistant_id`	`str`	schedule	必需
`执行此任务的 cron 调度。`	`str`	分配给定时任务运行的元数据。	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`metadata`	`按元数据键值对过滤状态。`	可选[联合[All, list[str]]]	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`定时任务运行。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`定时任务运行。`	feedback_keys	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[MultitaskStrategy]`	`可选[str]`	if_not_exists	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`创建的后台运行。`	`创建的后台运行。`	create `async` ¶

用法示例

client = get_client(url="http://localhost:2024")
cron_run = client.crons.create(
    assistant_id="agent",
    schedule="27 15 * * *",
    input={"messages": [{"role": "user", "content": "hello!"}]},
    metadata={"name":"my_run"},
    config={"configurable": {"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"
)

cron_id

delete(
    cron_id: str, headers: Optional[dict[str, str]] = None
) -> None

获取定时任务列表。

参数

名称	类型	描述	默认
`要删除的定时任务 ID。`	`str`	search `async` ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_client(url="http://localhost:2024")
await client.crons.delete(
    cron_id="cron_to_delete"
)

要搜索的助手 ID 或图名称。

search(
    *,
    assistant_id: Optional[str] = None,
    thread_id: Optional[str] = None,
    limit: int = 10,
    offset: int = 0,
    headers: Optional[dict[str, str]] = None
) -> list[Cron]

create_for_thread async ¶

参数

名称	类型	描述	默认
`assistant_id`	`可选[str]`	要搜索的线程 ID。	`无`
`要获取的线程 ID。`	`可选[str]`	list[Cron]	`无`
`limit`	`int`	要返回的最大结果数。	`10`
`offset`	`int`	要跳过的结果数。	`0`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Cron]: 搜索返回的定时任务列表。`	StoreClient ¶

用法示例

client = get_client(url="http://localhost:2024")
cron_jobs = await client.crons.search(
    assistant_id="my_assistant_id",
    thread_id="my_thread_id",
    limit=5,
    offset=5,
)
print(cron_jobs)

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

[
    {
        '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'
    }
]

存储提供了一个键值存储系统，用于在图执行期间持久化数据，从而允许跨线程进行有状态操作和数据共享。

用于与图的共享存储交互的客户端。

put_item

示例

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

方法

名称	描述
`存储或更新项目。`	get_item
`检索单个项目。`	delete_item
`删除项目。`	search_items
`在命名空间前缀内搜索项目。`	list_namespaces
`列出带可选匹配条件的命名空间。`	put_item `async` ¶

序列[str]

put_item(
    namespace: Sequence[str],
    /,
    key: str,
    value: dict[str, Any],
    index: Optional[
        Union[Literal[False], list[str]]
    ] = None,
    ttl: Optional[int] = None,
    headers: Optional[dict[str, str]] = None,
) -> None

get_item

参数

名称	类型	描述	默认
`namespace`	`表示命名空间路径的字符串列表。`	key	必需
`命名空间内项目的唯一标识符。`	`str`	value	必需
`包含项目数据的字典。`	`要与现有线程元数据合并的元数据。`	index	必需
`可选[联合[字面量[False], list[str]]]`	`控制搜索索引 - None（使用默认值）、False（禁用）或要索引的字段路径列表。`	ttl	`无`
`项目可选的存活时间（分钟），或 None 表示永不过期。`	`运行开始前等待的秒数。用于安排未来的运行。`	get_item `async` ¶	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_client(url="http://localhost:2024")
await client.store.put_item(
    ["documents", "user123"],
    key="item456",
    value={"title": "My Document", "content": "Hello World"}
)

项目的唯一标识符。

get_item(
    namespace: Sequence[str],
    /,
    key: str,
    *,
    refresh_ttl: Optional[bool] = None,
    headers: Optional[dict[str, str]] = None,
) -> Item

delete_item

参数

名称	类型	描述	默认
`命名空间内项目的唯一标识符。`	`str`	表示命名空间路径的可选字符串列表。	必需
`namespace`	`表示命名空间路径的字符串列表。`	refresh_ttl	必需
`是否在此读取操作时刷新 TTL。如果为 None，则使用存储的默认行为。`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	Item	`无`

返回

名称	类型	描述
`检索到的项目。`	`检索到的项目。`	delete_item `async` ¶
`headers`	`检索到的项目。`	可选的自定义请求头。

用法示例

client = get_client(url="http://localhost:2024")
item = await client.store.get_item(
    ["documents", "user123"],
    key="item456",
)
print(item)

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

{
    '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'
}

search_items `async` ¶

delete_item(
    namespace: Sequence[str],
    /,
    key: str,
    headers: Optional[dict[str, str]] = None,
) -> None

search_items

参数

名称	类型	描述	默认
`命名空间内项目的唯一标识符。`	`str`	表示命名空间路径的可选字符串列表。	必需
`namespace`	`表示命名空间路径的字符串列表。`	refresh_ttl	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_client(url="http://localhost:2024")
await client.store.delete_item(
    ["documents", "user123"],
    key="item456",
)

namespace_prefix

search_items(
    namespace_prefix: Sequence[str],
    /,
    filter: Optional[dict[str, Any]] = None,
    limit: int = 10,
    offset: int = 0,
    query: Optional[str] = None,
    refresh_ttl: Optional[bool] = None,
    headers: Optional[dict[str, str]] = None,
) -> SearchItemsResponse

list_namespaces

参数

名称	类型	描述	默认
`表示命名空间前缀的字符串列表。`	`表示命名空间路径的字符串列表。`	filter	必需
`可选[dict[str, Any]]`	`可选的键值对字典，用于过滤结果。`	要返回的最大项目数（默认为 10）。	`无`
`limit`	`int`	在返回结果之前要跳过的项目数（默认为 0）。	`10`
`offset`	`int`	query	`0`
`自然语言搜索的可选查询。`	`可选[str]`	是否在此搜索时刷新返回项目的 TTL。如果为 None，则使用存储的默认行为。	`无`
`是否在此读取操作时刷新 TTL。如果为 None，则使用存储的默认行为。`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	SearchItemsResponse	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Item]: 匹配搜索条件的项目列表。`	list_namespaces `async` ¶

用法示例

client = get_client(url="http://localhost:2024")
items = await client.store.search_items(
    ["documents"],
    filter={"author": "John Doe"},
    limit=5,
    offset=0
)
print(items)

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

{
    "items": [
        {
            "namespace": ["documents", "user123"],
            "key": "item789",
            "value": {
                "title": "Another Document",
                "author": "John Doe"
            },
            "created_at": "2024-07-30T12:00:00Z",
            "updated_at": "2024-07-30T12:00:00Z"
        },
        # ... additional items ...
    ]
}

prefix

list_namespaces(
    prefix: Optional[list[str]] = None,
    suffix: Optional[list[str]] = None,
    max_depth: Optional[int] = None,
    limit: int = 100,
    offset: int = 0,
    headers: Optional[dict[str, str]] = None,
) -> ListNamespaceResponse

put_item async ¶

参数

名称	类型	描述	默认
`可选[list[str]]`	`表示要过滤命名空间的前缀的可选字符串列表。`	suffix	`无`
`表示要过滤命名空间的后缀的可选字符串列表。`	`表示要过滤命名空间的前缀的可选字符串列表。`	max_depth	`无`
`指定要返回的命名空间最大深度的可选整数。`	`运行开始前等待的秒数。用于安排未来的运行。`	要返回的最大命名空间数（默认为 100）。	`无`
`limit`	`int`	在返回结果之前要跳过的命名空间数（默认为 0）。	`100`
`offset`	`int`	ListNamespaceResponse	`0`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[list[str]]: 匹配条件的命名空间列表。`	SyncLangGraphClient ¶

用法示例

client = get_client(url="http://localhost:2024")
namespaces = await client.store.list_namespaces(
    prefix=["documents"],
    max_depth=3,
    limit=10,
    offset=0
)
print(namespaces)

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

[
    ["documents", "user123", "reports"],
    ["documents", "user456", "invoices"],
    ...
]

此类提供对 LangGraph API 端点的同步访问，用于管理助手、线程、运行、定时任务和数据存储。

用于与 LangGraph API 交互的同步客户端。

SyncHttpClient ¶

示例

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

在底层 httpx 客户端之上提供错误消息和内容处理增强功能，镜像 HttpClient 的接口，但用于同步用法。

处理对 LangGraph API 的同步请求。

Client

属性

名称	类型	描述
`client`	`底层 HTTPX 同步客户端。`	使用 SSE 流式传输请求结果。

方法

名称	描述
`get`	发送 GET 请求。
`post`	发送 POST 请求。
`put`	发送 PUT 请求。
`patch`	发送 PATCH 请求。
`delete`	发送 DELETE 请求。
`stream`	get ¶

post ¶

get(
    path: str,
    *,
    params: Optional[QueryParamTypes] = None,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> Any

发送 GET 请求。

put ¶

post(
    path: str,
    *,
    json: Optional[dict],
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> Any

发送 POST 请求。

patch ¶

put(
    path: str,
    *,
    json: dict,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> Any

发送 PUT 请求。

delete ¶

patch(
    path: str,
    *,
    json: dict,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> Any

发送 PATCH 请求。

stream ¶

delete(
    path: str,
    *,
    json: Optional[Any] = None,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> None

发送 DELETE 请求。

SyncAssistantsClient ¶

stream(
    path: str,
    method: str,
    *,
    json: Optional[dict] = None,
    params: Optional[QueryParamTypes] = None,
    headers: Optional[dict[str, str]] = None,
    on_response: Optional[Callable[[Response], None]] = None
) -> Iterator[StreamPart]

get ¶

用于在 LangGraph 中同步管理助手的客户端。

此类提供与助手交互的方法，助手是图的版本化配置。

示例

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

方法

名称	描述
`get`	通过 ID 获取助手。
`get_graph`	通过 ID 获取助手的图。
`get_schemas`	通过 ID 获取助手的模式。
`get_subgraphs`	通过 ID 获取助手的模式。
`create`	创建新助手。
`update`	更新助手。
`delete`	删除助手。
`search`	搜索助手。
`get_versions`	列出助手的所有版本。
`set_latest`	更改助手的版本。

要获取的助手 ID 或图名称（用于使用默认助手）。

get(
    assistant_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> Assistant

通过 ID 获取助手。

参数

名称	类型	描述	默认
`assistant_id`	`str`	get_graph ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`Assistant`	`Assistant`	助手对象。

用法示例

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

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

{
    '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'}
}

get_schemas ¶

get_graph(
    assistant_id: str,
    *,
    xray: Union[int, bool] = False,
    headers: Optional[dict[str, str]] = None
) -> dict[str, list[dict[str, Any]]]

通过 ID 获取助手的图。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要获取其图的助手的 ID。	必需
`xray`	`联合[int, bool]`	包含子图的图表示。如果提供了整数值，则只包含深度小于或等于该值的子图。	`False`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`Graph`	`dict[str, list[dict[str, Any]]]`	助手的图信息，JSON 格式。

用法示例

client = get_sync_client(url="http://localhost:2024")
graph_info = client.assistants.get_graph(
    assistant_id="my_assistant_id"
)
print(graph_info)

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

{
    'nodes':
        [
            {'id': '__start__', 'type': 'schema', 'data': '__start__'},
            {'id': '__end__', 'type': 'schema', 'data': '__end__'},
            {'id': 'agent','type': 'runnable','data': {'id': ['langgraph', 'utils', 'RunnableCallable'],'name': 'agent'}},
        ],
    'edges':
        [
            {'source': '__start__', 'target': 'agent'},
            {'source': 'agent','target': '__end__'}
        ]
}

get_subgraphs ¶

get_schemas(
    assistant_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> GraphSchema

通过 ID 获取助手的模式。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要获取其模式的助手的 ID。	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`GraphSchema`	`GraphSchema`	助手的图模式。

用法示例

client = get_sync_client(url="http://localhost:2024")
schema = client.assistants.get_schemas(
    assistant_id="my_assistant_id"
)
print(schema)

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

{
    'graph_id': 'agent',
    'state_schema':
        {
            'title': 'LangGraphInput',
            '$ref': '#/definitions/AgentState',
            'definitions':
                {
                    'BaseMessage':
                        {
                            'title': 'BaseMessage',
                            'description': 'Base abstract Message class. Messages are the inputs and outputs of ChatModels.',
                            'type': 'object',
                            'properties':
                                {
                                 'content':
                                    {
                                        'title': 'Content',
                                        'anyOf': [
                                            {'type': 'string'},
                                            {'type': 'array','items': {'anyOf': [{'type': 'string'}, {'type': 'object'}]}}
                                        ]
                                    },
                                'additional_kwargs':
                                    {
                                        'title': 'Additional Kwargs',
                                        'type': 'object'
                                    },
                                'response_metadata':
                                    {
                                        'title': 'Response Metadata',
                                        'type': 'object'
                                    },
                                'type':
                                    {
                                        'title': 'Type',
                                        'type': 'string'
                                    },
                                'name':
                                    {
                                        'title': 'Name',
                                        'type': 'string'
                                    },
                                'id':
                                    {
                                        'title': 'Id',
                                        'type': 'string'
                                    }
                                },
                            'required': ['content', 'type']
                        },
                    'AgentState':
                        {
                            'title': 'AgentState',
                            'type': 'object',
                            'properties':
                                {
                                    'messages':
                                        {
                                            'title': 'Messages',
                                            'type': 'array',
                                            'items': {'$ref': '#/definitions/BaseMessage'}
                                        }
                                },
                            'required': ['messages']
                        }
                }
        },
    'config_schema':
        {
            'title': 'Configurable',
            'type': 'object',
            'properties':
                {
                    'model_name':
                        {
                            'title': 'Model Name',
                            'enum': ['anthropic', 'openai'],
                            'type': 'string'
                        }
                }
        }
}

create ¶

get_subgraphs(
    assistant_id: str,
    namespace: Optional[str] = None,
    recurse: bool = False,
    *,
    headers: Optional[dict[str, str]] = None
) -> Subgraphs

通过 ID 获取助手的模式。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要获取其模式的助手的 ID。	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`Subgraphs`	`Subgraphs`	助手的图模式。

update ¶

create(
    graph_id: Optional[str],
    config: Optional[Config] = None,
    *,
    metadata: Json = None,
    assistant_id: Optional[str] = None,
    if_exists: Optional[OnConflictBehavior] = None,
    name: Optional[str] = None,
    headers: Optional[dict[str, str]] = None,
    description: Optional[str] = None
) -> Assistant

创建新助手。

当图是可配置的且您希望基于不同配置创建不同助手时很有用。

参数

名称	类型	描述	默认
`graph_id`	`可选[str]`	助手应使用的图的 ID。图 ID 通常在 langgraph.json 配置中设置。	必需
`config`	`可选[Config]`	用于图的配置。	`无`
`metadata`	`Json`	要添加到助手的元数据。	`无`
`assistant_id`	`可选[str]`	要使用的助手 ID，如果未提供，将默认为随机 UUID。	`无`
`if_exists`	`可选[OnConflictBehavior]`	如何处理重复创建。默认在底层为 'raise'。必须是 'raise'（如果重复则抛出错误）或 'do_nothing'（返回现有助手）。	`无`
`name`	`可选[str]`	助手的名称。默认在底层为 'Untitled'。	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`
`description`	`可选[str]`	助手的可选描述。 description 字段适用于 langgraph-api server 版本 >=0.0.45	`无`

返回

名称	类型	描述
`Assistant`	`Assistant`	创建的助手。

用法示例

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

delete ¶

update(
    assistant_id: str,
    *,
    graph_id: Optional[str] = None,
    config: Optional[Config] = None,
    metadata: Json = None,
    name: Optional[str] = None,
    headers: Optional[dict[str, str]] = None,
    description: Optional[str] = None
) -> Assistant

更新助手。

使用此方法指向不同的图、更新配置或更改助手的元数据。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要更新的助手。	必需
`graph_id`	`可选[str]`	助手应使用的图的 ID。图 ID 通常在 langgraph.json 配置中设置。如果为 None，助手将继续指向相同的图。	`无`
`config`	`可选[Config]`	用于图的配置。	`无`
`metadata`	`Json`	要与现有助手元数据合并的元数据。	`无`
`name`	`可选[str]`	助手的新名称。	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`
`description`	`可选[str]`	助手的可选描述。 description 字段适用于 langgraph-api server 版本 >=0.0.45	`无`

返回

名称	类型	描述
`Assistant`	`Assistant`	已更新的助手。

用法示例

client = get_sync_client(url="http://localhost:2024")
assistant = client.assistants.update(
    assistant_id='e280dad7-8618-443f-87f1-8e41841c180f',
    graph_id="other-graph",
    config={"configurable": {"model_name": "anthropic"}},
    metadata={"number":2}
)

search ¶

delete(
    assistant_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> None

删除助手。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要删除的助手 ID。	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_sync_client(url="http://localhost:2024")
client.assistants.delete(
    assistant_id="my_assistant_id"
)

get_versions ¶

search(
    *,
    metadata: Json = None,
    graph_id: Optional[str] = None,
    limit: int = 10,
    offset: int = 0,
    headers: Optional[dict[str, str]] = None
) -> list[Assistant]

搜索助手。

参数

名称	类型	描述	默认
`metadata`	`Json`	要过滤的元数据。每个键值对的精确匹配过滤。	`无`
`graph_id`	`可选[str]`	要过滤的图的 ID。图 ID 通常在 langgraph.json 配置中设置。	`无`
`limit`	`int`	要返回的最大结果数。	`10`
`offset`	`int`	要跳过的结果数。	`0`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Assistant]`	list[Assistant]: 助手列表。

用法示例

client = get_sync_client(url="http://localhost:2024")
assistants = client.assistants.search(
    metadata = {"name":"my_name"},
    graph_id="my_graph_id",
    limit=5,
    offset=5
)

set_latest ¶

get_versions(
    assistant_id: str,
    metadata: Json = None,
    limit: int = 10,
    offset: int = 0,
    *,
    headers: Optional[dict[str, str]] = None
) -> list[AssistantVersion]

列出助手的所有版本。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要获取版本的助手 ID。	必需
`metadata`	`Json`	用于过滤版本的元数据。每个键值对的精确匹配过滤。	`无`
`limit`	`int`	要返回的最大版本数。	`10`
`offset`	`int`	要跳过的版本数。	`0`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[AssistantVersion]`	list[Assistant]: 助手列表。

用法示例

client = get_sync_client(url="http://localhost:2024")
assistant_versions = client.assistants.get_versions(
    assistant_id="my_assistant_id"
)

SyncThreadsClient ¶

set_latest(
    assistant_id: str,
    version: int,
    *,
    headers: Optional[dict[str, str]] = None
) -> Assistant

更改助手的版本。

参数

名称	类型	描述	默认
`assistant_id`	`str`	要删除的助手 ID。	必需
`要更改到的版本。`	`int`	ThreadsClient ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`Assistant`	`Assistant`	助手对象。

用法示例

client = get_sync_client(url="http://localhost:2024")
new_version_assistant = client.assistants.set_latest(
    assistant_id="my_assistant_id",
    version=3
)

此类提供创建、检索和管理线程的方法，线程表示对话或有状态交互。

用于在 LangGraph 中管理线程的同步客户端。

get ¶

示例

client = get_sync_client(url="http://localhost:2024")
thread = client.threads.create(metadata={"user_id": "123"})

方法

名称	描述
`get`	创建新线程。
`create`	更新线程。
`update`	删除线程。
`delete`	搜索线程。
`search`	copy
`复制线程。`	get_state
`获取线程状态。`	update_state
`更新线程状态。`	get_history
`获取线程状态历史。`	get `async` ¶

create ¶

get(
    thread_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> Thread

创建新线程。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	Thread	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`线程对象。`	`线程对象。`	create `async` ¶

用法示例

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

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

{
    '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'}
}

create ¶

create(
    *,
    metadata: Json = None,
    thread_id: Optional[str] = None,
    if_exists: Optional[OnConflictBehavior] = None,
    supersteps: Optional[
        Sequence[dict[str, Sequence[dict[str, Any]]]]
    ] = None,
    graph_id: Optional[str] = None,
    headers: Optional[dict[str, str]] = None
) -> Thread

更新线程。

参数

名称	类型	描述	默认
`metadata`	`Json`	线程 ID。如果为 None，ID 将是随机生成的 UUID。	`无`
`要获取的线程 ID。`	`可选[str]`	如何处理重复创建。默认在底层为 'raise'。必须是 'raise'（如果重复则抛出错误）或 'do_nothing'（返回现有线程）。	`无`
`if_exists`	`可选[OnConflictBehavior]`	supersteps	`无`
`可选[序列[dict[str, 序列[dict[str, Any]]]]]`	`创建线程时应用超步列表，每个超步包含一系列更新。每次更新都有 values 或 command 和 as_node。用于在部署之间复制线程。`	与线程关联的可选图 ID。	`无`
`graph_id`	`可选[str]`	创建的线程。	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`线程对象。`	`线程对象。`	update `async` ¶

用法示例

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

)

update ¶

update(
    thread_id: str,
    *,
    metadata: dict[str, Any],
    headers: Optional[dict[str, str]] = None
) -> Thread

删除线程。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	dict[str, Any]	必需
`metadata`	`要与现有线程元数据合并的元数据。`	delete `async` ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`线程对象。`	`线程对象。`	update `async` ¶

用法示例

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

delete ¶

delete(
    thread_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> None

搜索线程。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	search `async` ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client.threads.delete(
    thread_id="my_thread_id"
)

search ¶

search(
    *,
    metadata: Json = None,
    values: Json = None,
    status: Optional[ThreadStatus] = None,
    limit: int = 10,
    offset: int = 0,
    headers: Optional[dict[str, str]] = None
) -> list[Thread]

copy

参数

名称	类型	描述	默认
`metadata`	`Json`	values	`无`
`要过滤的状态值。`	`Json`	status	`无`
`可选[ThreadStatus]`	`要过滤的线程状态。必须是 'idle'、'busy'、'interrupted' 或 'error' 之一。`	要返回的线程数量限制。	`无`
`limit`	`int`	在线程表中开始搜索的偏移量。	`10`
`offset`	`int`	可选[ThreadSortBy]	`0`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Thread]: 匹配搜索参数的线程列表。`	copy `async` ¶

用法示例

client = get_sync_client(url="http://localhost:2024")
threads = client.threads.search(
    metadata={"number":1},
    status="interrupted",
    limit=15,
    offset=5
)

copy ¶

copy(
    thread_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> None

get_state

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	get_state `async` ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

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

get_state ¶

get_state(
    thread_id: str,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    *,
    subgraphs: bool = False,
    headers: Optional[dict[str, str]] = None
) -> ThreadState

update_state

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	checkpoint	必需
`可选[Checkpoint]`	`要获取状态的检查点。`	checkpoint_id	`无`
`包含子图状态。`	`bool`	ThreadState	`False`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`线程的状态。`	`线程的状态。`	update_state `async` ¶

用法示例

client = get_sync_client(url="http://localhost:2024")
thread_state = client.threads.get_state(
    thread_id="my_thread_id",
    checkpoint_id="my_checkpoint_id"
)
print(thread_state)

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

{
    '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'
        }
}

update_state ¶

update_state(
    thread_id: str,
    values: Optional[Union[dict, Sequence[dict]]],
    *,
    as_node: Optional[str] = None,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    headers: Optional[dict[str, str]] = None
) -> ThreadUpdateStateResponse

get_history

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	可选[联合[dict, 序列[dict]]]	必需
`要过滤的状态值。`	`用于更新状态的值。`	as_node	必需
`更新状态，就好像这个节点刚刚执行过一样。`	`可选[str]`	要更新状态的检查点。	`无`
`可选[Checkpoint]`	`要获取状态的检查点。`	(已弃用) 要更新状态的检查点 ID。	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`更新线程状态后的响应。`	`更新线程状态后的响应。`	get_history `async` ¶

用法示例

response = await client.threads.update_state(
    thread_id="my_thread_id",
    values={"messages":[{"role": "user", "content": "hello!"}]},
    as_node="my_node",
)
print(response)

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

{
    'checkpoint': {
        'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
        'checkpoint_ns': '',
        'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1',
        'checkpoint_map': {}
    }
}

get_history ¶

get_history(
    thread_id: str,
    *,
    limit: int = 10,
    before: Optional[str | Checkpoint] = None,
    metadata: Optional[dict] = None,
    checkpoint: Optional[Checkpoint] = None,
    headers: Optional[dict[str, str]] = None
) -> list[ThreadState]

get async ¶

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	返回此子图的状态。如果为空，则默认为根。	必需
`可选[Checkpoint]`	`要获取状态的检查点。`	要返回的最大状态数。	`无`
`limit`	`int`	before	`10`
`可选[str \| Checkpoint]`	`在此检查点之前返回状态。`	可选[dict]	`无`
`metadata`	`按元数据键值对过滤状态。`	list[ThreadState]	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[ThreadState]: 线程的状态历史。`	RunsClient ¶

用法示例

thread_state = client.threads.get_history(
    thread_id="my_thread_id",
    limit=5,
    before="my_timestamp",
    metadata={"name":"my_name"}
)

SyncRunsClient ¶

用于在 LangGraph 中管理运行的同步客户端。

此类提供创建、检索和管理运行（表示图的独立执行）的方法。

示例

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

方法

名称	描述
`stream`	创建后台运行。
`create`	create_batch
`创建一批无状态后台运行。`	wait
`创建运行，等待其完成并返回最终状态。`	list
`列出运行。`	获取运行。
`get`	cancel
`join`	cancel
`阻塞直到运行完成。返回线程的最终状态。`	join_stream
`实时流式传输运行输出，直到运行完成。`	删除运行。
`delete`	stream ¶

stream ¶

stream(
    thread_id: Optional[str],
    assistant_id: str,
    *,
    input: Optional[dict] = None,
    command: Optional[Command] = None,
    stream_mode: Union[
        StreamMode, Sequence[StreamMode]
    ] = "values",
    stream_subgraphs: bool = False,
    stream_resumable: bool = False,
    metadata: Optional[dict] = None,
    config: Optional[Config] = None,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    checkpoint_during: Optional[bool] = None,
    interrupt_before: Optional[
        Union[All, Sequence[str]]
    ] = None,
    interrupt_after: Optional[
        Union[All, Sequence[str]]
    ] = None,
    feedback_keys: Optional[Sequence[str]] = None,
    on_disconnect: Optional[DisconnectMode] = None,
    on_completion: Optional[OnCompletionBehavior] = None,
    webhook: Optional[str] = None,
    multitask_strategy: Optional[MultitaskStrategy] = None,
    if_not_exists: Optional[IfNotExists] = None,
    after_seconds: Optional[int] = None,
    headers: Optional[dict[str, str]] = None,
    on_run_created: Optional[
        Callable[[RunCreateMetadata], None]
    ] = None
) -> Iterator[StreamPart]

创建后台运行。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`可选[str]`	要从中流式传输的助手 ID 或图名称。如果使用图名称，将默认为从该图创建的第一个助手。	必需
`assistant_id`	`str`	input	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`可选[Command]`	`要执行的命令。不能与输入组合使用。`	要执行的命令。	`无`
`联合[StreamMode, 序列[StreamMode]]`	`要使用的流模式。`	'values'	`stream_subgraphs`
`是否流式传输子图的输出。`	`bool`	stream_resumable	`False`
`流是否可恢复。如果为 True，即使断开连接后，也可以完全恢复和重播流。`	`bool`	分配给运行的元数据。	`False`
`metadata`	`按元数据键值对过滤状态。`	助手的配置。	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[Checkpoint]`	`要获取状态的检查点。`	checkpoint_during	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`在执行前立即中断的节点。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`在执行前立即中断的节点。`	feedback_keys	`无`
`可选[序列[str]]`	`分配给运行的反馈键。`	on_disconnect	`无`
`可选[DisconnectMode]`	`要使用的断开连接模式。必须是 'cancel' 或 'continue' 之一。`	on_completion	`无`
`可选[OnCompletionBehavior]`	`是否删除或保留为无状态运行创建的线程。必须是 'delete' 或 'keep' 之一。`	webhook	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[MultitaskStrategy]`	`要使用的多任务策略。必须是 'reject'、'interrupt'、'rollback' 或 'enqueue' 之一。`	if_not_exists	`无`
`可选[IfNotExists]`	`如何处理缺失的线程。默认为 'reject'。必须是 'reject'（如果缺失则抛出错误）或 'create'（创建新线程）。`	after_seconds	`无`
`可选[int]`	`运行开始前等待的秒数。用于安排未来的运行。`	on_run_created	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`
`可选[可调用[[RunCreateMetadata], None]]`	`运行创建时的回调。`	Run	`无`

返回

类型	描述
`Iterator[StreamPart]`	Iterator[StreamPart]: 流结果的迭代器。

用法示例

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"},
    config={"configurable": {"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)

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

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)

create ¶

create(
    thread_id: Optional[str],
    assistant_id: str,
    *,
    input: Optional[dict] = None,
    command: Optional[Command] = None,
    stream_mode: Union[
        StreamMode, Sequence[StreamMode]
    ] = "values",
    stream_subgraphs: bool = False,
    stream_resumable: bool = False,
    metadata: Optional[dict] = None,
    config: Optional[Config] = None,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    checkpoint_during: Optional[bool] = None,
    interrupt_before: Optional[
        Union[All, Sequence[str]]
    ] = None,
    interrupt_after: Optional[
        Union[All, Sequence[str]]
    ] = None,
    webhook: Optional[str] = None,
    multitask_strategy: Optional[MultitaskStrategy] = None,
    on_completion: Optional[OnCompletionBehavior] = None,
    if_not_exists: Optional[IfNotExists] = None,
    after_seconds: Optional[int] = None,
    headers: Optional[dict[str, str]] = None,
    on_run_created: Optional[
        Callable[[RunCreateMetadata], None]
    ] = None
) -> Run

create_batch

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`可选[str]`	要从中流式传输的助手 ID 或图名称。如果使用图名称，将默认为从该图创建的第一个助手。	必需
`assistant_id`	`str`	input	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`可选[Command]`	`要执行的命令。不能与输入组合使用。`	要执行的命令。	`无`
`联合[StreamMode, 序列[StreamMode]]`	`要使用的流模式。`	'values'	`stream_subgraphs`
`是否流式传输子图的输出。`	`bool`	stream_resumable	`False`
`流是否可恢复。如果为 True，即使断开连接后，也可以完全恢复和重播流。`	`bool`	分配给运行的元数据。	`False`
`metadata`	`按元数据键值对过滤状态。`	助手的配置。	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[Checkpoint]`	`要获取状态的检查点。`	checkpoint_during	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`在执行前立即中断的节点。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`在执行前立即中断的节点。`	feedback_keys	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[MultitaskStrategy]`	`要使用的多任务策略。必须是 'reject'、'interrupt'、'rollback' 或 'enqueue' 之一。`	if_not_exists	`无`
`可选[OnCompletionBehavior]`	`是否删除或保留为无状态运行创建的线程。必须是 'delete' 或 'keep' 之一。`	webhook	`无`
`可选[IfNotExists]`	`如何处理缺失的线程。默认为 'reject'。必须是 'reject'（如果缺失则抛出错误）或 'create'（创建新线程）。`	after_seconds	`无`
`可选[int]`	`运行开始前等待的秒数。用于安排未来的运行。`	on_run_created	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`
`可选[可调用[[RunCreateMetadata], None]]`	`运行创建时的回调。`	Run	`无`

返回

名称	类型	描述
`创建的后台运行。`	`创建的后台运行。`	create_batch `async` ¶

用法示例

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"},
    config={"configurable": {"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)

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

{
    'run_id': 'my_run_id',
    'thread_id': 'my_thread_id',
    'assistant_id': 'my_assistant_id',
    'created_at': '2024-07-25T15:35:42.598503+00:00',
    'updated_at': '2024-07-25T15:35:42.598503+00:00',
    'metadata': {},
    'status': 'pending',
    'kwargs':
        {
            'input':
                {
                    'messages': [
                        {
                            'role': 'user',
                            'content': 'how are you?'
                        }
                    ]
                },
            'config':
                {
                    'metadata':
                        {
                            'created_by': 'system'
                        },
                    'configurable':
                        {
                            'run_id': 'my_run_id',
                            'user_id': None,
                            'graph_id': 'agent',
                            'thread_id': 'my_thread_id',
                            'checkpoint_id': None,
                            'model_name': "openai",
                            'assistant_id': 'my_assistant_id'
                        }
                },
            'webhook': "https://my.fake.webhook.com",
            'temporary': False,
            'stream_mode': ['values'],
            'feedback_keys': None,
            'interrupt_after': ["node_to_stop_after_1","node_to_stop_after_2"],
            'interrupt_before': ["node_to_stop_before_1","node_to_stop_before_2"]
        },
    'multitask_strategy': 'interrupt'
}

create_batch ¶

create_batch(
    payloads: list[RunCreate],
    *,
    headers: Optional[dict[str, str]] = None
) -> list[Run]

wait

wait ¶

wait(
    thread_id: Optional[str],
    assistant_id: str,
    *,
    input: Optional[dict] = None,
    command: Optional[Command] = None,
    metadata: Optional[dict] = None,
    config: Optional[Config] = None,
    checkpoint_during: Optional[bool] = None,
    checkpoint: Optional[Checkpoint] = None,
    checkpoint_id: Optional[str] = None,
    interrupt_before: Optional[
        Union[All, Sequence[str]]
    ] = None,
    interrupt_after: Optional[
        Union[All, Sequence[str]]
    ] = None,
    webhook: Optional[str] = None,
    on_disconnect: Optional[DisconnectMode] = None,
    on_completion: Optional[OnCompletionBehavior] = None,
    multitask_strategy: Optional[MultitaskStrategy] = None,
    if_not_exists: Optional[IfNotExists] = None,
    after_seconds: Optional[int] = None,
    headers: Optional[dict[str, str]] = None,
    on_run_created: Optional[
        Callable[[RunCreateMetadata], None]
    ] = None
) -> Union[list[dict], dict[str, Any]]

list

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`可选[str]`	要运行的助手 ID 或图名称。如果使用图名称，将默认为从该图创建的第一个助手。	必需
`assistant_id`	`str`	联合[list[dict], dict[str, Any]]	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`可选[Command]`	`要执行的命令。不能与输入组合使用。`	要执行的命令。	`无`
`metadata`	`按元数据键值对过滤状态。`	助手的配置。	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[Checkpoint]`	`要获取状态的检查点。`	checkpoint_during	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`在执行前立即中断的节点。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`在执行前立即中断的节点。`	feedback_keys	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[DisconnectMode]`	`要使用的断开连接模式。必须是 'cancel' 或 'continue' 之一。`	on_completion	`无`
`可选[OnCompletionBehavior]`	`是否删除或保留为无状态运行创建的线程。必须是 'delete' 或 'keep' 之一。`	webhook	`无`
`可选[MultitaskStrategy]`	`要使用的多任务策略。必须是 'reject'、'interrupt'、'rollback' 或 'enqueue' 之一。`	if_not_exists	`无`
`可选[IfNotExists]`	`如何处理缺失的线程。默认为 'reject'。必须是 'reject'（如果缺失则抛出错误）或 'create'（创建新线程）。`	after_seconds	`无`
`可选[int]`	`运行开始前等待的秒数。用于安排未来的运行。`	on_run_created	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`
`可选[可调用[[RunCreateMetadata], None]]`	`运行创建时的回调。`	Run	`无`

返回

类型	描述
`Union[list[dict], dict[str, Any]]`	list `async` ¶

用法示例

final_state_of_run = client.runs.wait(
    thread_id=None,
    assistant_id="agent",
    input={"messages": [{"role": "user", "content": "how are you?"}]},
    metadata={"name":"my_run"},
    config={"configurable": {"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"],
    webhook="https://my.fake.webhook.com",
    multitask_strategy="interrupt"
)
print(final_state_of_run)

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

{
    'messages': [
        {
            'content': 'how are you?',
            'additional_kwargs': {},
            'response_metadata': {},
            'type': 'human',
            'name': None,
            'id': 'f51a862c-62fe-4866-863b-b0863e8ad78a',
            '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-bf1cd3c6-768f-4c16-b62d-ba6f17ad8b36',
            'example': False,
            'tool_calls': [],
            'invalid_tool_calls': [],
            'usage_metadata': None
        }
    ]
}

list ¶

list(
    thread_id: str,
    *,
    limit: int = 10,
    offset: int = 0,
    headers: Optional[dict[str, str]] = None
) -> list[Run]

获取运行。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	可选[RunStatus]	必需
`limit`	`int`	要返回的最大结果数。	`10`
`offset`	`int`	要跳过的结果数。	`0`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Run]`	get `async` ¶

用法示例

client = get_sync_client(url="http://localhost:2024")
client.runs.list(
    thread_id="thread_id",
    limit=5,
    offset=5,
)

get ¶

get(
    thread_id: str,
    run_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> Run

cancel

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	run_id	必需
`要获取的运行 ID。`	`str`	运行对象。	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`创建的后台运行。`	`创建的后台运行。`	cancel `async` ¶

用法示例

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

cancel ¶

cancel(
    thread_id: str,
    run_id: str,
    *,
    wait: bool = False,
    action: CancelAction = "interrupt",
    headers: Optional[dict[str, str]] = None
) -> None

cancel

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	要取消的运行 ID。	必需
`要获取的运行 ID。`	`str`	是否等待运行完成。	必需
`创建运行，等待其完成并返回最终状态。`	`bool`	action	`False`
`CancelAction`	`取消运行时要执行的操作。可能的值为 interrupt 或 rollback。默认为 interrupt。`	'interrupt'	`join async ¶`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

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"
)

join ¶

join(
    thread_id: str,
    run_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> dict

join_stream

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	要加入的运行 ID。	必需
`要获取的运行 ID。`	`str`	dict	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`join_stream ¶`	无

用法示例

client = get_sync_client(url="http://localhost:2024")
client.runs.join(
    thread_id="thread_id_to_join",
    run_id="run_id_to_join"
)

join_stream ¶

join_stream(
    thread_id: str,
    run_id: str,
    *,
    stream_mode: Optional[
        Union[StreamMode, Sequence[StreamMode]]
    ] = None,
    cancel_on_disconnect: bool = False,
    headers: Optional[dict[str, str]] = None,
    last_event_id: Optional[str] = None
) -> Iterator[StreamPart]

cancel_on_disconnect

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	要加入的运行 ID。	必需
`要获取的运行 ID。`	`str`	dict	必需
`联合[StreamMode, 序列[StreamMode]]`	`要使用的流模式。必须是创建运行时传递的流模式的子集。后台运行默认包含所有流模式的并集。`	delete `async` ¶	`无`
`流断开连接时是否取消运行。`	`bool`	可选[联合[StreamMode, 序列[StreamMode]]]	`False`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`Iterator[StreamPart]`	无

用法示例

client = get_sync_client(url="http://localhost:2024")
client.runs.join_stream(
    thread_id="thread_id_to_join",
    run_id="run_id_to_join",
    stream_mode=["values", "debug"]
)

delete ¶

delete(
    thread_id: str,
    run_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> None

stream ¶

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	要删除的运行 ID。	必需
`要获取的运行 ID。`	`str`	CronClient ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_sync_client(url="http://localhost:2024")
client.runs.delete(
    thread_id="thread_id_to_delete",
    run_id="run_id_to_delete"
)

SyncCronClient ¶

用于在 LangGraph 中管理定时任务的同步客户端。

此类提供创建和管理用于自动化图执行的计划任务（cron 作业）的方法。

示例

client = get_sync_client(url="http://localhost:8123")
cron_job = client.crons.create_for_thread(thread_id="thread_123", assistant_id="asst_456", schedule="0 * * * *")

cron 客户端功能并非所有许可证都支持。请查阅相关许可证文档以获取最新功能可用性详情。

create_for_thread

方法

名称	描述
`为线程创建定时任务。`	创建定时运行。
`create`	删除定时任务。
`delete`	获取定时任务列表。
`search`	create_for_thread `async` ¶

create_for_thread ¶

create_for_thread(
    thread_id: str,
    assistant_id: str,
    *,
    schedule: str,
    input: Optional[dict] = None,
    metadata: Optional[dict] = None,
    checkpoint_during: Optional[bool] = None,
    config: Optional[Config] = None,
    interrupt_before: Optional[
        Union[All, list[str]]
    ] = None,
    interrupt_after: Optional[Union[All, list[str]]] = None,
    webhook: Optional[str] = None,
    multitask_strategy: Optional[str] = None,
    headers: Optional[dict[str, str]] = None
) -> Run

创建定时运行。

参数

名称	类型	描述	默认
`要获取的线程 ID。`	`str`	用于定时任务的助手 ID 或图名称。如果使用图名称，将默认为从该图创建的第一个助手。	必需
`assistant_id`	`str`	schedule	必需
`执行此任务的 cron 调度。`	`str`	分配给定时任务运行的元数据。	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`metadata`	`按元数据键值对过滤状态。`	可选[联合[All, list[str]]]	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`定时任务运行。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`定时任务运行。`	feedback_keys	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[MultitaskStrategy]`	`可选[str]`	if_not_exists	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`创建的后台运行。`	`创建的后台运行。`	create `async` ¶

用法示例

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"},
    config={"configurable": {"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"
)

create ¶

create(
    assistant_id: str,
    *,
    schedule: str,
    input: Optional[dict] = None,
    metadata: Optional[dict] = None,
    config: Optional[Config] = None,
    checkpoint_during: Optional[bool] = None,
    interrupt_before: Optional[
        Union[All, list[str]]
    ] = None,
    interrupt_after: Optional[Union[All, list[str]]] = None,
    webhook: Optional[str] = None,
    multitask_strategy: Optional[str] = None,
    headers: Optional[dict[str, str]] = None
) -> Run

删除定时任务。

参数

名称	类型	描述	默认
`assistant_id`	`str`	schedule	必需
`执行此任务的 cron 调度。`	`str`	分配给定时任务运行的元数据。	必需
`图的输入。`	`按元数据键值对过滤状态。`	command	`无`
`metadata`	`按元数据键值对过滤状态。`	可选[联合[All, list[str]]]	`无`
`config`	`可选[Config]`	要从其恢复的检查点。	`无`
`可选[bool]`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	interrupt_before	`无`
`可选[联合[All, 序列[str]]]`	`定时任务运行。`	interrupt_after	`无`
`在执行后立即中断的节点。`	`定时任务运行。`	feedback_keys	`无`
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	multitask_strategy	`无`
`可选[MultitaskStrategy]`	`可选[str]`	if_not_exists	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`创建的后台运行。`	`创建的后台运行。`	create `async` ¶

用法示例

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"},
    config={"configurable": {"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"
)

delete ¶

delete(
    cron_id: str,
    *,
    headers: Optional[dict[str, str]] = None
) -> None

获取定时任务列表。

参数

名称	类型	描述	默认
`要删除的定时任务 ID。`	`str`	search `async` ¶	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_sync_client(url="http://localhost:8123")
client.crons.delete(
    cron_id="cron_to_delete"
)

search ¶

search(
    *,
    assistant_id: Optional[str] = None,
    thread_id: Optional[str] = None,
    limit: int = 10,
    offset: int = 0,
    headers: Optional[dict[str, str]] = None
) -> list[Cron]

create_for_thread async ¶

参数

名称	类型	描述	默认
`assistant_id`	`可选[str]`	要搜索的线程 ID。	`无`
`要获取的线程 ID。`	`可选[str]`	list[Cron]	`无`
`limit`	`int`	要返回的最大结果数。	`10`
`offset`	`int`	要跳过的结果数。	`0`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Cron]: 搜索返回的定时任务列表。`	StoreClient ¶

用法示例

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

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

[
    {
        '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'
    }
]

SyncStoreClient ¶

用于对键值存储进行同步操作的客户端。

提供与远程键值存储交互的方法，允许在命名空间层次结构中存储和检索项目。

示例

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

方法

名称	描述
`存储或更新项目。`	get_item
`检索单个项目。`	delete_item
`删除项目。`	search_items
`在命名空间前缀内搜索项目。`	list_namespaces
`列出带可选匹配条件的命名空间。`	put_item `async` ¶

put_item ¶

put_item(
    namespace: Sequence[str],
    /,
    key: str,
    value: dict[str, Any],
    index: Optional[
        Union[Literal[False], list[str]]
    ] = None,
    ttl: Optional[int] = None,
    headers: Optional[dict[str, str]] = None,
) -> None

get_item

参数

名称	类型	描述	默认
`namespace`	`表示命名空间路径的字符串列表。`	key	必需
`命名空间内项目的唯一标识符。`	`str`	value	必需
`包含项目数据的字典。`	`要与现有线程元数据合并的元数据。`	index	必需
`可选[联合[字面量[False], list[str]]]`	`控制搜索索引 - None（使用默认值）、False（禁用）或要索引的字段路径列表。`	ttl	`无`
`项目可选的存活时间（分钟），或 None 表示永不过期。`	`运行开始前等待的秒数。用于安排未来的运行。`	get_item `async` ¶	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_sync_client(url="http://localhost:8123")
client.store.put_item(
    ["documents", "user123"],
    key="item456",
    value={"title": "My Document", "content": "Hello World"}
)

get_item ¶

get_item(
    namespace: Sequence[str],
    /,
    key: str,
    *,
    refresh_ttl: Optional[bool] = None,
    headers: Optional[dict[str, str]] = None,
) -> Item

delete_item

参数

名称	类型	描述	默认
`命名空间内项目的唯一标识符。`	`str`	表示命名空间路径的可选字符串列表。	必需
`namespace`	`表示命名空间路径的字符串列表。`	refresh_ttl	必需
`是否在此读取操作时刷新 TTL。如果为 None，则使用存储的默认行为。`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	Item	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

名称	类型	描述
`检索到的项目。`	`检索到的项目。`	delete_item `async` ¶

用法示例

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

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

{
    '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'
}

delete_item ¶

delete_item(
    namespace: Sequence[str],
    /,
    key: str,
    headers: Optional[dict[str, str]] = None,
) -> None

search_items

参数

名称	类型	描述	默认
`命名空间内项目的唯一标识符。`	`str`	表示命名空间路径的可选字符串列表。	必需
`namespace`	`表示命名空间路径的字符串列表。`	refresh_ttl	必需
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`无`	无

用法示例

client = get_sync_client(url="http://localhost:8123")
client.store.delete_item(
    ["documents", "user123"],
    key="item456",
)

search_items ¶

search_items(
    namespace_prefix: Sequence[str],
    /,
    filter: Optional[dict[str, Any]] = None,
    limit: int = 10,
    offset: int = 0,
    query: Optional[str] = None,
    refresh_ttl: Optional[bool] = None,
    headers: Optional[dict[str, str]] = None,
) -> SearchItemsResponse

list_namespaces

参数

名称	类型	描述	默认
`表示命名空间前缀的字符串列表。`	`表示命名空间路径的字符串列表。`	filter	必需
`可选[dict[str, Any]]`	`可选的键值对字典，用于过滤结果。`	要返回的最大项目数（默认为 10）。	`无`
`limit`	`int`	在返回结果之前要跳过的项目数（默认为 0）。	`10`
`offset`	`int`	query	`0`
`自然语言搜索的可选查询。`	`可选[str]`	是否在此搜索时刷新返回项目的 TTL。如果为 None，则使用存储的默认行为。	`无`
`是否在此读取操作时刷新 TTL。如果为 None，则使用存储的默认行为。`	`是否在运行期间（或仅在结束/中断时）进行检查点。`	SearchItemsResponse	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[Item]: 匹配搜索条件的项目列表。`	list_namespaces `async` ¶

用法示例

client = get_sync_client(url="http://localhost:8123")
items = client.store.search_items(
    ["documents"],
    filter={"author": "John Doe"},
    limit=5,
    offset=0
)
print(items)

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

{
    "items": [
        {
            "namespace": ["documents", "user123"],
            "key": "item789",
            "value": {
                "title": "Another Document",
                "author": "John Doe"
            },
            "created_at": "2024-07-30T12:00:00Z",
            "updated_at": "2024-07-30T12:00:00Z"
        },
        # ... additional items ...
    ]
}

list_namespaces ¶

list_namespaces(
    prefix: Optional[list[str]] = None,
    suffix: Optional[list[str]] = None,
    max_depth: Optional[int] = None,
    limit: int = 100,
    offset: int = 0,
    headers: Optional[dict[str, str]] = None,
) -> ListNamespaceResponse

put_item async ¶

参数

名称	类型	描述	默认
`可选[list[str]]`	`表示要过滤命名空间的前缀的可选字符串列表。`	suffix	`无`
`表示要过滤命名空间的后缀的可选字符串列表。`	`表示要过滤命名空间的前缀的可选字符串列表。`	max_depth	`无`
`指定要返回的命名空间最大深度的可选整数。`	`运行开始前等待的秒数。用于安排未来的运行。`	要返回的最大命名空间数（默认为 100）。	`无`
`limit`	`int`	在返回结果之前要跳过的命名空间数（默认为 0）。	`100`
`offset`	`int`	ListNamespaceResponse	`0`
`headers`	`可选[dict[str, str]]`	可选的自定义请求头。	`无`

返回

类型	描述
`list[list[str]]: 匹配条件的命名空间列表。`	SyncLangGraphClient ¶

用法示例

client = get_sync_client(url="http://localhost:8123")
namespaces = client.store.list_namespaces(
    prefix=["documents"],
    max_depth=3,
    limit=10,
    offset=0
)
print(namespaces)

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

[
    ["documents", "user123", "reports"],
    ["documents", "user456", "invoices"],
    ...
]

get_client ¶

get_client(
    *,
    url: Optional[str] = None,
    api_key: Optional[str] = None,
    headers: Optional[dict[str, str]] = None,
    timeout: Optional[TimeoutTypes] = None
) -> LangGraphClient

获取 LangGraphClient 实例。

参数

名称	类型	描述	默认
`url`	`可选[str]`	LangGraph API 的 URL。	`无`
`api_key`	`可选[str]`	API 密钥。如果未提供，将从环境中读取。优先级：1. 显式参数 2. LANGGRAPH_API_KEY 3. LANGSMITH_API_KEY 4. LANGCHAIN_API_KEY	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义头部	`无`
`timeout`	`可选[TimeoutTypes]`	HTTP 客户端的可选超时配置。接受 httpx.Timeout 实例、浮点数（秒）或超时元组。元组格式为 (connect, read, write, pool)。如果未提供，默认为 connect=5s, read=300s, write=300s, pool=5s。	`无`

返回

名称	类型	描述
`LangGraphClient`	`LangGraphClient`	用于访问 AssistantsClient、
	`LangGraphClient`	ThreadsClient、RunsClient 和 CronClient 的顶层客户端。

示例

from langgraph_sdk import get_client

# get top-level LangGraphClient
client = get_client(url="http://localhost:8123")

# example usage: client.<model>.<method_name>()
assistants = await client.assistants.get(assistant_id="some_uuid")

get_sync_client ¶

get_sync_client(
    *,
    url: Optional[str] = None,
    api_key: Optional[str] = None,
    headers: Optional[dict[str, str]] = None,
    timeout: Optional[TimeoutTypes] = None
) -> SyncLangGraphClient

获取同步 LangGraphClient 实例。

参数

名称	类型	描述	默认
`url`	`可选[str]`	LangGraph API 的 URL。	`无`
`api_key`	`可选[str]`	API 密钥。如果未提供，将从环境中读取。优先级：1. 显式参数 2. LANGGRAPH_API_KEY 3. LANGSMITH_API_KEY 4. LANGCHAIN_API_KEY	`无`
`headers`	`可选[dict[str, str]]`	可选的自定义头部	`无`
`timeout`	`可选[TimeoutTypes]`	HTTP 客户端的可选超时配置。接受 httpx.Timeout 实例、浮点数（秒）或超时元组。元组格式为 (connect, read, write, pool)。如果未提供，默认为 connect=5s, read=300s, write=300s, pool=5s。	`无`

返回：SyncLangGraphClient：用于访问 AssistantsClient、ThreadsClient、RunsClient 和 CronClient 的顶层同步客户端。

示例

from langgraph_sdk import get_sync_client

# get top-level synchronous LangGraphClient
client = get_sync_client(url="http://localhost:8123")

# example usage: client.<model>.<method_name>()
assistant = client.assistants.get(assistant_id="some_uuid")

用于与 LangGraph API 交互的数据模型。

类

名称	描述
`配置`	调用的配置选项。
`检查点`	表示执行过程中的一个检查点。
`GraphSchema`	定义图的结构和属性。
`AssistantBase`	助手的基本模型。
`AssistantVersion`	表示助手的特定版本。
`Assistant`	表示具有附加属性的助手。
`中断`	表示执行流中的中断。
`线程对象。`	表示对话线程。
`ThreadTask`	表示线程中的任务。
`线程的状态。`	表示线程的状态。
`更新线程状态后的响应。`	表示更新线程状态的响应。
`创建的后台运行。`	表示单个执行运行。
`Cron`	表示计划任务。
`RunCreate`	定义启动后台运行的参数。
`检索到的项目。`	表示图存储中的单个文档或数据条目。
`list[list[str]]: 匹配条件的命名空间列表。`	列出命名空间的响应结构。
`SearchItem`	包含来自搜索操作的可选相关性得分的项目。
`list[Item]: 匹配搜索条件的项目列表。`	搜索项目的响应结构。
`StreamPart`	表示流响应的一部分。
`发送`	表示要发送到图中特定节点的消息。
`Command`	表示一个或多个命令，用于控制图的执行流程和状态。
`RunCreateMetadata`	运行创建请求的元数据。

属性

名称	类型	描述
`Json`		表示一个类似 JSON 的结构，可以是 None 或带有字符串键和任意值的字典。
`RunStatus`		表示运行的状态
`ThreadStatus`		表示线程的状态
`StreamMode`		定义流模式
`DisconnectMode`		指定断开连接时的行为
`MultitaskStrategy`		定义如何处理多个任务
`OnConflictBehavior`		指定冲突时的行为
`OnCompletionBehavior`		定义完成后的操作
`All`		表示通配符或“全部”选择器。
`IfNotExists`		如果线程不存在，则指定行为
`取消运行时要执行的操作。可能的值为 interrupt 或 rollback。默认为 interrupt。`		取消运行时的操作。
`AssistantSortBy`		要排序的字段。
`ThreadSortBy`		要排序的字段。
`SortOrder`		排序顺序。

Json `module-attribute` ¶

Json = Optional[dict[str, Any]]

表示一个类似 JSON 的结构，可以是 None 或带有字符串键和任意值的字典。

RunStatus `module-attribute` ¶

RunStatus = Literal[
    "pending",
    "running",
    "error",
    "success",
    "timeout",
    "interrupted",
]

表示运行的状态：- "pending"：运行正在等待开始。- "running"：运行正在执行。- "error"：运行遇到错误并停止。- "success"：运行成功完成。- "timeout"：运行超出时间限制。- "interrupted"：运行被手动停止或中断。

ThreadStatus `module-attribute` ¶

ThreadStatus = Literal[
    "idle", "busy", "interrupted", "error"
]

表示线程的状态：- "idle"：线程当前未处理任何任务。- "busy"：线程正在积极处理任务。- "interrupted"：线程的执行被中断。- "error"：任务处理过程中发生异常。

StreamMode `module-attribute` ¶

StreamMode = Literal[
    "values",
    "messages",
    "updates",
    "events",
    "debug",
    "custom",
    "messages-tuple",
]

定义流模式：- "values"：仅流式传输值。- "messages"：流式传输完整消息。- "updates"：流式传输状态更新。- "events"：流式传输执行过程中发生的事件。- "debug"：流式传输详细调试信息。- "custom"：流式传输自定义事件。

DisconnectMode `module-attribute` ¶

DisconnectMode = Literal['cancel', 'continue']

指定断开连接时的行为：- "cancel"：断开连接时取消操作。- "continue"：即使断开连接也继续操作。

MultitaskStrategy `module-attribute` ¶

MultitaskStrategy = Literal[
    "reject", "interrupt", "rollback", "enqueue"
]

定义如何处理多个任务：- "reject"：繁忙时拒绝新任务。- "interrupt"：为新任务中断当前任务。- "rollback"：回滚当前任务并开始新任务。- "enqueue"：将新任务排队以供后续执行。

OnConflictBehavior `module-attribute` ¶

OnConflictBehavior = Literal['raise', 'do_nothing']

指定冲突时的行为：- "raise"：发生冲突时引发异常。- "do_nothing"：忽略冲突并继续。

OnCompletionBehavior `module-attribute` ¶

OnCompletionBehavior = Literal['delete', 'keep']

定义完成后的操作：- "delete"：完成后删除资源。- "keep"：完成后保留资源。

All `module-attribute` ¶

All = Literal['*']

表示通配符或“全部”选择器。

IfNotExists `module-attribute` ¶

IfNotExists = Literal['create', 'reject']

如果线程不存在，则指定行为：- "create"：如果线程不存在则创建新线程。- "reject"：如果线程不存在则拒绝操作。

CancelAction ¶

CancelAction = Literal['interrupt', 'rollback']

取消运行时要执行的操作。- "interrupt"：简单地取消运行。- "rollback"：取消运行。然后删除运行和相关检查点。

AssistantSortBy `module-attribute` ¶

AssistantSortBy = Literal[
    "assistant_id",
    "graph_id",
    "name",
    "created_at",
    "updated_at",
]

要排序的字段。

ThreadSortBy `module-attribute` ¶

ThreadSortBy = Literal[
    "thread_id", "status", "created_at", "updated_at"
]

要排序的字段。

SortOrder `module-attribute` ¶

SortOrder = Literal['asc', 'desc']

排序顺序。

Config ¶

基类：TypedDict

调用的配置选项。

属性

名称	类型	描述
`标签`	`列表[字符串]`	此调用及任何子调用（例如，调用 LLM 的链）的标签。
`recursion_limit`	`int`	调用可递归的最大次数。如果未提供，默认为 25。
`configurable`	`要与现有线程元数据合并的元数据。`	此 Runnable 上以前可配置的属性的运行时值，

tags `instance-attribute` ¶

tags: list[str]

此调用及任何子调用（例如，调用 LLM 的链）的标签。您可以使用这些标签来过滤调用。

recursion_limit `instance-attribute` ¶

recursion_limit: int

调用可递归的最大次数。如果未提供，默认为 25。

configurable `instance-attribute` ¶

configurable: dict[str, Any]

通过 .configurable_fields() 或 .configurable_alternatives() 在此 Runnable 或子 Runnable 上先前设置为可配置的属性的运行时值。请检查 .output_schema() 以获取已设置为可配置的属性的描述。

Checkpoint ¶

基类：TypedDict

表示执行过程中的一个检查点。

属性

名称	类型	描述
`要获取的线程 ID。`	`str`	与此检查点关联的线程的唯一标识符。
`checkpoint_ns`	`str`	检查点的命名空间；内部用于管理子图状态。
`(已弃用) 要获取状态的检查点 ID。`	`可选[str]`	检查点本身的可选唯一标识符。
`checkpoint_map`	`可选的键值对字典，用于过滤结果。`	包含检查点特定数据的可选字典。

thread_id `instance-attribute` ¶

thread_id: str

与此检查点关联的线程的唯一标识符。

checkpoint_ns `instance-attribute` ¶

checkpoint_ns: str

检查点的命名空间；内部用于管理子图状态。

checkpoint_id `instance-attribute` ¶

checkpoint_id: Optional[str]

检查点本身的可选唯一标识符。

checkpoint_map `instance-attribute` ¶

checkpoint_map: Optional[dict[str, Any]]

包含检查点特定数据的可选字典。

GraphSchema ¶

基类：TypedDict

定义图的结构和属性。

属性

名称	类型	描述
`graph_id`	`str`	图的 ID。
`input_schema`	`按元数据键值对过滤状态。`	图输入的模式。
`output_schema`	`按元数据键值对过滤状态。`	图输出的模式。
`state_schema`	`按元数据键值对过滤状态。`	图状态的模式。
`config_schema`	`按元数据键值对过滤状态。`	图配置的模式。

graph_id `instance-attribute` ¶

graph_id: str

图的 ID。

input_schema `instance-attribute` ¶

input_schema: Optional[dict]

图输入的模式。如果无法从图中生成 JSON 模式，则缺失。

output_schema `instance-attribute` ¶

output_schema: Optional[dict]

图输出的模式。如果无法从图中生成 JSON 模式，则缺失。

state_schema `instance-attribute` ¶

state_schema: Optional[dict]

图状态的模式。如果无法从图中生成 JSON 模式，则缺失。

config_schema `instance-attribute` ¶

config_schema: Optional[dict]

图配置的模式。如果无法从图中生成 JSON 模式，则缺失。

AssistantBase ¶

基类：TypedDict

助手的基本模型。

属性

名称	类型	描述
`assistant_id`	`str`	助手的 ID。
`graph_id`	`str`	图的 ID。
`config`	`配置`	助手配置。
`created_at`	`datetime`	创建助手的时间。
`metadata`	`Json`	助手元数据。
`要更改到的版本。`	`int`	助手的版本
`name`	`str`	助手的名称
`description`	`可选[str]`	助手的描述

assistant_id `instance-attribute` ¶

assistant_id: str

助手的 ID。

graph_id `instance-attribute` ¶

graph_id: str

图的 ID。

config `instance-attribute` ¶

config: Config

助手配置。

created_at `instance-attribute` ¶

created_at: datetime

创建助手的时间。

metadata `instance-attribute` ¶

metadata: Json

助手元数据。

version `instance-attribute` ¶

version: int

助手的版本

name `instance-attribute` ¶

name: str

助手的名称

description `instance-attribute` ¶

description: Optional[str]

助手的描述

AssistantVersion ¶

基类：AssistantBase

表示助手的特定版本。

属性

名称	类型	描述
`assistant_id`	`str`	助手的 ID。
`graph_id`	`str`	图的 ID。
`config`	`配置`	助手配置。
`created_at`	`datetime`	创建助手的时间。
`metadata`	`Json`	助手元数据。
`要更改到的版本。`	`int`	助手的版本
`name`	`str`	助手的名称
`description`	`可选[str]`	助手的描述

assistant_id `instance-attribute` ¶

assistant_id: str

助手的 ID。

graph_id `instance-attribute` ¶

graph_id: str

图的 ID。

config `instance-attribute` ¶

config: Config

助手配置。

created_at `instance-attribute` ¶

created_at: datetime

创建助手的时间。

metadata `instance-attribute` ¶

metadata: Json

助手元数据。

version `instance-attribute` ¶

version: int

助手的版本

name `instance-attribute` ¶

name: str

助手的名称

description `instance-attribute` ¶

description: Optional[str]

助手的描述

Assistant ¶

基类：AssistantBase

表示具有附加属性的助手。

属性

名称	类型	描述
`updated_at`	`datetime`	助手最后更新时间。
`assistant_id`	`str`	助手的 ID。
`graph_id`	`str`	图的 ID。
`config`	`配置`	助手配置。
`created_at`	`datetime`	创建助手的时间。
`metadata`	`Json`	助手元数据。
`要更改到的版本。`	`int`	助手的版本
`name`	`str`	助手的名称
`description`	`可选[str]`	助手的描述

updated_at `instance-attribute` ¶

updated_at: datetime

助手最后更新时间。

assistant_id `instance-attribute` ¶

assistant_id: str

助手的 ID。

graph_id `instance-attribute` ¶

graph_id: str

图的 ID。

config `instance-attribute` ¶

config: Config

助手配置。

created_at `instance-attribute` ¶

created_at: datetime

创建助手的时间。

metadata `instance-attribute` ¶

metadata: Json

助手元数据。

version `instance-attribute` ¶

version: int

助手的版本

name `instance-attribute` ¶

name: str

助手的名称

description `instance-attribute` ¶

description: Optional[str]

助手的描述

Interrupt ¶

基类：TypedDict

表示执行流中的中断。

属性

名称	类型	描述
`包含项目数据的字典。`	`任意`	与中断关联的值。
`when`	`字面量['during']`	中断发生的时间。
`resumable`	`bool`	中断是否可以恢复。
`ns`	`表示要过滤命名空间的前缀的可选字符串列表。`	中断的可选命名空间。

value `instance-attribute` ¶

value: Any

与中断关联的值。

when `instance-attribute` ¶

when: Literal['during']

中断发生的时间。

resumable `instance-attribute` ¶

resumable: bool

中断是否可以恢复。

ns `instance-attribute` ¶

ns: Optional[list[str]]

中断的可选命名空间。

Thread ¶

基类：TypedDict

表示对话线程。

属性

名称	类型	描述
`要获取的线程 ID。`	`str`	线程的 ID。
`created_at`	`datetime`	创建线程的时间。
`updated_at`	`datetime`	线程最后更新时间。
`metadata`	`Json`	线程元数据。
`可选[ThreadStatus]`	`ThreadStatus`	线程的状态，可以是 'idle'、'busy'、'interrupted' 之一。
`要过滤的状态值。`	`Json`	线程的当前状态。
`中断`	`字典[字符串, 列表[Interrupt]]`	在此线程中抛出的中断

thread_id `instance-attribute` ¶

thread_id: str

线程的 ID。

created_at `instance-attribute` ¶

created_at: datetime

创建线程的时间。

updated_at `instance-attribute` ¶

updated_at: datetime

线程最后更新时间。

metadata `instance-attribute` ¶

metadata: Json

线程元数据。

status `instance-attribute` ¶

status: ThreadStatus

线程的状态，可以是 'idle'、'busy'、'interrupted' 之一。

values `instance-attribute` ¶

values: Json

线程的当前状态。

interrupts `instance-attribute` ¶

interrupts: dict[str, list[Interrupt]]

在此线程中抛出的中断

ThreadTask ¶

基类：TypedDict

表示线程中的任务。

ThreadState ¶

基类：TypedDict

表示线程的状态。

属性

名称	类型	描述
`要过滤的状态值。`	`Union[列表[字典], 字典[字符串, 任意]]`	状态值。
`next`	`表示命名空间路径的字符串列表。`	要执行的下一个节点。如果为空，则线程在收到新输入之前完成。
`可选[Checkpoint]`	`检查点`	检查点的 ID。
`metadata`	`Json`	此状态的元数据
`created_at`	`可选[str]`	状态创建的时间戳
`parent_checkpoint`	`要获取状态的检查点。`	父检查点的 ID。如果缺失，则这是根检查点。
`任务`	`序列[ThreadTask]`	在此步骤中要执行的任务。如果已尝试，可能包含错误。

values `instance-attribute` ¶

values: Union[list[dict], dict[str, Any]]

状态值。

next `instance-attribute` ¶

next: Sequence[str]

要执行的下一个节点。如果为空，则线程在收到新输入之前完成。

checkpoint `instance-attribute` ¶

checkpoint: Checkpoint

检查点的 ID。

metadata `instance-attribute` ¶

metadata: Json

此状态的元数据

created_at `instance-attribute` ¶

created_at: Optional[str]

状态创建的时间戳

parent_checkpoint `instance-attribute` ¶

parent_checkpoint: Optional[Checkpoint]

父检查点的 ID。如果缺失，则这是根检查点。

tasks `instance-attribute` ¶

tasks: Sequence[ThreadTask]

在此步骤中要执行的任务。如果已尝试，可能包含错误。

ThreadUpdateStateResponse ¶

基类：TypedDict

表示更新线程状态的响应。

属性

名称	类型	描述
`可选[Checkpoint]`	`检查点`	最新状态的检查点。

checkpoint `instance-attribute` ¶

checkpoint: Checkpoint

最新状态的检查点。

Run ¶

基类：TypedDict

表示单个执行运行。

属性

名称	类型	描述
`要获取的运行 ID。`	`str`	运行的 ID。
`要获取的线程 ID。`	`str`	线程的 ID。
`assistant_id`	`str`	用于此运行的助手。
`created_at`	`datetime`	创建运行的时间。
`updated_at`	`datetime`	运行最后更新时间。
`可选[ThreadStatus]`	`RunStatus`	运行的状态。 'pending', 'running', "error", 'success', "timeout", "interrupted" 之一。
`metadata`	`Json`	运行元数据。
`可选[MultitaskStrategy]`	`MultitaskStrategy`	处理同一线程上并发运行的策略。

run_id `instance-attribute` ¶

run_id: str

运行的 ID。

thread_id `instance-attribute` ¶

thread_id: str

线程的 ID。

assistant_id `instance-attribute` ¶

assistant_id: str

用于此运行的助手。

created_at `instance-attribute` ¶

created_at: datetime

创建运行的时间。

updated_at `instance-attribute` ¶

updated_at: datetime

运行最后更新时间。

status `instance-attribute` ¶

status: RunStatus

运行的状态。 'pending', 'running', "error", 'success', "timeout", "interrupted" 之一。

metadata `instance-attribute` ¶

metadata: Json

运行元数据。

multitask_strategy `instance-attribute` ¶

multitask_strategy: MultitaskStrategy

处理同一线程上并发运行的策略。

Cron ¶

基类：TypedDict

表示计划任务。

属性

名称	类型	描述
`要删除的定时任务 ID。`	`str`	cron 的 ID。
`要获取的线程 ID。`	`可选[str]`	线程的 ID。
`end_time`	`可选[datetime]`	停止运行 cron 的结束日期。
`执行此任务的 cron 调度。`	`str`	运行的计划，cron 格式。
`created_at`	`datetime`	创建 cron 的时间。
`updated_at`	`datetime`	cron 最后更新时间。
`payload`	`join_stream ¶`	用于创建新运行的运行负载。

cron_id `instance-attribute` ¶

cron_id: str

cron 的 ID。

thread_id `instance-attribute` ¶

thread_id: Optional[str]

线程的 ID。

end_time `instance-attribute` ¶

end_time: Optional[datetime]

停止运行 cron 的结束日期。

schedule `instance-attribute` ¶

schedule: str

运行的计划，cron 格式。

created_at `instance-attribute` ¶

created_at: datetime

创建 cron 的时间。

updated_at `instance-attribute` ¶

updated_at: datetime

cron 最后更新时间。

payload `instance-attribute` ¶

payload: dict

用于创建新运行的运行负载。

RunCreate ¶

基类：TypedDict

定义启动后台运行的参数。

属性

名称	类型	描述
`要获取的线程 ID。`	`可选[str]`	要运行的线程的标识符。如果未提供，则运行是无状态的。
`assistant_id`	`str`	用于此运行的助手的标识符。
`图的输入。`	`按元数据键值对过滤状态。`	运行的初始输入数据。
`metadata`	`按元数据键值对过滤状态。`	与运行关联的附加元数据。
`config`	`可选[Config]`	运行的配置选项。
`(已弃用) 要获取状态的检查点 ID。`	`可选[str]`	要从中恢复的检查点标识符。
`可选[联合[All, 序列[str]]]`	`表示要过滤命名空间的前缀的可选字符串列表。`	在执行中断之前中断的节点名称列表。
`在执行后立即中断的节点。`	`表示要过滤命名空间的前缀的可选字符串列表。`	在执行中断之后中断的节点名称列表。
`LangGraph API 调用完成后调用的 Webhook。`	`可选[str]`	用于发送运行进度网络钩子通知的 URL。
`可选[MultitaskStrategy]`	`要使用的多任务策略。必须是 'reject'、'interrupt'、'rollback' 或 'enqueue' 之一。`	处理同一线程上并发运行的策略。

thread_id `instance-attribute` ¶

thread_id: Optional[str]

要运行的线程的标识符。如果未提供，则运行是无状态的。

assistant_id `instance-attribute` ¶

assistant_id: str

用于此运行的助手的标识符。

input `instance-attribute` ¶

input: Optional[dict]

运行的初始输入数据。

metadata `instance-attribute` ¶

metadata: Optional[dict]

与运行关联的附加元数据。

config `instance-attribute` ¶

config: Optional[Config]

运行的配置选项。

checkpoint_id `instance-attribute` ¶

checkpoint_id: Optional[str]

要从中恢复的检查点标识符。

interrupt_before `instance-attribute` ¶

interrupt_before: Optional[list[str]]

在执行中断之前中断的节点名称列表。

interrupt_after `instance-attribute` ¶

interrupt_after: Optional[list[str]]

在执行中断之后中断的节点名称列表。

webhook `instance-attribute` ¶

webhook: Optional[str]

用于发送运行进度网络钩子通知的 URL。

multitask_strategy `instance-attribute` ¶

multitask_strategy: Optional[MultitaskStrategy]

处理同一线程上并发运行的策略。

Item ¶

基类：TypedDict

表示图存储中的单个文档或数据条目。

项目用于存储跨线程内存。

属性

名称	类型	描述
`namespace`	`列表[字符串]`	项目的命名空间。命名空间类似于文档的目录。
`命名空间内项目的唯一标识符。`	`str`	项目在其命名空间内的唯一标识符。
`包含项目数据的字典。`	`要与现有线程元数据合并的元数据。`	项目中存储的值。这是文档本身。
`created_at`	`datetime`	项目创建时的时间戳。
`updated_at`	`datetime`	项目最后更新时的时间戳。

namespace `instance-attribute` ¶

namespace: list[str]

项目的命名空间。命名空间类似于文档的目录。

key `instance-attribute` ¶

key: str

项目在其命名空间内的唯一标识符。

通常，键无需全局唯一。

value `instance-attribute` ¶

value: dict[str, Any]

项目中存储的值。这是文档本身。

created_at `instance-attribute` ¶

created_at: datetime

项目创建时的时间戳。

updated_at `instance-attribute` ¶

updated_at: datetime

项目最后更新时的时间戳。

ListNamespaceResponse ¶

基类：TypedDict

列出命名空间的响应结构。

属性

名称	类型	描述
`namespaces`	`列表[列表[字符串]]`	命名空间路径列表，其中每个路径都是字符串列表。

namespaces `instance-attribute` ¶

namespaces: list[list[str]]

命名空间路径列表，其中每个路径都是字符串列表。

SearchItem ¶

基类：Item

包含来自搜索操作的可选相关性得分的项目。

属性

名称	类型	描述
`score`	`可选[浮点数]`	相关性/相似度得分。在使用自然语言查询搜索兼容存储时包含。

namespace `instance-attribute` ¶

namespace: list[str]

项目的命名空间。命名空间类似于文档的目录。

key `instance-attribute` ¶

key: str

项目在其命名空间内的唯一标识符。

通常，键无需全局唯一。

value `instance-attribute` ¶

value: dict[str, Any]

项目中存储的值。这是文档本身。

created_at `instance-attribute` ¶

created_at: datetime

项目创建时的时间戳。

updated_at `instance-attribute` ¶

updated_at: datetime

项目最后更新时的时间戳。

SearchItemsResponse ¶

基类：TypedDict

搜索项目的响应结构。

属性

名称	类型	描述
`items`	`列表[SearchItem]`	与搜索条件匹配的项目列表。

items `instance-attribute` ¶

items: list[SearchItem]

与搜索条件匹配的项目列表。

StreamPart ¶

基类：NamedTuple

表示流响应的一部分。

属性

名称	类型	描述
`event`	`str`	此流部分的事件类型。
`data`	`join_stream ¶`	与事件关联的数据负载。

event `instance-attribute` ¶

event: str

此流部分的事件类型。

data `instance-attribute` ¶

data: dict

与事件关联的数据负载。

Send ¶

基类：TypedDict

表示要发送到图中特定节点的消息。

此类型用于显式地向图中的节点发送消息，通常在 Command 对象中用于控制图的执行流程。

属性

名称	类型	描述
`node`	`str`	要发送消息的目标节点的名称。
`图的输入。`	`可选的键值对字典，用于过滤结果。`	包含要传递给节点的输入数据的可选字典。

node `instance-attribute` ¶

node: str

要发送消息的目标节点的名称。

input `instance-attribute` ¶

input: Optional[dict[str, Any]]

包含要传递给节点的输入数据的可选字典。

如果为 None，则调用节点时没有输入。

Command ¶

基类：TypedDict

表示一个或多个命令，用于控制图的执行流程和状态。

此类型定义了节点可以返回的控制命令，以影响图的执行。它允许您导航到其他节点，更新图状态，并从中断中恢复。

属性

名称	类型	描述
`goto`	`Union[Send, str, Sequence[Union[Send, str]]]`	指定执行应在何处继续。可以是
`update`	`Union[dict[str, Any], Sequence[元组[字符串, 任意]]]`	要应用于图状态的更新。可以是
`resume`	`任意`	中断后用于恢复执行的值。

goto `instance-attribute` ¶

goto: Union[Send, str, Sequence[Union[Send, str]]]

指定执行应在何处继续。可以是

要导航到的字符串节点名称
用于执行具有特定输入的节点的 Send 对象
要按顺序执行的节点名称或 Send 对象的序列

update `instance-attribute` ¶

update: Union[dict[str, Any], Sequence[tuple[str, Any]]]

要应用于图状态的更新。可以是

要合并的状态更新字典
用于有序更新的 (键, 值) 元组序列

resume `instance-attribute` ¶

resume: Any

中断后用于恢复执行的值。与 interrupt() 结合使用以实现控制流。

RunCreateMetadata ¶

基类：TypedDict

运行创建请求的元数据。

属性

名称	类型	描述
`要获取的运行 ID。`	`str`	运行的 ID。
`要获取的线程 ID。`	`可选[str]`	线程的 ID。

run_id `instance-attribute` ¶

run_id: str

运行的 ID。

thread_id `instance-attribute` ¶

thread_id: Optional[str]

线程的 ID。

模块

名称	描述
`异常`	身份验证系统中使用的异常。
`类型`	LangGraph 的身份验证和授权类型。

类

名称	描述
`Auth`	将自定义身份验证和授权管理添加到您的 LangGraph 应用程序。

Auth ¶

将自定义身份验证和授权管理添加到您的 LangGraph 应用程序。

Auth 类提供了处理 LangGraph 应用程序中身份验证和授权的统一系统。它支持自定义用户身份验证协议以及针对不同资源和操作的细粒度授权规则。

要使用，请创建单独的 python 文件并将该文件的路径添加到 LangGraph API 配置文件 (langgraph.json)。在该文件中，创建 Auth 类的实例并根据需要注册身份验证和授权处理程序。

langgraph.json 示例文件

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

然后 LangGraph 服务器将加载您的身份验证文件并在每次请求到来时在服务器端运行它。

基本用法

from langgraph_sdk import Auth

my_auth = Auth()

async def verify_token(token: str) -> str:
    # Verify token and return user_id
    # This would typically be a call to your auth server
    return "user_id"

@auth.authenticate
async def authenticate(authorization: str) -> str:
    # Verify token and return user_id
    result = await verify_token(authorization)
    if result != "user_id":
        raise Auth.exceptions.HTTPException(
            status_code=401, detail="Unauthorized"
        )
    return result

# Global fallback handler
@auth.on
async def authorize_default(params: Auth.on.value):
    return False # Reject all requests (default behavior)

@auth.on.threads.create
async def authorize_thread_create(params: Auth.on.threads.create.value):
    # Allow the allowed user to create a thread
    assert params.get("metadata", {}).get("owner") == "allowed_user"

@auth.on.store
async def authorize_store(ctx: Auth.types.AuthContext, value: Auth.types.on):
    assert ctx.user.identity in value["namespace"], "Not authorized"

请求处理流程

身份验证（您的 @auth.authenticate 处理程序）首先在每个请求上执行
对于授权，将调用最具体的匹配处理程序
- 如果存在针对精确资源和操作的处理程序，则使用该处理程序（例如，@auth.on.threads.create）
- 否则，如果存在针对资源并具有任何操作的处理程序，则使用该处理程序（例如，@auth.on.threads）
- 最后，如果没有特定的处理程序匹配，则使用全局处理程序（例如，@auth.on）
- 如果未设置全局处理程序，则接受请求

这允许您使用全局处理程序设置默认行为，同时根据需要覆盖特定路由。

方法

名称	描述
`authenticate`	注册身份验证处理函数。

属性

名称	类型	描述
`类型`		身份验证类型定义的引用。
`异常`		身份验证异常定义的引用。
`on`		授权处理程序的入口点，用于控制对特定资源的访问。

types `class-attribute` `instance-attribute` ¶

types = types

身份验证类型定义的引用。

提供对身份验证系统中使用的所有类型定义的访问，例如 ThreadsCreate、AssistantsRead 等。

exceptions `class-attribute` `instance-attribute` ¶

exceptions = exceptions

身份验证异常定义的引用。

提供对身份验证系统中使用的所有异常定义的访问，例如 HTTPException 等。

on `instance-attribute` ¶

on = _On(self)

授权处理程序的入口点，用于控制对特定资源的访问。

on 类提供了一种灵活的方式来定义应用程序中不同资源和操作的授权规则。它支持三种主要用法模式

适用于所有资源和操作的全局处理程序
适用于资源上所有操作的资源特定处理程序
用于细粒度控制的资源和操作特定处理程序

每个处理程序必须是接受两个参数的异步函数

ctx (AuthContext): 包含请求上下文和已认证的用户信息
value: 正在授权的数据（类型因端点而异）

处理程序应返回以下之一

- None or True: Accept the request
- False: Reject with 403 error
- FilterType: Apply filtering rules to the response

示例

所有请求的全局处理程序

@auth.on
async def reject_unhandled_requests(ctx: AuthContext, value: Any) -> None:
    print(f"Request to {ctx.path} by {ctx.user.identity}")
    return False

资源特定处理程序。这将优先于全局处理程序，适用于 threads 资源上的所有操作

@auth.on.threads
async def check_thread_access(ctx: AuthContext, value: Any) -> bool:
    # Allow access only to threads created by the user
    return value.get("created_by") == ctx.user.identity

资源和操作特定处理程序

@auth.on.threads.delete
async def prevent_thread_deletion(ctx: AuthContext, value: Any) -> bool:
    # Only admins can delete threads
    return "admin" in ctx.user.permissions

多个资源或操作

@auth.on(resources=["threads", "runs"], actions=["create", "update"])
async def rate_limit_writes(ctx: AuthContext, value: Any) -> bool:
    # Implement rate limiting for write operations
    return await check_rate_limit(ctx.user.identity)

store 资源的身份验证有点不同，因为其结构是开发人员定义的。您通常希望在命名空间中强制执行用户凭据。Y

@auth.on.store
async def check_store_access(ctx: AuthContext, value: Auth.types.on) -> bool:
    # Assuming you structure your store like (store.aput((user_id, application_context), key, value))
    assert value["namespace"][0] == ctx.user.identity

authenticate ¶

authenticate(fn: AH) -> AH

注册身份验证处理函数。

身份验证处理程序负责验证凭据并返回用户范围。它可以按名称接受以下任何参数

- request (Request): The raw ASGI request object
- body (dict): The parsed request body
- path (str): The request path, e.g., "/threads/abcd-1234-abcd-1234/runs/abcd-1234-abcd-1234/stream"
- method (str): The HTTP method, e.g., "GET"
- path_params (dict[str, str]): URL path parameters, e.g., {"thread_id": "abcd-1234-abcd-1234", "run_id": "abcd-1234-abcd-1234"}
- query_params (dict[str, str]): URL query parameters, e.g., {"stream": "true"}
- headers (dict[bytes, bytes]): Request headers
- authorization (str | None): The Authorization header value (e.g., "Bearer <token>")

参数

名称	类型	描述	默认
`fn`	`AH`	要注册的身份验证处理函数。必须返回用户的表示。这可以是：- 字符串（用户 ID）- 包含 {"identity": str, "permissions": list[str]} 的字典 - 或具有身份和权限属性的对象。权限可由您的下游处理程序选择性使用。	必需

返回

类型	描述
`AH`	已注册的处理程序函数。

引发

类型	描述
`ValueError`	如果已注册身份验证处理程序。

示例

基本令牌身份验证

@auth.authenticate
async def authenticate(authorization: str) -> str:
    user_id = verify_token(authorization)
    return user_id

接受完整的请求上下文

@auth.authenticate
async def authenticate(
    method: str,
    path: str,
    headers: dict[str, bytes]
) -> str:
    user = await verify_request(method, path, headers)
    return user

返回用户名和权限

@auth.authenticate
async def authenticate(
    method: str,
    path: str,
    headers: dict[str, bytes]
) -> Auth.types.MinimalUserDict:
    permissions, user = await verify_request(method, path, headers)
    # Permissions could be things like ["runs:read", "runs:write", "threads:read", "threads:write"]
    return {
        "identity": user["id"],
        "permissions": permissions,
        "display_name": user["name"],
    }

LangGraph 的身份验证和授权类型。

此模块定义了 LangGraph 中用于身份验证、授权和请求处理的核心类型。它包括用户协议、身份验证上下文和各种 API 操作的类型化字典。

注意

所有 typing.TypedDict 类默认使用 total=False 使所有字段 typing.Optional。

类

名称	描述
`ThreadsCreate`	创建新线程的参数。
`ThreadsRead`	读取线程状态或运行信息的参数。
`ThreadsUpdate`	更新线程或运行的参数。
`ThreadsDelete`	删除线程的参数。
`ThreadsSearch`	搜索线程的参数。
`RunsCreate`	创建运行的有效载荷。
`AssistantsCreate`	创建助手的有效载荷。
`AssistantsRead`	读取助手的有效载荷。
`AssistantsUpdate`	更新助手的有效载荷。
`AssistantsDelete`	删除助手的有效载荷。
`AssistantsSearch`	搜索助手的有效载荷。
`StoreGet`	通过命名空间和键检索特定项目的操作。
`StoreSearch`	在指定命名空间层次结构中搜索项目的操作。
`StoreListNamespaces`	列出和过滤存储中命名空间的操作。
`StorePut`	在存储中存储、更新或删除项目的操作。
`StoreDelete`	从存储中删除项目的操作。
`on`	不同 API 操作的类型定义命名空间。

属性

名称	类型	描述
`MetadataInput`		附加到实体上的任意元数据的类型。

RunStatus `module-attribute` ¶

RunStatus = Literal[
    "pending", "error", "success", "timeout", "interrupted"
]

运行执行状态。

值

pending: 运行已排队或正在进行中
error: 运行失败并出现错误
success: 运行成功完成
timeout: 运行超出时间限制
interrupted: 运行被手动中断

MultitaskStrategy `module-attribute` ¶

MultitaskStrategy = Literal[
    "reject", "rollback", "interrupt", "enqueue"
]

处理多个并发任务的策略。

值

reject: 在任务进行中时拒绝新任务
rollback: 取消当前任务并启动新任务
interrupt: 中断当前任务并启动新任务
enqueue: 将新任务排队在当前任务之后运行

OnConflictBehavior `module-attribute` ¶

OnConflictBehavior = Literal['raise', 'do_nothing']

遇到冲突时的行为。

值

raise: 冲突时引发异常
do_nothing: 静默忽略冲突

IfNotExists `module-attribute` ¶

IfNotExists = Literal['create', 'reject']

实体不存在时的行为。

值

create: 创建实体
reject: 拒绝操作

FilterType `module-attribute` ¶

FilterType = Union[
    Dict[
        str,
        Union[str, Dict[Literal["$eq", "$contains"], str]],
    ],
    Dict[str, str],
]

授权处理程序的响应类型。

支持精确匹配和运算符

精确匹配简写：{"field": "value"}
精确匹配：{"field": {"$eq": "value"}}
包含：{"field": {"$contains": "value"}}

示例

资源所有者的简单精确匹配过滤器

filter = {"owner": "user-abcd123"}

精确匹配过滤器的显式版本

filter = {"owner": {"$eq": "user-abcd123"}}

包含关系

filter = {"participants": {"$contains": "user-abcd123"}}

组合过滤器（视为逻辑 AND）

filter = {"owner": "user-abcd123", "participants": {"$contains": "user-efgh456"}}

ThreadStatus `module-attribute` ¶

ThreadStatus = Literal[
    "idle", "busy", "interrupted", "error"
]

线程状态。

值

idle: 线程可用
busy: 线程正在处理中
interrupted: 线程被中断
error: 线程遇到错误

MetadataInput `module-attribute` ¶

MetadataInput = Dict[str, Any]

附加到实体上的任意元数据的类型。

允许为任何实体存储自定义键值对。键必须是字符串，值可以是任何可 JSON 序列化的类型。

示例

metadata = {
    "created_by": "user123",
    "priority": 1,
    "tags": ["important", "urgent"]
}

HandlerResult `module-attribute` ¶

HandlerResult = Union[None, bool, FilterType]

处理程序的结果可以是： * None | True：接受请求。 * False：以 403 错误拒绝请求 * FilterType：要应用的过滤器

Authenticator `module-attribute` ¶

Authenticator = Callable[
    ...,
    Awaitable[
        Union[
            MinimalUser,
            str,
            BaseUser,
            MinimalUserDict,
            Mapping[str, Any],
        ],
    ],
]

用于身份验证函数的类型。

身份验证器可以返回： 1. 字符串 (user_id) 2. 包含 {"identity": str, "permissions": list[str]} 的字典 3. 具有 identity 和 permissions 属性的对象

权限可供您的授权逻辑在下游使用，以确定对不同资源的访问权限。

如果函数签名中包含以下任何参数，authenticate 装饰器将自动按名称注入它们

参数

名称	类型	描述	默认
`请求 (request)`	`请求 (Request)`	原始 ASGI 请求对象	必需
`主体 (body)`	`join_stream ¶`	解析后的请求主体	必需
`路径 (path)`	`str`	请求路径	必需
`方法 (method)`	`str`	HTTP 方法 (GET, POST, etc.)	必需
`路径参数 (path_params)`	`dict[str, str] \| None`	URL 路径参数	必需
`查询参数 (query_params)`	`dict[str, str] \| None`	URL 查询参数	必需
`headers`	`dict[str, bytes] \| None`	请求头	必需
`授权 (authorization)`	`str \| None`	Authorization 头部值（例如 "Bearer")	必需

示例

带令牌的基本认证

from langgraph_sdk import Auth

auth = Auth()

@auth.authenticate
async def authenticate1(authorization: str) -> Auth.types.MinimalUserDict:
    return await get_user(authorization)

多参数认证

@auth.authenticate
async def authenticate2(
    method: str,
    path: str,
    headers: dict[str, bytes]
) -> Auth.types.MinimalUserDict:
    # Custom auth logic using method, path and headers
    user = verify_request(method, path, headers)
    return user

接受原始 ASGI 请求

MY_SECRET = "my-secret-key"
@auth.authenticate
async def get_current_user(request: Request) -> Auth.types.MinimalUserDict:
    try:
        token = (request.headers.get("authorization") or "").split(" ", 1)[1]
        payload = jwt.decode(token, MY_SECRET, algorithms=["HS256"])
    except (IndexError, InvalidTokenError):
        raise HTTPException(
            status_code=401,
            detail="Invalid token",
            headers={"WWW-Authenticate": "Bearer"},
        )

    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://api.myauth-provider.com/auth/v1/user",
            headers={"Authorization": f"Bearer {MY_SECRET}"}
        )
        if response.status_code != 200:
            raise HTTPException(status_code=401, detail="User not found")

        user_data = response.json()
        return {
            "identity": user_data["id"],
            "display_name": user_data.get("name"),
            "permissions": user_data.get("permissions", []),
            "is_authenticated": True,
        }

MinimalUser ¶

基类：Protocol

用户对象至少必须暴露 identity 属性。

属性

名称	类型	描述
`身份 (identity)`	`str`	用户的唯一标识符。

identity `property` ¶

identity: str

用户的唯一标识符。

这可以是用户名、电子邮件或用于区分系统中不同用户的任何其他唯一标识符。

MinimalUserDict ¶

基类：TypedDict

用户的字典表示。

属性

名称	类型	描述
`身份 (identity)`	`必填[str]`	用户必需的唯一标识符。
`显示名称 (display_name)`	`str`	用户的可选显示名称。
`已认证 (is_authenticated)`	`bool`	用户是否已认证。默认为 True。
`权限 (permissions)`	`表示命名空间路径的字符串列表。`	与用户关联的权限列表。

identity `instance-attribute` ¶

identity: Required[str]

用户必需的唯一标识符。

display_name `instance-attribute` ¶

display_name: str

用户的可选显示名称。

is_authenticated `instance-attribute` ¶

is_authenticated: bool

用户是否已认证。默认为 True。

permissions `instance-attribute` ¶

permissions: Sequence[str]

与用户关联的权限列表。

您可以在 @auth.on 授权逻辑中使用这些权限来确定对不同资源的访问权限。

BaseUser ¶

基类：Protocol

基础 ASGI 用户协议

方法

名称	描述
`__getitem__`	从您的最小用户字典中获取一个键。
`__contains__`	检查属性是否存在。
`__iter__`	迭代用户的键。

属性

名称	类型	描述
`已认证 (is_authenticated)`	`bool`	用户是否已认证。
`显示名称 (display_name)`	`str`	用户的显示名称。
`身份 (identity)`	`str`	用户的唯一标识符。
`权限 (permissions)`	`表示命名空间路径的字符串列表。`	与用户关联的权限。

is_authenticated `property` ¶

is_authenticated: bool

用户是否已认证。

display_name `property` ¶

display_name: str

用户的显示名称。

identity `property` ¶

identity: str

用户的唯一标识符。

permissions `property` ¶

permissions: Sequence[str]

与用户关联的权限。

getitem ¶

__getitem__(key)

从您的最小用户字典中获取一个键。

contains ¶

__contains__(key)

检查属性是否存在。

iter ¶

__iter__()

迭代用户的键。

StudioUser ¶

一个从 LangGraph 工作室认证请求中填充的用户对象。

注意：Studio 认证可以在您的 langgraph.json 配置中禁用。

{
  "auth": {
    "disable_studio_auth": true
  }
}

您可以在授权处理程序 (@auth.on) 中使用 isinstance 检查，以专门控制从 LangGraph Studio UI 访问实例的开发人员的访问权限。

示例

@auth.on
async def allow_developers(ctx: Auth.types.AuthContext, value: Any) -> None:
    if isinstance(ctx.user, Auth.types.StudioUser):
        return None
    ...
    return False

BaseAuthContext ¶

认证上下文的基类。

提供授权决策所需的基本认证信息。

属性

名称	类型	描述
`权限 (permissions)`	`表示命名空间路径的字符串列表。`	授予已认证用户的权限。
`用户 (user)`	`BaseUser`	已认证的用户。

permissions `instance-attribute` ¶

permissions: Sequence[str]

授予已认证用户的权限。

user `instance-attribute` ¶

user: BaseUser

已认证的用户。

AuthContext ¶

基类：BaseAuthContext

完整的认证上下文，包含资源和操作信息。

扩展 BaseAuthContext，包含正在访问的特定资源和操作，允许进行细粒度的访问控制决策。

属性

名称	类型	描述
`资源 (resource)`	`Literal['runs', 'threads', 'crons', 'assistants', 'store']`	正在访问的资源。
`CancelAction`	`Literal['create', 'read', 'update', 'delete', 'search', 'create_run', 'put', 'get', 'list_namespaces']`	对资源执行的操作。
`权限 (permissions)`	`表示命名空间路径的字符串列表。`	授予已认证用户的权限。
`用户 (user)`	`BaseUser`	已认证的用户。

resource `instance-attribute` ¶

resource: Literal[
    "runs", "threads", "crons", "assistants", "store"
]

正在访问的资源。

action `instance-attribute` ¶

action: Literal[
    "create",
    "read",
    "update",
    "delete",
    "search",
    "create_run",
    "put",
    "get",
    "list_namespaces",
]

对资源执行的操作。

大多数资源支持以下操作：- create：创建新资源 - read：读取资源信息 - update：更新现有资源 - delete：删除资源 - search：搜索资源

存储支持以下操作：- put：在存储中添加或更新文档 - get：从存储中获取文档 - list_namespaces：列出存储中的命名空间

permissions `instance-attribute` ¶

permissions: Sequence[str]

授予已认证用户的权限。

user `instance-attribute` ¶

user: BaseUser

已认证的用户。

ThreadsCreate ¶

基类：TypedDict

创建新线程的参数。

示例

create_params = {
    "thread_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
    "metadata": {"owner": "user123"},
    "if_exists": "do_nothing"
}

属性

名称	类型	描述
`要获取的线程 ID。`	`UUID`	线程的唯一标识符。
`metadata`	`MetadataInput`	要附加到线程的可选元数据。
`if_exists`	`OnConflictBehavior`	当具有相同 ID 的线程已存在时的行为。

thread_id `instance-attribute` ¶

thread_id: UUID

线程的唯一标识符。

metadata `instance-attribute` ¶

metadata: MetadataInput

要附加到线程的可选元数据。

if_exists `instance-attribute` ¶

if_exists: OnConflictBehavior

当具有相同 ID 的线程已存在时的行为。

ThreadsRead ¶

基类：TypedDict

读取线程状态或运行信息的参数。

此类型用于三种上下文： 1. 读取线程、线程版本或线程状态信息：仅提供 thread_id 2. 读取运行信息：提供 thread_id 和 run_id

属性

名称	类型	描述
`要获取的线程 ID。`	`UUID`	线程的唯一标识符。
`要获取的运行 ID。`	`可选[UUID]`	用于筛选的运行 ID。仅在读取线程内的运行信息时使用。

thread_id `instance-attribute` ¶

thread_id: UUID

线程的唯一标识符。

run_id `instance-attribute` ¶

run_id: Optional[UUID]

用于筛选的运行 ID。仅在读取线程内的运行信息时使用。

ThreadsUpdate ¶

基类：TypedDict

更新线程或运行的参数。

用于更新线程、线程版本或取消运行。

属性

名称	类型	描述
`要获取的线程 ID。`	`UUID`	线程的唯一标识符。
`metadata`	`MetadataInput`	要更新的可选元数据。
`CancelAction`	`可选[Literal['interrupt', 'rollback']]`	对线程执行的可选操作。

thread_id `instance-attribute` ¶

thread_id: UUID

线程的唯一标识符。

metadata `instance-attribute` ¶

metadata: MetadataInput

要更新的可选元数据。

action `instance-attribute` ¶

action: Optional[Literal['interrupt', 'rollback']]

对线程执行的可选操作。

ThreadsDelete ¶

基类：TypedDict

删除线程的参数。

用于删除线程、线程版本或运行。

属性

名称	类型	描述
`要获取的线程 ID。`	`UUID`	线程的唯一标识符。
`要获取的运行 ID。`	`可选[UUID]`	用于筛选的可选运行 ID。

thread_id `instance-attribute` ¶

thread_id: UUID

线程的唯一标识符。

run_id `instance-attribute` ¶

run_id: Optional[UUID]

用于筛选的可选运行 ID。

ThreadsSearch ¶

基类：TypedDict

搜索线程的参数。

用于搜索线程或运行。

属性

名称	类型	描述
`metadata`	`MetadataInput`	用于筛选的可选元数据。
`要过滤的状态值。`	`MetadataInput`	用于筛选的可选值。
`可选[ThreadStatus]`	`可选[ThreadStatus]`	用于筛选的可选状态。
`limit`	`int`	返回结果的最大数量。
`offset`	`int`	分页的偏移量。
`要获取的线程 ID。`	`可选[UUID]`	用于筛选的可选线程 ID。

metadata `instance-attribute` ¶

metadata: MetadataInput

用于筛选的可选元数据。

values `instance-attribute` ¶

values: MetadataInput

用于筛选的可选值。

status `instance-attribute` ¶

status: Optional[ThreadStatus]

用于筛选的可选状态。

limit `instance-attribute` ¶

limit: int

返回结果的最大数量。

offset `instance-attribute` ¶

offset: int

分页的偏移量。

thread_id `instance-attribute` ¶

thread_id: Optional[UUID]

用于筛选的可选线程 ID。

RunsCreate ¶

基类：TypedDict

创建运行的有效载荷。

示例

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"
}

属性

名称	类型	描述
`assistant_id`	`可选[UUID]`	此运行要使用的可选助手 ID。
`要获取的线程 ID。`	`可选[UUID]`	此运行要使用的可选线程 ID。
`要获取的运行 ID。`	`可选[UUID]`	此运行要使用的可选运行 ID。
`可选[ThreadStatus]`	`可选[RunStatus]`	此运行的可选状态。
`metadata`	`MetadataInput`	此运行的可选元数据。
`阻止插入新的运行（如果已有一个正在进行中）。`	`bool`	此运行的多任务策略。
`可选[MultitaskStrategy]`	`MultitaskStrategy`	此运行的 IfNotExists。
`可选[IfNotExists]`	`IfNotExists`	创建运行前等待的秒数。
`可选[int]`	`int`	kwargs
`Dict[str, Any]`	`传递给运行的关键字参数。`	更新现有运行时的操作。
`CancelAction`	`可选[Literal['interrupt', 'rollback']]`	assistant_id `instance-attribute` ¶

thread_id `instance-attribute` ¶

assistant_id: Optional[UUID]

此运行要使用的可选助手 ID。

run_id `instance-attribute` ¶

thread_id: Optional[UUID]

此运行要使用的可选线程 ID。

status `instance-attribute` ¶

run_id: Optional[UUID]

此运行要使用的可选运行 ID。

metadata `instance-attribute` ¶

status: Optional[RunStatus]

此运行的可选状态。

prevent_insert_if_inflight `instance-attribute` ¶

metadata: MetadataInput

此运行的可选元数据。

multitask_strategy `instance-attribute` ¶

prevent_insert_if_inflight: bool

此运行的多任务策略。

if_not_exists `instance-attribute` ¶

multitask_strategy: MultitaskStrategy

此运行的 IfNotExists。

after_seconds `instance-attribute` ¶

if_not_exists: IfNotExists

创建运行前等待的秒数。

kwargs `instance-attribute` ¶

after_seconds: int

kwargs

action `instance-attribute` ¶

kwargs: Dict[str, Any]

更新现有运行时的操作。

AssistantsCreate ¶

action: Optional[Literal['interrupt', 'rollback']]

assistant_id instance-attribute ¶

助手的唯一标识符。

基类：TypedDict

创建助手的有效载荷。

示例

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

属性

名称	类型	描述
`assistant_id`	`UUID`	此助手要使用的图 ID。
`graph_id`	`str`	可选[联合[Dict[str, Any], Any]]
`config`	`助手的可选配置。`	要附加到助手的可选元数据。
`metadata`	`MetadataInput`	当具有相同 ID 的助手已存在时的行为。
`if_exists`	`OnConflictBehavior`	助手的名称。
`name`	`str`	assistant_id `instance-attribute` ¶

graph_id `instance-attribute` ¶

assistant_id: UUID

此助手要使用的图 ID。

config `instance-attribute` ¶

graph_id: str

可选[联合[Dict[str, Any], Any]]

metadata `instance-attribute` ¶

config: Optional[Union[Dict[str, Any], Any]]

要附加到助手的可选元数据。

if_exists `instance-attribute` ¶

metadata: MetadataInput

当具有相同 ID 的助手已存在时的行为。

name `instance-attribute` ¶

if_exists: OnConflictBehavior

助手的名称。

AssistantsRead ¶

name: str

assistant_id instance-attribute ¶

assistant_id `instance-attribute` ¶

基类：TypedDict

读取助手的有效载荷。

示例

read_params = {
    "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
    "metadata": {"owner": "user123"}
}

属性

名称	类型	描述
`assistant_id`	`UUID`	此助手要使用的图 ID。
`metadata`	`MetadataInput`	用于筛选的可选元数据。

metadata `instance-attribute` ¶

assistant_id: UUID

此助手要使用的图 ID。

AssistantsUpdate ¶

metadata: MetadataInput

用于筛选的可选元数据。

要更新的可选图 ID。

基类：TypedDict

更新助手的有效载荷。

示例

update_params = {
    "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
    "graph_id": "graph123",
    "config": {"key": "value"},
    "metadata": {"owner": "user123"},
    "name": "Assistant 1",
    "version": 1
}

属性

名称	类型	描述
`assistant_id`	`UUID`	此助手要使用的图 ID。
`graph_id`	`可选[str]`	要更新的可选配置。
`config`	`助手的可选配置。`	要更新的可选名称。
`metadata`	`MetadataInput`	要更新的可选元数据。
`name`	`可选[str]`	要更新的可选版本。
`要更改到的版本。`	`运行开始前等待的秒数。用于安排未来的运行。`	assistant_id `instance-attribute` ¶

graph_id `instance-attribute` ¶

assistant_id: UUID

此助手要使用的图 ID。

config `instance-attribute` ¶

graph_id: Optional[str]

要更新的可选配置。

metadata `instance-attribute` ¶

config: Optional[Union[Dict[str, Any], Any]]

要更新的可选名称。

name `instance-attribute` ¶

metadata: MetadataInput

要更新的可选元数据。

version `instance-attribute` ¶

name: Optional[str]

要更新的可选版本。

AssistantsDelete ¶

version: Optional[int]

assistant_id instance-attribute ¶

assistant_id `instance-attribute` ¶

基类：TypedDict

删除助手的有效载荷。

示例

delete_params = {
    "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000")
}

属性

名称	类型	描述
`assistant_id`	`UUID`	此助手要使用的图 ID。

AssistantsSearch ¶

assistant_id: UUID

此助手要使用的图 ID。

用于筛选的可选图 ID。

基类：TypedDict

搜索助手的有效载荷。

示例

search_params = {
    "graph_id": "graph123",
    "metadata": {"owner": "user123"},
    "limit": 10,
    "offset": 0
}

属性

名称	类型	描述
`graph_id`	`可选[str]`	graph_id `instance-attribute` ¶
`metadata`	`MetadataInput`	用于筛选的可选元数据。
`limit`	`int`	返回结果的最大数量。
`offset`	`int`	分页的偏移量。

metadata `instance-attribute` ¶

graph_id: Optional[str]

graph_id instance-attribute ¶

limit `instance-attribute` ¶

metadata: MetadataInput

用于筛选的可选元数据。

offset `instance-attribute` ¶

limit: int

返回结果的最大数量。

CronsCreate ¶

offset: int

分页的偏移量。

创建 Cron 作业的有效载荷。

基类：TypedDict

Cron 作业的有效载荷。

示例

create_params = {
    "payload": {"key": "value"},
    "schedule": "0 0 * * *",
    "cron_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
    "thread_id": UUID("123e4567-e89b-12d3-a456-426614174001"),
    "user_id": "user123",
    "end_time": datetime(2024, 3, 16, 10, 0, 0)
}

属性

名称	类型	描述
`payload`	`传递给运行的关键字参数。`	Cron 作业的调度。
`执行此任务的 cron 调度。`	`str`	Cron 作业的可选唯一标识符。
`要删除的定时任务 ID。`	`可选[UUID]`	此 Cron 作业要使用的可选线程 ID。
`要获取的线程 ID。`	`可选[UUID]`	用户 ID (user_id)
`此 Cron 作业要使用的可选用户 ID。`	`可选[str]`	Cron 作业的可选结束时间。
`end_time`	`可选[datetime]`	payload `instance-attribute` ¶

schedule `instance-attribute` ¶

payload: Dict[str, Any]

Cron 作业的调度。

cron_id `instance-attribute` ¶

schedule: str

Cron 作业的可选唯一标识符。

thread_id `instance-attribute` ¶

cron_id: Optional[UUID]

此 Cron 作业要使用的可选线程 ID。

user_id `instance-attribute` ¶

thread_id: Optional[UUID]

用户 ID (user_id)

end_time `instance-attribute` ¶

user_id: Optional[str]

Cron 作业的可选结束时间。

CronsDelete ¶

end_time: Optional[datetime]

payload instance-attribute ¶

删除 Cron 作业的有效载荷。

基类：TypedDict

Cron 作业的唯一标识符。

示例

delete_params = {
    "cron_id": UUID("123e4567-e89b-12d3-a456-426614174000")
}

属性

名称	类型	描述
`要删除的定时任务 ID。`	`UUID`	cron_id `instance-attribute` ¶

CronsRead ¶

cron_id: UUID

cron_id instance-attribute ¶

读取 Cron 作业的有效载荷。

基类：TypedDict

cron_id instance-attribute ¶

示例

read_params = {
    "cron_id": UUID("123e4567-e89b-12d3-a456-426614174000")
}

属性

名称	类型	描述
`要删除的定时任务 ID。`	`UUID`	cron_id `instance-attribute` ¶

CronsUpdate ¶

cron_id: UUID

cron_id instance-attribute ¶

更新 Cron 作业的有效载荷。

基类：TypedDict

可选[Dict[str, Any]]

示例

update_params = {
    "cron_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
    "payload": {"key": "value"},
    "schedule": "0 0 * * *"
}

属性

名称	类型	描述
`要删除的定时任务 ID。`	`UUID`	cron_id `instance-attribute` ¶
`payload`	`要更新的可选有效载荷。`	要更新的可选调度。
`执行此任务的 cron 调度。`	`可选[str]`	cron_id `instance-attribute` ¶

payload `instance-attribute` ¶

cron_id: UUID

cron_id instance-attribute ¶

schedule `instance-attribute` ¶

payload: Optional[Dict[str, Any]]

要更新的可选调度。

CronsSearch ¶

schedule: Optional[str]

cron_id instance-attribute ¶

搜索 Cron 作业的有效载荷。

基类：TypedDict

用于筛选的可选助手 ID。

示例

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

属性

名称	类型	描述
`assistant_id`	`可选[UUID]`	assistant_id `instance-attribute` ¶
`要获取的线程 ID。`	`可选[UUID]`	用于筛选的可选线程 ID。
`limit`	`int`	返回结果的最大数量。
`offset`	`int`	分页的偏移量。

thread_id `instance-attribute` ¶

assistant_id: Optional[UUID]

assistant_id instance-attribute ¶

limit `instance-attribute` ¶

thread_id: Optional[UUID]

用于筛选的可选线程 ID。

offset `instance-attribute` ¶

limit: int

返回结果的最大数量。

StoreGet ¶

offset: int

分页的偏移量。

元组[str, ...]

基类：TypedDict

通过命名空间和键检索特定项目的操作。

属性

名称	类型	描述
`namespace`	`唯一标识项目位置的分层路径。`	项目在其特定命名空间内的唯一标识符。
`命名空间内项目的唯一标识符。`	`str`	namespace `instance-attribute` ¶

key `instance-attribute` ¶

namespace: tuple[str, ...]

项目在其特定命名空间内的唯一标识符。

StoreSearch ¶

key: str

namespace instance-attribute ¶

定义搜索范围的前缀过滤器。

基类：TypedDict

在指定命名空间层次结构中搜索项目的操作。

属性

名称	类型	描述
`namespace`	`唯一标识项目位置的分层路径。`	用于基于精确匹配或比较运算符筛选结果的键值对。
`可选[dict[str, Any]]`	`可选的键值对字典，用于过滤结果。`	搜索结果中返回的最大项目数。
`limit`	`int`	为分页跳过的匹配项目数。
`offset`	`int`	用于语义搜索功能的自然语言搜索查询。
`自然语言搜索的可选查询。`	`可选[str]`	namespace `instance-attribute` ¶

filter `instance-attribute` ¶

namespace: tuple[str, ...]

用于基于精确匹配或比较运算符筛选结果的键值对。

limit `instance-attribute` ¶

filter: Optional[dict[str, Any]]

搜索结果中返回的最大项目数。

offset `instance-attribute` ¶

limit: int

为分页跳过的匹配项目数。

query `instance-attribute` ¶

offset: int

用于语义搜索功能的自然语言搜索查询。

StoreListNamespaces ¶

query: Optional[str]

namespace instance-attribute ¶

可选[元组[str, ...]]

基类：TypedDict

列出和过滤存储中命名空间的操作。

属性

名称	类型	描述
`namespace`	`前缀过滤命名空间。`	筛选命名空间的可选条件。
`表示要过滤命名空间的后缀的可选字符串列表。`	`前缀过滤命名空间。`	返回的命名空间层级最大深度。
`指定要返回的命名空间最大深度的可选整数。`	`运行开始前等待的秒数。用于安排未来的运行。`	返回的命名空间最大数量。
`limit`	`int`	为分页跳过的命名空间数量。
`offset`	`int`	namespace `instance-attribute` ¶

suffix `instance-attribute` ¶

namespace: Optional[tuple[str, ...]]

筛选命名空间的可选条件。

max_depth `instance-attribute` ¶

suffix: Optional[tuple[str, ...]]

返回的命名空间层级最大深度。

超出此深度的命名空间将被截断。

max_depth: Optional[int]

返回的命名空间最大数量。

注意

limit instance-attribute ¶

offset `instance-attribute` ¶

limit: int

为分页跳过的命名空间数量。

StorePut ¶

offset: int

namespace instance-attribute ¶

标识项目位置的分层路径。

基类：TypedDict

在存储中存储、更新或删除项目的操作。

属性

名称	类型	描述
`namespace`	`唯一标识项目位置的分层路径。`	项目在其命名空间内的唯一标识符。
`命名空间内项目的唯一标识符。`	`str`	要存储的数据，或 None 以标记项目删除。
`包含项目数据的字典。`	`可选的键值对字典，用于过滤结果。`	用于全文搜索的可选索引配置。
`可选[联合[字面量[False], list[str]]]`	`控制搜索索引 - None（使用默认值）、False（禁用）或要索引的字段路径列表。`	namespace `instance-attribute` ¶

key `instance-attribute` ¶

namespace: tuple[str, ...]

项目在其命名空间内的唯一标识符。

value `instance-attribute` ¶

key: str

要存储的数据，或 None 以标记项目删除。

index `instance-attribute` ¶

value: Optional[dict[str, Any]]

用于全文搜索的可选索引配置。

StoreDelete ¶

index: Optional[Union[Literal[False], list[str]]]

namespace instance-attribute ¶

namespace `instance-attribute` ¶

基类：TypedDict

从存储中删除项目的操作。

属性

名称	类型	描述
`namespace`	`唯一标识项目位置的分层路径。`	项目在其特定命名空间内的唯一标识符。
`命名空间内项目的唯一标识符。`	`str`	namespace `instance-attribute` ¶

key `instance-attribute` ¶

namespace: tuple[str, ...]

项目在其特定命名空间内的唯一标识符。

on ¶

key: str

namespace instance-attribute ¶

此类别组织了不同资源（线程、助手、cron）上创建、读取、更新、删除和搜索操作的类型定义。

不同 API 操作的类型定义命名空间。

用法

线程相关操作的类型。

from langgraph_sdk import Auth

auth = Auth()

@auth.on
def handle_all(params: Auth.on.value):
    raise Exception("Not authorized")

@auth.on.threads.create
def handle_thread_create(params: Auth.on.threads.create.value):
    # Handle thread creation
    pass

@auth.on.assistants.search
def handle_assistant_search(params: Auth.on.assistants.search.value):
    # Handle assistant search
    pass

类

名称	描述
`threads`	助手相关操作的类型。
`assistants`	Cron 相关操作的类型。
`crons`	存储相关操作的类型。
`store`	threads ¶

线程创建参数的类型。

助手相关操作的类型。

类

名称	描述
`create`	create_run
`创建或流式传输运行的类型。`	读取 (read)
`线程读取参数的类型。`	线程更新参数的类型。
`update`	线程删除参数的类型。
`delete`	线程搜索参数的类型。
`search`	create ¶

create_run ¶

create_run

read ¶

读取 (read)

update ¶

线程更新参数的类型。

delete ¶

线程删除参数的类型。

search ¶

线程搜索参数的类型。

assistants ¶

create ¶

助手创建参数的类型。

Cron 相关操作的类型。

类

名称	描述
`create`	助手读取参数的类型。
`线程读取参数的类型。`	助手更新参数的类型。
`update`	助手删除参数的类型。
`delete`	助手搜索参数的类型。
`search`	create ¶

read ¶

助手读取参数的类型。

update ¶

助手更新参数的类型。

delete ¶

助手删除参数的类型。

search ¶

助手搜索参数的类型。

crons ¶

create ¶

Cron 创建参数的类型。

存储相关操作的类型。

类

名称	描述
`create`	Cron 读取参数的类型。
`线程读取参数的类型。`	Cron 更新参数的类型。
`update`	Cron 删除参数的类型。
`delete`	Cron 搜索参数的类型。
`search`	create ¶

read ¶

Cron 读取参数的类型。

update ¶

Cron 更新参数的类型。

delete ¶

Cron 删除参数的类型。

search ¶

Cron 搜索参数的类型。

store ¶

create ¶

存储放置参数的类型。

threads ¶

类

名称	描述
`put`	存储获取参数的类型。
`get`	存储搜索参数的类型。
`search`	存储删除参数的类型。
`delete`	存储列出命名空间参数的类型。
`列出带可选匹配条件的命名空间。`	put ¶

get ¶

存储获取参数的类型。

search ¶

存储搜索参数的类型。

delete ¶

存储删除参数的类型。

list_namespaces ¶

存储列出命名空间参数的类型。

HTTPException

put ¶

身份验证系统中使用的异常。

类

名称	描述
`您可以抛出的 HTTP 异常，以返回特定的 HTTP 错误响应。`	HTTPException ¶

基类：`Exception`

由于此异常在认证模块中定义，我们默认状态码为 401。

HTTPException ¶

状态码 (status_code)

参数

名称	类型	描述	默认
`错误的 HTTP 状态码。默认为 401 "Unauthorized"（未经授权）。`	`int`	详细信息 (detail)	`401`
`详细错误信息。如果为 None，则根据状态码使用默认信息。`	`可选[str]`	可选[映射[str, str]]	`无`
`headers`	`要在错误响应中包含的额外 HTTP 头部。`	添加头部	`无`

示例

默认

raise HTTPException()
# HTTPException(status_code=401, detail='Unauthorized')

自定义错误

raise HTTPException(headers={"X-Custom-Header": "Custom Value"})
# HTTPException(status_code=401, detail='Unauthorized', headers={"WWW-Authenticate": "Bearer"})

返回顶部

raise HTTPException(status_code=404, detail="Not found")

Python SDK 参考¶

LangGraphClient ¶

HttpClient ¶

get async ¶

post async ¶

put async ¶

patch async ¶

delete async ¶

stream async ¶

AssistantsClient ¶

get async ¶

get_graph async ¶

get_schemas async ¶

get_subgraphs async ¶

create async ¶

update async ¶

delete async ¶

search async ¶

get_versions async ¶

set_latest async ¶

线程维护图在多次交互/调用（又称运行）中的状态。它累积并持久化图的状态，允许在图的不同调用之间保持连续性。

thread_id

要添加到线程的元数据。

要更新的线程 ID。

要删除的线程 ID。

要过滤的线程元数据。

要复制的线程 ID。

要获取状态的线程 ID。

要更新的线程 ID。

要获取状态历史的线程 ID。

运行是助手的单个调用，带有可选的输入、配置和元数据。此客户端管理运行，可以是有状态的（在线程上）或无状态的。

要分配给线程的线程 ID。如果为 None，将创建无状态运行。

运行创建时可选的回调。

wait async ¶

要在其上创建运行的线程 ID。如果为 None，将创建无状态运行。

要列出运行的线程 ID。

要获取的线程 ID。

要取消的线程 ID。

要加入的线程 ID。

实时流式传输运行输出，直到运行完成。输出不缓冲，因此在此调用之前产生的任何输出都不会在此处接收。

要删除的线程 ID。

运行是助手对可选输入和配置的单次调用。此客户端允许安排定期运行以自动发生。

要运行定时任务的线程 ID。

delete async ¶

cron_id

要搜索的助手 ID 或图名称。

存储提供了一个键值存储系统，用于在图执行期间持久化数据，从而允许跨线程进行有状态操作和数据共享。

序列[str]

项目的唯一标识符。

search_items async ¶

namespace_prefix

prefix

此类提供对 LangGraph API 端点的同步访问，用于管理助手、线程、运行、定时任务和数据存储。

在底层 httpx 客户端之上提供错误消息和内容处理增强功能，镜像 HttpClient 的接口，但用于同步用法。

post ¶

put ¶

patch ¶

delete ¶

stream ¶

SyncAssistantsClient ¶

get ¶

要获取的助手 ID 或图名称（用于使用默认助手）。

get_schemas ¶

get_subgraphs ¶

create ¶

update ¶

delete ¶

search ¶

get_versions ¶

set_latest ¶

SyncThreadsClient ¶

此类提供创建、检索和管理线程的方法，线程表示对话或有状态交互。

create ¶

create ¶

update ¶

delete ¶

search ¶

copy ¶

get_state ¶

update_state ¶

get `async` ¶

post `async` ¶

put `async` ¶

patch `async` ¶

delete `async` ¶

stream `async` ¶

get `async` ¶

get_graph `async` ¶

get_schemas `async` ¶

get_subgraphs `async` ¶

create `async` ¶

update `async` ¶

delete `async` ¶

search `async` ¶

get_versions `async` ¶

set_latest `async` ¶

wait `async` ¶

delete `async` ¶

search_items `async` ¶

Json `module-attribute` ¶

RunStatus `module-attribute` ¶

ThreadStatus `module-attribute` ¶

StreamMode `module-attribute` ¶

DisconnectMode `module-attribute` ¶

MultitaskStrategy `module-attribute` ¶

OnConflictBehavior `module-attribute` ¶

OnCompletionBehavior `module-attribute` ¶

All `module-attribute` ¶

IfNotExists `module-attribute` ¶

AssistantSortBy `module-attribute` ¶

ThreadSortBy `module-attribute` ¶

SortOrder `module-attribute` ¶

tags `instance-attribute` ¶

recursion_limit `instance-attribute` ¶

configurable `instance-attribute` ¶

thread_id `instance-attribute` ¶

checkpoint_ns `instance-attribute` ¶

checkpoint_id `instance-attribute` ¶

checkpoint_map `instance-attribute` ¶

graph_id `instance-attribute` ¶

input_schema `instance-attribute` ¶

output_schema `instance-attribute` ¶

state_schema `instance-attribute` ¶

config_schema `instance-attribute` ¶

assistant_id `instance-attribute` ¶

graph_id `instance-attribute` ¶

config `instance-attribute` ¶

created_at `instance-attribute` ¶

metadata `instance-attribute` ¶

version `instance-attribute` ¶

name `instance-attribute` ¶

description `instance-attribute` ¶

assistant_id `instance-attribute` ¶

graph_id `instance-attribute` ¶

config `instance-attribute` ¶

created_at `instance-attribute` ¶

metadata `instance-attribute` ¶

version `instance-attribute` ¶