GPT vs Claude Comprehensive Comparison

import time
import openai
import anthropic

# Performance benchmark comparison
class ModelBenchmark:
    def __init__(self, openai_key, anthropic_key):
        self.openai_client = openai.OpenAI(
            api_key=openai_key,
            base_url="https://api.n1n.ai/v1"
        )
        self.anthropic_client = anthropic.Anthropic(
            api_key=anthropic_key,
            base_url="https://api.n1n.ai/v1"
        )
    
    def test_response_time(self, prompt):
        # Test GPT-4o
        start = time.time()
        gpt_response = self.openai_client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=500
        )
        gpt_time = time.time() - start
        
        # Test Claude
        start = time.time()
        claude_response = self.anthropic_client.messages.create(
            model="claude-3-5-sonnet-20241022",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=500
        )
        claude_time = time.time() - start
        
        return {
            "gpt-4o": {"time": gpt_time, "response": gpt_response},
            "claude-3.5": {"time": claude_time, "response": claude_response}
        }

# Intelligent model selection by use case
def select_model(task_type, requirements):
    """Recommend the best model based on task type"""
    
    if task_type == "coding":
        if requirements.get("quality") == "high":
            return "gpt-4o"  # Strongest coding capability
        else:
            return "gpt-4o-mini"  # Cost-effective
    
    elif task_type == "creative_writing":
        if requirements.get("context_length", 0) > 100000:
            return "claude-3-5-sonnet"  # 200K context
        else:
            return "gpt-4o"  # Balanced choice
    
    elif task_type == "customer_service":
        if requirements.get("cost") == "low":
            return "claude-3-5-haiku"  # Lowest cost
        else:
            return "gpt-4o-mini"  # Fast response
    
    elif task_type == "data_analysis":
        return "gpt-4o"  # Strong mathematical reasoning
    
    elif task_type == "research":
        return "claude-3-5-sonnet"  # Deep analysis capability
    
    return "gpt-4o-mini"  # Default choice

# Cost calculator
class CostOptimizer:
    # Pricing (per 1M tokens)
    PRICING = {
        "gpt-4o": {"input": 2.50, "output": 10.00},
        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
        "claude-3-5-sonnet": {"input": 3.00, "output": 15.00},
        "claude-3-5-haiku": {"input": 0.25, "output": 1.25}
    }
    
    @classmethod
    def estimate_cost(cls, model, input_tokens, output_tokens):
        """Estimate API call cost"""
        pricing = cls.PRICING[model]
        input_cost = (input_tokens / 1_000_000) * pricing["input"]
        output_cost = (output_tokens / 1_000_000) * pricing["output"]
        
        return {
            "model": model,
            "input_cost": round(input_cost, 4),
            "output_cost": round(output_cost, 4),
            "total_cost": round(input_cost + output_cost, 4)
        }