langgraph/how-tos/pass-run-time-values-to-tools/

[giscus[bot]]

langgraph/how-tos/pass-run-time-values-to-tools/

Build language agents as graphs

https://langchain-ai.github.io/langgraph/how-tos/pass-run-time-values-to-tools/

[smathalikunnel]

the document introduction mentions the usage of Runnable, and RunnableConfig -

"To pass run time information, we will leverage the Runnable interface. The standard runnables methods (invoke, batch, stream etc.) accept a 2nd argument which is a RunnableConfig."

But not clear from the tutorial if (or where) these objects are being used.

[AFRT927]

The documentation on this link: https://langchain-ai.github.io/langgraph/how-tos/pass-run-time-values-to-tools/
is no longer accessible.

Can you show me how pass run time values to tools when working with langgraph?

[vbarda]

@AFRT927 i think it might have been removed by mistake, check this out here in the meantime https://github.com/langchain-ai/langgraph/blob/main/examples/pass-run-time-values-to-tools.ipynb

[AFRT927]

@vbarda It is correct, thank you very much!

[cplog]

is this method still valide?
with 0.1.9 version
I got
ImportError: cannot import name 'InjectedState' from 'langgraph.prebuilt' (/.../llm_base/lib/python3.10/site-packages/langgraph/prebuilt/__init__.py)

[vbarda]

@cplog thanks for reporting! should be fixed in 0.1.10 -- please let us know if you run into any other issues

[chintagunta]

I am able to read the state, but unable to update it, pls help.
Tried: 1. Setting the value, 2. Returning the object {key, value}
Didn't work.

[antoremin]

Would love a native support for state updates in tool nodes!

[dean2727]

What I did to update my state was, inside of the function where I define my agent node, after invoke(), I can check the last message to see if it is of type ToolMessage. If it is, and my tool is defined with response_format="content_and_artifact", then I can access the .artifact attribute of the message, which contains the the data (resulting from the tool call, the second element of the tuple) that I can then use to update state. And, because this is an agent node, I can update the state by returning a dictionary with whatever keys (aspects of the state) that were updated.

[antoremin]

For my case, I ended up getting len() of tool calls kwargs in agent node response and popping that number from the queue.

[fletchertyler914]

You need to define a custom Tool Node, and after invoking the tool from the node, you can extract the properties you want to update the state with from the tool message/artifact.

So Agent -> Tool Call -> Custom Tool Node -> Agent
When the Custom Tool Node invokes the tool call, you can use the result to update the state directly by returning it from the Custom Tool Node.

[vbarda]

Hi folks! We have now added support for updating the state from the tools using the new Command type. Please see this how-to guide for reference https://langchain-ai.github.io/langgraph/how-tos/update-state-from-tools/. Let me know if you have any questions / feedback

[ashantanu]

should we use RunnableConfig or InjectedState? what is the recommended way?

[hepbc]

Hi friends: this function's artifact is a list of Documents

@tool(parse_docstring=True, response_format="content_and_artifact")
def get_context(question: List[str]) -> Tuple[str, List[Document]]:

How can I define it to return another data type like json or a pandas dataframe? Would appreciate some help here!

Thanks

[hepbc]

@vbarda could you help? Application is as follows: a tool returning a dataframe, say dates and price, and another tool plotting it.
Thanks and look forward!

[vbarda]

hm, have you tried returning the dataframe in your function instead of the document list? did you get any errors?

[FMurray]

Using version 0.2.4, my tool is always being invoked with the InjectedState parameter, even though the tool call schema shows that it's not included:

from langgraph.prebuilt import InjectedState

class ChessMove(BaseModel):
    san: str = Field(description="SAN (standard algebraic notation) of a chess move")

@tool("make-move", args_schema=ChessMove)
def make_move(san: str, state: Annotated[dict, InjectedState]) -> str:
    """Make a move in the chess game"""
    board = state.get("board")
    board.push_san(san)
    return board.fen()
  
tool = make_move
tools = [make_move]

Tool call schema:

{'title': 'make-move',
 'description': 'Make a move in the chess game',
 'type': 'object',
 'properties': {'san': {'title': 'San',
   'description': 'SAN (standard algebraic notation) of a chess move',
   'type': 'string'}},
 'required': ['san']}

[vbarda]

that's by design -- the state is not included in the schema because it's not sent to the LLM. see the end of this section https://langchain-ai.github.io/langgraph/how-tos/pass-run-time-values-to-tools/#defining-the-tools

[FMurray]

I think you misread - the tool invoke is always passing the state arg, even though I've annotated it as previously mentioned

[tmishinev]

is that valid when passing a PyDantic Schema to the @tool(args_schema = )

still prompts me for the state as a missing arg

[Stihotvor]

@haroldsnyers But if You enable the docstring parser, doesn't it disable the pydantic validation? I need pydantic to validate the input....

[fletchertyler914]

I just hit this same issue. I am needing a tool which passes config and state with no arguments. Passing config alone works fine, but as soon as I add state via state: Annotated[dict, InjectedState] I get a pydantic error:

ValidationError: 1 validation error for guest_sample_tool
state
  Field required [type=missing, input_value={}, input_type=dict]
    For further information visit https://errors.pydantic.dev/2.9/v/missing

I did try to use the docstring but it doesnt help:

@tool(parse_docstring=True, response_format="content_and_artifact")
def guest_sample_tool(
    configs: RunnableConfig,
    state: Annotated[dict, InjectedState]
):
    """
    Call this tool to get a guest sample.

    Args: None
    """

[phfifofum]

I have the same issue today, had to ditch structured tool... anyone got a fix or workaround?

[haroldsnyers]

@haroldsnyers But if You enable the docstring parser, doesn't it disable the pydantic validation? I need pydantic to validate the input....

@Stihotvor Yeah I guess it does disable it, have you been able to use pydantic to get the state ?

[SaujanyaV]

I just hit this same issue. I am needing a tool which passes config and state with no arguments. Passing config alone works fine, but as soon as I add state via state: Annotated[dict, InjectedState] I get a pydantic error:

ValidationError: 1 validation error for guest_sample_tool
state
  Field required [type=missing, input_value={}, input_type=dict]
    For further information visit https://errors.pydantic.dev/2.9/v/missing

Were you able to find a fix? I'm stuck with the same error.

[rbaks]

Using v0.2.4, I implemented a custom tool node like the one in the documentation.

def  call_tool(state: State):
	tools_by_name = {...}
	messages = state["messages"]
	last_message = messages[-1]
	output_messages = []
	tool_results = {}
	for  tool_call  in  last_message.tool_calls:
		try:
			result = tools_by_name[tool_call["name"]].invoke(tool_call["args"])
			output_messages.append(
				ToolMessage(
					content=json.dumps(result),
					name=tool_call["name"],
					tool_call_id=tool_call["id"],
				)
			)
			tool_results.update(result)
		except  Exception  as  e:
			output_messages.append(
				ToolMessage(
					content="",
					name=tool_call["name"],
					tool_call_id=tool_call["id"],
					additional_kwargs={"error": str(e)},
				)
			)
			
	return {
	    "messages": output_messages,
	    **tool_results, # A way to update the state with the tool results
	}

And then when I need to inject state into a tool:

@tool
def  generate_chart(request: str, state: Annotated[dict, InjectedState]):
	...

It outputs the error

{
  "error": "1 validation error for generate_chartSchema\nstate\n  field required (type=value_error.missing)"
}

I suspect it is caused by my custom tool node implementation. is there a way to solve this issue?

[vbarda]

yea you would need to add support for that in your tool-calling node -- see the implementation here https://github.com/langchain-ai/langgraph/blob/main/libs/langgraph/langgraph/prebuilt/tool_node.py#L383

[rafael-siqueira-akad]

Can you elaborate and how this can be easily done? I would believe that custom tool node implementations are fairly common among users. Thanks!

[haroldsnyers]

You can also simply add the content/response of other tools/generations in your state, and then as @rbaks mentioned, use the @tool to get your state. Here is an example tool definition

"""Code generation tool."""

import logging

from typing_extensions import Annotated

from langgraph.prebuilt import InjectedState

from genai.agents.mini_agents.tools.code.plotter.python_plot_prompt import (
    prompt_template,
)
from genai.agents.mini_agents.tools.code.coder import cached_get_chain
from langchain_core.tools import tool

rag_chain = cached_get_chain(prompt_template)


@tool(parse_docstring=True, response_format="content")
def code_chart_tool(chart_message: str, state: Annotated[dict, InjectedState]):
    """
    Generate the python code related to plotting.
      Can write code.
      Input should be a code question related to plotting.
      Output is the plotly code to generate a graph that answers the question.

    Args:
        chart_message: The question or message that describes the chart to be generated.

    """
    logging.info("FUNCTION get_coder_chart_tool")
    if state.get("data"):
        llm_response = rag_chain.invoke(
            input={
                "question": chart_message,
                "data": state.get("data"),
            },
        )

        return llm_response["output"]
    else:
        return "Error: Data is missing"

[kivy0]

I'm trying to do the same thing with create_tool_calling_agent. Nothing works, maybe someone knows if it is possible to achieve similar behavior. The state would be first passed from the graph to the agent and then to the tools.

[sylviashea]

yeah i'm tearing my hair out here trying to inject the custom state with create_tool_calling_agent. It doesn't seem like InjectedState or InjectedToolArg are compatible with it.
I've also tried creating a ToolAgentAction and manually updating my arguments, as shown below:

# function_name: [arg_from_state]
state_args = {
    "my_function_that_needs_args_from_state": ["item_from_state"],
}
def execute_tools(state) -> dict:
    agent_action = state['agent_outcome']
    if not isinstance(agent_action, list):
        agent_action = [agent_action]

    steps = []

    for tool_action in agent_action:
        updated_input = copy.deepcopy(tool_action.tool_input)

        for key in state_args.get(tool_action.tool, []):
            updated_input[key] = state.get(key)
  
        updated_action = ToolAgentAction(
            tool=tool_action.tool,
            tool_input=updated_input,
            log=tool_action.log, 
            tool_call_id=tool_action.tool_call_id,  
            message_log=tool_action.message_log 
        )
        output = tool_executor.invoke(updated_action)
        steps.append((updated_action, str(output)))
    return {
        "intermediate_steps": steps,
    }

the tool_input contains the updated args, but neither the tool_action.message or tool_action.log has them updated. It seems like those need to contain the new args as well, but home-making them has proven to be a giant pain.

[MrAlekhin]

Is there a straightforward way to modify InjectedState inside the tool? or its only for reading the state?

What's is suggested way to modify the state right from the @tool?

[vbarda]

InjectedState is only for reading the state, we're working on adding support to modify state from tools as well, stay tuned

[vbarda]

For now the suggested way would be to

• return the outputs with desired state update from the tool (potentially via a tool artifact)
• create a custom implementation for the tool-calling node that can take those artifacts and produce the final state update that includes the updates from the tool(s)

[alex-kowalczyk]

Is there a bug in the examples?
tool_node = ToolNode(tools) is defined but never used in create_react_agent calls.

[JeffBasso]

[JeffBasso]

I found the place to correct, never mind

[Denis-root]

But this only works with the pre-built agent create_react_agent.

I have a basic React agent schema created with nodes only and using ToolNode, but I can't inject anything from the State class.

class State(MessagesState):
results: list

def hacer_post_json(url: str, data: dict, config: RunnableConfig, res: Annotated[list, InjectedState("resultados")]) -> dict:

I get an error that the results key doesn't exist...

And if I use
state: Annotated[dict, InjectedState]

I only get the messages key.

[Denis-root]

After reading repeatedly and consulting gpt [xd], I think I found an answer. I don't know if it's the official one.

According to the errors when running, it said that the "resultados" key was required but wasn't being passed as an argument.

So I entered it manually in the invoke, and eurekaaa, I was able to intercept it within the method.

for chunk in app.stream(
{"messages": [("human", x)], "resultados": []}, config, stream_mode="values"
):
chunk["messages"][-1].pretty_print()

I just don't understand why you can't set a default value when declaring the class. I tried, but it never worked.

[Jonnathanz]

Unfortunately, this is a workaround and it doesn’t work well with the assistant.

Using bind_tools, it is possible to call multiple tools in a single prompt, whereas using this method, it only calls one tool.