How can I retrieve a DataFrame as a local variable after LangChain ReAct agent execution?

Below is an explanation of why you’re seeing the summary dictionary and how to adjust your workflow.

Why the Agent Returns a Summary

The ReAct agent is designed for iterative reasoning and text-based responses. When you call
agent_executor.invoke({"input": user_prompt}) the agent internally executes a series of steps (via tools such as the Python REPL) and then returns its final descriptive answer as text. This is why you see a dictionary summarizing the steps rather than a raw Python object like a DataFrame.

Approaches to Retrieve the Pandas DataFrame

There are two main approaches:

1. Call the Tool Directly

Since the tool function load_excel_response correctly returns the DataFrame, you can bypass the agent and call it directly:

PYTHONCopied
# Direct call, bypassing the agent
df = load_excel_response(filepath=path)
print(df.head())

This way, you directly obtain the DataFrame in your main script without going through the ReAct chain.

2. Use a Custom Wrapper to Capture the Output

If you wish to keep the agent orchestration and still obtain the object, you have a couple options:

• Custom Logging / Callback:
  Modify your tool or agent so that when the tool is invoked it not only returns a DataFrame but also stores it in a shared location (for example, a global variable or an attribute on a custom object). Then, after invoking the agent, you can retrieve it from that shared location. For example:

  PYTHONCopied
  # Define a shared registry where the tool can store its output
  shared_outputs = {}
  
  @tool
  def load_excel_response(filepath: str):
      """Load an Excel file and return a transformed DataFrame."""
      df = pd.read_excel(filepath, skiprows=2, names=["responses"]).reset_index(drop=True)
      df = df.select_dtypes(include=["object"])
      # Store the DataFrame in a global dictionary
      shared_outputs["df"] = df
      return f"DataFrame loaded with shape {df.shape}"
  
  # Invoke agent as usual
  response = agent_executor.invoke({"input": user_prompt})
  print("Agent response:", response)
  
  # Retrieve the DataFrame from the shared registry
  df = shared_outputs.get("df")
  if df is not None:
      print("DataFrame recovered locally:")
      print(df.head())
  else:
      print("DataFrame not found.")

• Return a Serialized Representation:
  You might consider modifying the tool to serialize the DataFrame (for example, using df.to_json()) so that it can be included in the output. Then after the agent execution you can parse the string back into a DataFrame:

  PYTHONCopied
  @tool
  def load_excel_response(filepath: str):
      """Load an Excel file and return a transformed DataFrame as JSON."""
      df = pd.read_excel(filepath, skiprows=2, names=["responses"]).reset_index(drop=True)
      df = df.select_dtypes(include=["object"])
      # Convert the DataFrame to JSON, which can be reconstituted later
      return df.to_json(orient="split")
  
  # Then later:
  import json
  response = agent_executor.invoke({"input": user_prompt})
  # Assuming the JSON is included in the agent's final message, extract it
  json_str = response.get("output")  # or wherever the agent includes it
  df = pd.read_json(json_str, orient="split")
  print(df.head())

Note: The above serialization approach requires the agent to use the JSON string rather than a raw DataFrame if you want to obtain the full data in your script.

Recommendation

For most cases—especially when you need the raw data—the simplest solution is to either:

• Call your data processing function (load_excel_response) directly before or after using the agent.
• Use a shared location or modify your tool’s behavior so that it saves the result in a variable accessible by your main script.

The LangChain ReAct agents are primarily designed for natural language interactions and may not return raw data objects by default.

By adopting one of these approaches, you will be able to retrieve and work with your DataFrame locally in your main script.