ReAct Pattern: The Most Important Agentic Pattern

import json
import math
import openai

# Tool implementations
def calculator(expression: str) -> str:
    """Evaluates a math expression safely."""
    try:
        allowed = {
            "abs": abs, "round": round,
            "min": min, "max": max,
            "sqrt": math.sqrt, "pow": pow
        }
        result = eval(expression, {"__builtins__": {}}, allowed)
        return str(result)
    except Exception as e:
        return f"Error: {e}"

def search(query: str) -> str:
    """Simulates a web search. Replace with real API."""
    # In production, call Google/Bing/Tavily API here
    knowledge = {
        "population of france": "The population of France in 2024 is approximately 68.4 million.",
        "population of germany": "The population of Germany in 2024 is approximately 84.5 million.",
        "eiffel tower height": "The Eiffel Tower is 330 meters tall including antennas.",
    }
    for key, value in knowledge.items():
        if key in query.lower():
            return value
    return f"No results found for: {query}"

# Registry mapping tool names to functions
TOOLS = {
    "calculator": calculator,
    "search": search,
    "finish": None  # special action to end the loop
}

SYSTEM_PROMPT = """You are a helpful assistant that answers questions
by reasoning step by step and using tools when needed.

You have access to these tools:
- search(query): Search for factual information
- calculator(expression): Evaluate math expressions
- finish(answer): Return the final answer to the user

For each step, you MUST respond in EXACTLY this format:

Thought: [your reasoning about what to do next]
Action: [tool_name]
Action Input: [input to the tool]

When you have enough information to answer, use:

Thought: [your final reasoning]
Action: finish
Action Input: [your complete final answer]

RULES:
- Always start with a Thought before taking an Action
- Use one tool per step
- Wait for the Observation before your next Thought
- Do NOT make up facts. Use the search tool to verify information
- If a tool returns an error, try a different approach
"""

def run_react_agent(question: str, max_iterations: int = 10) -> str:
    client = openai.OpenAI()

    # Start with the user's question
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": question}
    ]

    for i in range(max_iterations):
        # Ask the model to think and pick an action
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            temperature=0
        )
        assistant_message = response.choices[0].message.content
        messages.append({"role": "assistant", "content": assistant_message})

        # Parse the action from the model's output
        action, action_input = parse_action(assistant_message)

        if action is None:
            # Model didn't follow the format, nudge it
            messages.append({
                "role": "user",
                "content": "Please respond using the Thought/Action/Action Input format."
            })
            continue

        # Check if the model wants to finish
        if action == "finish":
            return action_input

        # Execute the tool
        if action not in TOOLS:
            observation = f"Error: Unknown tool '{action}'. Available tools: {list(TOOLS.keys())}"
        else:
            observation = TOOLS[action](action_input)

        # Append the observation and loop back
        messages.append({
            "role": "user",
            "content": f"Observation: {observation}"
        })

        print(f"--- Step {i + 1} ---")
        print(f"Thought + Action: {assistant_message}")
        print(f"Observation: {observation}\n")

    return "Agent stopped: reached maximum iterations without finishing."


def parse_action(text: str):
    """Extract action and action input from model output."""
    action = None
    action_input = None

    for line in text.strip().split("\n"):
        if line.startswith("Action:") and "Action Input" not in line:
            action = line.split("Action:", 1)[1].strip().lower()
        elif line.startswith("Action Input:"):
            action_input = line.split("Action Input:", 1)[1].strip()

    return action, action_input

if __name__ == "__main__":
    answer = run_react_agent(
        "What is the combined population of France and Germany? "
        "Give me the exact sum."
    )
    print(f"\nFinal Answer: {answer}")

--- Step 1 ---
Thought: I need to find the population of France first.
Action: search
Action Input: population of France
Observation: The population of France in 2024 is approximately 68.4 million.

--- Step 2 ---
Thought: Now I need the population of Germany.
Action: search
Action Input: population of Germany
Observation: The population of Germany in 2024 is approximately 84.5 million.

--- Step 3 ---
Thought: I have both numbers. Let me add them.
Action: calculator
Action Input: 68.4 + 84.5
Observation: 152.9

--- Step 4 ---
Thought: I now have the combined population.
Action: finish
Action Input: The combined population of France and Germany is approximately 152.9 million.

Final Answer: The combined population of France and Germany is approximately 152.9 million.