<i @%SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK J r J r J r Jr SSKJr SSKJrJrJrJrJrJr SSKrSSKrSSKrSSKJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrD SSKEJFrFJGrGJHrH \R"\J5rKS rLS9S:S jjrMS;S jrNSSjjrS"SS5rT"SS5rUS?SjrVS@SjrW"SS5rX"SS5rY"SS5rZ"SS5r["SS 5r\SSSSS.SAS"jjr]"S#S!5r^"S$S%5r_SBS&jr`S@S'jra"S(S)5rb"S*S+5rc"S,S-5rd"S.S/5re"S0S15rfSCS2jrg/rhS3\iS4'SDS5jrj\R"S6S79SES8j5rl\S\m\n\\m\\m4\n\\m\\m\\m\\m4\R4rpg)FaThe LangGraph client implementations connect to the LangGraph API. This module provides both asynchronous ([get_client(url="http://localhost:2024"))](#get_client) or [LangGraphClient](#LangGraphClient)) and synchronous ([get_sync_client(url="http://localhost:2024"))](#get_sync_client) or [SyncLanggraphClient](#SyncLanggraphClient)) clients to interacting with the LangGraph API's core resources such as Assistants, Threads, Runs, and Cron jobs, as well as its persistent document Store. ) annotationsN) AsyncIteratorIteratorMappingSequence) TracebackType)AnyCallableLiteralOptionalUnionoverload))All AssistantAssistantSelectFieldAssistantSortByAssistantVersion CancelAction CheckpointCommandConfigContextCronCronSelectField CronSortByDisconnectMode Durability GraphSchema IfNotExistsItemJsonListNamespaceResponseMultitaskStrategyOnCompletionBehaviorOnConflictBehaviorQueryParamTypesRun RunCreateRunCreateMetadataRunSelectField RunStatusSearchItemsResponse SortOrder StreamMode StreamPart SubgraphsThreadThreadSelectField ThreadSortBy ThreadState ThreadStatusThreadStreamModeThreadUpdateStateResponse) SSEDecoderaiter_lines_rawiter_lines_raw) x-api-keycU(aU$SHSn[R"US35=n(dM%UR5RS5RS5s $ g)zGet the API key from the environment. Precedence: 1. explicit argument 2. LANGGRAPH_API_KEY 3. LANGSMITH_API_KEY 4. LANGCHAIN_API_KEY ) LANGGRAPH LANGSMITH LANGCHAIN_API_KEY"'N)osgetenvstrip)api_keyprefixenvs d/home/dmtnaga/Documents/work/airagagent/rag_env/lib/python3.13/site-packages/langgraph_sdk/client.py _get_api_keyrJUsX9))vhh/0 03 099;$$S)//4 4: cU=(d 0n[HnX!;dM [SUS35e SS[R30UEn[ U5nU(aXS'U$)z1Combine api_key and custom user-provided headers.zCannot set reserved header 'rBz User-Agentzlanggraph-sdk-py/r;)RESERVED_HEADERS ValueError langgraph_sdk __version__rJ)rFcustom_headersheaderheaderss rI _get_headersrTest$)rN"  #;F81EF F# )-*C*C)DE G7#G&  NrKcj[US5(a*[UR5(aUR5$[US5(a*[UR5(aUR5$[ U[ [ 45(a [U5$[S[U5S35e)N model_dumpdictzObject of type z is not JSON serializable) hasattrcallablerVrW isinstanceset frozensetlist TypeErrortype)objs rI_orjson_defaultrayssL!!hs~~&>&>~~ f  (388"4"4xxz C#y) * *Cy/$s)4MNOOrKz5(\/threads\/(?P.+))?\/runs\/(?P.+)cURRS5=n(aM[RU5=n(a1[ UR S5UR S5=(d SS9$g)z/Extract run metadata from the response headers.zContent-Locationrun_id thread_idN)rcrd)rSget_RUN_METADATA_PATTERNsearchr)group)responsecontent_locationmatchs rI_get_run_metadata_from_responserlsh%,,001CDDD&--.>??? ;;x(kk+.6$  rK)urlrFrStimeoutLangGraphClientc SnUcb[RRS5S:Xa'[5"SSS9n[R U5 SnOSSKJn Sn[5"USS 9nUc[R"S S 9n[R"UUUb[R"U5O[R"S S S S S9[X5S9n[U5$![a S nN~f=f)uwCreate and configure a LangGraphClient. The client provides programmatic access to a LangGraph Platform deployment. It supports both remote servers and local in-process connections (when running inside a LangGraph server). Args: url: Base URL of the LangGraph API. – If `None`, the client first attempts an in-process connection via ASGI transport. If that fails, it falls back to `http://localhost:8123`. api_key: API key for authentication. If omitted, the client reads from environment variables in the following order: 1. Function argument 2. `LANGGRAPH_API_KEY` 3. `LANGSMITH_API_KEY` 4. `LANGCHAIN_API_KEY` headers: Additional HTTP headers to include in requests. Merged with authentication headers. timeout: HTTP timeout configuration. May be: – `httpx.Timeout` instance – float (total seconds) – tuple `(connect, read, write, pool)` in seconds Defaults: connect=5, read=300, write=300, pool=5. Returns: LangGraphClient: A top-level client exposing sub-clients for assistants, threads, runs, and cron operations. ???+ example "Connect to a remote server:" ```python from langgraph_sdk import get_client # get top-level LangGraphClient client = get_client(url="http://localhost:8123") # example usage: client..() assistants = await client.assistants.get(assistant_id="some_uuid") ``` ???+ example "Connect in-process to a running LangGraph server:" ```python from langgraph_sdk import get_client client = get_client(url=None) async def my_node(...): subagent_result = await client.runs.wait( thread_id=None, assistant_id="agent", input={"messages": [{"role": "user", "content": "Foo"}]}, ) ``` N$__LANGGRAPH_DEFER_LOOPBACK_TRANSPORTtruez/noauth)app root_pathz http://apir)rs)rthttp://localhost:8123retries,connectreadwritepoolbase_url transportrnrS)rCenvironreget_asgi_transport_registered_transportsappendlanggraph_api.serverrs ExceptionhttpxAsyncHTTPTransport AsyncClientTimeoutrTro)rmrFrSrnrrsclients rI get_clientrsD26I { ::>>@ AV K*,KI " ) )) 4C .4".0 J ,,Q7   " MM' "qs#AFW. F 6 "" .- .sC C'&C'cP\rSrSrSrS SjrS SjrS SjrS SjrSr g) roakTop-level client for LangGraph API. Attributes: assistants: Manages versioned configuration for your graphs. threads: Handles (potentially) multi-turn interactions, such as conversational threads. runs: Controls individual invocations of the graph. crons: Manages scheduled operations. store: Interfaces with persistent, shared data storage. c([U5Ul[UR5Ul[ UR5Ul[ UR5Ul[UR5Ul [UR5Ul gN) HttpClienthttpAssistantsClient assistants ThreadsClientthreads RunsClientruns CronClientcrons StoreClientstoreselfrs rI__init__LangGraphClient.__init__s^v& *4995$TYY/ tyy)  *  + rKc# U$7f)z Enter the async context manager.rs rI __aenter__LangGraphClient.__aenter__ s  sc@# UR5IShvN gN7f)zExit the async context manager.N)acloserexc_typeexc_valexc_tbs rI __aexit__LangGraphClient.__aexit__skkms c# [US5(a-URRR5IShvN ggN7fz!Close the underlying HTTP client.rN)rXrrrrs rIrLangGraphClient.acloses6 4 ))""))+ + + ! +s9AAArrrrrrNrzhttpx.AsyncClientreturnNone)rrorztype[BaseException] | NonerzBaseException | NonerzTracebackType | Nonerrrr) __name__ __module__ __qualname____firstlineno____doc__rrrr__static_attributes__rrKrIrorosA,,&%   ,rKcf\rSrSrSrSSjrSSSS.SSjjrSSSS.SSjjrSSSS.SSjjrSSSS.SS jjr SSSSS .SS jjr SSSSS S .SSjjr SSSSS .SSjjr Sr g)ri zHandle async requests to the LangGraph API. Adds additional error messaging & content handling above the provided httpx client. Attributes: client (httpx.AsyncClient): Underlying HTTPX async client. cXlgrrrs rIrHttpClient.__init__* rKNparamsrS on_responsec# URRXUS9IShvN nU(aU"U5 UR5 [U5IShvN $N7![RalnUR 5IShvN R 5n[RS:aURU5 Ue[RSU3US9 UeSnAff=fN7f)Send a GET request.rrSN Error from langgraph-api: exc_info) rreraise_for_statusrHTTPStatusErrorareaddecodesys version_infoadd_noteloggererror _adecode_jsonrpathrrSrrebodys rIreHttpClient.get-s++//$w/G G  N    #1%%% H $$ '')OO++-D7* 4 G 9$@1 MG  &sKCACACCCC.CBACCCc.# Ub[U5IShvN upgO0SpvU(aURU5 URRXXsS9IShvN nU(aU"U5 UR 5 [U5IShvN $NwN9![ R aln UR5IShvN R5n [RS:aU RU 5 U e[RSU 3U S9 U eSn A ff=fN7fzSend a POST request.NrKrScontentrrrr) _aencode_jsonupdaterpostrrrrrrrrrrr rrjsonrrSrrequest_headersrrrrs rIrHttpClient.postDs  -:4-@'@ $OW')3W   " "7 +++"" 7#    N    #1%%%)(A  $$ '')OO++-D7* 4 G 9$@1 MG  &s^DB ?DBD)B9DDDDD$D 7B:8AD  DDc # [U5IShvN upgU(aURU5 URRXXsS9IShvN nU(aU"U5 UR 5 [U5IShvN $NsN9![ R aln UR5IShvN R5n [RS:aU RU 5 U e[RSU 3U S9 U eSn A ff=fN7f)Send a PUT request.Nrrrr)rrrputrrrrrrrrrrrrs rIrHttpClient.putes*7t)<#<    " "7 +++// 7"    N    #1%%%#$= $$ '')OO++-D7* 4 G 9$@1 MG  &^DB;D BD"B 2DD DD D D0B31ADD  Dc # [U5IShvN upgU(aURU5 URRXXsS9IShvN nU(aU"U5 UR 5 [U5IShvN $NsN9![ R aln UR5IShvN R5n [RS:aU RU 5 U e[RSU 3U S9 U eSn A ff=fN7f)Send a PATCH request.Nrrrr)rrrpatchrrrrrrrrrrrrs rIrHttpClient.patchs*7t)<#<    " "7 +++## 7$    N    #1%%%#$= $$ '')OO++-D7* 4 G 9$@1 MG  &rrrrSrc# URRSXX4S9IShvN nU(aU"U5 UR5 gN%![RalnUR 5IShvN R 5n[RS:aURU5 Ue[RSU3US9 UeSnAff=f7f)Send a DELETE request.DELETErrrSNrrr) rrequestrrrrrrrrrr rrrrrSrrrrs rIdeleteHttpClient.deletes++%% df&    N     $$ '')OO++-D7* 4 G 9$@1 MG  s?C AC A C  C C0A31ACC  C rvrrrSrreconnect_limitc # [U5IShvN upU(aURU5 URRX!XUS9IShvN n U(aU"U 5 U R 5 U RRS5n US::dU (d$[!U 5IShvN sSSS5IShvN $[!U 5IShvN sSSS5IShvN $NN![ R aln U R5IShvN R5n [RS:aU RU 5 U e[RSU 3U S9 U eSn A ff=fNNNN![ R"ad [$R&"SU 3S S 9 U R)5IShvN UR+U S UUS - S 9IShvN ssSSS5IShvN $f=f!,IShvN (df  g=f7f)@Send a request that automatically reconnects to Location header.Nrrrrlocationr2Request failed, attempting reconnect to Location:  stacklevelGETrSr)rrrstreamrrrrrrrrrrrSrer HTTPErrorwarningswarnrrequest_reconnectrrmethodrrrSrrrrrrrlocs rIr HttpClient.request_reconnects*7t)<#<    " "7 +;;%% /6&  A ""$))-- +C!#3*1--!   " *1--%   $= (( ggi//1##w.JJt$LL#=dV!DqLQ  .! $.% &??  HN hhj  !33+$3a$7 43   & '   sH C%=H C'H G/$C)46G/*E,+G/. H :E.;H E4E0E4 H E2 H 'H )E)=E$DAE$$E))G/.H 0E42H 4?G,3F64G,GG,G/ H $G'%H +G,,G//H5G8 6 HH c# [U5IShvN upxSUS'SUS'U(aURU5 UR5V V s0sHupU R5S;dMX_M n n n Sn Sn SnSn[ U cUOU 5nU bU US 'U cUOS nU cUOSnU cUOSnS nUR R UU =(d UUUUS 9IShvN nU cU(aU"U5 UR5 UR"R%SS5R'S5SnSU;a[R("SU<35eUR"R%S5nU(aUn [+5n[-U5ShvN nURUR/S5S9nUcM,UR0b UR0n UR2(dUR4cMeU7v MlGNs sn n fGN%![RalnUR5IShvN R5n[RS:aURU5 Ue[R!SU3US9 UeSnAff=fN URS5=n(a<UR0b UR0n UR2(d UR4bU7v O ![R6a U ceS nOf=fSSS5IShvN O!,IShvN (df  O=fU(a#US- nX:a[R("S5eGMg7f)zStream results using SSE.Ntext/event-streamAcceptno-store Cache-Control content-typecontent-lengthrrvT Last-Event-IDrFrrrrr;JExpected response header Content-Type to contain 'text/event-stream', got r )linerKr*Exceeded maximum SSE reconnection attempts)rritemslowerrWrrrrrrrrrrrrrSre partitionTransportErrorr8r9rstrip last_event_ideventdatar rrrrrrSrrrkeyvaluereconnect_headersr%reconnect_pathreconnect_attemptsmax_reconnect_attemptscurrent_headerscurrent_methodcurrent_contentcurrent_paramsretryresrr content_typereconnect_locationdecoderrsses rIrHttpClient.streams\*7t)<#< $7!+5(   " "7 +.335 5 yy{"DD CJ5  %) %)!""#1#9?PO(3@0'5'=V5N)7)?gTO'5'=V4NE{{))&$''% * !)k$((* #{{~rBLLSQRST &l:..+.0 &)[[__Z%@"%%7N%,&&5c&:*d%nn$++e2DnE?&44@070E0E "yyCHH,@&) M$= .,,"%))+--557D''72 4(G 'A$%HST UG ,*&:&nnS11s1"00<,3,A,AM99(< #&I!&- E !Sr"a'"%>..D sMG2;M G5+G51A%MG;ML .G>>AI>I9%H(&AI99I>>L JKAL K63L 5K66L 9 MLM L"L  L"2Mrr rstrrQueryParamTypes | NonerSMapping[str, str] | Noner'Callable[[httpx.Response], None] | Nonerr rr;rzdict[str, Any] | list | Nonerr<rSr=rr>rr rr;rrWrr<rSr=rr>rr rr;rz Any | Nonerr<rSr=rr>rrrr;rr;rdict[str, Any] | Nonerr<rSr=rr>rintrr )rr;rr;rrCrr<rSr=rr>rAsyncIterator[StreamPart]rrrrrrrerrrrr rrrrKrIrr sD*.,0?C &&' & * & = & &8*.,0?C&&+ & ' & * &=& &L*.,0?C&& & ' & * &=& &D*.,0?C&& & ' & * &=& &B )-,0?C  '  * = <'+)-,0?C ... $ . ' .*.=.. .j'+)-,0?Ciii $ i ' i*i=i #iirKrc# Uc0S4$[R"5RS[RU[ [R [R-5IShvN n[[U55nSnX#S.nXA4$N!7fNzapplication/json)zContent-Lengthz Content-Type) asyncioget_running_looprun_in_executororjsondumpsraOPT_SERIALIZE_NUMPYOPT_NON_STR_KEYSr;lenrrcontent_lengthr5rSs rIrrTs~ |4x))+;;   ""V%<%<<  DT^N%L!/NG = sA$B &B'"B c# UR5IShvN nU(a<[R"5RS[R U5IShvN $S$NIN7fr)rrIrJrKrLloadsrrs rIrrdsR?D &&(88v||TRR Rs"A$A AA$A"A$"A$c H\rSrSrSrSSjrSSS.SSjjrSSSS.SS jjrSSS.SS jjrSSSS.SS jjjr S SSSSSSSSS .S!S jjjr SSSSSSSSS.S"Sjjr SSS.S#Sjjr SSSSSSSSSS. S$Sjjr SSSSS.S%SjjrS&SSS.S'SjjjrSSS.S(SjjrSrg))rima=Client for managing assistants in LangGraph. This class provides methods to interact with assistants, which are versioned configurations of your graph. ???+ example "Example" ```python client = get_client(url="http://localhost:2024") assistant = await client.assistants.get("assistant_id_123") ``` cXlgrrrrs rIrAssistantsClient.__init__{ rKNrSrcX# URRSU3X#S9IShvN $N7f)a6Get an assistant by ID. Args: assistant_id: The ID of the assistant to get. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Assistant: Assistant Object. ???+ example "Example Usage" ```python assistant = await client.assistants.get( assistant_id="my_assistant_id" ) print(assistant) ``` ```shell ---------------------------------------------------- { 'assistant_id': 'my_assistant_id', 'graph_id': 'agent', 'created_at': '2024-06-25T17:10:33.109781+00:00', 'updated_at': '2024-06-25T17:10:33.109781+00:00', 'config': {}, 'metadata': {'created_by': 'system'}, 'version': 1, 'name': 'my_assistant' } ``` /assistants/r\Nrrer assistant_idrSrs rIreAssistantsClient.get~s8RYY]]<. )7#    !*(*FxrayrSrc# SU0nU(aURU5 URRSUS3XSS9IShvN $N7f)aIGet the graph of an assistant by ID. Args: assistant_id: The ID of the assistant to get the graph of. xray: Include graph representation of subgraphs. If an integer value is provided, only subgraphs with a depth less than or equal to the value will be included. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Graph: The graph information for the assistant in JSON format. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") graph_info = await client.assistants.get_graph( assistant_id="my_assistant_id" ) print(graph_info) ``` ```shell -------------------------------------------------------------------------------------------------------------------------- { '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__'} ] } ``` rer^/graphrNrrrerrarerSr query_paramss rI get_graphAssistantsClient.get_graphsTd~     'YY]]<. / #    s>AAAcZ# URRSUS3X#S9IShvN $N7f)aGet the schemas of an assistant by ID. Args: assistant_id: The ID of the assistant to get the schema of. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: GraphSchema: The graph schema for the assistant. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") schema = await client.assistants.get_schemas( assistant_id="my_assistant_id" ) print(schema) ``` ```shell ---------------------------------------------------------------------------------------------------------------------------- { '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'] } } }, 'context_schema': { 'title': 'Context', 'type': 'object', 'properties': { 'model_name': { 'title': 'Model Name', 'enum': ['anthropic', 'openai'], 'type': 'string' } } } } ``` r^/schemasr\Nr_r`s rI get_schemasAssistantsClient.get_schemass:jYY]]<. 17#    s "+)+c# SU0nU(a0UEUEnUb)URRSUSU3UUS9IShvN $URRSUS3UUS9IShvN $N+N7f)aGet the schemas of an assistant by ID. Args: assistant_id: The ID of the assistant to get the schema of. namespace: Optional namespace to filter by. recurse: Whether to recursively get subgraphs. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Subgraphs: The graph schema for the assistant. recurseNr^ /subgraphs/r /subgraphsr_rra namespacerrrSr get_paramss rI get_subgraphsAssistantsClient.get_subgraphs^s, ) 1J1&1J  |nK {C!'  |nJ7!'   s!9A+A'&A+"A)#A+)A+contextmetadatara if_existsnamerS descriptionrc# SU0n U(aX+S'U(aX;S'U(aXKS'U(aX[S'U(aXkS'U(aX{S'U (aXS'URRS XU S 9IS hvN $N7f) aCreate a new assistant. Useful when graph is configurable and you want to create different assistants based on different configurations. Args: graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration. config: Configuration to use for the graph. metadata: Metadata to add to assistant. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" assistant_id: Assistant ID to use, will default to a random UUID if not provided. if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood. Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing assistant). name: The name of the assistant. Defaults to 'Untitled' under the hood. headers: Optional custom headers to include with the request. description: Optional description of the assistant. The description field is available for langgraph-api server version>=0.0.45 params: Optional query parameters to include with the request. Returns: Assistant: The created assistant. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") assistant = await client.assistants.create( graph_id="agent", context={"model_name": "openai"}, metadata={"number":1}, assistant_id="my-assistant-id", if_exists="do_nothing", name="my_name" ) ``` graph_idconfigr{r|rar}r~r /assistantsrrSrNrr rrrr{r|rar}r~rSrrpayloads rIcreateAssistantsClient.createsf #   &H  !(I  "*J  &2N # #,K "FO %0M "YY^^ $    sA0A92A73A9rrr{r|r~rSrrc# 0n U(aX*S'U(aX:S'U(aXJS'U(aXZS'U(aXjS'U(aXS'URRSU3U UU S9IS hvN $N7f) aUpdate an assistant. Use this to point to a different graph, update the configuration, or change the metadata of an assistant. Args: assistant_id: Assistant to update. graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration. If None, assistant will keep pointing to same graph. config: Configuration to use for the graph. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" metadata: Metadata to merge with existing assistant metadata. name: The new name for the assistant. headers: Optional custom headers to include with the request. description: Optional description of the assistant. The description field is available for langgraph-api server version>=0.0.45 params: Optional query parameters to include with the request. Returns: Assistant: The updated assistant. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") assistant = await client.assistants.update( assistant_id='e280dad7-8618-443f-87f1-8e41841c180f', graph_id="other-graph", context={"model_name": "anthropic"}, metadata={"number":2} ) ``` rrr{r|r~rr^rNrr rrarrr{r|r~rSrrrs rIrAssistantsClient.updates^#% "*J   &H  !(I  "*J  "FO %0M "YY__<. ) %    sA'A0)A.*A0cZ# URRSU3X#S9IShvN gN7f)aDelete an assistant. Args: assistant_id: The assistant ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.assistants.delete( assistant_id="my_assistant_id" ) ``` r^r\Nrrr`s rIrAssistantsClient.deletes46ii<. )7   !+)+ r r|rlimitoffsetsort_by sort_orderselectrSrc # UUS.n U(aXS'U(aX*S'U(aXZS'U(aXjS'U(aXzS'URRSU UU S9IS hvN $N7f) aOSearch for assistants. Args: metadata: Metadata to filter by. Exact match filter for each KV pair. graph_id: The ID of the graph to filter by. The graph ID is normally set in your langgraph.json configuration. limit: The maximum number of results to return. offset: The number of results to skip. sort_by: The field to sort by. sort_order: The order to sort by. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: list[Assistant]: A list of assistants. ???+ example "Example Usage" ```python 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 ) ``` rrr|rrrr/assistants/searchrNr rr|rrrrrrrSrrs rIrgAssistantsClient.search-s~T#  "*J  "*J  !(I  $.L !  &H YY^^  $    sAA%A#A%r|rrSrc# 0nU(aXS'U(aX%S'URRSXSUS9IShvN $N7f)aCount assistants matching filters. Args: metadata: Metadata to filter by. Exact match for each key/value. graph_id: Optional graph id to filter by. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: int: Number of assistants matching the criteria. r|r/assistants/countrNrrr|rrSrrs rIcountAssistantsClient.countksM&#% "*J  "*J YY^^ gv$    7A>Ac~# UUS.nU(aX'S'URRSUS3UUUS9IShvN $N7f)aList all versions of an assistant. Args: assistant_id: The assistant ID to get versions for. metadata: Metadata to filter versions by. Exact match filter for each KV pair. limit: The maximum number of versions to return. offset: The number of versions to skip. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: list[AssistantVersion]: A list of assistant versions. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") assistant_versions = await client.assistants.get_versions( assistant_id="my_assistant_id" ) ``` rr|r^ /versionsrNrrrar|rrrSrrs rI get_versionsAssistantsClient.get_versionss[D#  "*J YY^^<. 2 $    s 4=;=cf# SU0nURRSUS3UUUS9IShvN $N7f)aChange the version of an assistant. Args: assistant_id: The assistant ID to delete. version: The version to change to. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Assistant: Assistant Object. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") new_version_assistant = await client.assistants.set_latest( assistant_id="my_assistant_id", version=3 ) ``` versionr^/latestrNrrrarrSrrs rI set_latestAssistantsClient.set_latestsJ>$-g"6YY^^<. 0 $    s (1/1rXrrrrrar;rSr=rr<rr rar;rez int | boolrSr=rr<rzdict[str, list[dict[str, Any]]]rar;rSr=rr<rrNF rar;rv str | NonerrboolrSr=rr<rr0rrrr Config | Noner{Context | Noner|r!rarr}OnConflictBehavior | Noner~rrSr=rrrr<rrrar;rrrrr{rr|r!r~rrSr=rrrr<rrrar;rSr=rr<rrr|r!rrrrDrrDrzAssistantSortBy | NonerSortOrder | Nonerz!list[AssistantSelectField] | NonerSr=rr<rzlist[Assistant] r|r!rrrSr=rr<rrDNrrrar;r|r!rrDrrDrSr=rr<rzlist[AssistantVersion] rar;rrDrSr=rr<rrrrrrrrrerkrorxrrrrgrrrrrrKrIrrms -1)- + + * + ' +  + b!,0)- 8 8  8 * 8 ' 8  )8 |-1)- w w * w ' w  w x!% $ -1)-$$$ $ * $'$ $R!%E #'#'/3,0"&)-E E E  E  E !E -E E *E  E 'E  E V $ $"&,0"&)-A A  A  A  A A A *A  A 'A  A N-1)-   *  '    D#*.'+48,0)-< <  <  <  < (< %< 2< *< '<  < B#,0)-     *  '    > , -1)-, , ,  ,  , *, ',  , f-1)- & & & * & ' &  & & rKrc R\rSrSrSrSSjrSSS.SSjjrSSSSSSSSS.S SjjrSSSS .S!S jjrSSS.S"S jjr SSSSS S SSSSSS. S#Sjjr SSSSSS.S$Sjjr SSS.S"Sjjr S%SSSS.S&Sjjjr SSSSSS.S'SjjrS SSSSSS.S(SjjrSSSSS.S)SjjrSrg)*riaClient for managing threads in LangGraph. A thread maintains the state of a graph across multiple interactions/invocations (aka runs). It accumulates and persists the graph's state, allowing for continuity between separate invocations of the graph. ???+ example "Example" ```python client = get_client(url="http://localhost:2024")) new_thread = await client.threads.create(metadata={"user_id": "123"}) ``` cXlgrrXrYs rIrThreadsClient.__init__r[rKNr\cX# URRSU3X#S9IShvN $N7f)aGet a thread by ID. Args: thread_id: The ID of the thread to get. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Thread: Thread object. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") thread = await client.threads.get( thread_id="my_thread_id" ) print(thread) ``` ```shell ----------------------------------------------------- { 'thread_id': 'my_thread_id', 'created_at': '2024-07-18T18:35:15.540834+00:00', 'updated_at': '2024-07-18T18:35:15.540834+00:00', 'metadata': {'graph_id': 'agent'} } ``` /threads/r\Nr_rrdrSrs rIreThreadsClient.gets8PYY]] { #W#    rcr|rdr} superstepsrttlrSrc # 0n U(aX)S'U(dU(a0U=(d 0EU(aSU0O0EU S'U(aX9S'U(aGUV V s/sH4n SU SV s/sHn U SU RS5U SS .PM sn 0PM6 sn n U S 'Ub([U[[45(a US S .U S'OXiS'URR SXUS9IS hvN $s sn fs sn n fN7f)aCreate a new thread. Args: metadata: Metadata to add to thread. thread_id: ID of thread. If None, ID will be a randomly generated UUID. if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood. Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing thread). supersteps: Apply a list of supersteps when creating a thread, each containing a sequence of updates. Each update has `values` or `command` and `as_node`. Used for copying a thread between deployments. graph_id: Optional graph ID to associate with the thread. ttl: Optional time-to-live in minutes for the thread. You can pass an integer (minutes) or a mapping with keys `ttl` and optional `strategy` (defaults to "delete"). headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Thread: The created thread. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") thread = await client.threads.create( metadata={"number":1}, thread_id="my-thread-id", if_exists="raise" ) ``` rdrr|r}updatesvaluescommandas_noderrrrNrrstrategyr/threadsrrerZrDfloatrr rr|rdr}rrrrSrrsus rIrThreadsClient.creates&V#% #,K x#>r#-5J)2#GJ  #,K $ %$A "#9   ".A '(k'(uuY'7'(| ".   $ %GL ! ?#U|,,),(!C!$YY^^ Wf$   #  %& s7AC/C' %C"C' AC/C-C/"C''C/rrSrc# SU0nUb([U[[45(a USS.US'OX6S'URR SU3UUUS9IShvN $N7f)aUpdate a thread. Args: thread_id: ID of thread to update. metadata: Metadata to merge with existing thread metadata. ttl: Optional time-to-live in minutes for the thread. You can pass an integer (minutes) or a mapping with keys `ttl` and optional `strategy` (defaults to "delete"). headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Thread: The created thread. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") thread = await client.threads.update( thread_id="my-thread-id", metadata={"number":1}, ttl=43_200, ) ``` r|NrrrrrrZrDrrrrrdr|rrSrrs rIrThreadsClient.updateistD$.x"8 ?#U|,,),(!C!$YY__ { # %    sAAAAcZ# URRSU3X#S9IShvN gN7f)aDelete a thread. Args: thread_id: The ID of the thread to delete. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost2024) await client.threads.delete( thread_id="my_thread_id" ) ``` rr\Nrrs rIrThreadsClient.deletes+6ii9+6WWWrrr r|ridsstatusrrrrrrSrc # UUS.n U(aXS'U(aX,S'U(aXN7f) a Get the state of a thread. Args: thread_id: The ID of the thread to get the state of. checkpoint: The checkpoint to get the state of. checkpoint_id: (deprecated) The checkpoint ID to get the state of. subgraphs: Include subgraphs states. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: ThreadState: the thread of the state. ???+ example "Example Usage" ```python 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) ``` ```shell ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- { 'values': { 'messages': [ { 'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False }, { 'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None } ] }, 'next': [], 'checkpoint': { 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'checkpoint_ns': '', 'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1' } 'metadata': { 'step': 1, 'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2', 'source': 'loop', 'writes': { 'agent': { 'messages': [ { 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'name': None, 'type': 'ai', 'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'example': False, 'tool_calls': [], 'usage_metadata': None, 'additional_kwargs': {}, 'response_metadata': {}, 'invalid_tool_calls': [] } ] } }, 'user_id': None, 'graph_id': 'agent', 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'created_by': 'system', 'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'}, 'created_at': '2024-07-25T15:35:44.184703+00:00', 'parent_config': { 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'checkpoint_ns': '', 'checkpoint_id': '1ef4a9b8-d80d-6fa7-8000-9300467fad0f' } } ``` r/state/checkpoint checkpointrrNr/state/r/staterrrerrdr checkpoint_idrrSrrws rI get_stateThreadsClient.get_state;s\ I;&78$.G (  %y1J5 5f5 I;gm_=!'  &y1J5 5f5 I;f-!' 's4-B3B-AB30B/17B3(B1)B3/B31B3rrrrSrc# SU0nU(aXXS'U(aXHS'U(aX8S'URRSUS3XUS9IShvN $N7f) aUpdate the state of a thread. Args: thread_id: The ID of the thread to update. values: The values to update the state with. as_node: Update the state as if this node had just executed. checkpoint: The checkpoint to update the state of. checkpoint_id: (deprecated) The checkpoint ID to update the state of. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: ThreadUpdateStateResponse: Response after updating a thread's state. ???+ example "Example Usage" ```python 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) ``` ```shell ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- { 'checkpoint': { 'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2', 'checkpoint_ns': '', 'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1', 'checkpoint_map': {} } } ``` rrrrrrrNr rrdrrrrrSrrs rI update_stateThreadsClient.update_stateslf f#  '4O $ $.L ! !(I YY^^ {& )QW$    sAA A Arbeforer|rrSrc# SU0nU(aX8S'U(aXHS'U(aXXS'URRSUS3UUUS9IShvN $N7f) aGet the state history of a thread. Args: thread_id: The ID of the thread to get the state history for. checkpoint: Return states for this subgraph. If empty defaults to root. limit: The maximum number of states to return. before: Return states before this checkpoint. metadata: Filter states by metadata key-value pairs. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: list[ThreadState]: the state history of the thread. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024) thread_state = await client.threads.get_history( thread_id="my_thread_id", limit=5, ) ``` rr r|rr/historyrNr rrdrr r|rrSrrs rI get_historyThreadsClient.get_historyspJ U#   &H  "*J  $.L !YY^^ {( + $    sA A A A run_modes)r% stream_moderSrc# SU0nU(aURU5 URRSUS3S0U(aSU0O0EU=(d 0EUS9$7f)a(Get a stream of events for a thread. Args: thread_id: The ID of the thread to get the stream for. last_event_id: The ID of the last event to get. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Iterator[StreamPart]: An iterator of stream parts. ???+ example "Example Usage" ```python for chunk in client.threads.join_stream( thread_id="my_thread_id", last_event_id="my_event_id", ): print(chunk) ``` rr/streamrrr\rrr)rrdr%rrSrrjs rI join_streamThreadsClient.join_stream6syB ;      'yy {' * 7DO]3"=b    sAArXrrdr;rSr=rr<rr1r|r!rdrr}rrz4Sequence[dict[str, Sequence[dict[str, Any]]]] | Nonerrrint | Mapping[str, Any] | NonerSr=rr<rr1 rdr;r|Mapping[str, Any]rrrSr=rr<rr1rdr;rSr=rr<rrr|r!rr!rSequence[str] | NonerThreadStatus | NonerrDrrDrzThreadSortBy | Nonerrrzlist[ThreadSelectField] | NonerSr=rr<rz list[Thread] r|r!rr!rr rSr=rr<rrDNNrdr;rCheckpoint | NonerrrrrSr=rr<rr4rdr;rz&dict[str, Any] | Sequence[dict] | Nonerrrr$rrrSr=rr<rr7rdr;rrDr zstr | Checkpoint | Noner|Mapping[str, Any] | Nonerr$rSr=rr<rzlist[ThreadState]) rdr;r%rr-ThreadStreamMode | Sequence[ThreadStreamMode]rSr=rr<rrErrrrrrrerrrrgrrrrrrrrrKrIrrs  -1)- * * * * ' *  * ^ $/3KO#.2,0)-K K  K - K I K K ,K *K 'K  K d/3,0)-- - $ - , - * - '-  - f-1)- XX* X ' X  X@$(&*'+'+15,0)-E E  E " E $ E E E %E %E /E *E 'E  E T&*,0)-    $  *  '   H-1)-   *  '    D)-$( F  ,0)-FF&F" F  F*F'F FZ#(,$(,0)-= = 7=  = & = "= *= '=  #= F*.-1(,,0)-2 2  2 ( 2 + 2 &2 *2 '2  2 p%)EP,0)-- - " - C - * - '-  #- - rKrc\rSrSrSrS)Sjr\SSSSSSSSSSSSSSSSSSSSSSS.S*Sjj5r\SSSSSSSSSSSSSSSSSSSS .S+S jj5rSSSSSSSSSSSSSSSSSSSSSSSSS .S,S jjr\SSSSSSSSSSSSSSSSSSS .S-Sjj5r\SSSSSSSSSSSSSSSSSSSSS.S.Sjj5rSSSSSSSSSSSSSSSSSSSSSSS.S/SjjrSSS.S0Sjjr \SSSSSSSSSSSSSSSSSSSS.S1Sjj5r \SSSSSSSSSSSSSSSSSS.S2Sjj5r SSSSSSSSSSSSSSSSSSSSSS.S3Sjjr SSSSSSS.S4Sjjr SSS.S5S jjr SS!SSS".S6S#jjr SSS.S7S$jjrSSSSSS%.S8S&jjrSSS.S9S'jjrS(rg):rifaClient for managing runs in LangGraph. A run is a single assistant invocation with optional input, config, context, and metadata. This client manages runs, which can be stateful (on threads) or stateless. ???+ example "Example" ```python client = get_client(url="http://localhost:2024") run = await client.runs.create(assistant_id="asst_123", thread_id="thread_456", input={"query": "Hello"}) ``` cXlgrrXrYs rIrRunsClient.__init__tr[rKNrF)inputrrstream_subgraphsstream_resumabler|rr{rrcheckpoint_duringinterrupt_beforeinterrupt_after feedback_keys on_disconnectwebhookmultitask_strategy if_not_exists after_secondsrSron_run_createdcgrr)rrdrar-rrr.r/r|rr{rrr0r1r2r3r4r5r6r7r8rSrr9s rIrRunsClient.streamws8%(rK)r-rrr.r/r|rr0r1r2r3r4 on_completionr7r5r8rSrr9cgrr)rrdrar-rrr.r/r|rr0r1r2r3r4r<r7r5r8rSrr9s rIrr;s2%(rKr-rrr.r/r|rr{rrr0r1r2r3r4r<r5r6r7r8rSrr9 durabilityc ^U b[R"S[SS9 0SU_SU(a,UR5VVs0sHunnUcM UU_M snnOS_SU _SU _S U_S U_S U_S U_S U_SU_SU_SU_SU_SU _SU _SU _SU_UUUUUS.EnUbSUS3OSnSU4SjjnURR USUR5VVs0sHunnUcM UU_M snnUUT(aUS9$SS9$s snnfs snnf)aCreate a run and stream the results. Args: thread_id: the thread ID to assign to the thread. If None will create a stateless run. assistant_id: The assistant ID or graph name to stream from. If using graph name, will default to first assistant created from that graph. input: The input to the graph. command: A command to execute. Cannot be combined with input. stream_mode: The stream mode(s) to use. stream_subgraphs: Whether to stream output from subgraphs. stream_resumable: Whether the stream is considered resumable. If true, the stream can be resumed and replayed in its entirety even after disconnection. metadata: Metadata to assign to the run. config: The configuration for the assistant. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. feedback_keys: Feedback keys to assign to run. on_disconnect: The disconnect mode to use. Must be one of 'cancel' or 'continue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. on_run_created: Callback when a run is created. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: AsyncIterator[StreamPart]: Asynchronous iterator of stream results. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024) async for chunk in client.runs.stream( thread_id=None, assistant_id="agent", input={"messages": [{"role": "user", "content": "how are you?"}]}, stream_mode=["values","debug"], metadata={"name":"my_run"}, context={"model_name": "anthropic"}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], feedback_keys=["my_feedback_key_1","my_feedback_key_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ): print(chunk) ``` ```shell ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ StreamPart(event='metadata', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2'}) StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}]}) StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}, {'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}) StreamPart(event='end', data=None) ``` Nd`checkpoint_during` is deprecated and will be removed in a future version. Use `durability` instead.rrr-rrr{r|rr.r/rar1r2r3r5rrr0r6r7r4r<r8r?r /runs/streamcL>T(a[U5=n(a T"U5 gggz)Callback function to handle the response.Nrlr4r|r9s rIr&RunsClient.stream..on_response@&/Ns/S#S8#Sx($T~rKPOSTrr4httpx.Responser r DeprecationWarningr rr rrdrar-rrr.r/r|rr{rrr0r1r2r3r4r<r5r6r7r8rSrr9r?kvrendpointrs ` rIrr;sR  ( MMv"   U GN'--/C/$!QQA/CTX f  w     ;   0   0  L   0    ]  w *! " ]# $ !2% & !"4' (+***$1 8$ {, /   ) yy  #*==?D?41aa$!Q$?D'5    <@    EDJE C5 C5 C;C;)r-rrr.r/r|r0rr{r1r2r5r<r7r8rSrr9c # g7frr)rrdrar-rrr.r/r|r0rr{r1r2r5r<r7r8rSrr9s rIrRunsClient.createNs 0r-rrr.r/r|rr{rrr0r1r2r5r6r7r8rSrr9c # g7frrrrdrar-rrr.r/r|rr{rrr0r1r2r5r6r7r8rSrr9s rIrrUhs 4rVr-rrr.r/r|rr{rrr0r1r2r5r6r7r<r8rSrr9r?c^# U b[R"S[SS9 0SU_SU(a,UR5VVs0sHunnUcM UU_M snnOS_SU_SU_S U_S U _S U _S U_S U_SU_SU_SU_SU _SU _SU _SU_SU_UUUS.EnUR5VVs0sHunnUcM UU_M nnnSU4SjjnURR U(aSUS3OSUUUT(aUOSS9IShvN $s snnfs snnfN7f)aCreate a background run. Args: thread_id: the thread ID to assign to the thread. If None will create a stateless run. assistant_id: The assistant ID or graph name to stream from. If using graph name, will default to first assistant created from that graph. input: The input to the graph. command: A command to execute. Cannot be combined with input. stream_mode: The stream mode(s) to use. stream_subgraphs: Whether to stream output from subgraphs. stream_resumable: Whether the stream is considered resumable. If true, the stream can be resumed and replayed in its entirety even after disconnection. metadata: Metadata to assign to the run. config: The configuration for the assistant. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. headers: Optional custom headers to include with the request. on_run_created: Optional callback to call when a run is created. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: Run: The created background run. ???+ example "Example Usage" ```python 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"}, context={"model_name": "openai"}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) print(background_run) ``` ```shell -------------------------------------------------------------------------------- { '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, 'assistant_id': 'my_assistant_id' }, }, 'context': { 'model_name': 'openai' } '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' } ``` NrArrr-rrr.r/rr{r|rar1r2r5rrr0r6r7r<r8r?cL>T(a[U5=n(a T"U5 gggrErFrGs rIr&RunsClient.create..on_response/ rIrKr/runsrrKr r rNr rrrrdrar-rrr.r/r|rr{rrr0r1r2r5r6r7r<r8rSrr9r?rPrQrrs ` rIrrUsV  ( MMv"   U GN'--/C/$!QQA/CTX ;   0    0  f  w    L   0    w  * ]! " !2# $ !"4% & ]' (+*$- 0%,MMOEODAqq41a4OE ) YY^^,5i {% (7'5 4 $   9D*F s7=D  C= C= A D " D0D7AD 8D 9D r\c# SSjnUVs/sH oT"U5PM nnURRSXbUS9IShvN $s snfN 7f),Create a batch of stateless background runs.cbUR5VVs0sH upUcM X_M snn$s snnfrr rrPrQs rIfilter_payload/RunsClient.create_batch..filter_payloadE (%,]]_F_TQDAD_F FF ++ /runs/batchrNrr(rrpayloadsrSrrgrfiltereds rI create_batchRunsClient.create_batch< sX G=0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. on_disconnect: The disconnect mode to use. Must be one of 'cancel' or 'continue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. headers: Optional custom headers to include with the request. on_run_created: Optional callback to call when a run is created. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: Union[list[dict], dict[str, Any]]: The output of the run. ???+ example "Example Usage" ```python 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"}, context={"model_name": "anthropic"}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) print(final_state_of_run) ``` ```shell ------------------------------------------------------------------------------------------------------------------------------------------- { '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 } ] } ``` NrArrr-rrr{r|rar1r2r5rrr6r0r7r4r<r8r?r /runs/waitcL>T(a[U5=n(a T"U5 gggrErFrGs rIr$RunsClient.wait..on_response rIrKrJr __error__rz: messagerK) r r rNr rr rZrWrre)rrdrar-rr|rr{rrr0r1r2r5r4r<r6r7r8rsrSrr9r?rPrQrrRrris ` rIrvrw s"d  ( MMv"   U GN'--/C/$!QQA/CTX f  w     L   0    w  *  ]  !"4  !2 ]! " ]# $ ]% & ]' ( *) .2;1Fi {* -L  ) 44  #*==?D?41aa$!Q$?D'5 4 5   8T**x'8K0$77K(,,W56b+9N9R9RS\9]8^_ [D>E s7=E7 E) E) A5E7 E/E/E74E55BE7rrrrrrrSrc# UUS.nUbXHS'U(aXXS'U(aURU5 URRSUS3XS9IShvN $N7f)aVList runs. Args: thread_id: The thread ID to list runs for. limit: The maximum number of results to return. offset: The number of results to skip. status: The status of the run to filter by. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: list[Run]: The runs for the thread. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.runs.list( thread_id="thread_id", limit=5, offset=5, ) ``` rNrrrr_rrh rrdrrrrrSrrjs rIr]RunsClient.list+ ssJ(   %+ " %+ "     'YY]] {% (#    sAAAAc^# URRSUSU3X4S9IShvN $N7f)aGet a run. Args: thread_id: The thread ID to get. run_id: The run ID to get. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Run: Run object. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") run = await client.runs.get( thread_id="thread_id_to_delete", run_id="run_id_to_delete", ) ``` r/runs/r\Nr_rrdrcrSrs rIreRunsClient.get] s=>YY]] {& 17#    s $-+- interruptrvactionrSrc# U(aSOSUS.nU(aURU5 U(a+URRSUSUS3SUUS9IS hvN $URRSUSUS3S UUS 9IS hvN $N/N7f) aGet a run. Args: thread_id: The thread ID to cancel. run_id: The run ID to cancel. wait: Whether to wait until run has completed. action: Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. Default is `interrupt`. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python 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" ) ``` rrrvrrr/cancelrJrNrrrr rrrdrcrvrrSrrjs rIcancelRunsClient.cancel sLA1      ' 44I;fVHG<# 5 I;fVHG<# ( s$AB B*B BB B cd# URRSUSUS3SUUS9IShvN $N7f)aBlock until a run is done. Returns the final state of the thread. Args: thread_id: The thread ID to join. run_id: The run ID to join. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") result =await client.runs.join( thread_id="thread_id_to_join", run_id="run_id_to_join" ) ``` rr/joinrr\Nrr rs rIjoinRunsClient.join sH<YY00 {& 6  1    s '0.0cancel_on_disconnectrrSrr%cUUS.nU(aURU5 URRSUSUS3SU0U(aSU0O0EU=(d 0E=(d SS9$) aStream output from a run in real-time, until the run is done. Output is not buffered, so any output produced before this call will not be received here. Args: thread_id: The thread ID to join. run_id: The run ID to join. cancel_on_disconnect: Whether to cancel the run when the stream is disconnected. stream_mode: The stream mode(s) to use. Must be a subset of the stream modes passed when creating the run. Background runs default to having the union of all stream modes. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. last_event_id: The last event ID to use for the stream. Returns: AsyncIterator[StreamPart]: The stream of parts. ???+ example "Example Usage" ```python 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) ``` )rrrrrrrNrr rrdrcrrrSrr%rjs rIrRunsClient.join_stream sV%9&      'yy {& 8 7DO]3"=b  rKc`# URRSUSU3X4S9IShvN gN7f)aDelete a run. Args: thread_id: The thread ID to delete. run_id: The run ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.runs.delete( thread_id="thread_id_to_delete", run_id="run_id_to_delete" ) ``` rrr\Nrrs rIrRunsClient.delete s:<ii {& 17   s $.,.rXr)2rdr;rar;r-r'rCommand | Noner!StreamMode | Sequence[StreamMode]r.rr/rr|r'rrr{rrr$rrr0 bool | Noner1All | Sequence[str] | Noner2rr3rr4DisconnectMode | Noner5rr6MultitaskStrategy | Noner7IfNotExists | Noner8 int | NonerSr=rr<r9*Callable[[RunCreateMetadata], None] | NonerrE),rdrrar;r-r'rrrrr.rr/rr|r'rrr0rr1rr2rr3rr4rr<OnCompletionBehavior | Noner7rr5rr8rrSr=rr<r9rrrE)6rdrrar;r-r'rrrrr.rr/rr|r'rrr{rrr$rrr0rr1rr2rr3rr4rr<rr5rr6rr7rr8rrSr=rr<r9rr?Durability | NonerrE)*rdrrar;r-r'rrrrr.rr/rr|r'r0rrrr{rr1rr2rr5rr<rr7rr8rrSr=rr<r9rrr'.rdr;rar;r-r'rrrrr.rr/rr|r'rrr{rrr$rrr0rr1rr2rr5rr6rr7rr8rrSr=rr<r9rrr'2rdrrar;r-r'rrrrr.rr/rr|r'rrr{rrr$rrr0rr1rr2rr5rr6rr7rr<rr8rrSr=rr<r9rr?rrr'rnzlist[RunCreate]rSr=rr<r list[Run],rdr;rar;r-r'rrr|r'rrr{rrr$rrr0rr1rr2rr5rr4rr6rr7rr8rrsrrSr=rr<r9rrlist[dict] | dict[str, Any](rdrrar;r-r'rrr|r'rrr{rr0rr1rr2rr5rr4rr<rr7rr8rrsrrSr=rr<r9rrr)0rdrrar;r-r'rrr|r'rrr{rrr$rrr0rr1rr2rr5rr4rr<rr6rr7rr8rrsrrSr=rr<r9rr?rrrrdr;rrDrrDrzRunStatus | Nonerzlist[RunSelectField] | NonerSr=rr<rr rdr;rcr;rSr=rr<rr'rdr;rcr;rvrrrrSr=rr<rr rdr;rcr;rSr=rr<rrW)rdr;rcr;rrr(StreamMode | Sequence[StreamMode] | NonerSr=rr<r%rrrE rdr;rcr;rSr=rr<rrrrrrrrrrrrprvr]rerrrrrrrKrIrrfsQ   +/"&9A!&!&-1 $"&(,$()-7;6:.2/3"7;,0$(,0)-EI5((( ( (  (7(((+(( (&("('( 5!("4#($,%(&-'(()(*5+(,*-(."/(0*1(2'3(4C5(6 #7((: +/"&9A!&!&-1 $)-7;6:.2/359,0"$(,0)-EI/((( ( (  (7(((+(('(5(4(,( -!("3#($*%(&'((")(**+(,'-(.C/(0 #1((>+/"&9A!&!&-1 $"&(,$()-7;6:.2/359"7;,0$(,0)-EI(,9\ \ \ ( \  \ 7\ \ \ +\ \  \ &\ "\ '\ 5!\ "4#\ $,%\ &-'\ (3)\ *+\ ,5-\ .*/\ 0"1\ 2*3\ 4'5\ 6C7\ 8&9\ : #;\ | +/"&9A!&!&-1)- $"&7;6:"59,0$(,0)-EI- (   7+' 54 !"3#$*%&"'(*)*'+,C-. /2 +/"&9A!&!&-1 $"&(,$()-7;6:"7;,0$(,0)-EI1 (   7+ &"' 5!"4#$%&5'(*)*"+,*-.'/0C12 3@+/"&9A!&!&-1 $"&(,$()-7;6:"7;,059$(,0)-EI(,5v v v ( v  v 7v v v +v v  v &v "v 'v 5!v "4#v $%v &5'v (*)v *3+v ,"-v .*/v 0'1v 2C3v 4&5v 6 7v x-1)-  ! *  '    " +/"&-1 $"&(,$()-7;6:"/37;,0$( ,0)-EI/*** ( *  *+** *&*"*'*5*4** -!*"5#*$*%*&"'*()***+*,'-*.C/*0 %1**4 +/"&-1 $"&)-7;6:"/359,0$( ,0)-EI+*** ( *  *+** *'*5*4**-*3* *!*""#*$%*&*'*(')**C+*, %-**:+/"&-1 $"&(,$()-7;6:"/3597;,0$( ,0)-EI(,3hhh ( h  h+hh h&h"h'h5h4hh -!h"3#h$5%h&*'h(")h*+h,*-h.'/h0C1h2&3h4 %5h\#'.2,0)-0 0  0  0 ! 0 ,0 *0 '0  0 n-1)- ! ! ! * ! ' !  ! P*,0)-888  8  8*8'8 8~-1)- # # # * # ' #  # T&+@D,0)-$(9 9 9 # 9 > 9 *9 '9 "9  #9 @-1)-      *  '      rKrc r\rSrSrSrSSjrSSSSSSSSSSSS. SSjjrSSSSSSSSSSSS. SSjjrSSS.SS jjrSSS S SSSSSS . SS jjr SSSSS.SSjjr Sr g)ri= aClient for managing recurrent runs (cron jobs) in LangGraph. A run is a single invocation of an assistant with optional input, config, and context. This client allows scheduling recurring runs to occur automatically. ???+ example "Example Usage" ```python 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"} ) ``` !!! note "Feature Availability" The crons client functionality is not supported on all licenses. Please check the relevant license documentation for the most up-to-date details on feature availability. cXlgrrXr http_clients rIrCronClient.__init__U  rKN r-r|rr{r0r1r2r5r6rSrc # UUUUUUUU U U S. nU (aXS'UR5VVs0sHunnUcM UU_M nnnURRSUS3UU US9IShvN $s snnfN 7f)aCreate a cron job for a thread. Args: thread_id: the thread ID to run the cron job on. assistant_id: The assistant ID or graph name to use for the cron job. If using graph name, will default to first assistant created from that graph. schedule: The cron schedule to execute this job on. input: The input to the graph. metadata: Metadata to assign to the cron job runs. config: The configuration for the assistant. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Run: The cron run. ???+ example "Example Usage" ```python 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"}, context={"model_name": "openai"}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) ``` scheduler-rr|r{rar0r1r2r5r6Nr /runs/cronsrr rrrrdrarr-r|rr{r0r1r2r5r6rSrrrPrQs rIcreate_for_threadCronClient.create_for_threadX s~! (!2 0.   ,>( )$+MMOEODAqq41a4OEYY^^ {+ . $   F s!,A6 A.A.&A6)A4* A6c # UUUUUUUUU U S. nU (aXS'UR5VVs0sHunnUcM UU_M nnnURRSXU S9IShvN $s snnfN 7f)aCreate a cron run. Args: assistant_id: The assistant ID or graph name to use for the cron job. If using graph name, will default to first assistant created from that graph. schedule: The cron schedule to execute this job on. input: The input to the graph. metadata: Metadata to assign to the cron job runs. config: The configuration for the assistant. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Run: The cron run. ???+ example "Example Usage" ```python 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"}, context={"model_name": "openai"}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) ``` rr6Nrrrrrarr-r|rr{r0r1r2r5r6rSrrrPrQs rIrCronClient.create sv! (!2 0.   ,>( )$+MMOEODAqq41a4OEYY^^ $   F s!,A1 A)A)!A1$A/% A1r\cZ# URRSU3X#S9IShvN gN7f)aDelete a cron. Args: cron_id: The cron ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.crons.delete( cron_id="cron_to_delete" ) ``` /runs/crons/r\Nrrcron_idrSrs rIrCronClient.delete s+6iigY7XXXrrr rardrrrrrrSrc # UUUUS.n U(aXZS'U(aXjS'U(aXzS'U R5V V s0sH upU cM X_M n n n URRSXU S9IShvN $s sn n fN 7f)aGet a list of cron jobs. Args: assistant_id: The assistant ID or graph name to search for. thread_id: the thread ID to search for. limit: The maximum number of results to return. offset: The number of results to skip. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: list[Cron]: The list of cron jobs returned by the search, ???+ example "Example Usage" ```python 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) ``` ```shell ---------------------------------------------------------- [ { 'cron_id': '1ef3cefa-4c09-6926-96d0-3dc97fd5e39b', 'assistant_id': 'my_assistant_id', 'thread_id': 'my_thread_id', 'user_id': None, 'payload': { 'input': {'start_time': ''}, 'schedule': '4 * * * *', 'assistant_id': 'my_assistant_id' }, 'schedule': '4 * * * *', 'next_run_date': '2024-07-25T17:04:00+00:00', 'end_time': None, 'created_at': '2024-07-08T06:02:23.073257+00:00', 'updated_at': '2024-07-08T06:02:23.073257+00:00' } ] ``` rardrrrrrN/runs/crons/searchrr rrardrrrrrrSrrrPrQs rIrgCronClient.search sB)"   !(I  $.L !  &H $+MMOEODAq414OEYY^^ w$   F s"*]VVVVs A-AA-&A+'A-c\# URRSXS.UUS9IShvN gN7f)aDelete an item. Args: key: The unique identifier for the item. namespace: Optional list of strings representing the namespace path. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") await client.store.delete_item( ["documents", "user123"], key="item456", ) ``` rrrNrrrvr)rSrs rI delete_itemStoreClient.delete_item s7:ii (5    s ",*,c z# UUUUUUS.n URRS[U 5UUS9IShvN $N7f)aSearch for items within a namespace prefix. Args: namespace_prefix: List of strings representing the namespace prefix. filter: Optional dictionary of key-value pairs to filter results. limit: Maximum number of items to return (default is 10). offset: Number of items to skip before returning results (default is 0). query: Optional query for natural language search. refresh_ttl: Whether to refresh the TTL on items returned by this search. If None, uses the store's default behavior. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: list[Item]: A list of items matching the search criteria. ???+ example "Example Usage" ```python client = get_client(url="http://localhost:2024") items = await client.store.search_items( ["documents"], filter={"author": "John Doe"}, limit=5, offset=0 ) print(items) ``` ```shell ---------------------------------------------------------------- { "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 ... ] } ``` namespace_prefixfilterrrqueryr/store/items/searchrNrrr rrrrrrrrSrrs rI search_itemsStoreClient.search_items& sXz!1&  YY^^ !( $    s 2;9;cx# UUUUUS.nURRS[U5UUS9IShvN $N7f)adList namespaces with optional match conditions. Args: prefix: Optional list of strings representing the prefix to filter namespaces. suffix: Optional list of strings representing the suffix to filter namespaces. max_depth: Optional integer specifying the maximum depth of namespaces to return. limit: Maximum number of namespaces to return (default is 100). offset: Number of namespaces to skip before returning results (default is 0). headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: list[list[str]]: A list of namespaces matching the criteria. ???+ example "Example Usage" ```python 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"], ... ] ``` rGsuffix max_depthrr/store/namespacesrNr rrGrr rrrSrrs rIlist_namespacesStoreClient.list_namespacesr sU\"  YY^^ ( $    s 1:8:rXrNNNNr)r;r*rrz!Literal[False] | list[str] | NonerrrSr=rr<rv Sequence[str]rr r)r;rvrrrrSr=rr<rr r" r)r;rSr=rr<rvrrrNrrNNNNrr'rrDrrDrrrrrSr=rr<rrrr,)NNNdrNNrGlist[str] | Nonerrr rrrDrrDrSr=rr<rr" rrrrrrrrrrr rrrKrIrr s 48,0)-2  2 ! 2 1 2 2 *2 '2  2  2 t$(,0)-7W 7W 7W ! 7W*7W'7W 7W|-1)- "  " * " ' "  "  " P,0 #',0)-J ) J  J  J J !J *J 'J 'J  J \$(#' $,0)-9  9 !9  9  9  9 *9 '9  9 9 rKrSyncLangGraphClientc UcSn[R"SS9n[R"UUUb[R"U5O[R"SSSSS9[ X5S9n[ U5$)aXGet a synchronous LangGraphClient instance. Args: url: The URL of the LangGraph API. api_key: The API key. If not provided, it will be read from the environment. Precedence: 1. explicit argument 2. LANGGRAPH_API_KEY 3. LANGSMITH_API_KEY 4. LANGCHAIN_API_KEY headers: Optional custom headers timeout: Optional timeout configuration for the HTTP client. Accepts an httpx.Timeout instance, a float (seconds), or a tuple of timeouts. Tuple format is (connect, read, write, pool) If not provided, defaults to connect=5s, read=300s, write=300s, and pool=5s. Returns: SyncLangGraphClient: The top-level synchronous client for accessing AssistantsClient, ThreadsClient, RunsClient, and CronClient. ???+ example "Example" ```python from langgraph_sdk import get_sync_client # get top-level synchronous LangGraphClient client = get_sync_client(url="http://localhost:8123") # example usage: client..() assistant = client.assistants.get(assistant_id="some_uuid") ``` rurvrwryrzr)r HTTPTransportClientrrTr)rmrFrSrnrrs rIget_sync_clientr spN {%##A.I \\" MM' "qs#AFW. F v &&rKcP\rSrSrSrS SjrS SjrS SjrS SjrSr g) ri a^Synchronous client for interacting with the LangGraph API. This class provides synchronous access to LangGraph API endpoints for managing assistants, threads, runs, cron jobs, and data storage. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.get("asst_123") ``` c([U5Ul[UR5Ul[ UR5Ul[ UR5Ul[UR5Ul [UR5Ul gr) SyncHttpClientrSyncAssistantsClientrSyncThreadsClientrSyncRunsClientrSyncCronClientrSyncStoreClientrrs rIrSyncLangGraphClient.__init__ s^"6* .tyy9(3 "499- #DII. $TYY/ rKcU$)zEnter the sync context manager.rrs rI __enter__SyncLangGraphClient.__enter__ s rKc$UR5 g)zExit the sync context manager.N)closers rI__exit__SyncLangGraphClient.__exit__s  rKcp[US5(a%URRR5 ggr)rXrrr+rs rIr+SyncLangGraphClient.close s* 4 II   " " $ !rKrNrz httpx.Clientrr)rrrr) rrrrrrr(r,r+rrrKrIrr sA 0,&%   %rKcf\rSrSrSrSSjrSSSS.SSjjrSSSS.SSjjrSSSS.SSjjrSSSS.SS jjr SSSSS .SS jjr SSSSS S .SSjjr SSSSS .SSjjr Sr g)r ia Handle synchronous requests to the LangGraph API. Provides error messaging and content handling enhancements above the underlying httpx client, mirroring the interface of [HttpClient](#HttpClient) but for sync usage. Attributes: client (httpx.Client): Underlying HTTPX sync client. cXlgrrrs rIrSyncHttpClient.__init__rrKNrcURRXUS9nU(aU"U5 UR5 [U5$![RacnUR 5R 5n[RS:aURU5 Ue[RSU3US9 UeSnAff=f)rrrrrN) rrerrrr|rrrrrr _decode_jsonrs rIreSyncHttpClient.gets KKOODO A  N    A$$ 668??$D7* 4 G 9$@1 MG  sAB=AB88B=cUb[U5upgO0SpvU(aURU5 URRXXsS9nU(aU"U5 UR 5 [U5$![ R acn UR5R5n [RS:aU RU 5 U e[RSU 3U S9 U eSn A ff=fr) _encode_jsonrrrrrrr|rrrrrrr5rs rIrSyncHttpClient.post4s  '3D'9 $OW')3W   " "7 + KK   7    N    A$$ 668??$D7* 4 G 9$@1 MG  sA22C)AC$$C)c[U5upgU(aURU5 URRXXsS9nU(aU"U5 UR 5 [U5$![ R acn UR5R5n [RS:aU RU 5 U e[RSU 3U S9 U eSn A ff=f)rrrrrN)r8rrrrrrr|rrrrrrr5rs rIrSyncHttpClient.putTs$0#5    " "7 + KKOO 7    N    A$$ 668??$D7* 4 G 9$@1 MG  A++C"?ACC"c[U5upgU(aURU5 URRXXsS9nU(aU"U5 UR 5 [U5$![ R acn UR5R5n [RS:aU RU 5 U e[RSU 3U S9 U eSn A ff=f)rrrrrN)r8rrrrrrr|rrrrrrr5rs rIrSyncHttpClient.patchrs$0#5    " "7 + KK   7    N    A$$ 668??$D7* 4 G 9$@1 MG  r<rcnURRSXX4S9nU(aU"U5 UR5 g![RacnUR 5R 5n[RS:aURU5 Ue[RSU3US9 UeSnAff=f)rrrrrrN) rrrrrr|rrrrrrrs rIrSyncHttpClient.deletes KK   df    N    $$ 668??$D7* 4 G 9$@1 MG  s=B4AB//B4rvrc <[U5upU(aURU5 URRX!XUS9n U(aU"U 5 U R 5 U RRS5n US::dU (d[!U 5sSSS5 $[!U 5sSSS5 $![ R acn U R5R5n [RS:aU RU 5 U e[RSU 3U S9 U eSn A ff=f![ R"aI [$R&"SU 3S S 9 U R)5 UR+U S UUS - S 9ssSSS5 $f=f!,(df  g=f)rrrrrNrrrrrrrr)r8rrrrrrr|rrrrrrrSrer5r r r r+r r s rIr  SyncHttpClient.request_reconnects$0#5    " "7 + [[   /6  A ""$))-- +C!#3#A!  " #A%  (( vvx(##w.JJt$LL#=dV!DqLQ  ??  HN  --+$3a$7 .3  & '  sPF B3"2F  D-3D*AD%%D**F -AF >F  F  F  Fc#># Ub[U5upxO0SpSUS'SUS'U(aURU5 UR5V V s0sHupU R5S;dMX_M n n n Sn Sn SnSn[ U cUOU 5nU bU US 'U cUOS nU cUOSnU cUOSnS nUR R UU =(d UUUUS 9nU cU(aU"U5 UR5 UR"R%SS5R'S5SnSU;a[R("SU<35eUR"R%S5nU(aUn [+5n[-U5HenURUR/S55nUcM(UR0b UR0n UR2(dUR4cMaUv Mg URS5=n(a;UR0b UR0n UR2(d UR4bUv SSS5 U(a#US- nX:a[R("S5eGMgs sn n f![RacnUR5R5n[RS:aURU5 Ue[R!SU3US9 UeSnAff=f![R6a U ceS nNf=f!,(df  N=f7f)z*Stream the results of a request using SSE.NrrrrrrrvTrrFrrrrrrrrrrrKrr)r8rr r!rWrrrrrr|rrrrrrrSrer"r#r8r:r$r%r&r'r r(s rIrSyncHttpClient.streams8  '3D'9 $OW')4W$7!+5(   " "7 +.335 5 yy{"DD CJ5  %) %)!""#1#9?PO(3@0'5'=V5N)7)?gTO'5'=V4NE##&$''% $ !)k$((* #{{~rBLLSQRST &l:..+.0 &)[[__Z%@"%%7N$,& .s 3%nnT[[-?@?&44@070E0E "yyCHH,@&) !4&nnS11s1"00<,3,A,AM99(<#&Ikl"a'"%>..D i F,,HHJ..0D''72 4(G 'A$%HST UG 8!&- E !QsA L I,*I,0A!LL %I25ArIterator[StreamPart]rFrrKrIr r sD*.,0?C '  *  =  8*.,0?C+  '  * = J*.,0?C  '  * = F*.,0?C  '  * = B )-,0?C  '  * = <'+)-,0?C ... $ . ' .*.=.. .j'+)-,0?Chhh $ h ' h*h=h hhrKr c[R"U[[R[R-5n[ [ U55nSnX#S.nXA4$rH)rLrMrarNrOr;rPrQs rIr8r8CsN << ""V%<%<< D T^N%L!/NG =rKc`UR5nU(a[R"U5$S$r)r|rLrTrUs rIr5r5Os# 668D!%6<< /4/rKc H\rSrSrSrSSjrSSS.SSjjrSSSS.SS jjrSSS.SS jjrSSSS.SS jjjr S SSSSSSSSS .S!S jjjr SSSSSSSSS.S"Sjjr SSS.S#Sjjr SSSSSSSSSS. S$Sjjr SSSSS.S%SjjrS&SSS.S'SjjjrSSS.S(SjjrSrg))r!iTaKClient for managing assistants in LangGraph synchronously. This class provides methods to interact with assistants, which are versioned configurations of your graph. ???+ example "Examples" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.get("assistant_id_123") ``` cXlgrrXrYs rIrSyncAssistantsClient.__init__ar[rKNr\c<URRSU3X#S9$)aJGet an assistant by ID. Args: assistant_id: The ID of the assistant to get OR the name of the graph (to use the default assistant). headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Assistant: Assistant Object. ???+ example "Example Usage" ```python assistant = client.assistants.get( assistant_id="my_assistant_id" ) print(assistant) ``` ```shell ---------------------------------------------------- { 'assistant_id': 'my_assistant_id', 'graph_id': 'agent', 'created_at': '2024-06-25T17:10:33.109781+00:00', 'updated_at': '2024-06-25T17:10:33.109781+00:00', 'config': {}, 'context': {}, 'metadata': {'created_by': 'system'} } ``` r^r\r_r`s rIreSyncAssistantsClient.getds+Ryy}}<. )7  rKFrdcvSU0nU(aURU5 URRSUS3XSS9$)a1Get the graph of an assistant by ID. Args: assistant_id: The ID of the assistant to get the graph of. xray: Include graph representation of subgraphs. If an integer value is provided, only subgraphs with a depth less than or equal to the value will be included. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Graph: The graph information for the assistant in JSON format. ???+ example "Example Usage" ```python 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__'} ] } ``` rer^rgrrhris rIrkSyncAssistantsClient.get_graphsG\~     'yy}}<. /   rKc>URRSUS3X#S9$)aWGet the schemas of an assistant by ID. Args: assistant_id: The ID of the assistant to get the schema of. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: GraphSchema: The graph schema for the assistant. ???+ example " Example Usage" ```python client = get_sync_client(url="http://localhost:2024") schema = client.assistants.get_schemas( assistant_id="my_assistant_id" ) print(schema) ``` ```shell ---------------------------------------------------------------------------------------------------------------------------- { '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' } } }, 'context_schema': { 'title': 'Context', 'type': 'object', 'properties': { 'model_name': { 'title': 'Model Name', 'enum': ['anthropic', 'openai'], 'type': 'string' } } } } ``` r^rnr\r_r`s rIro SyncAssistantsClient.get_schemass-Byy}}<. 17  rKcSU0nU(a0UEUEnUb!URRSUSU3UUS9$URRSUS3UUS9$)a1Get the schemas of an assistant by ID. Args: assistant_id: The ID of the assistant to get the schema of. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Subgraphs: The graph schema for the assistant. rrr^rsrrtr_rus rIrx"SyncAssistantsClient.get_subgraphsKs( ) 1J1&1J  99==|nK {C!!  99==|nJ7!! rKrzcSU0n U(aX+S'U(aX;S'U(aXKS'U(aX[S'U(aXkS'U(aX{S'U (aXS'URRS XU S 9$) aCreate a new assistant. Useful when graph is configurable and you want to create different assistants based on different configurations. Args: graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration. config: Configuration to use for the graph. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" metadata: Metadata to add to assistant. assistant_id: Assistant ID to use, will default to a random UUID if not provided. if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood. Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing assistant). name: The name of the assistant. Defaults to 'Untitled' under the hood. headers: Optional custom headers to include with the request. description: Optional description of the assistant. The description field is available for langgraph-api server version>=0.0.45 params: Optional query parameters to include with the request. Returns: Assistant: The created assistant. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.create( graph_id="agent", context={"model_name": "openai"}, metadata={"number":1}, assistant_id="my-assistant-id", if_exists="do_nothing", name="my_name" ) ``` rrr{r|rar}r~rrrrrs rIrSyncAssistantsClient.createosf #   &H  !(I  "*J  &2N # #,K "FO %0M "yy~~   rKrc0n U(aX*S'U(aX:S'U(aXJS'U(aXZS'U(aXjS'U(aXS'URRSU3U UU S9$) aUpdate an assistant. Use this to point to a different graph, update the configuration, or change the metadata of an assistant. Args: assistant_id: Assistant to update. graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration. If None, assistant will keep pointing to same graph. config: Configuration to use for the graph. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" metadata: Metadata to merge with existing assistant metadata. name: The new name for the assistant. headers: Optional custom headers to include with the request. description: Optional description of the assistant. The description field is available for langgraph-api server version>=0.0.45 Returns: Assistant: The updated assistant. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") assistant = client.assistants.update( assistant_id='e280dad7-8618-443f-87f1-8e41841c180f', graph_id="other-graph", context={"model_name": "anthropic"}, metadata={"number":2} ) ``` rrr{r|r~rr^rrrs rIrSyncAssistantsClient.updatesxZ#% "*J   &H  !(I  "*J  "FO %0M "yy<. )   rKc>URRSU3X#S9 g)aDelete an assistant. Args: assistant_id: The assistant ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.assistants.delete( assistant_id="my_assistant_id" ) ``` r^r\Nrr`s rIrSyncAssistantsClient.deletes"6 < ~6WrKrrrc UUS.n U(aXS'U(aX*S'U(aXZS'U(aXjS'U(aXzS'URRSU UU S9$) aSearch for assistants. Args: metadata: Metadata to filter by. Exact match filter for each KV pair. graph_id: The ID of the graph to filter by. The graph ID is normally set in your langgraph.json configuration. limit: The maximum number of results to return. offset: The number of results to skip. headers: Optional custom headers to include with the request. Returns: list[Assistant]: A list of assistants. ???+ example "Example Usage" ```python 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 ) ``` rr|rrrrrrrrs rIrgSyncAssistantsClient.searchsqN#  "*J  "*J  !(I  $.L !  &H yy~~    rKrch0nU(aXS'U(aX%S'URRSXSUS9$)rr|rrrrrs rIrSyncAssistantsClient.countOs@&#% "*J  "*J yy~~ gv  rKcbUUS.nU(aX'S'URRSUS3UUUS9$)acList all versions of an assistant. Args: assistant_id: The assistant ID to get versions for. metadata: Metadata to filter versions by. Exact match filter for each KV pair. limit: The maximum number of versions to return. offset: The number of versions to skip. headers: Optional custom headers to include with the request. Returns: list[Assistant]: A list of assistants. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") assistant_versions = client.assistants.get_versions( assistant_id="my_assistant_id" ) ``` rr|r^rrrrs rIr!SyncAssistantsClient.get_versionsksND#  "*J yy~~<. 2   rKcJSU0nURRSUS3UUUS9$)aChange the version of an assistant. Args: assistant_id: The assistant ID to delete. version: The version to change to. headers: Optional custom headers to include with the request. Returns: Assistant: Assistant Object. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") new_version_assistant = client.assistants.set_latest( assistant_id="my_assistant_id", version=3 ) ``` rr^rrrrs rIrSyncAssistantsClient.set_latests=<$-g"6yy~~<. 0   rKrXrr rrrrrrrrrrrrrrrrrrrKrIr!r!Ts -1)- + + * + ' +  + b!,0)- 3 3  3 * 3 ' 3  )3 r-1)- C C * C ' C  C P!% " -1)-""" " * "'" "N!%E #'#'/3,0"&)-E E E  E  E !E -E E *E  E 'E  E V $ $"&,0"&)-? ?  ?  ?  ? ? ? *?  ? '?  ? J-1)- XX* X ' X  X@#*.'+48,0)-9 9  9  9  9 (9 %9 29 *9 '9  9 |#,0)-     *  '    > , -1)-, , ,  ,  , *, ',  , f-1)- % % % * % ' %  % % rKr!c R\rSrSrSrSSjrSSS.SSjjrSSSSSSSSS.S SjjrSSSS .S!S jjrSSS.S"S jjr SSSSS S SSSSSS. S#Sjjr SSSSSS.S$Sjjr SSS.S"Sjjr S%SSSS.S&Sjjjr SSSSSS.S'SjjrS SSSSSS.S(SjjrSSSSS.S)SjjrSrg)*r"ia]Synchronous client for managing threads in LangGraph. This class provides methods to create, retrieve, and manage threads, which represent conversations or stateful interactions. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:2024") thread = client.threads.create(metadata={"user_id": "123"}) ``` cXlgrrXrYs rIrSyncThreadsClient.__init__r[rKNr\c<URRSU3X#S9$)aGet a thread by ID. Args: thread_id: The ID of the thread to get. headers: Optional custom headers to include with the request. Returns: Thread: Thread object. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") thread = client.threads.get( thread_id="my_thread_id" ) print(thread) ``` ```shell ----------------------------------------------------- { 'thread_id': 'my_thread_id', 'created_at': '2024-07-18T18:35:15.540834+00:00', 'updated_at': '2024-07-18T18:35:15.540834+00:00', 'metadata': {'graph_id': 'agent'} } ``` rr\r_rs rIreSyncThreadsClient.gets#Lyy}}y 4g}UUrKrc 0n U(aX)S'U(dU(a0U=(d 0EU(aSU0O0EU S'U(aX9S'U(aGUV V s/sH4n SU SV s/sHn U SU RS5U SS .PM sn 0PM6 sn n U S 'Ub([U[[45(a US S .U S 'OXiS 'URR SXUS9$s sn fs sn n f)aCreate a new thread. Args: metadata: Metadata to add to thread. thread_id: ID of thread. If None, ID will be a randomly generated UUID. if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood. Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing thread). supersteps: Apply a list of supersteps when creating a thread, each containing a sequence of updates. Each update has `values` or `command` and `as_node`. Used for copying a thread between deployments. graph_id: Optional graph ID to associate with the thread. ttl: Optional time-to-live in minutes for the thread. You can pass an integer (minutes) or a mapping with keys `ttl` and optional `strategy` (defaults to "delete"). headers: Optional custom headers to include with the request. Returns: Thread: The created thread. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") thread = client.threads.create( metadata={"number":1}, thread_id="my-thread-id", if_exists="raise" ) ``` ) rdrr|r}rrrrrrrrrrrrrs rIrSyncThreadsClient.createsV#% #,K x#>r#-5J)2#GJ  #,K $ %$A "#9   ".A '(k'(uuY'7'(| ".   $ %GL ! ?#U|,,),(!C!$yy~~jwPV~WW#  %sC%CCCrcSU0nUb([U[[45(a USS.US'OX6S'URR SU3UUUS9$)aUpdate a thread. Args: thread_id: ID of thread to update. metadata: Metadata to merge with existing thread metadata. ttl: Optional time-to-live in minutes for the thread. You can pass an integer (minutes) or a mapping with keys `ttl` and optional `strategy` (defaults to "delete"). headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Thread: The created thread. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") thread = client.threads.update( thread_id="my-thread-id", metadata={"number":1}, ttl=43_200, ) ``` r|rrrrrrrs rIrSyncThreadsClient.updateEsgD$.x"8 ?#U|,,),(!C!$yy { #   rKc>URRSU3X#S9 g)aWDelete a thread. Args: thread_id: The ID of the thread to delete. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client.threads.delete( thread_id="my_thread_id" ) ``` rr\Nrrs rIrSyncThreadsClient.deletets"4 9YK0'QrKrrrc UUS.n U(aXS'U(aX,S'U(aX>I;&78$.G "  %y1J5 5f5 99==I;gm_=!!  &y1J5 5f5 99==I;f-!! rKrcSU0nU(aXXS'U(aXHS'U(aX8S'URRSUS3XUS9$)a:Update the state of a thread. Args: thread_id: The ID of the thread to update. values: The values to update the state with. as_node: Update the state as if this node had just executed. checkpoint: The checkpoint to update the state of. headers: Optional custom headers to include with the request. Returns: ThreadUpdateStateResponse: Response after updating a thread's state. ???+ example "Example Usage" ```python 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': {} } } ``` rrrrrrrrrs rIrSyncThreadsClient.update_states_` f#  '4O $ $.L ! !(I yy~~ {& )QW  rKr cSU0nU(aX8S'U(aXHS'U(aXXS'URRSUS3UUUS9$)aGet the state history of a thread. Args: thread_id: The ID of the thread to get the state history for. checkpoint: Return states for this subgraph. If empty defaults to root. limit: The maximum number of states to return. before: Return states before this checkpoint. metadata: Filter states by metadata key-value pairs. headers: Optional custom headers to include with the request. Returns: list[ThreadState]: the state history of the thread. ???+ example "Example Usage" ```python thread_state = client.threads.get_history( thread_id="my_thread_id", limit=5, before="my_timestamp", metadata={"name":"my_name"} ) ``` rr r|rrr rrrs rIrSyncThreadsClient.get_historyscL U#   &H  "*J  $.L !yy~~ {( +   rKr)rr%rSrcSU0nU(aURU5 URRSUS3S0U(aSU0O0EU=(d 0EUS9$)aIGet a stream of events for a thread. Args: thread_id: The ID of the thread to get the stream for. last_event_id: The ID of the last event to get. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: Iterator[StreamPart]: An iterator of stream parts. ???+ example "Example Usage" ```python for chunk in client.threads.join_stream( thread_id="my_thread_id", last_event_id="my_event_id", stream_mode="run_modes", ): print(chunk) ``` rrrrrr\r)rrdrr%rSrrjs rIrSyncThreadsClient.join_streamsvD ;      'yy {' * 7DO]3"=b    rKrXrarrrrrr!r"r#r%r&) rdr;rr(r%rrSr=rr<rrEr)rrKrIr"r"s  -1)- &V&V* &V ' &V  &VV $/3KO#.2,0)-IXIX IX - IX I IXIX,IX*IX'IX IX`/3,0)-- - $ - , - * - '-  - f-1)- RR* R ' R  R>$(&*'+'+15,0)-> >  > " > $ > > > %> %> /> *> '>  > F&*,0)-    $  *  '   H-1)-   *  '    D)-$( E  ,0)-EE&E" E  E*E'E EX#(,$(,0)-: : 7:  : & : ": *: ':  #: @*.-1(,,0)-3 3  3 ( 3 + 3 &3 *3 '3  3 rFQ$(,0)-. . C . " . * . '.  . . rKr"c\rSrSrSrS)Sjr\SSSSSSSSSSSSSSSSSSSSSS.S*Sjj5r\SSSSSSSSSSSSSSSSSSSSS .S+S jj5rSSSSSSSSSSSSSSSSSSSSSSSSS .S,S jjr\SSSSSSSSSSSSSSSSSSS .S-Sjj5r\SSSSSSSSSSSSSSSSSSSSS.S.Sjj5rSSSSSSSSSSSSSSSSSSSSSSS.S/SjjrSSS.S0Sjjr \SSSSSSSSSSSSSSSSSSSS.S1Sjj5r \SSSSSSSSSSSSSSSSSS.S2Sjj5r SSSSSSSSSSSSSSSSSSSSSS.S3Sjjr SSSSSSS.S4Sjjr SSS.S5S jjr SS!SSS".S6S#jjr SSS.S7S$jjrSSSSSS%.S8S&jjrSSS.S9S'jjrS(rg):r#i8a^Synchronous client for managing runs in LangGraph. This class provides methods to create, retrieve, and manage runs, which represent individual executions of graphs. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:2024") run = client.runs.create(thread_id="thread_123", assistant_id="asst_456") ``` cXlgrrXrYs rIrSyncRunsClient.__init__Fr[rKNrF)r-rrr.r|rr{rrr0r1r2r3r4r5r6r7r8rSrr9cgrr)rrdrar-rrr.r|rr{rrr0r1r2r3r4r5r6r7r8rSrr9s rIrSyncRunsClient.streamIs6 #rK)r-rrr.r/r|rr{r0r1r2r3r4r<r7r5r8rSrr9cgrr)rrdrar-rrr.r/r|rr{r0r1r2r3r4r<r7r5r8rSrr9s rIrrfs4 #rKr>c ^U b[R"S[SS9 0SU_SU(a,UR5VVs0sHunnUcM UU_M snnOS_SU _SU _S U_S U_S U_S U_S U_SU_SU_SU_SU_SU _SU _SU _SU_UUUUUS.EnUbSUS3OSnSU4SjjnURR USUR5VVs0sHunnUcM UU_M snnUUT(aUS9$SS9$s snnfs snnf)aCreate a run and stream the results. Args: thread_id: the thread ID to assign to the thread. If None will create a stateless run. assistant_id: The assistant ID or graph name to stream from. If using graph name, will default to first assistant created from that graph. input: The input to the graph. command: The command to execute. stream_mode: The stream mode(s) to use. stream_subgraphs: Whether to stream output from subgraphs. stream_resumable: Whether the stream is considered resumable. If true, the stream can be resumed and replayed in its entirety even after disconnection. metadata: Metadata to assign to the run. config: The configuration for the assistant. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. feedback_keys: Feedback keys to assign to run. on_disconnect: The disconnect mode to use. Must be one of 'cancel' or 'continue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. headers: Optional custom headers to include with the request. on_run_created: Optional callback to call when a run is created. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: Iterator[StreamPart]: Iterator of stream results. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") async for chunk in client.runs.stream( thread_id=None, assistant_id="agent", input={"messages": [{"role": "user", "content": "how are you?"}]}, stream_mode=["values","debug"], metadata={"name":"my_run"}, context={"model_name": "anthropic"}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], feedback_keys=["my_feedback_key_1","my_feedback_key_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ): print(chunk) ``` ```shell ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ StreamPart(event='metadata', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2'}) StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}]}) StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}, {'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]}) StreamPart(event='end', data=None) ``` NrArrr-rrr{r|rr.r/rar1r2r3r5rrr0r6rBrrCcL>T(a[U5=n(a T"U5 gggrErFrGs rIr*SyncRunsClient.stream..on_responserIrKrJrrKrMrOs ` rIrrsL  ( MMv"   U GN'--/C/$!QQA/CTX f  w     ;   0   0  L   0    ]  w *! " ]# $ !2% & !"4' (+***$1 8$ {, /   ) yy  #*==?D?41aa$!Q$?D'5    <@    EDJErS)r-rrr.r/r|rr{r0r1r2r5r<r7r8rSrr9cgrr)rrdrar-rrr.r/r|rr{r0r1r2r5r<r7r8rSrr9s rIrSyncRunsClient.creates0rKrWcgrrrYs rIrr6s4rKrZc^U b[R"S[SS9 0SU_SU(a,UR5VVs0sHunnUcM UU_M snnOS_SU_SU_S U_S U _S U _S U_S U_SU_SU_SU_SU _SU _SU _SU_SU_UUUS.EnUR5VVs0sHunnUcM UU_M nnnSU4SjjnURR U(aSUS3OSUUUT(aUS9$SS9$s snnfs snnf)a&Create a background run. Args: thread_id: the thread ID to assign to the thread. If None will create a stateless run. assistant_id: The assistant ID or graph name to stream from. If using graph name, will default to first assistant created from that graph. input: The input to the graph. command: The command to execute. stream_mode: The stream mode(s) to use. stream_subgraphs: Whether to stream output from subgraphs. stream_resumable: Whether the stream is considered resumable. If true, the stream can be resumed and replayed in its entirety even after disconnection. metadata: Metadata to assign to the run. config: The configuration for the assistant. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. headers: Optional custom headers to include with the request. on_run_created: Optional callback to call when a run is created. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: Run: The created background run. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") background_run = client.runs.create( thread_id="my_thread_id", assistant_id="my_assistant_id", input={"messages": [{"role": "user", "content": "hello!"}]}, metadata={"name":"my_run"}, context={"model_name": "openai"}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) print(background_run) ``` ```shell -------------------------------------------------------------------------------- { '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, 'assistant_id': 'my_assistant_id' } }, 'context': { 'model_name': 'openai' }, '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' } ``` NrArrr-rrr.r/rr{r|rar1r2r5rrr0r6r7r\cL>T(a[U5=n(a T"U5 gggrErFrGs rIr*SyncRunsClient.create..on_responserIrKrr_rrKr`ras ` rIrrRsV  ( MMv"   U GN'--/C/$!QQA/CTX ;   0    0  f  w    L   0    w  * ]! " !2# $ !"4% & ]' (+*$- 0%,MMOEODAqq41a4OE ) yy~~,5i {% (7'5   <@   9D*Fs C5 C5 C;.C;r\czSSjnUVs/sH oT"U5PM nnURRSXbUS9$s snf)rccbUR5VVs0sH upUcM X_M snn$s snnfrrerfs rIrg3SyncRunsClient.create_batch..filter_payloadrirjrkrrlrrms rIrpSyncRunsClient.create_batch sK G=0.6.0" checkpoint: The checkpoint to resume from. checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. on_disconnect: The disconnect mode to use. Must be one of 'cancel' or 'continue'. on_completion: Whether to delete or keep the thread created for a stateless run. Must be one of 'delete' or 'keep'. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. if_not_exists: How to handle missing thread. Defaults to 'reject'. Must be either 'reject' (raise error if missing), or 'create' (create new thread). after_seconds: The number of seconds to wait before starting the run. Use to schedule future runs. raise_error: Whether to raise an error if the run fails. headers: Optional custom headers to include with the request. on_run_created: Optional callback to call when a run is created. durability: The durability to use for the run. Values are "sync", "async", or "exit". "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps Returns: Union[list[dict], dict[str, Any]]: The output of the run. ???+ example "Example Usage" ```python 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"}, context={"model_name": "anthropic"}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) print(final_state_of_run) ``` ```shell ------------------------------------------------------------------------------------------------------------------------------------------- { '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 } ] } ``` NrArrr-rrr{r|rar1r2r5rrr6r7r4r0r<r8)rsr?cL>T(a[U5=n(a T"U5 gggrErFrGs rIr(SyncRunsClient.wait..on_responserIrKrr|rJrrK)r r rNr rr )rrdrar-rr|rr{r0rrr1r2r5r4r<r6r7r8rsrSrr9r?rPrQrrrRs ` rIrvrOsh  ( MMv"   U GN'--/C/$!QQA/CTX f  w     L   0    w  *  ]  !"4  ] ]! " !2# $ ]% & ]' ('$+ 0 ) 2;1Fi {* -L yy**  #*==?D?41aa$!Q$?D'5 +  <@ +  ;D@Es C2 C2 C8C8rrrcX#S.nUbXHS'U(aXXS'U(aURU5 URRSUS3XS9$)a%List runs. Args: thread_id: The thread ID to list runs for. limit: The maximum number of results to return. offset: The number of results to skip. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: list[Run]: The runs for the thread. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.runs.list( thread_id="thread_id", limit=5, offset=5, ) ``` rrrrr_rrhrs rIr]SyncRunsClient.lists_F27'I  %+ " %+ "     'yy}} {% (  rKcBURRSUSU3X4S9$)aZGet a run. Args: thread_id: The thread ID to get. run_id: The run ID to get. headers: Optional custom headers to include with the request. Returns: Run: Run object. ???+ example "Example Usage" ```python run = client.runs.get( thread_id="thread_id_to_delete", run_id="run_id_to_delete", ) ``` rrr\r_rs rIreSyncRunsClient.get s0:yy}} {& 17  rKrrcU(aSOSUS.nU(aURU5 U(a$URRSUSUS3SSUUS 9$URRSUSUS3SUUS 9$) aGet a run. Args: thread_id: The thread ID to cancel. run_id: The run ID to cancel. wait: Whether to wait until run has completed. action: Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. Default is `interrupt`. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.runs.cancel( thread_id="thread_id_to_cancel", run_id="run_id_to_cancel", wait=True, action="interrupt" ) ``` rrrrrrrJNrrrs rIrSyncRunsClient.cancelAsLA1      ' 99..I;fVHG<# / yy~~ {& 8   rKcHURRSUSUS3SUUS9$)aBlock until a run is done. Returns the final state of the thread. Args: thread_id: The thread ID to join. run_id: The run ID to join. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.runs.join( thread_id="thread_id_to_join", run_id="run_id_to_join" ) ``` rrrrr\rrs rIrSyncRunsClient.join{s;<yy** {& 6  +  rKrcUUS.nU(aURU5 URRSUSUS3SU0U(aSU0O0EU=(d 0E=(d SS9$) aStream output from a run in real-time, until the run is done. Output is not buffered, so any output produced before this call will not be received here. Args: thread_id: The thread ID to join. run_id: The run ID to join. stream_mode: The stream mode(s) to use. Must be a subset of the stream modes passed when creating the run. Background runs default to having the union of all stream modes. cancel_on_disconnect: Whether to cancel the run when the stream is disconnected. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. last_event_id: The last event ID to use for the stream. Returns: None ???+ example "Example Usage" ```python 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"] ) ``` )rrrrrrrNrrrs rIrSyncRunsClient.join_streamsT'$8      'yy {& 8 7DO]3"=b  rKcDURRSUSU3X4S9 g)aDelete a run. Args: thread_id: The thread ID to delete. run_id: The run ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:2024") client.runs.delete( thread_id="thread_id_to_delete", run_id="run_id_to_delete" ) ``` rrr\Nrrs rIrSyncRunsClient.deletes-<  {& 17  rKrXra)0rdr;rar;r-r'rrrrr.rr|r'rrr{rrr$rrr0rr1rr2rr3rr4rr5rr6rr7rr8rrSr=rr<r9rrrE).rdrrar;r-r'rrrrr.rr/rr|r'rrr{rr0rr1rr2rr3rr4rr<rr7rr5rr8rrSr=rr<r9rrrE)6rdrrar;r-r'rrrrr.rr/rr|r'rrr{rrr$rrr0rr1rr2rr3rr4rr<rr5rr6rr7rr8rrSr=rr<r9rr?rrrE)*rdrrar;r-r'rrrrr.rr/rr|r'rrr{rr0rr1rr2rr5rr<rr7rr8rrSr=rr<r9rrr'rrrrr)0rdrrar;r-r'rrr|r'rrr{rr0rrr$rrr1rr2rr5rr4rr<rr6rr7rr8rrsrrSr=rr<r9rr?rrrrrrr)rdr;rcr;rrrrrSr=rr<r%rrrErrrrKrIr#r#8sR   +/"&9A!&-1 $"&(,$()-7;6:.2/3"7;,0$(,0)-EI3### ( #  #7##+## #&#"#'#5# 4!#",##$-%#&'#(5)#**+#,"-#.*/#0'1#2C3#4 5##8 +/"&9A!&!&-1 $"&)-7;6:.2/359,0"$(,0)-EI1### ( #  #7###+## #'#5#4# ,!#"-##$3%#&*'#()#*"+#,*-#.'/#0C1#2 3##@+/"&9A!&!&-1 $"&(,$()-7;6:.2/359"7;,0$(,0)-EI(,9X X X ( X  X 7X X X +X X  X &X "X 'X 5!X "4#X $,%X &-'X (3)X *+X ,5-X .*/X 0"1X 2*3X 4'5X 6C7X 8&9X : ;X t +/"&9A!&!&-1 $"&)-7;6:"59,0$(,0)-EI- (   7+ '54 !"3#$*%&"'(*)*'+,C-. /2 +/"&9A!&!&-1 $"&(,$()-7;6:"7;,0$(,0)-EI1 (   7+ &"' 5!"4#$%&5'(*)*"+,*-.'/0C12 3@+/"&9A!&!&-1 $"&(,$()-7;6:"7;,059$(,0)-EI(,5v v v ( v  v 7v v v +v v  v &v "v 'v 5!v "4#v $%v &5'v (*)v *3+v ,"-v .*/v 0'1v 2C3v 4&5v 6 7v x-1)-  ! *  '    " +/"&-1 $"&(,$()-7;6:"/37;,0$( ,0)-EI/*** ( *  *+** *&*"*'*5*4** -!*"5#*$*%*&"'*()***+*,'-*.C/*0 %1**4 +/"&-1 $"&)-7;6:"/359,0$( ,0)-EI+*** ( *  *+** *'*5*4**-*3* *!*""#*$%*&*'*(')**C+*, %-**:+/"&-1 $"&)-(,$(7;6:"/3597;,0$( ,0)-EI(,3a a a ( a  a +a a  a 'a &a "a 5a 4a a -!a "3#a $5%a &*'a (")a *+a ,*-a .'/a 0C1a 2&3a 4 %5a N#'.2,0)-, ,  ,  , ! , ,, *, ',  , f-1)-    *  '    L*,0)-8 8 8  8  8 *8 '8  8 ~-1)- # # # * # ' #  # T&+@D,0)-$(8 8 8 # 8 > 8 *8 '8 "8  8 ~-1)-      *  '      rKr#c r\rSrSrSrSSjrSSSSSSSSSSSS. SSjjrSSSSSSSSSSSS. SSjjrSSS.SS jjrSSS S SSSSSS . SS jjr SSSSS.SSjjr Sr g)r$ia[Synchronous client for managing cron jobs in LangGraph. This class provides methods to create and manage scheduled tasks (cron jobs) for automated graph executions. ???+ example "Example" ```python 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 * * * *") ``` !!! note "Feature Availability" The crons client functionality is not supported on all licenses. Please check the relevant license documentation for the most up-to-date details on feature availability. cXlgrrXrs rIrSyncCronClient.__init__rrKNrc UUUUUUU U UU U S. nUR5VVs0sHunnUcM UU_M nnnURRSUS3UU US9$s snnf)aCreate a cron job for a thread. Args: thread_id: the thread ID to run the cron job on. assistant_id: The assistant ID or graph name to use for the cron job. If using graph name, will default to first assistant created from that graph. schedule: The cron schedule to execute this job on. input: The input to the graph. metadata: Metadata to assign to the cron job runs. config: The configuration for the assistant. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. headers: Optional custom headers to include with the request. Returns: Run: The cron run. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") cron_run = client.crons.create_for_thread( thread_id="my-thread-id", assistant_id="agent", schedule="27 15 * * *", input={"messages": [{"role": "user", "content": "hello!"}]}, metadata={"name":"my_run"}, context={"model_name": "openai"}, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) ``` ) rr-rr|r{rar1r2r0r5r6rrrrrs rIr SyncCronClient.create_for_threadsx! ( 0.!2"4  %,MMOEODAqq41a4OEyy~~ {+ .   Fs AAc UUUUUUUU U UU S. nUR5VVs0sHunnUcM UU_M nnnURRSXU S9$s snnf)aCreate a cron run. Args: assistant_id: The assistant ID or graph name to use for the cron job. If using graph name, will default to first assistant created from that graph. schedule: The cron schedule to execute this job on. input: The input to the graph. metadata: Metadata to assign to the cron job runs. config: The configuration for the assistant. context: Static context to add to the assistant. !!! version-added "Supported with langgraph>=0.6.0" checkpoint_during: Whether to checkpoint during the run (or only at the end/interruption). interrupt_before: Nodes to interrupt immediately before they get executed. interrupt_after: Nodes to Nodes to interrupt immediately after they get executed. webhook: Webhook to call after LangGraph API call is done. multitask_strategy: Multitask strategy to use. Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'. headers: Optional custom headers to include with the request. Returns: Run: The cron run. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") cron_run = client.crons.create( assistant_id="agent", schedule="27 15 * * *", input={"messages": [{"role": "user", "content": "hello!"}]}, metadata={"name":"my_run"}, context={"model_name": "openai"}, checkpoint_during=True, interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"], interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"], webhook="https://my.fake.webhook.com", multitask_strategy="interrupt" ) ``` ) rr-rr|r{rar1r2r5r0r6rrrrs rIrSyncCronClient.createbs|v! ( 0.!2"4  %,MMOEODAqq41a4OEyy~~   Fs AAr\c>URRSU3X#S9 g)aDelete a cron. Args: cron_id: The cron ID to delete. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") client.crons.delete( cron_id="cron_to_delete" ) ``` rr\Nrrs rIrSyncCronClient.deletes"6 <y17RrKrrrc UUUUS.n U(aXZS'U(aXjS'U(aXzS'U R5V V s0sH upU cM X_M n n n URRSXU S9$s sn n f)aGet a list of cron jobs. Args: assistant_id: The assistant ID or graph name to search for. thread_id: the thread ID to search for. limit: The maximum number of results to return. offset: The number of results to skip. headers: Optional custom headers to include with the request. Returns: list[Cron]: The list of cron jobs returned by the search, ???+ example "Example Usage" ```python 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) ``` ```shell ---------------------------------------------------------- [ { 'cron_id': '1ef3cefa-4c09-6926-96d0-3dc97fd5e39b', 'assistant_id': 'my_assistant_id', 'thread_id': 'my_thread_id', 'user_id': None, 'payload': { 'input': {'start_time': ''}, 'schedule': '4 * * * *', 'assistant_id': 'my_assistant_id' }, 'schedule': '4 * * * *', 'next_run_date': '2024-07-25T17:04:00+00:00', 'end_time': None, 'created_at': '2024-07-08T06:02:23.073257+00:00', 'updated_at': '2024-07-08T06:02:23.073257+00:00' } ] ``` rrrrrrrrs rIrgSyncCronClient.searchs~)"   !(I  $.L !  &H $+MMOEODAq414OEyy~~ w  Fs A- A-rch0nU(aXS'U(aX%S'URRSXSUS9$)rrardrrrrs rIrSyncCronClient.counts@&#% &2N # #,K yy~~ gv  rKrX)rr rrrrrrrrrrKrIr$r$s" +/-1 $"&)-3726")-,0)-!N N N  N ( N +N N  N 'N 1N 0N N 'N *N '!N " #N j+/-1 $"&)-3726")-,0)-J J  J ( J + J J  J 'J 1J 0J J 'J *J 'J !J `-1)- SS* S ' S  S@$( $%)'+/3,0)-M !M  M  M  M #M %M -M *M 'M  M d$( $,0)-  !   *  '     rKr$c$\rSrSrSrS SjrSSSjjrSSSS.SSjjrSSSjjrSSS jjr SSSS .SS jjjr S r g)r%i7aA client for synchronous operations on a key-value store. Provides methods to interact with a remote key-value store, allowing storage and retrieval of items within namespaced hierarchies. ???+ example "Example" ```python client = get_sync_client(url="http://localhost:2024")) client.store.put_item(["users", "profiles"], "user123", {"name": "Alice", "age": 30}) ``` cXlgrrXrYs rIrSyncStoreClient.__init__Er[rKNcUHnSU;dM [SUS35e UUUUUS.n URRS[U 5XgS9 g)a:Store or update an item. Args: namespace: A list of strings representing the namespace path. key: The unique identifier for the item within the namespace. value: A dictionary containing the item's data. index: Controls search indexing - None (use defaults), False (disable), or list of field paths to index. ttl: Optional time-to-live in minutes for the item, or None for no expiration. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") client.store.put_item( ["documents", "user123"], key="item456", value={"title": "My Document", "content": "Hello World"} ) ``` rrrrrrNrrs rIrSyncStoreClient.put_itemHskHEe| /w6gh #   !8'  rKrcUHnSU;dM [SUS35e USRU5S.nUbX7S'U(aURU5 URR SXtS9$)aRetrieve a single item. Args: key: The unique identifier for the item. namespace: Optional list of strings representing the namespace path. refresh_ttl: Whether to refresh the TTL on this read operation. If None, uses the store's default behavior. headers: Optional custom headers to include with the request. Returns: Item: The retrieved item. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") item = client.store.get_item( ["documents", "user123"], key="item456", ) print(item) ``` ```shell ---------------------------------------------------------------- { 'namespace': ['documents', 'user123'], 'key': 'item456', 'value': {'title': 'My Document', 'content': 'Hello World'}, 'created_at': '2024-07-30T12:00:00Z', 'updated_at': '2024-07-30T12:00:00Z' } ``` rrrr)rvrrr)rNrrrre)rrvr)rrSrrrjs rIrSyncStoreClient.get_item|s{XEe| /w6gh #)1DE  "*5 '     'yy}}^L}RRrKc@URRSX!S.UUS9 g)aDelete an item. Args: key: The unique identifier for the item. namespace: Optional list of strings representing the namespace path. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: None ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") client.store.delete_item( ["documents", "user123"], key="item456", ) ``` rrrNrrs rIrSyncStoreClient.delete_items*:  5  rKc ^UUUUUUS.n URRS[U 5UUS9$)aSearch for items within a namespace prefix. Args: namespace_prefix: List of strings representing the namespace prefix. filter: Optional dictionary of key-value pairs to filter results. limit: Maximum number of items to return (default is 10). offset: Number of items to skip before returning results (default is 0). query: Optional query for natural language search. refresh_ttl: Whether to refresh the TTL on items returned by this search. If None, uses the store's default behavior. headers: Optional custom headers to include with the request. params: Optional query parameters to include with the request. Returns: list[Item]: A list of items matching the search criteria. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") items = client.store.search_items( ["documents"], filter={"author": "John Doe"}, limit=5, offset=0 ) print(items) ``` ```shell ---------------------------------------------------------------- { "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 ... ] } ``` rrrrrs rIrSyncStoreClient.search_itemssKx!1&  yy~~ !(   rKr\c\UUUUUS.nURRS[U5UUS9$)a5List namespaces with optional match conditions. Args: prefix: Optional list of strings representing the prefix to filter namespaces. suffix: Optional list of strings representing the suffix to filter namespaces. max_depth: Optional integer specifying the maximum depth of namespaces to return. limit: Maximum number of namespaces to return (default is 100). offset: Number of namespaces to skip before returning results (default is 0). headers: Optional custom headers to include with the request. Returns: list[list[str]]: A list of namespaces matching the criteria. ???+ example "Example Usage" ```python client = get_sync_client(url="http://localhost:8123") namespaces = client.store.list_namespaces( prefix=["documents"], max_depth=3, limit=10, offset=0 ) print(namespaces) ``` ```shell ---------------------------------------------------------------- [ ["documents", "user123", "reports"], ["documents", "user456", "invoices"], ... ] ``` rr rrr s rIr SyncStoreClient.list_namespaces#sH`"  yy~~ (   rKrXrarrrr"rrr)NNNrrrrrrKrIr%r%7s 48,0)-2  2 ! 2 1 2 2 *2 '2  2  2 t$(,0)-7S 7S 7S ! 7S*7S'7S 7S|-1)- "  " * " ' "  "  " P,0 #',0)-H ) H  H  H H !H *H 'H 'H  H X$(#' $ ; -1)-;  ; !;  ;  ;  ; *; ';  ; ; rKr%cbUR5VVs0sH upUcM X_M snn$s snnfrre)drPrQs rIrras(WWY 8YTQ!DADY 88 8rjzlist[httpx.ASGITransport]rc*[H nXlM gr)rrs)rsrs rIconfigure_loopback_transportsris+  ,rKr)maxsizechSSKJn UR$![a [Rs$f=f)Nrasgi_transport) langgraph_apir ASGITransport ImportErrorrrs rIrrns1#0+++ #"""#s 11r)rFrrr)rFrrQr=rzdict[str, str])r`r rr )rirLrzRunCreateMetadata | None) rmrrFrrSr=rnTimeoutTypes | Nonerro)rr rz#tuple[dict[str, str], bytes | None])rrLrr ) rmrrFrrSr=rnrrr)rr rztuple[dict[str, str], bytes])rrrzdict[str, Any])rsr rr)rztype[httpx.ASGITransport])qr __future__rrI functoolsloggingrCrerr collections.abcrrrrtypesrtypingr r r r r rrrLrOlanggraph_sdk.schemarrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7langgraph_sdk.sser8r9r: getLoggerrrrMrJrTracompilerfrlrrorrrrrrrrrrr r8r5r!r"r#r$r%rr__annotations__r lru_cacherrtupler TimeoutTypesrrKrIrs# FF ***********VJI   8 $"   )A(P <   "(,#' ^# ^#^#& ^# ! ^#  ^#B#,#,Lqqh  n  n  bE  E  PT T nD D N g g X (,#' 5' 5'5'& 5' ! 5'  5'p&%&%Rqqh 0 j  j  Zt  t  nB B Jw w t g g T 95716  Q# #  (5/8E? *+ (5/8E?HUOXe_ LM MM  rK