RunnableConfig in Tools with Legacy AgentExecutor vs. Graph AgentExecutor

[rhlarora84]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

import asyncio
import os
import random

from langchain import hub
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.tools import tool
from langchain_core.runnables import RunnableConfig
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

model = ChatOpenAI(
    ...
)


@tool
def where_cat_is_hiding(config: RunnableConfig) -> str:
    """Where is the cat hiding right now?"""
    print("Runnable Config:", config)
    return random.choice(["under the bed", "on the shelf"])


@tool
def get_items(place: str, config: RunnableConfig) -> str:
    """Use this tool to look up which items are in the given place."""
    print("Runnable Config:", config)
    if "bed" in place:  # For under the bed
        return "socks, shoes and dust bunnies"
    if "shelf" in place:  # For 'shelf'
        return "books, pencils and pictures"
    else:  # if the agent decides to ask about a different place
        return "cat snacks"


# Get the prompt to use - you can modify this!
prompt = hub.pull("hwchase17/openai-tools-agent")
tools = [get_items, where_cat_is_hiding]
agent = create_openai_tools_agent(model, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools)


graph = create_react_agent(model, tools=tools)


def print_stream(stream):
    for s in stream:
        message = s["messages"][-1]
        if isinstance(message, tuple):
            print(message)
        else:
            message.pretty_print()


async def main():
  # Runnable Config not available inside Tool
    async for chunk in agent_executor.astream(
            {"input": "what's items are located where the cat is hiding?"},
            config={"configurable": {"username": "test"}}
    ):
        print(chunk)

   # Runnable Config is available inside Tool
    inputs = {"messages": [("user", "what's items are located where the cat is hiding?")]}
    print_stream(graph.stream(inputs, stream_mode="values", config={"configurable": {"username": "test"}}))


asyncio.run(main())

Description

I am trying to use the RunnableConfig in the Tool, but it does not work with the leagcy AgentExecutor. It works fine with the Graph based react Agent.

I can see the content of RunnableConfig with Graphs. Is this feature not going to be supported with Legacy AgentExecutor?

System Info

langchain==0.2.13
langchain-anthropic==0.1.22
langchain-aws==0.1.16
langchain-community==0.2.12
langchain-core==0.2.30
langchain-experimental==0.0.64
langchain-ollama==0.1.0rc0
langchain-openai==0.1.21
langchain-text-splitters==0.2.1
langchainhub==0.1.21
langdetect==1.0.9
langgraph==0.2.3
langgraph-checkpoint==1.0.2
langserve==0.2.2
langsmith==0.1.99

[dosubot[bot]]

The RunnableConfig feature is not supported with the legacy AgentExecutor. This is evident from the code snippet in the LangChain repository, which raises an error when attempting to save configurations for AgentExecutor ^[1].

To achieve similar functionality, you should migrate to the Graph-based React Agent, which fully supports RunnableConfig. Here are the primary differences and steps to migrate:

1. Configuration Parameters:

   • AgentExecutor: Uses parameters like return_intermediate_steps, max_iterations, and max_execution_time.
   • Graph-based React Agent: Uses state_modifier and supports recursion_limit.

2. Prompt Templates:

   • AgentExecutor: Requires a prompt template.
   • Graph-based React Agent: Uses state_modifier instead of a prompt template.

3. Memory:

   • AgentExecutor: Uses chat memory.
   • Graph-based React Agent: Uses a checkpointer for persistence.

4. Iterating through Steps:

   • AgentExecutor: Uses stream or iter methods.
   • Graph-based React Agent: Uses stream or astream methods.

5. Intermediate Steps:

   • AgentExecutor: Uses return_intermediate_steps.
   • Graph-based React Agent: Appends all messages to the central state.

6. Max Iterations:

   • AgentExecutor: Uses max_iterations.
   • Graph-based React Agent: Uses recursion_limit.

Here is an example of how to migrate your code to use the Graph-based React Agent:

import asyncio
import os
import random

from langchain import hub
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

model = ChatOpenAI(...)

@tool
def where_cat_is_hiding(config: RunnableConfig) -> str:
    print("Runnable Config:", config)
    return random.choice(["under the bed", "on the shelf"])

@tool
def get_items(place: str, config: RunnableConfig) -> str:
    print("Runnable Config:", config)
    if "bed" in place:
        return "socks, shoes and dust bunnies"
    if "shelf" in place:
        return "books, pencils and pictures"
    else:
        return "cat snacks"

tools = [get_items, where_cat_is_hiding]
graph = create_react_agent(model, tools=tools)

def print_stream(stream):
    for s in stream:
        message = s["messages"][-1]
        if isinstance(message, tuple):
            print(message)
        else:
            message.pretty_print()

async def main():
    inputs = {"messages": [("user", "what's items are located where the cat is hiding?")]}
    print_stream(graph.stream(inputs, stream_mode="values", config={"configurable": {"username": "test"}}))

asyncio.run(main())

By following these steps, you can ensure compatibility with RunnableConfig and leverage the advanced features of the Graph-based React Agent ^[2][3].

To continue talking to Dosu, mention @dosu.

[rhlarora84]

@hwchase17 will the legacy AgentExecutor support the RunnableConfig in near future? We are using legacy memory management and store the input human message and output AI message into DynamoDb (intermediate steps are ignored). The interfaces for existing memory are different with the new Checkpointer concept in Langgraph so transition isn't going to be an easy task keeping backwards compatibility.

Worst case - we migrate to new AgentExecutor. Any suggestions on memory transition are welcome here but one approach I can think of is to populate the Agentstate.messages from DynamoDb before the graph workflow

• either by using Context
• or a start node before the agent executes
  and do something similar to save the final AI message.

[dosubot[bot]]

The legacy AgentExecutor does not support RunnableConfig and there are no indications that it will in the near future. Transitioning to the new AgentExecutor is recommended for leveraging RunnableConfig and other advanced features.

For memory transition, you can populate Agentstate.messages from DynamoDb before the graph workflow. Here’s how you can achieve this:

1. Fetch Messages from DynamoDb: Retrieve the messages from DynamoDb and store them in a list.
2. Initialize the Agent with the Retrieved Messages: Use the retrieved messages to initialize the agent's state.

Here’s an example:

import boto3
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

# Initialize DynamoDB client
dynamodb = boto3.client('dynamodb')

# Function to fetch messages from DynamoDb
def fetch_messages_from_dynamodb(table_name, session_id):
    response = dynamodb.query(
        TableName=table_name,
        KeyConditionExpression='session_id = :session_id',
        ExpressionAttributeValues={
            ':session_id': {'S': session_id}
        }
    )
    messages = [(item['role']['S'], item['content']['S']) for item in response['Items']]
    return messages

# Fetch messages from DynamoDb
table_name = 'YourDynamoDbTableName'
session_id = 'your-session-id'
messages = fetch_messages_from_dynamodb(table_name, session_id)

# Initialize the model and tools
model = ChatOpenAI(model="gpt-4o")
tools = [get_items, where_cat_is_hiding]  # Assuming these tools are defined elsewhere

# Create the agent with the retrieved messages
app = create_react_agent(model, tools)

# Initialize the agent's state with the retrieved messages
config = {"configurable": {"thread_id": session_id}}
response = app.invoke({"messages": messages}, config=config)

# Print the output
print(response["messages"][-1].content)

This approach ensures that the agent's state is correctly initialized with the retrieved messages from DynamoDb before executing the graph workflow ^[1][2].

To continue talking to Dosu, mention @dosu.

[rhlarora84]

Thanks @dosu. This should work and I can save the response once the agent has completed processing.

I also need to add the system message which I can do through state_modifier. May be the state_modifier with a Runnable is another approach here.