Comprehensive comparison for AI technology in applications

import cohere
import os
from typing import List, Dict, Optional
from datetime import datetime
import logging

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

class CustomerSupportClassifier:
    """
    Production-ready customer support ticket classifier using Cohere.
    Classifies incoming support tickets and generates appropriate responses.
    """
    
    def __init__(self, api_key: Optional[str] = None):
        """Initialize Cohere client with API key from environment or parameter."""
        self.api_key = api_key or os.getenv('COHERE_API_KEY')
        if not self.api_key:
            raise ValueError("Cohere API key must be provided or set in COHERE_API_KEY env variable")
        
        self.client = cohere.Client(self.api_key)
        self.categories = ['billing', 'technical_support', 'account_management', 'general_inquiry']
    
    def classify_ticket(self, ticket_text: str) -> Dict:
        """Classify support ticket into predefined categories."""
        try:
            examples = [
                cohere.ClassifyExample(text="I was charged twice for my subscription", label="billing"),
                cohere.ClassifyExample(text="My account won't let me log in", label="technical_support"),
                cohere.ClassifyExample(text="How do I update my email address?", label="account_management"),
                cohere.ClassifyExample(text="What are your business hours?", label="general_inquiry"),
                cohere.ClassifyExample(text="Refund request for incorrect charge", label="billing"),
                cohere.ClassifyExample(text="App keeps crashing on startup", label="technical_support")
            ]
            
            response = self.client.classify(
                model='embed-english-v3.0',
                inputs=[ticket_text],
                examples=examples
            )
            
            classification = response.classifications[0]
            
            return {
                'category': classification.prediction,
                'confidence': classification.confidence,
                'timestamp': datetime.utcnow().isoformat(),
                'success': True
            }
            
        except cohere.CohereError as e:
            logger.error(f"Cohere API error during classification: {str(e)}")
            return {'success': False, 'error': str(e)}
        except Exception as e:
            logger.error(f"Unexpected error during classification: {str(e)}")
            return {'success': False, 'error': 'Internal classification error'}
    
    def generate_response(self, ticket_text: str, category: str) -> Dict:
        """Generate an appropriate response based on ticket category."""
        try:
            prompt = f"""You are a helpful customer support agent. A customer has submitted a {category} ticket.

Customer message: {ticket_text}

Provide a professional, empathetic response that addresses their concern. Keep it concise and actionable.

Response:"""
            
            response = self.client.generate(
                model='command',
                prompt=prompt,
                max_tokens=200,
                temperature=0.7,
                stop_sequences=["\n\n"]
            )
            
            return {
                'response': response.generations[0].text.strip(),
                'success': True
            }
            
        except cohere.CohereError as e:
            logger.error(f"Cohere API error during generation: {str(e)}")
            return {'success': False, 'error': str(e)}
        except Exception as e:
            logger.error(f"Unexpected error during generation: {str(e)}")
            return {'success': False, 'error': 'Internal generation error'}
    
    def process_ticket(self, ticket_text: str) -> Dict:
        """Complete workflow: classify ticket and generate response."""
        if not ticket_text or len(ticket_text.strip()) == 0:
            return {'success': False, 'error': 'Empty ticket text provided'}
        
        # Classify the ticket
        classification_result = self.classify_ticket(ticket_text)
        
        if not classification_result.get('success'):
            return classification_result
        
        # Generate response based on classification
        generation_result = self.generate_response(
            ticket_text,
            classification_result['category']
        )
        
        if not generation_result.get('success'):
            return generation_result
        
        return {
            'success': True,
            'category': classification_result['category'],
            'confidence': classification_result['confidence'],
            'suggested_response': generation_result['response'],
            'processed_at': classification_result['timestamp']
        }

# Example usage
if __name__ == '__main__':
    classifier = CustomerSupportClassifier()
    
    ticket = "I've been charged $99 but my subscription should only be $49 per month"
    result = classifier.process_ticket(ticket)
    
    if result['success']:
        print(f"Category: {result['category']}")
        print(f"Confidence: {result['confidence']:.2f}")
        print(f"Suggested Response: {result['suggested_response']}")
    else:
        print(f"Error: {result['error']}")