LLM Token Usage Calculator

import tiktoken
import json

class TokenCalculator:
    def __init__(self, model="gpt-3.5-turbo"):
        self.model = model
        self.encoding = tiktoken.encoding_for_model(model)
        
        # Pricing per 1K tokens (update as needed)
        self.pricing = {
            "gpt-4": {"input": 0.03, "output": 0.06},
            "gpt-3.5-turbo": {"input": 0.0005, "output": 0.0015},
            "gpt-4-turbo": {"input": 0.01, "output": 0.03}
        }
    
    def count_tokens(self, text):
        """Count tokens in text"""
        return len(self.encoding.encode(text))
    
    def calculate_cost(self, prompt, completion):
        """Calculate cost for a request"""
        prompt_tokens = self.count_tokens(prompt)
        completion_tokens = self.count_tokens(completion)
        
        prices = self.pricing.get(self.model, self.pricing["gpt-3.5-turbo"])
        
        prompt_cost = (prompt_tokens / 1000) * prices["input"]
        completion_cost = (completion_tokens / 1000) * prices["output"]
        
        return {
            "prompt_tokens": prompt_tokens,
            "completion_tokens": completion_tokens,
            "total_tokens": prompt_tokens + completion_tokens,
            "prompt_cost": prompt_cost,
            "completion_cost": completion_cost,
            "total_cost": prompt_cost + completion_cost
        }

# Usage
calculator = TokenCalculator("gpt-3.5-turbo")
result = calculator.calculate_cost(
    prompt="Explain quantum computing",
    completion="Quantum computing uses quantum bits..."
)
print(json.dumps(result, indent=2))

// Using js-tiktoken library
import { getEncoding } from 'js-tiktoken'

class TokenCalculator {
  private encoding: any
  private pricing = {
    'gpt-4': { input: 0.03, output: 0.06 },
    'gpt-3.5-turbo': { input: 0.0005, output: 0.0015 },
    'claude-3-sonnet': { input: 0.003, output: 0.015 }
  }

  constructor(private model: string = 'gpt-3.5-turbo') {
    // For GPT models, use cl100k_base encoding
    this.encoding = getEncoding('cl100k_base')
  }

  countTokens(text: string): number {
    return this.encoding.encode(text).length
  }

  calculateCost(prompt: string, completion: string) {
    const promptTokens = this.countTokens(prompt)
    const completionTokens = this.countTokens(completion)
    
    const prices = this.pricing[this.model] || this.pricing['gpt-3.5-turbo']
    
    const promptCost = (promptTokens / 1000) * prices.input
    const completionCost = (completionTokens / 1000) * prices.output
    
    return {
      promptTokens,
      completionTokens,
      totalTokens: promptTokens + completionTokens,
      promptCost: parseFloat(promptCost.toFixed(6)),
      completionCost: parseFloat(completionCost.toFixed(6)),
      totalCost: parseFloat((promptCost + completionCost).toFixed(6))
    }
  }
  
  // Batch calculation
  calculateBatchCost(requests: Array<{prompt: string, completion: string}>) {
    return requests.reduce((acc, req) => {
      const cost = this.calculateCost(req.prompt, req.completion)
      return {
        totalTokens: acc.totalTokens + cost.totalTokens,
        totalCost: acc.totalCost + cost.totalCost
      }
    }, { totalTokens: 0, totalCost: 0 })
  }
}

// Usage
const calculator = new TokenCalculator('gpt-3.5-turbo')
const result = calculator.calculateCost(
  'What is machine learning?',
  'Machine learning is a subset of AI...'
)
console.log(result)

class CostTracker:
    def __init__(self):
        self.daily_usage = {}
        self.monthly_usage = {}
        
    def track_request(self, model, prompt_tokens, completion_tokens, cost):
        """Track individual request costs"""
        today = datetime.now().strftime("%Y-%m-%d")
        month = datetime.now().strftime("%Y-%m")
        
        # Daily tracking
        if today not in self.daily_usage:
            self.daily_usage[today] = {
                "requests": 0,
                "total_tokens": 0,
                "total_cost": 0,
                "by_model": {}
            }
        
        self.daily_usage[today]["requests"] += 1
        self.daily_usage[today]["total_tokens"] += prompt_tokens + completion_tokens
        self.daily_usage[today]["total_cost"] += cost
        
        # Model-specific tracking
        if model not in self.daily_usage[today]["by_model"]:
            self.daily_usage[today]["by_model"][model] = {
                "requests": 0,
                "tokens": 0,
                "cost": 0
            }
        
        self.daily_usage[today]["by_model"][model]["requests"] += 1
        self.daily_usage[today]["by_model"][model]["tokens"] += prompt_tokens + completion_tokens
        self.daily_usage[today]["by_model"][model]["cost"] += cost
    
    def get_daily_report(self, date=None):
        """Get usage report for a specific day"""
        if date is None:
            date = datetime.now().strftime("%Y-%m-%d")
        
        return self.daily_usage.get(date, {
            "requests": 0,
            "total_tokens": 0,
            "total_cost": 0,
            "by_model": {}
        })
    
    def get_cost_alerts(self, daily_limit=100, monthly_limit=3000):
        """Check if costs exceed limits"""
        today = datetime.now().strftime("%Y-%m-%d")
        month = datetime.now().strftime("%Y-%m")
        
        daily_cost = self.daily_usage.get(today, {}).get("total_cost", 0)
        monthly_cost = sum(day.get("total_cost", 0) for day in self.daily_usage.values()
                          if day.startswith(month))
        
        alerts = []
        if daily_cost > daily_limit:
            alerts.append(f"Daily cost (${daily_cost:.2f}) exceeds limit (${daily_limit})")
        if monthly_cost > monthly_limit:
            alerts.append(f"Monthly cost (${monthly_cost:.2f}) exceeds limit (${monthly_limit})")
        
        return alerts