Comprehensive comparison for AI technology in applications

import anthropic
import os
from typing import List, Dict, Optional
import json
import logging
from datetime import datetime

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class AICustomerSupportAgent:
    """
    Production-ready AI customer support agent using Anthropic's Claude API.
    Handles customer inquiries with context awareness and conversation history.
    """
    
    def __init__(self, api_key: Optional[str] = None):
        """
        Initialize the AI support agent with API credentials.
        
        Args:
            api_key: Anthropic API key. If None, reads from environment.
        """
        self.api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
        if not self.api_key:
            raise ValueError("ANTHROPIC_API_KEY must be set")
        
        self.client = anthropic.Anthropic(api_key=self.api_key)
        self.conversation_history: List[Dict[str, str]] = []
        
    def generate_response(
        self,
        user_message: str,
        customer_context: Optional[Dict] = None,
        max_tokens: int = 1024,
        temperature: float = 0.7
    ) -> Dict[str, any]:
        """
        Generate AI response to customer inquiry with context.
        
        Args:
            user_message: The customer's question or message
            customer_context: Additional context (order history, account info)
            max_tokens: Maximum tokens in response
            temperature: Response creativity (0.0-1.0)
            
        Returns:
            Dict containing response text, usage stats, and metadata
        """
        try:
            # Build system prompt with customer context
            system_prompt = self._build_system_prompt(customer_context)
            
            # Add user message to history
            self.conversation_history.append({
                "role": "user",
                "content": user_message
            })
            
            # Call Claude API
            response = self.client.messages.create(
                model="claude-3-5-sonnet-20241022",
                max_tokens=max_tokens,
                temperature=temperature,
                system=system_prompt,
                messages=self.conversation_history
            )
            
            # Extract assistant response
            assistant_message = response.content[0].text
            
            # Add to conversation history
            self.conversation_history.append({
                "role": "assistant",
                "content": assistant_message
            })
            
            logger.info(f"Generated response for user message: {user_message[:50]}...")
            
            return {
                "success": True,
                "response": assistant_message,
                "usage": {
                    "input_tokens": response.usage.input_tokens,
                    "output_tokens": response.usage.output_tokens
                },
                "timestamp": datetime.utcnow().isoformat(),
                "model": response.model
            }
            
        except anthropic.APIError as e:
            logger.error(f"API error: {str(e)}")
            return {
                "success": False,
                "error": "API error occurred",
                "details": str(e)
            }
        except Exception as e:
            logger.error(f"Unexpected error: {str(e)}")
            return {
                "success": False,
                "error": "Internal error",
                "details": str(e)
            }
    
    def _build_system_prompt(self, customer_context: Optional[Dict]) -> str:
        """
        Build system prompt with customer context for personalized responses.
        """
        base_prompt = (
            "You are a helpful customer support agent. "
            "Provide clear, concise, and empathetic responses. "
            "If you don't know something, admit it and offer to escalate."
        )
        
        if customer_context:
            context_str = json.dumps(customer_context, indent=2)
            base_prompt += f"\n\nCustomer Context:\n{context_str}"
        
        return base_prompt
    
    def reset_conversation(self):
        """Reset conversation history for new customer session."""
        self.conversation_history = []
        logger.info("Conversation history reset")


# Example usage
if __name__ == "__main__":
    agent = AICustomerSupportAgent()
    
    customer_info = {
        "customer_id": "12345",
        "tier": "premium",
        "recent_orders": ["ORD-001", "ORD-002"]
    }
    
    result = agent.generate_response(
        user_message="I haven't received my order ORD-002 yet. Can you help?",
        customer_context=customer_info
    )
    
    if result["success"]:
        print(f"AI Response: {result['response']}")
        print(f"Tokens used: {result['usage']}")
    else:
        print(f"Error: {result['error']}")