Cost Optimization Guide

from agenticants import AgenticAnts
import pandas as pd
 
ants = AgenticAnts(api_key=os.getenv('AGENTICANTS_API_KEY'))
 
class CostAnalyzer:
    def __init__(self):
        self.ants = ants
    
    def analyze_cost_breakdown(self, period="last_30_days"):
        """Analyze cost breakdown by components"""
        
        # Get cost breakdown
        cost_breakdown = self.ants.finops.get_cost_breakdown(period=period)
        
        print("💰 AI Cost Breakdown")
        print("=" * 50)
        print(f"Total Cost: ${cost_breakdown['total_cost']:.2f}")
        print(f"Period: {period}")
        print()
        
        # Breakdown by component
        print("By Component:")
        for component, cost in cost_breakdown['by_component'].items():
            percentage = (cost / cost_breakdown['total_cost']) * 100
            print(f"  {component}: ${cost:.2f} ({percentage:.1f}%)")
        
        # Breakdown by model
        print("\nBy Model:")
        for model, cost in cost_breakdown['by_model'].items():
            percentage = (cost / cost_breakdown['total_cost']) * 100
            print(f"  {model}: ${cost:.2f} ({percentage:.1f}%)")
        
        # Breakdown by agent
        print("\nBy Agent:")
        for agent, cost in cost_breakdown['by_agent'].items():
            percentage = (cost / cost_breakdown['total_cost']) * 100
            print(f"  {agent}: ${cost:.2f} ({percentage:.1f}%)")
        
        return cost_breakdown
    
    def analyze_cost_trends(self, period="last_90_days"):
        """Analyze cost trends over time"""
        
        trends = self.ants.finops.get_cost_trends(period=period)
        
        print("📈 Cost Trends")
        print("=" * 50)
        
        # Calculate trend
        if len(trends) >= 2:
            first_cost = trends[0]['cost']
            last_cost = trends[-1]['cost']
            trend_percentage = ((last_cost - first_cost) / first_cost) * 100
            
            if trend_percentage > 0:
                print(f"📈 Costs increased by {trend_percentage:.1f}% over {period}")
            else:
                print(f"📉 Costs decreased by {abs(trend_percentage):.1f}% over {period}")
        
        # Show daily costs
        print("\nDaily Costs:")
        for day in trends[-7:]:  # Last 7 days
            print(f"  {day['date']}: ${day['cost']:.2f}")
        
        return trends

import { AgenticAnts } from '@agenticants/sdk'
 
const ants = new AgenticAnts({ apiKey: process.env.AGENTICANTS_API_KEY })
 
class CostAttributionAnalyzer {
  private ants: AgenticAnts
  
  async analyzeCostAttribution(period: string = 'last_30_days') {
    // Get cost attribution data
    const attribution = await this.ants.finops.getCostAttribution({ period })
    
    console.log('💰 Cost Attribution Analysis')
    console.log('='.repeat(50))
    console.log(`Total Cost: $${attribution.totalCost.toFixed(2)}`)
    console.log(`Period: ${period}`)
    console.log()
    
    // By customer
    console.log('By Customer:')
    attribution.byCustomer.forEach(customer => {
      const percentage = (customer.cost / attribution.totalCost) * 100
      console.log(`  ${customer.name}: $${customer.cost.toFixed(2)} (${percentage.toFixed(1)}%)`)
    })
    
    // By team
    console.log('\nBy Team:')
    attribution.byTeam.forEach(team => {
      const percentage = (team.cost / attribution.totalCost) * 100
      console.log(`  ${team.name}: $${team.cost.toFixed(2)} (${percentage.toFixed(1)}%)`)
    })
    
    // By use case
    console.log('\nBy Use Case:')
    attribution.byUseCase.forEach(useCase => {
      const percentage = (useCase.cost / attribution.totalCost) * 100
      console.log(`  ${useCase.name}: $${useCase.cost.toFixed(2)} (${percentage.toFixed(1)}%)`)
    })
    
    return attribution
  }
  
  async identifyHighCostCustomers() {
    const attribution = await this.ants.finops.getCostAttribution({ period: 'last_30_days' })
    
    console.log('🔍 High Cost Customers')
    console.log('='.repeat(50))
    
    const highCostCustomers = attribution.byCustomer
      .filter(customer => customer.cost > 100) // > $100
      .sort((a, b) => b.cost - a.cost)
    
    highCostCustomers.forEach(customer => {
      console.log(`${customer.name}: $${customer.cost.toFixed(2)}`)
      console.log(`  Queries: ${customer.queryCount}`)
      console.log(`  Avg cost per query: $${(customer.cost / customer.queryCount).toFixed(4)}`)
    })
    
    return highCostCustomers
  }
}

class CostEfficiencyAnalyzer:
    def __init__(self):
        self.ants = ants
    
    def analyze_cost_efficiency(self, period="last_30_days"):
        """Analyze cost efficiency metrics"""
        
        efficiency_metrics = self.ants.finops.get_efficiency_metrics(period=period)
        
        print("⚡ Cost Efficiency Metrics")
        print("=" * 50)
        print(f"Cost per Query: ${efficiency_metrics['cost_per_query']:.4f}")
        print(f"Cost per Token: ${efficiency_metrics['cost_per_token']:.6f}")
        print(f"Cost per Successful Query: ${efficiency_metrics['cost_per_successful_query']:.4f}")
        print(f"Cost per Hour: ${efficiency_metrics['cost_per_hour']:.2f}")
        
        # Efficiency trends
        print("\nEfficiency Trends:")
        trends = efficiency_metrics['trends']
        if trends['cost_per_query']['trend'] > 0:
            print(f"📈 Cost per query increased by {trends['cost_per_query']['percentage']:.1f}%")
        else:
            print(f"📉 Cost per query decreased by {abs(trends['cost_per_query']['percentage']):.1f}%")
        
        return efficiency_metrics
    
    def identify_inefficient_operations(self):
        """Identify inefficient operations"""
        
        inefficient_ops = self.ants.finops.get_inefficient_operations()
        
        print("🐌 Inefficient Operations")
        print("=" * 50)
        
        for op in inefficient_ops:
            print(f"Operation: {op['name']}")
            print(f"  Cost: ${op['cost']:.2f}")
            print(f"  Efficiency Score: {op['efficiency_score']:.2f}")
            print(f"  Optimization Potential: {op['optimization_potential']:.1f}%")
            print()
        
        return inefficient_ops

class ModelSelectionOptimizer:
    def __init__(self):
        self.ants = ants
    
    def optimize_model_selection(self):
        """Optimize model selection for cost and performance"""
        
        # Analyze current model usage
        model_analysis = self.ants.finops.get_model_analysis()
        
        print("🤖 Model Selection Optimization")
        print("=" * 50)
        
        recommendations = []
        
        for model, data in model_analysis.items():
            print(f"\nModel: {model}")
            print(f"  Cost: ${data['cost']:.2f}")
            print(f"  Performance: {data['performance_score']:.2f}")
            print(f"  Usage: {data['usage_count']} queries")
            
            # Generate recommendations
            if data['performance_score'] > 0.9 and data['cost'] > 0.01:
                recommendation = {
                    'model': model,
                    'action': 'consider_smaller_model',
                    'potential_savings': data['cost'] * 0.3,
                    'reason': 'High performance with high cost - consider smaller model'
                }
                recommendations.append(recommendation)
                print(f"  💡 Recommendation: Consider smaller model (Save ${recommendation['potential_savings']:.2f})")
        
        return recommendations
    
    def compare_models(self, task_type: str):
        """Compare models for specific task types"""
        
        model_comparison = self.ants.finops.compare_models(task_type=task_type)
        
        print(f"🔍 Model Comparison for {task_type}")
        print("=" * 50)
        
        for model, metrics in model_comparison.items():
            print(f"\n{model}:")
            print(f"  Cost per query: ${metrics['cost_per_query']:.4f}")
            print(f"  Performance score: {metrics['performance_score']:.2f}")
            print(f"  Latency: {metrics['latency']}ms")
            print(f"  Quality score: {metrics['quality_score']:.2f}")
        
        # Find best model for cost-performance ratio
        best_model = min(model_comparison.items(), 
                        key=lambda x: x[1]['cost_per_query'] / x[1]['performance_score'])
        
        print(f"\n🏆 Best cost-performance ratio: {best_model[0]}")
        
        return model_comparison

class PromptOptimizer {
  private ants: AgenticAnts
  
  async optimizePrompts() {
    console.log('📝 Prompt Optimization')
    console.log('='.repeat(50))
    
    // Analyze prompt efficiency
    const promptAnalysis = await this.ants.finops.getPromptAnalysis()
    
    promptAnalysis.forEach(prompt => {
      console.log(`\nPrompt: ${prompt.name}`)
      console.log(`  Current length: ${prompt.currentLength} tokens`)
      console.log(`  Cost per query: $${prompt.costPerQuery.toFixed(4)}`)
      console.log(`  Quality score: ${prompt.qualityScore}`)
      
      if (prompt.optimizationPotential > 20) {
        console.log(`  💡 Optimization potential: ${prompt.optimizationPotential}%`)
        console.log(`  Potential savings: $${prompt.potentialSavings.toFixed(2)}/month`)
      }
    })
    
    return promptAnalysis
  }
  
  async implementPromptOptimizations() {
    const optimizations = await this.ants.finops.getPromptOptimizations()
    
    console.log('🚀 Implementing Prompt Optimizations')
    console.log('='.repeat(50))
    
    for (const optimization of optimizations) {
      console.log(`\nOptimizing: ${optimization.promptName}`)
      console.log(`  Original length: ${optimization.originalLength} tokens`)
      console.log(`  Optimized length: ${optimization.optimizedLength} tokens`)
      console.log(`  Reduction: ${optimization.reductionPercentage}%`)
      console.log(`  Monthly savings: $${optimization.monthlySavings.toFixed(2)}`)
      
      // Apply optimization
      await this.ants.finops.applyPromptOptimization(optimization.id)
      console.log(`  ✅ Applied optimization`)
    }
  }
}

class CachingOptimizer:
    def __init__(self):
        self.ants = ants
    
    def implement_response_caching(self):
        """Implement response caching to reduce costs"""
        
        print("💾 Implementing Response Caching")
        print("=" * 50)
        
        # Analyze cache potential
        cache_analysis = self.ants.finops.get_cache_analysis()
        
        print(f"Cache hit potential: {cache_analysis['hit_potential']:.1f}%")
        print(f"Potential monthly savings: ${cache_analysis['monthly_savings']:.2f}")
        
        # Configure caching
        self.ants.cache.configure({
            "strategy": "semantic_similarity",
            "similarity_threshold": 0.95,
            "ttl": "24h",
            "max_size": "1GB"
        })
        
        print("✅ Response caching configured")
        
        return cache_analysis
    
    def implement_embedding_caching(self):
        """Implement embedding caching for vector operations"""
        
        print("🔍 Implementing Embedding Caching")
        print("=" * 50)
        
        # Configure embedding cache
        self.ants.cache.configure_embedding_cache({
            "enabled": True,
            "strategy": "exact_match",
            "ttl": "7d",
            "max_size": "500MB"
        })
        
        print("✅ Embedding caching configured")
    
    def monitor_cache_performance(self):
        """Monitor cache performance"""
        
        cache_metrics = self.ants.cache.get_performance_metrics()
        
        print("📊 Cache Performance")
        print("=" * 50)
        print(f"Hit rate: {cache_metrics['hit_rate']:.1f}%")
        print(f"Miss rate: {cache_metrics['miss_rate']:.1f}%")
        print(f"Cost savings: ${cache_metrics['cost_savings']:.2f}")
        print(f"Cache size: {cache_metrics['cache_size']}")
        
        return cache_metrics

class RequestOptimizer {
  private ants: AgenticAnts
  
  async optimizeRequestPatterns() {
    console.log('📊 Request Pattern Optimization')
    console.log('='.repeat(50))
    
    // Analyze request patterns
    const patterns = await this.ants.finops.getRequestPatterns()
    
    patterns.forEach(pattern => {
      console.log(`\nPattern: ${pattern.name}`)
      console.log(`  Frequency: ${pattern.frequency} requests/day`)
      console.log(`  Cost per request: $${pattern.costPerRequest.toFixed(4)}`)
      console.log(`  Total daily cost: $${pattern.dailyCost.toFixed(2)}`)
      
      if (pattern.optimizationPotential > 15) {
        console.log(`  💡 Optimization potential: ${pattern.optimizationPotential}%`)
      }
    })
    
    return patterns
  }
  
  async implementRequestOptimizations() {
    const optimizations = await this.ants.finops.getRequestOptimizations()
    
    console.log('🚀 Implementing Request Optimizations')
    console.log('='.repeat(50))
    
    for (const optimization of optimizations) {
      console.log(`\nOptimizing: ${optimization.name}`)
      console.log(`  Strategy: ${optimization.strategy}`)
      console.log(`  Expected savings: ${optimization.savingsPercentage}%`)
      console.log(`  Monthly savings: $${optimization.monthlySavings.toFixed(2)}`)
      
      // Apply optimization
      await this.ants.finops.applyRequestOptimization(optimization.id)
      console.log(`  ✅ Applied optimization`)
    }
  }
}

class BudgetManager:
    def __init__(self):
        self.ants = ants
    
    def setup_budgets(self):
        """Setup comprehensive budget management"""
        
        print("💰 Setting Up Budgets")
        print("=" * 50)
        
        # Create monthly budget
        monthly_budget = self.ants.finops.create_budget({
            "name": "Monthly AI Budget",
            "amount": 1000,
            "period": "monthly",
            "alerts": [
                {"threshold": 0.7, "type": "warning"},  # 70%
                {"threshold": 0.9, "type": "critical"}  # 90%
            ]
        })
        
        # Create team budgets
        team_budgets = [
            {"team": "engineering", "amount": 500},
            {"team": "product", "amount": 300},
            {"team": "marketing", "amount": 200}
        ]
        
        for budget in team_budgets:
            self.ants.finops.create_budget({
                "name": f"{budget['team']} Team Budget",
                "amount": budget["amount"],
                "period": "monthly",
                "team": budget["team"],
                "alerts": [
                    {"threshold": 0.8, "type": "warning"},
                    {"threshold": 0.95, "type": "critical"}
                ]
            })
        
        print("✅ Budgets created successfully")
        
        return monthly_budget
    
    def monitor_budget_usage(self):
        """Monitor budget usage"""
        
        budgets = self.ants.finops.get_budgets()
        
        print("📊 Budget Usage")
        print("=" * 50)
        
        for budget in budgets:
            usage_percentage = (budget['used'] / budget['amount']) * 100
            print(f"\n{budget['name']}:")
            print(f"  Used: ${budget['used']:.2f} / ${budget['amount']:.2f}")
            print(f"  Usage: {usage_percentage:.1f}%")
            
            if usage_percentage > 90:
                print("  ⚠️  Critical: Budget almost exceeded!")
            elif usage_percentage > 70:
                print("  ⚠️  Warning: Budget usage high!")
        
        return budgets

class CostAlertManager {
  private ants: AgenticAnts
  
  async setupCostAlerts() {
    console.log('🚨 Setting Up Cost Alerts')
    console.log('='.repeat(50))
    
    // Create cost spike alert
    await this.ants.alerts.create({
      name: 'Cost Spike Alert',
      condition: 'hourly_cost > 50',
      window: '1h',
      channels: ['email', 'slack'],
      severity: 'warning'
    })
    
    // Create daily budget alert
    await this.ants.alerts.create({
      name: 'Daily Budget Alert',
      condition: 'daily_cost > 100',
      window: '1d',
      channels: ['email', 'slack'],
      severity: 'critical'
    })
    
    // Create anomaly detection alert
    await this.ants.alerts.create({
      name: 'Cost Anomaly Alert',
      condition: 'cost_anomaly > 2.0',
      window: '1h',
      channels: ['slack', 'pagerduty'],
      severity: 'warning'
    })
    
    console.log('✅ Cost alerts configured')
  }
  
  async monitorCostAlerts() {
    const alerts = await this.ants.alerts.getCostAlerts()
    
    console.log('📊 Cost Alert Status')
    console.log('='.repeat(50))
    
    alerts.forEach(alert => {
      const status = alert.active ? '🔴 ACTIVE' : '🟢 OK'
      console.log(`${alert.name}: ${status}`)
      if (alert.active) {
        console.log(`  Triggered: ${alert.triggeredAt}`)
        console.log(`  Current value: ${alert.currentValue}`)
        console.log(`  Threshold: ${alert.threshold}`)
      }
    })
    
    return alerts
  }
}

class ROIAnalyzer:
    def __init__(self):
        self.ants = ants
    
    def calculate_roi(self, period="last_30_days"):
        """Calculate ROI for AI investments"""
        
        roi_data = self.ants.finops.calculate_roi(period=period)
        
        print("📈 ROI Analysis")
        print("=" * 50)
        print(f"Period: {period}")
        print(f"Total AI Costs: ${roi_data['total_costs']:.2f}")
        print(f"Revenue Generated: ${roi_data['revenue_generated']:.2f}")
        print(f"Cost Savings: ${roi_data['cost_savings']:.2f}")
        print(f"ROI: {roi_data['roi_percentage']:.1f}%")
        print(f"Payback Period: {roi_data['payback_period']} days")
        
        # ROI by use case
        print("\nROI by Use Case:")
        for use_case, roi in roi_data['by_use_case'].items():
            print(f"  {use_case}: {roi['roi_percentage']:.1f}%")
        
        return roi_data
    
    def track_roi_trends(self, period="last_90_days"):
        """Track ROI trends over time"""
        
        trends = self.ants.finops.get_roi_trends(period=period)
        
        print("📊 ROI Trends")
        print("=" * 50)
        
        for trend in trends[-7:]:  # Last 7 days
            print(f"{trend['date']}: {trend['roi_percentage']:.1f}%")
        
        return trends

class BusinessImpactAnalyzer {
  private ants: AgenticAnts
  
  async measureBusinessImpact() {
    console.log('📊 Business Impact Analysis')
    console.log('='.repeat(50))
    
    const impact = await this.ants.finops.getBusinessImpact()
    
    console.log(`Customer Satisfaction: ${impact.customerSatisfaction}%`)
    console.log(`Response Time Improvement: ${impact.responseTimeImprovement}%`)
    console.log(`Error Rate Reduction: ${impact.errorRateReduction}%`)
    console.log(`Cost per Customer: $${impact.costPerCustomer.toFixed(2)}`)
    console.log(`Revenue per Customer: $${impact.revenuePerCustomer.toFixed(2)}`)
    
    // Calculate business value
    const businessValue = impact.revenuePerCustomer - impact.costPerCustomer
    console.log(`Net Business Value per Customer: $${businessValue.toFixed(2)}`)
    
    return impact
  }
  
  async trackBusinessMetrics() {
    const metrics = await this.ants.finops.getBusinessMetrics()
    
    console.log('📈 Business Metrics Trends')
    console.log('='.repeat(50))
    
    metrics.forEach(metric => {
      console.log(`\n${metric.name}:`)
      console.log(`  Current: ${metric.current}`)
      console.log(`  Trend: ${metric.trend}`)
      console.log(`  Change: ${metric.changePercentage}%`)
    })
    
    return metrics
  }
}

class ContinuousOptimizer:
    def __init__(self):
        self.ants = ants
    
    def setup_automated_optimization(self):
        """Setup automated optimization processes"""
        
        print("🤖 Setting Up Automated Optimization")
        print("=" * 50)
        
        # Configure automatic model selection
        self.ants.finops.configure_auto_model_selection({
            "enabled": True,
            "optimization_goal": "cost_performance_ratio",
            "evaluation_period": "weekly"
        })
        
        # Configure automatic prompt optimization
        self.ants.finops.configure_auto_prompt_optimization({
            "enabled": True,
            "optimization_threshold": 0.1,  # 10% improvement
            "evaluation_period": "daily"
        })
        
        # Configure automatic caching
        self.ants.finops.configure_auto_caching({
            "enabled": True,
            "cache_threshold": 0.8,  # 80% similarity
            "evaluation_period": "hourly"
        })
        
        print("✅ Automated optimization configured")
    
    def run_optimization_cycle(self):
        """Run optimization cycle"""
        
        print("🔄 Running Optimization Cycle")
        print("=" * 50)
        
        # Get optimization recommendations
        recommendations = self.ants.finops.get_optimization_recommendations()
        
        print(f"Found {len(recommendations)} optimization opportunities")
        
        for rec in recommendations:
            print(f"\nOptimization: {rec['title']}")
            print(f"  Potential savings: {rec['savings_percentage']:.1f}%")
            print(f"  Monthly savings: ${rec['monthly_savings']:.2f}")
            print(f"  Risk level: {rec['risk_level']}")
            
            if rec['risk_level'] == 'low':
                print(f"  ✅ Applying optimization...")
                self.ants.finops.apply_optimization(rec['id'])
            else:
                print(f"  ⚠️  Manual review required")
        
        return recommendations

class OptimizationMonitor {
  private ants: AgenticAnts
  
  async monitorOptimizations() {
    console.log('📊 Optimization Monitoring')
    console.log('='.repeat(50))
    
    const optimizations = await this.ants.finops.getActiveOptimizations()
    
    optimizations.forEach(optimization => {
      console.log(`\nOptimization: ${optimization.name}`)
      console.log(`  Status: ${optimization.status}`)
      console.log(`  Applied: ${optimization.appliedAt}`)
      console.log(`  Savings: ${optimization.savingsPercentage}%`)
      console.log(`  Monthly savings: $${optimization.monthlySavings.toFixed(2)}`)
      
      if (optimization.performanceImpact) {
        console.log(`  Performance impact: ${optimization.performanceImpact}%`)
      }
    })
    
    return optimizations
  }
  
  async trackOptimizationImpact() {
    const impact = await this.ants.finops.getOptimizationImpact()
    
    console.log('📈 Optimization Impact')
    console.log('='.repeat(50))
    console.log(`Total savings: $${impact.totalSavings.toFixed(2)}`)
    console.log(`Performance impact: ${impact.performanceImpact}%`)
    console.log(`Quality impact: ${impact.qualityImpact}%`)
    
    return impact
  }
}

class CostOptimizationChecklist:
    def __init__(self):
        self.ants = ants
    
    def run_optimization_checklist(self):
        """Run comprehensive optimization checklist"""
        
        print("✅ Cost Optimization Checklist")
        print("=" * 50)
        
        checklist = [
            ("Model Selection", self.check_model_selection),
            ("Prompt Optimization", self.check_prompt_optimization),
            ("Caching Implementation", self.check_caching),
            ("Budget Management", self.check_budget_management),
            ("ROI Tracking", self.check_roi_tracking),
            ("Automated Optimization", self.check_automated_optimization)
        ]
        
        results = {}
        
        for item, check_function in checklist:
            try:
                result = check_function()
                results[item] = result
                status = "✅ PASS" if result['passed'] else "❌ FAIL"
                print(f"{item}: {status}")
                if not result['passed']:
                    print(f"  Issues: {result['issues']}")
            except Exception as e:
                results[item] = {"passed": False, "issues": [str(e)]}
                print(f"{item}: ❌ ERROR - {e}")
        
        return results
    
    def check_model_selection(self):
        """Check model selection optimization"""
        # Implement model selection checks
        return {"passed": True, "issues": []}
    
    def check_prompt_optimization(self):
        """Check prompt optimization"""
        # Implement prompt optimization checks
        return {"passed": True, "issues": []}
    
    def check_caching(self):
        """Check caching implementation"""
        # Implement caching checks
        return {"passed": True, "issues": []}
    
    def check_budget_management(self):
        """Check budget management"""
        # Implement budget management checks
        return {"passed": True, "issues": []}
    
    def check_roi_tracking(self):
        """Check ROI tracking"""
        # Implement ROI tracking checks
        return {"passed": True, "issues": []}
    
    def check_automated_optimization(self):
        """Check automated optimization"""
        # Implement automated optimization checks
        return {"passed": True, "issues": []}

class CostOptimizationStrategy {
  private ants: AgenticAnts
  
  async implementOptimizationStrategy() {
    console.log('🎯 Implementing Cost Optimization Strategy')
    console.log('='.repeat(50))
    
    // Phase 1: Quick Wins
    console.log('\nPhase 1: Quick Wins')
    await this.implementQuickWins()
    
    // Phase 2: Model Optimization
    console.log('\nPhase 2: Model Optimization')
    await this.optimizeModels()
    
    // Phase 3: Advanced Optimization
    console.log('\nPhase 3: Advanced Optimization')
    await this.implementAdvancedOptimizations()
    
    // Phase 4: Continuous Optimization
    console.log('\nPhase 4: Continuous Optimization')
    await this.setupContinuousOptimization()
  }
  
  private async implementQuickWins() {
    // Implement quick wins like caching, prompt optimization
    console.log('✅ Implemented quick wins')
  }
  
  private async optimizeModels() {
    // Optimize model selection and usage
    console.log('✅ Optimized models')
  }
  
  private async implementAdvancedOptimizations() {
    // Implement advanced optimizations
    console.log('✅ Implemented advanced optimizations')
  }
  
  private async setupContinuousOptimization() {
    // Setup continuous optimization processes
    console.log('✅ Setup continuous optimization')
  }
}

def debug_cost_spikes():
    # Analyze cost spikes
    spikes = ants.finops.get_cost_spikes(period="last_7_days")
    
    print("Cost Spike Analysis:")
    for spike in spikes:
        print(f"Date: {spike['date']}")
        print(f"Cost: ${spike['cost']:.2f}")
        print(f"Percentage increase: {spike['percentage_increase']:.1f}%")
        print(f"Likely cause: {spike['likely_cause']}")
        print("---")

async function debugHighCostPerQuery() {
  const highCostQueries = await ants.finops.getHighCostQueries({
    threshold: 0.01, // $0.01 per query
    period: 'last_24h'
  })
  
  console.log('High Cost Queries:')
  highCostQueries.forEach(query => {
    console.log(`Cost: $${query.cost.toFixed(4)}`)
    console.log(`Query: ${query.query}`)
    console.log(`Model: ${query.model}`)
  })
}