Comprehensive comparison for AI technology in Agent Framework applications

import os
from typing import Dict, List, Optional
import autogen
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager
from autogen.agentchat.contrib.retrieve_assistant_agent import RetrieveAssistantAgent
from autogen.agentchat.contrib.retrieve_user_proxy_agent import RetrieveUserProxyAgent

# Configuration for LLM
config_list = [
    {
        "model": "gpt-4",
        "api_key": os.environ.get("OPENAI_API_KEY"),
        "temperature": 0.7,
    }
]

llm_config = {
    "timeout": 600,
    "cache_seed": 42,
    "config_list": config_list,
}

class CustomerSupportSystem:
    """Production-grade customer support system using AutoGen agents."""
    
    def __init__(self):
        self.initialize_agents()
    
    def initialize_agents(self) -> None:
        """Initialize all agents with proper error handling."""
        try:
            # Triage agent: Routes customer queries to appropriate handlers
            self.triage_agent = AssistantAgent(
                name="TriageAgent",
                system_message="""You are a customer support triage agent. 
                Analyze customer queries and categorize them as: BILLING, TECHNICAL, or GENERAL.
                Provide a brief summary and severity level (LOW, MEDIUM, HIGH).
                Format: CATEGORY|SEVERITY|SUMMARY""",
                llm_config=llm_config,
            )
            
            # Billing specialist agent
            self.billing_agent = AssistantAgent(
                name="BillingSpecialist",
                system_message="""You are a billing specialist. Handle payment issues, 
                refunds, subscription changes, and invoice queries. Be precise with numbers 
                and always verify account details before suggesting actions.""",
                llm_config=llm_config,
            )
            
            # Technical support agent
            self.tech_agent = AssistantAgent(
                name="TechnicalSupport",
                system_message="""You are a technical support engineer. Diagnose technical 
                issues, provide troubleshooting steps, and escalate complex problems. 
                Always ask for system information when relevant.""",
                llm_config=llm_config,
            )
            
            # User proxy for human interaction
            self.user_proxy = UserProxyAgent(
                name="CustomerProxy",
                human_input_mode="NEVER",
                max_consecutive_auto_reply=10,
                is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),
                code_execution_config=False,
            )
            
        except Exception as e:
            raise RuntimeError(f"Failed to initialize agents: {str(e)}")
    
    def route_query(self, customer_query: str) -> Dict[str, str]:
        """Route customer query through triage and appropriate specialist."""
        if not customer_query or not isinstance(customer_query, str):
            return {"error": "Invalid query format", "status": "failed"}
        
        try:
            # Step 1: Triage the query
            self.user_proxy.initiate_chat(
                self.triage_agent,
                message=f"Triage this customer query: {customer_query}"
            )
            
            triage_response = self.user_proxy.last_message()["content"]
            
            # Parse triage response
            if "|" in triage_response:
                category, severity, summary = triage_response.split("|", 2)
                category = category.strip()
            else:
                category = "GENERAL"
                severity = "MEDIUM"
                summary = triage_response
            
            # Step 2: Route to appropriate specialist
            if "BILLING" in category.upper():
                specialist = self.billing_agent
            elif "TECHNICAL" in category.upper():
                specialist = self.tech_agent
            else:
                specialist = self.triage_agent
            
            # Step 3: Get specialist response
            self.user_proxy.initiate_chat(
                specialist,
                message=f"Handle this {category} issue (Severity: {severity}): {customer_query}"
            )
            
            specialist_response = self.user_proxy.last_message()["content"]
            
            return {
                "status": "success",
                "category": category,
                "severity": severity,
                "summary": summary.strip(),
                "resolution": specialist_response,
                "agent": specialist.name
            }
            
        except Exception as e:
            return {
                "status": "error",
                "error": str(e),
                "fallback_message": "We're experiencing technical difficulties. A human agent will contact you shortly."
            }

# Example usage
if __name__ == "__main__":
    support_system = CustomerSupportSystem()
    
    # Test queries
    queries = [
        "I was charged twice for my subscription this month",
        "The application keeps crashing when I try to export data",
        "How do I change my account email address?"
    ]
    
    for query in queries:
        print(f"\nProcessing: {query}")
        result = support_system.route_query(query)
        print(f"Result: {result}")