API Cost Optimization Complete Guide

class TokenOptimizer:
    """Token optimization tool class"""
    
    def optimize_prompt(self, prompt: str) -> str:
        """Optimize prompts to reduce token usage"""
        # 1. Remove extra spaces and line breaks
        prompt = ' '.join(prompt.split())
        
        # 2. Use concise instructions
        replacements = {
            "Please provide a detailed explanation of": "Explain",
            "Could you please": "Please",
            "I would like you to": "Please",
            "Can you help me understand": "Explain",
        }
        
        for long_form, short_form in replacements.items():
            prompt = prompt.replace(long_form, short_form)
        
        # 3. Remove redundant information
        prompt = self._remove_redundancy(prompt)
        
        return prompt
    
    def _remove_redundancy(self, text: str) -> str:
        """Remove redundant information"""
        # Implement deduplication logic
        lines = text.split('\n')
        unique_lines = []
        seen = set()
        
        for line in lines:
            line_hash = hash(line.strip().lower())
            if line_hash not in seen:
                seen.add(line_hash)
                unique_lines.append(line)
        
        return '\n'.join(unique_lines)
    
    def calculate_cost(self, text: str, model: str) -> dict:
        """Calculate estimated cost"""
        import tiktoken
        
        # Get corresponding model encoder
        encoding = tiktoken.encoding_for_model(model)
        tokens = len(encoding.encode(text))
        
        # Pricing (example prices, check official pricing for actual rates)
        pricing = {
            "gpt-4o": {"input": 0.03, "output": 0.06},  # per 1K tokens
            "gpt-4o-mini": {"input": 0.0002, "output": 0.0006},
            "gpt-3.5-turbo": {"input": 0.0005, "output": 0.0015},
            "claude-3-sonnet": {"input": 0.003, "output": 0.015},
            "claude-3-haiku": {"input": 0.00025, "output": 0.00125}
        }
        
        model_price = pricing.get(model, pricing["gpt-3.5-turbo"])
        
        return {
            "tokens": tokens,
            "estimated_cost": (tokens / 1000) * model_price["input"],
            "model": model
        }

# usingExample
optimizer = TokenOptimizer()

# Before optimization
original_prompt = """
Could you please provide a detailed explanation of how machine learning works?
I would like you to explain the basic concepts, algorithms, and applications.
Please include examples if possible.
"""

# After optimization
optimized = optimizer.optimize_prompt(original_prompt)
print(f"Before optimization: {len(original_prompt)} characters")
print(f"After optimization: {len(optimized)} characters")
print(f"Saved: {(1 - len(optimized)/len(original_prompt))*100:.1f}%")

# Calculate cost
cost_info = optimizer.calculate_cost(optimized, "gpt-4o-mini")
print(f"Token count: {cost_info['tokens']}")
print(f"Estimated cost: ${cost_info['estimated_cost']:.4f}")