13. AutoGen & OpenAI Agents SDK

flowchart LR
    subgraph AUTOGEN["AutoGen — Conversational"]
        A1["User"] <--> A2["Planner Agent"]
        A2 <--> A3["Coder Agent"]
        A2 <--> A4["Reviewer Agent"]
        A3 <--> A5["Executor Agent"]
    end

    subgraph OPENAI_SDK["OpenAI Agents SDK — Production"]
        O1["User"] --> O2["Agent Runner"]
        O2 --> O3["Agent"]
        O3 --> O4["🛠️ Tools"]
        O3 --> O5["🛡️ Guardrails"]
        O3 --> O6["💾 Memory"]
        O2 --> O7["🔍 Tracing"]
    end

    style AUTOGEN fill:#3b82f6,color:#fff
    style OPENAI_SDK fill:#22c55e,color:#fff

sequenceDiagram
    participant User
    participant Planner
    participant Coder
    participant Executor

    User->>Planner: "Build a weather dashboard"
    Planner->>Coder: "Can you write the HTML/CSS for a weather dashboard?"
    Coder->>Coder: Generate code
    Coder-->>Planner: "Here's the HTML with weather cards"
    Planner->>Executor: "Can you test this in a browser?"
    Executor->>Executor: Run in headless browser
    Executor-->>Planner: "Renders correctly. But the API endpoint is missing."
    Planner->>Coder: "Add a mock API endpoint for testing"
    Coder-->>Planner: "Added. Updated the code."
    Planner-->>User: "✅ Dashboard is ready. Includes HTML and mock API."

flowchart TD
    subgraph AUTOGEN_ARCH["AutoGen Architecture"]
        AGENTS["🤖 Conversational Agents\nEach agent has a role and capabilities"]
        CHAT["💬 Agent Chat\nAgents communicate via messages"]
        ROUTING["🔀 Group Chat\nMultiple agents in one conversation"]
        TERM["⏹️ Termination\nConditions to end the conversation"]
        HITL["👤 Human-in-the-Loop\nHuman can join the conversation"]
    end

    AGENTS --> CHAT
    CHAT --> ROUTING
    ROUTING --> TERM
    TERM --> HITL

    style AUTOGEN_ARCH fill:#3b82f6,color:#fff

from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

# 1. Create agents
planner = AssistantAgent(
    name="Planner",
    system_message="You are a project planner. Break down tasks and coordinate work.",
    llm_config={"config_list": [{"model": "gpt-4", "api_key": "..."}]}
)

coder = AssistantAgent(
    name="Coder",
    system_message="You write Python code. Always include error handling.",
    llm_config={"config_list": [{"model": "gpt-4", "api_key": "..."}]}
)

reviewer = AssistantAgent(
    name="Reviewer",
    system_message="You review code for bugs, security issues, and best practices.",
    llm_config={"config_list": [{"model": "gpt-4", "api_key": "..."}]}
)

# 2. Set up group chat
group_chat = GroupChat(
    agents=[planner, coder, reviewer],
    messages=[],
    max_round=12  # Prevent infinite conversation
)

manager = GroupChatManager(
    groupchat=group_chat,
    llm_config={"config_list": [{"model": "gpt-4", "api_key": "..."}]}
)

# 3. Start the conversation
user_proxy = UserProxyAgent(name="User", human_input_mode="TERMINATE")
user_proxy.initiate_chat(
    manager,
    message="Create a Python script that fetches weather data from an API"
)

flowchart TD
    subgraph SDK["OpenAI Agents SDK"]
        RUNNER["🏃 Agent Runner\nExecutes agent loops"]
        AGENT["🤖 Agent\nCore reasoning unit"]
        TOOLS["🛠️ Tools\nFunctions the agent can call"]
        HANDOFFS["🤝 Handoffs\nPass to another agent"]
        GUARDRAILS["🛡️ Guardrails\nSafety & validation"]
        TRACING["🔍 Tracing\nObservability & debugging"]
        MEMORY["💾 Memory\nConversation history"]
    end

    USER["User Input"] --> RUNNER
    RUNNER --> AGENT
    AGENT --> TOOLS
    AGENT --> HANDOFFS
    RUNNER --> GUARDRAILS
    RUNNER --> TRACING
    RUNNER --> MEMORY

    style SDK fill:#3b82f6,color:#fff
    style RUNNER fill:#8b5cf6,color:#fff
    style AGENT fill:#f59e0b,color:#fff

from agents import Agent, Runner, function_tool, Guardrail, InputGuardrail

# 1. Define tools
@function_tool
def search_knowledge_base(query: str) -> str:
    """Search the internal knowledge base for information."""
    return f"Results for '{query}': [relevant documentation...]"

@function_tool
def get_customer_info(customer_id: str) -> dict:
    """Get customer account information."""
    return {"name": "Alice", "plan": "enterprise", "status": "active"}

# 2. Create specialized agents
support_agent = Agent(
    name="Support Agent",
    instructions="You are a helpful support agent. Use tools to help customers.",
    tools=[search_knowledge_base, get_customer_info]
)

billing_agent = Agent(
    name="Billing Agent",
    instructions="Handle billing and payment questions only.",
    tools=[get_invoice, process_refund]
)

# 3. Create router agent with handoffs
triage_agent = Agent(
    name="Triage Agent",
    instructions="Route customers to the right agent. Support questions → Support Agent. "
                 "Billing questions → Billing Agent.",
    handoffs=[support_agent, billing_agent]
)

# 4. Add guardrails
safety_guardrail = InputGuardrail(
    check=lambda msg: "harmful" not in msg.lower()
)

# 5. Run with tracing
result = Runner.run(
    triage_agent,
    input="I need help with my account",
    guardrails=[safety_guardrail],
    tracing=True  # Enables full observability
)

print(result.final_output)

flowchart TD
    QUESTION["Which framework should I choose?"]
    QUESTION --> Q1["Need custom,\nstateful workflows?"]
    Q1 -->|"Yes"| LANGGRAPH["LangGraph\nBest for: Complex agent\nworkflows with loops"]
    Q1 -->|"No"| Q2["Need role-based\nagent teams?"]
    Q2 -->|"Yes"| CREWAI["CrewAI\nBest for: Multi-agent\nteam collaboration"]
    Q2 -->|"No"| Q3["Need agent-to-agent\nconversations?"]
    Q3 -->|"Yes"| AUTOGEN["AutoGen\nBest for: Conversational\nmulti-agent systems"]
    Q3 -->|"No"| OPENAI["OpenAI Agents SDK\nBest for: Production-ready\nsingle/multi agents"]

    style QUESTION fill:#f59e0b,color:#fff
    style LANGGRAPH fill:#3b82f6,color:#fff
    style CREWAI fill:#8b5cf6,color:#fff
    style AUTOGEN fill:#22c55e,color:#fff
    style OPENAI fill:#ef4444,color:#fff