Managing and Reducing Costs › Measuring Cost Optimization Impact

import os
from anthropic import Anthropic
from datetime import datetime
import statistics

class CostAnalyzer:
    """Analyze and compare costs across different optimization strategies."""
    
    def __init__(self):
        self.client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
        self.baseline_costs = []
        self.optimized_costs = []
    
    def _calculate_cost(self, usage):
        """Calculate cost from token usage."""
        input_cost = (usage.input_tokens / 1_000_000) * 3.00
        output_cost = (usage.output_tokens / 1_000_000) * 15.00
        return input_cost + output_cost
    
    def run_baseline(self, queries):
        """Run queries without optimization."""
        print("Running baseline (no optimization)...")
        
        for query in queries:
            response = self.client.messages.create(
                model="claude-sonnet-4-5",
                max_tokens=1024,  # No limits
                messages=[{"role": "user", "content": query}]
            )
            
            cost = self._calculate_cost(response.usage)
            self.baseline_costs.append(cost)
    
    def run_optimized(self, queries):
        """Run queries with optimization."""
        print("Running optimized version...")
        
        system_prompt = """You are a helpful assistant. Provide concise, direct answers.
        Use 1-2 sentences for simple questions."""
        
        for query in queries:
            response = self.client.messages.create(
                model="claude-sonnet-4-5",
                max_tokens=200,  # Limited
                system=system_prompt,
                messages=[{"role": "user", "content": query}]
            )
            
            cost = self._calculate_cost(response.usage)
            self.optimized_costs.append(cost)
    
    def generate_report(self):
        """Generate cost comparison report."""
        baseline_total = sum(self.baseline_costs)
        optimized_total = sum(self.optimized_costs)
        savings = baseline_total - optimized_total
        savings_percent = (savings / baseline_total) * 100
        
        baseline_avg = statistics.mean(self.baseline_costs)
        optimized_avg = statistics.mean(self.optimized_costs)
        
        report = f"""
=== Cost Optimization Report ===

Baseline (No Optimization):
  Total cost: ${baseline_total:.4f}
  Average per query: ${baseline_avg:.6f}
  Number of queries: {len(self.baseline_costs)}

Optimized:
  Total cost: ${optimized_total:.4f}
  Average per query: ${optimized_avg:.6f}
  Number of queries: {len(self.optimized_costs)}

Savings:
  Total saved: ${savings:.4f}
  Percentage saved: {savings_percent:.1f}%
  
Projected Monthly Savings (at 10,000 queries/month):
  ${savings * (10000 / len(self.baseline_costs)):.2f}
"""
        return report

## Run the analysis
analyzer = CostAnalyzer()

test_queries = [
    "What is Python?",
    "What is JavaScript?",
    "What is machine learning?",
    "What are neural networks?",
    "What is deep learning?",
    "What is natural language processing?",
    "What are transformers?",
    "What is computer vision?",
    "What is reinforcement learning?",
    "What is data science?"
]

analyzer.run_baseline(test_queries)
analyzer.run_optimized(test_queries)

print(analyzer.generate_report())