Request for Integrating AgentExecutor Functionality into LangGraph Reasoner Node for Python REPL Queries

[mraguth]

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

I am using this reference and I added 'python repl' to tools box. However, the reasoner is not executing the python code. Details are in the description.

https://colab.research.google.com/drive/14ncV0nviLcP9IDzmFSRGSXb7Bgpz212v?usp=sharing#scrollTo=RH1ap_Yuztf5

Description

I am using a simple re-act agent in LangGraph with a few tools. As an experiment, I added a Python REPL so that I can query my DataFrame using pandas functions. However, my re-act node called 'reasoner' lacks the AgentExecutor functionality. As a result, my Python DataFrame queries are not executing correctly, despite having the REPL tool in my toolbox.

When I execute my Python queries via the AgentExecutor (as shown below), everything works great.

agent_executor = AgentExecutor(
    agent=agent, 
    tools=tools, 
    max_iterations=5, 
    early_stopping_method="generate",
    allow_dangerous_code=True,
    allow_dangerous_requests=True,
    agent_executor_kwargs={"handle_parsing_errors": True},
    verbose=False,
) | (lambda x: x["output"])

# Typing for playground inputs
class AgentInputs(BaseModel):
    input: str

agent_executor = agent_executor.with_types(input_type=AgentInputs)

But when I attempt to use the LangGraph node concept, the 'reasoner' node fails to return the Python query results, despite having the REPL tool.

def reasoner(state):
    query = state["query"]
    messages = state["messages"]
    # System message
    sys_msg = SystemMessage(content="You are a helpful assistant tasked with using python dataframe analyzer to analyze df dataframe and get valid insights, search tools, the yahoo finance tool and performing arithmetic on a set of inputs.")
    message = HumanMessage(content=query)
    messages.append(message)
    result = [llm_with_tools.invoke([sys_msg] + messages)]
    return {"messages":result}

tools = [add, multiply, divide, search, get_stock_price,repl, retriever_tool]

llm = llm
llm_with_tools = llm.bind_tools(tools)

My request is as follows: Is it possible to inject the AgentExecutor functionality into the above 'reasoner' node when the question pertains to the Python REPL? Please advise.

System Info

Name: langchain
Version: 0.3.0

[mraguth]

@dosu...or if you tell us how I incorporate agent_executor function in to regular react state, that would be great as well.

[mraguth]

@dosu can you give me an example how I incorporate my python 'agent_executor' below into a simple langgraph? can you give me a small example, please?

agent_executor = AgentExecutor(
    agent=agent, 
    tools=tools, 
    max_iterations=5, 
    early_stopping_method="generate",
    allow_dangerous_code=True,
    allow_dangerous_requests=True,
    agent_executor_kwargs={"handle_parsing_errors": True},
    verbose=False,
) | (lambda x: x["output"])

# Typing for playground inputs
class AgentInputs(BaseModel):
    input: str

agent_executor = agent_executor.with_types(input_type=AgentInputs)

[dosubot[bot]]

To incorporate the agent_executor function into a LangGraph reasoner node to execute Python REPL queries, you can follow these steps:

1. Define the Tools: Create the tools you want to use, such as a search tool or a retriever.
2. Initialize the Language Model: Set up the language model and bind the tools to it.
3. Create the Agent: Use the create_python_agent function to create the agent with the language model and the Python REPL tool.
4. Combine Agent with Tools: Use the AgentExecutor to combine the agent with the tools.
5. Run the Agent: Execute the agent with the desired input.

Here is a code example based on your requirements:

from langchain_community.tools.tavily_search import TavilySearchResults
from langchain_community.document_loaders import WebBaseLoader
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain.tools.retriever import create_retriever_tool
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_experimental.tools.python.tool import PythonREPLTool
from langchain_experimental.agents.agent_toolkits.python.base import create_python_agent
from langchain_core.prompts import ChatPromptTemplate
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_core.pydantic_v1 import BaseModel, Field
from typing import Annotated, Sequence, TypedDict
import operator
import pandas as pd
import io
import base64
from PIL import Image
from IPython.display import display

# Define the tools
search = TavilySearchResults(max_results=2)
loader = WebBaseLoader("https://docs.smith.langchain.com/overview")
docs = loader.load()
documents = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200).split_documents(docs)
vector = FAISS.from_documents(documents, OpenAIEmbeddings())
retriever = vector.as_retriever()
retriever_tool = create_retriever_tool(retriever, "langsmith_search", "Search for information about LangSmith. For any questions about LangSmith, you must use this tool!")
python_repl_tool = PythonREPLTool()
tools = [search, retriever_tool, python_repl_tool]

# Initialize the language model
model = ChatOpenAI(model="gpt-4")

# Create the agent
agent = create_python_agent(llm=model, tool=python_repl_tool)

# Combine agent with tools inside AgentExecutor
agent_executor = AgentExecutor(agent=agent, tools=tools)

# Define the state and nodes for LangGraph
class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], operator.add]

class RawToolMessage(ToolMessage):
    raw: dict
    tool_name: str

def call_model(state: AgentState) -> dict:
    messages = []
    chain = prompt | model_with_tools
    messages.append(chain.invoke({"messages": state["messages"]}))
    return {"messages": messages}

def execute_python(state: AgentState) -> dict:
    messages = []
    df_code = _upload_dfs_to_repl(state)
    last_ai_msg = [msg for msg in state["messages"] if isinstance(msg, AIMessage)][-1]
    for tool_call in last_ai_msg.tool_calls:
        if tool_call["name"] != "python_shell":
            continue
        generated_code = tool_call["args"]["code"]
        repl_result = repl.execute(df_code + "\n" + generated_code)
        messages.append(
            RawToolMessage(
                _repl_result_to_msg_content(repl_result),
                raw=repl_result,
                tool_call_id=tool_call["id"],
                tool_name=tool_call["name"],
            )
        )
    return {"messages": messages}

def _upload_dfs_to_repl(state: AgentState) -> str:
    df_dicts = [
        msg.raw
        for msg in state["messages"]
        if isinstance(msg, RawToolMessage) and msg.tool_name == "create_df_from_sql"
    ]
    name_df_map = {name: df for df_dict in df_dicts for name, df in df_dict.items()}
    for name, df in name_df_map.items():
        buffer = io.StringIO()
        df.to_csv(buffer)
        buffer.seek(0)
        repl.upload_file(data=buffer, remote_file_path=name + ".csv")
    df_code = "import pandas as pd\n" + "\n".join(
        f"{name} = pd.read_csv('/mnt/data/{name}.csv')" for name in name_df_map
    )
    return df_code

def _repl_result_to_msg_content(repl_result: dict) -> str:
    content = {}
    for k, v in repl_result.items():
        if isinstance(repl_result[k], dict) and repl_result[k]["type"] == "image":
            base64_str = repl_result[k]["base64_data"]
            img = Image.open(io.BytesIO(base64.decodebytes(bytes(base64_str, "utf-8"))))
            display(img)
        else:
            content[k] = repl_result[k]
    return json.dumps(content, indent=2)

def should_continue(state: AgentState) -> str:
    return "execute_python" if state["messages"][-1].tool_calls else END

# Define the graph
workflow = StateGraph(AgentState)
workflow.add_node("call_model", call_model)
workflow.add_node("execute_python", execute_python)
workflow.set_entry_point("call_model")
workflow.add_conditional_edges("call_model", should_continue)

app = workflow.compile()

# Run the agent
response = agent_executor.invoke({"input": "hi!"})
print(response)

response = agent_executor.invoke({"input": "how can langsmith help with testing?"})
print(response)

response = agent_executor.invoke({"input": "whats the weather in sf?"})
print(response)

This code sets up the necessary tools, initializes the language model, creates the agent using create_python_agent, combines it with the tools using AgentExecutor, and runs the agent with different inputs. Additionally, it demonstrates how to use prompt templates and system messages to control the agent's behavior, which is essential when migrating from legacy LangChain agents to LangGraph ^[1][2][3][4].

To continue talking to Dosu, mention @dosu.

[mraguth]

@dosu Getting error 'NameError: name 'ToolMessage' is not defined'... please help

[dosubot[bot]]

To resolve the 'NameError: name 'ToolMessage' is not defined' error, you need to ensure that you have imported ToolMessage from the appropriate module. Add the following import statement to your code:

from langchain_core.messages.tool import ToolMessage

Here is the corrected code snippet:

from langchain_core.messages import HumanMessage
from langchain_core.messages.tool import ToolMessage

query = "What is 3 * 12? Also, what is 11 + 49?"

messages = [HumanMessage(query)]

ai_msg = llm_with_tools.invoke(messages)

print(ai_msg.tool_calls)

messages.append(ai_msg)

for tool_call in ai_msg.tool_calls:
    selected_tool = {"add": add, "multiply": multiply}[tool_call["name"].lower()]
    tool_msg = selected_tool.invoke(tool_call)
    messages.append(tool_msg)

messages

This should resolve the NameError by ensuring that ToolMessage is defined in your implementation ^[1][2][3].

To continue talking to Dosu, mention @dosu.