1. Initialize: Agent receives task/question
2. Loop until task is solved or max iterations:
   a. Generate Thought: Model reasons about current state and next step
   b. Generate Action: Model decides which tool to call with what parameters
   c. Execute Action: System executes the tool call
   d. Generate Observation: System returns result to the agent
   e. Append to context: Add (Thought, Action, Observation) to conversation history
3. Generate Final Answer based on accumulated observations

Question: What is the population of the capital of France?

Thought 1: I need to first identify the capital of France.
Action 1: Search[capital of France]
Observation 1: Paris is the capital and most populous city of France.

Thought 2: Now I know Paris is the capital. I need to find its population.
Action 2: Search[population of Paris]
Observation 2: The population of Paris is approximately 2.1 million (city proper) and 10.9 million (metropolitan area).

Thought 3: I have found the information needed to answer the question.
Action 3: Finish[The population of Paris is approximately 2.1 million]

class ReActAgent:
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = {tool.name: tool for tool in tools}
        self.max_iterations = 10
    
    def run(self, task):
        context = [{"role": "user", "content": task}]
        
        for i in range(self.max_iterations):
            # Generate Thought + Action
            response = self.llm.generate(context)
            
            # Parse the response
            thought = self.extract_thought(response)
            action_name, action_input = self.extract_action(response)
            
            # Execute action
            if action_name == "Finish":
                return action_input
            
            tool = self.tools.get(action_name)
            observation = tool.execute(action_input)
            
            # Append to context
            context.append({
                "role": "assistant",
                "content": f"Thought: {thought}\nAction: {action_name}[{action_input}]"
            })
            context.append({
                "role": "user",
                "content": f"Observation: {observation}"
            })
        
        return "Max iterations reached"

from typing import List, Dict, Callable
import openai

class Tool:
    def __init__(self, name: str, description: str, func: Callable):
        self.name = name
        self.description = description
        self.func = func
    
    def execute(self, input_str: str) -> str:
        return self.func(input_str)

# Define some simple tools
def search_tool(query: str) -> str:
    """Simulated search - in practice, call a real API"""
    knowledge_base = {
        "capital of France": "Paris is the capital of France.",
        "population of Paris": "Paris has a population of approximately 2.1 million in the city proper.",
        "Eiffel Tower height": "The Eiffel Tower is 330 meters (1,083 ft) tall."
    }
    return knowledge_base.get(query.lower(), "No information found.")

def calculator_tool(expression: str) -> str:
    """Safe calculator"""
    try:
        result = eval(expression, {"__builtins__": {}}, {})
        return str(result)
    except:
        return "Invalid expression"

# Create ReAct Agent
class SimpleReActAgent:
    def __init__(self, model="gpt-4"):
        self.model = model
        self.tools = [
            Tool("Search", "Search for information", search_tool),
            Tool("Calculator", "Perform calculations", calculator_tool),
        ]
        self.max_iterations = 5
    
    def create_prompt(self, task: str, history: List[Dict]) -> str:
        """Build the ReAct prompt"""
        tool_descriptions = "\n".join([
            f"{tool.name}: {tool.description}" for tool in self.tools
        ])
        
        prompt = f"""You are an agent that solves tasks by reasoning and acting.

Available tools:
{tool_descriptions}

Use this format:
Thought: [your reasoning about what to do next]
Action: [ToolName][input]

When you have the final answer:
Thought: [reasoning about the answer]
Action: Finish[final answer]

Task: {task}

"""
        # Append history
        for entry in history:
            prompt += entry + "\n"
        
        return prompt
    
    def parse_response(self, text: str) -> tuple:
        """Extract thought and action from LLM response"""
        lines = text.strip().split("\n")
        thought = ""
        action_name = ""
        action_input = ""
        
        for line in lines:
            if line.startswith("Thought:"):
                thought = line.replace("Thought:", "").strip()
            elif line.startswith("Action:"):
                action_part = line.replace("Action:", "").strip()
                # Parse Action: ToolName[input]
                if "[" in action_part:
                    action_name = action_part.split("[")[0].strip()
                    action_input = action_part.split("[")[1].rstrip("]")
        
        return thought, action_name, action_input
    
    def run(self, task: str) -> str:
        """Execute the ReAct loop"""
        history = []
        
        for iteration in range(self.max_iterations):
            # Generate prompt
            prompt = self.create_prompt(task, history)
            
            # Call LLM
            response = openai.ChatCompletion.create(
                model=self.model,
                messages=[{"role": "user", "content": prompt}],
                temperature=0
            )
            
            llm_output = response.choices[0].message.content
            thought, action_name, action_input = self.parse_response(llm_output)
            
            print(f"\n--- Iteration {iteration + 1} ---")
            print(f"Thought: {thought}")
            print(f"Action: {action_name}[{action_input}]")
            
            # Check if finished
            if action_name == "Finish":
                return action_input
            
            # Execute action
            tool = next((t for t in self.tools if t.name == action_name), None)
            if tool:
                observation = tool.execute(action_input)
            else:
                observation = f"Unknown tool: {action_name}"
            
            print(f"Observation: {observation}")
            
            # Update history
            history.append(f"Thought: {thought}")
            history.append(f"Action: {action_name}[{action_input}]")
            history.append(f"Observation: {observation}")
        
        return "Failed to complete task within max iterations"

# Example usage
if __name__ == "__main__":
    agent = SimpleReActAgent()
    result = agent.run("What is the height of the Eiffel Tower in meters?")
    print(f"\n=== Final Answer ===\n{result}")