User: "Analyze our Q1 sales data"
    ↓
ChatGPT: Waits for user to paste data
    ↓
Returns: "Sales increased 15%..."

User: "Analyze our Q1 sales data"
    ↓
Agent: "I need to fetch our database. Let me query the sales table."
    ↓
Agent: Makes API call to database
    ↓
Agent: "I got the data. Let me calculate trends..."
    ↓
Agent: "Sales increased 15%. Let me generate a report and save it."
    ↓
Agent: Creates file, emails stakeholders
    ↓
User receives: Full report in email

1. Observe: What's the current state?
2. Think: What should I do next?
3. Act: Execute action (API call, code, etc.)
4. Evaluate: Did it work? What's the new state?
5. Repeat until goal is achieved

Goal: "Book a flight from NYC to LA for March 15"

Loop 1:
- Observe: No flights booked yet
- Think: Need to search flights
- Act: Call flight search API
- Evaluate: Got 5 options, prices $300–500

Loop 2:
- Observe: Flight options available
- Think: User prefers early morning, cheapest
- Act: Filter flights (6am, <$350)
- Evaluate: Found Southwest 6:30am for $299

Loop 3:
- Observe: Selected flight, need payment
- Think: Ask user for payment
- Act: Process payment
- Evaluate: Booked! Confirmation sent

from langchain.agents import load_tools, initialize_agent
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI

# Create LLM
llm = ChatOpenAI(model="gpt-4", temperature=0)

# Load built-in tools
tools = load_tools([
    "google-search",      # Web search
    "python_repl",         # Execute Python code
    "requests"             # HTTP requests
])

# Initialize agent
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.OPENAI_FUNCTIONS,
    verbose=True
)

# Run agent
response = agent.run("What's the current price of Bitcoin?")
# Agent searches web, parses data, returns answer

from langchain.agents import Tool
from langchain.utilities import GoogleSearchAPIWrapper
    """Query sales database"""
    results = db.execute(query)
def send_email(to: str, subject: str, body: str) -> str:
    """Send email"""
    mailer.send(to=to, subject=subject, body=body)
    return "Email sent"

# Convert to LangChain tools
tools = [
    Tool(
        name="Database",
        func=query_sales_database,
        description="Query the sales database. Use SQL."
    ),
    Tool(
        name="Email",
        func=send_email,
        description="Send an email"
    ),
]

# Use in agent
agent = initialize_agent(tools, llm, agent=AgentType.OPENAI_FUNCTIONS)
agent.run("Email our team about this month's sales figures")

from langchain.agents import AgentExecutor
from langchain.prompts import ChatPromptTemplate
from langchain.schema import AgentAction, AgentFinish

class SalesAnalysisAgent:
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = {tool.name: tool for tool in tools}
        self.history = []

    def run(self, goal: str):
        state = {
            "goal": goal,
            "current_step": 0,
            "results": {},
        }

        max_iterations = 10
        for i in range(max_iterations):
            # Think: What's the next step?
            thought = self.llm.predict(
                f"Goal: {goal}\nCurrent results: {state['results']}\n\n" +
                f"What should you do next?"
            )

            # Decide: Which tool to use?
            if "query database" in thought.lower():
                # Act: Query database
                results = self.tools["Database"].func(
                    "SELECT * FROM sales WHERE date > '2026-01-01'"
                )
                state["results"]["query"] = results
            elif "analyze" in thought.lower():
                # Act: Analyze
                analysis = f"Sales data shows {results}"

            state["current_step"] = i


# Use it
agent = SalesAnalysisAgent(llm, tools)
report = agent.run("Generate Q1 sales report")

from langchain.agents import AgentType, initialize_agent
from langchain.chat_models import ChatOpenAI
from langchain.tools import Tool

# Simple, Python-first

from llama_index.agent import OpenAIAgent

# Data-focused agents

from autogen import AssistantAgent, UserProxyAgent

assistant = AssistantAgent("assistant")
user_proxy = UserProxyAgent("user")

# Multi-agent conversations

from crewai import Agent, Task, Crew

# Agent teams with specific roles

Goal: Analyze sales data
Loop 1: $0.01 (think)
Loop 2: $0.01 (act: query DB)
Loop 3: $0.01 (think)
Loop 4: $0.01 (act: analyze)
Loop 5: $0.01 (think)
...
Total: 20 loops × $0.01 = $0.20 per request

Initial prompt: 500 tokens
Loop 1 result: 200 tokens
Loop 2 result: 200 tokens
...
After 10 loops: 500 + (10 × 200) = 2500 tokens

Tool(
    name="QueryDatabase",
    func=query_db,
    description="Query sales database. Input: SQL query. Output: JSON results. "
                "Always use parameterized queries. Only SELECT queries allowed."
)

def run_agent(goal):
    agent = initialize_agent(...)
    result = agent.run(goal)
    
    # Verify result
    if "error" in result.lower():
        # Retry or escalate
        return retry_with_human_confirmation(goal)
    
    return result

import logging

logging.basicConfig(level=logging.DEBUG)

# Track every step
for step in agent.steps:
    print(f"Step: {step.action}")
    print(f"Tool used: {step.tool}")
    print(f"Result: {step.result}")