From Chatbot to Agent: Implementing the ReAct Pattern in Python

import os
from openai import OpenAI

# Setup OpenAI client (ensure OPENAI_API_KEY is set in environment)
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))

def query_llm(prompt):
    response = client.chat.completions.create(
        model="gpt-4o", # Or gpt-3.5-turbo
        messages=[
             {"role": "system", "content": "You are a helpful assistant."},
             {"role": "user", "content": prompt}
        ],
        temperature=0
    )
    return response.choices[0].message.content

# The difficult query
user_query = "What is the current stock price of Datadog (DDOG) multiplied by 1.5?"

print(f"User Query: {user_query}")
print("-" * 20)
print(query_llm(user_query))

# Output varies, but usually something like:
# "I cannot provide real-time stock prices as my data is not current..."
# Or worse, it hallucinates a number.

# In a real app, this would hit an external API (e.g., Alpha Vantage or Yahoo Finance)
def get_stock_price(ticker: str) -> str:
    """Useful for when you need to find the current price of a stock."""
    print(f"[TOOL LOG] Fetching price for {ticker}...")
    # Simulating mock data for stability
    mock_data = {
        "DDOG": "120.50",
        "GOOGL": "175.20"
    }
    return mock_data.get(ticker.upper(), "Error: Ticker not found")

def calculator(expression: str) -> str:
    """Useful for performing math calculations. Input must be a valid python expression."""
    print(f"[TOOL LOG] Calculating: {expression}...")
    try:
        # WARNING: eval() is dangerous in production without strict sandboxing. 
        # Using here for simplicity of tutorial.
        return str(eval(expression)) 
    except Exception as e:
        return f"Error calculating: {e}"

# Registry of available tools
tools_registry = {
    "get_stock_price": get_stock_price,
    "calculator": calculator

REACT_SYSTEM_PROMPT = """
You are an agent designed to answer questions requiring external information and math.
You have access to the following tools:

1. get_stock_price(ticker: str): Useful for when you need to find the current price of a stock.
2. calculator(expression: str): Useful for performing math calculations.

Use the following format rigorously:

Question: the input question you must answer
Thought: you should always think about what to do next. 
Action: the action to take, should be one of [get_stock_price, calculator]
Action Input: the input to the action, e.g., DDOG or 100 * 1.5
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!
"""

import re

def agent_execution_loop(user_query):
    # Initialize conversation history with the instructions
    history = [
        {"role": "system", "content": REACT_SYSTEM_PROMPT},
        {"role": "user", "content": f"Question: {user_query}"}
    ]

    max_steps = 5 # Safety mechanism to prevent infinite loops
    step_count = 0

    while step_count < max_steps:
        step_count += 1
        
        # 1. Call LLM with current history
        response = client.chat.completions.create(
            model="gpt-4o", 
            messages=history,
            temperature=0, # Keep temp low for deterministic actions
            stop=["Observation:"] # Stop generating before it tries to fake an observation
        )
        llm_output = response.choices[0].message.content
        print(f"--- Step {step_count} LLM Output ---")
        print(llm_output)
        
        # Append LLM's thought process to history
        history.append({"role": "assistant", "content": llm_output})

        # 2. Check for Final Answer
        if "Final Answer:" in llm_output:
            return llm_output.split("Final Answer:")[1].strip()

        # 3. Parse Action and Input using Regex
        # Looking for patterns like: Action: get_stock_price\nAction Input: DDOG
        action_match = re.search(r"Action: (\w+)", llm_output)
        input_match = re.search(r"Action Input: (.+)", llm_output)

        if action_match and input_match:
            tool_name = action_match.group(1)
            tool_input = input_match.group(1).strip()
            
            # 4. Execute Tool
            if tool_name in tools_registry:
                tool_function = tools_registry[tool_name]
                observation = tool_function(tool_input)
                
                observation_message = f"Observation: {observation}"
                print(f"--- Step {step_count} Output ---")
                print(observation_message)
                
                # Append observation to history so the LLM sees it next turn
                history.append({"role": "user", "content": observation_message})
            else:
                 history.append({"role": "user", "content": f"Observation: Error: Tool {tool_name} not found."})

    return "Error: Maximum steps reached without final answer."

# The difficult query again
user_query = "What is the current stock price of Datadog (DDOG) multiplied by 1.5?"

print(f"Starting ReAct Agent for: {user_query}\n")
final_result = agent_execution_loop(user_query)

print("\n" + "="*30)
print(f"FINAL RESULT: {final_result}")