$60K On-Premise vs $2M Cloud:
Por Qué Tu Factura AI Explota

#!/usr/bin/env python3
"""
Script para monitorear GPU utilization real-time y detectar idle waste.
Requiere: nvidia-smi, boto3 (para enviar métricas a CloudWatch)
"""

import subprocess
import time
import json
from datetime import datetime


def get_gpu_stats():
    """Query nvidia-smi para obtener GPU utilization y memory usage."""
    try:
        result = subprocess.run([
            'nvidia-smi',
            '--query-gpu=index,name,utilization.gpu,memory.used,memory.total',
            '--format=csv,noheader,nounits'
        ], capture_output=True, text=True, check=True)

        gpu_stats = []
        for line in result.stdout.strip().split('\n'):
            idx, name, util, mem_used, mem_total = line.split(', ')
            gpu_stats.append({
                'index': int(idx),
                'name': name,
                'utilization': float(util),
                'memory_used_mb': float(mem_used),
                'memory_total_mb': float(mem_total),
                'memory_percent': (float(mem_used) / float(mem_total)) * 100
            })
        return gpu_stats
    except subprocess.CalledProcessError as e:
        print(f"Error ejecutando nvidia-smi: {e}")
        return []


def calculate_waste(stats, threshold=85):
    """
    Calcula waste financiero basado en utilization.
    
    Args:
        stats: Lista de GPU stats dictionaries
        threshold: Utilization target óptimo (default 85%)
    
    Returns:
        Dict con waste analysis
    """
    total_gpus = len(stats)
    underutilized = sum(1 for gpu in stats if gpu['utilization'] < threshold)
    avg_util = sum(gpu['utilization'] for gpu in stats) / total_gpus if total_gpus > 0 else 0

    # Asumiendo costo promedio $4/hora por GPU (A100 ballpark)
    cost_per_hour = 4.0
    hours_per_month = 730
    monthly_cost = total_gpus * cost_per_hour * hours_per_month

    # Waste = (target_util - actual_util) * monthly_cost
    waste_percent = max(0, threshold - avg_util) / 100
    monthly_waste = monthly_cost * waste_percent

    return {
        'total_gpus': total_gpus,
        'underutilized_count': underutilized,
        'avg_utilization': round(avg_util, 2),
        'monthly_cost': round(monthly_cost, 2),
        'monthly_waste': round(monthly_waste, 2),
        'waste_percent': round(waste_percent * 100, 2)
    }


def main():
    """Main monitoring loop."""
    print("🔍 Iniciando GPU Utilization Monitor...")
    print("Press Ctrl+C para detener\n")

    try:
        while True:
            stats = get_gpu_stats()

            if not stats:
                print("⚠️ No GPUs detectadas")
                time.sleep(10)
                continue

            waste = calculate_waste(stats)

            # Output real-time
            print(f"\n{'='*60}")
            print(f"Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
            print(f"{'='*60}")

            for gpu in stats:
                status = "✅" if gpu['utilization'] >= 85 else "⚠️ "
                print(f"{status} GPU {gpu['index']} ({gpu['name']}):")
                print(f"   Utilization: {gpu['utilization']:.1f}%")
                print(f"   Memory: {gpu['memory_used_mb']:.0f}MB / {gpu['memory_total_mb']:.0f}MB ({gpu['memory_percent']:.1f}%)")

            print(f"\n📊 Waste Analysis:")
            print(f"   Avg Utilization: {waste['avg_utilization']}%")
            print(f"   Underutilized GPUs: {waste['underutilized_count']}/{waste['total_gpus']}")
            print(f"   Monthly Cost: ${waste['monthly_cost']:,.2f}")
            print(f"   Monthly Waste: ${waste['monthly_waste']:,.2f} ({waste['waste_percent']}%)")

            if waste['monthly_waste'] > 1000:
                print(f"\n🚨 ALERT: Waste excede $1,000/mes - revisar workload optimization")

            time.sleep(60)  # Check every minute

    except KeyboardInterrupt:
        print("\n\n✅ Monitor detenido")


if __name__ == "__main__":
    main()

 #!/bin/bash
#
# Script para detectar recursos zombie en AWS
# Ejecutar con: ./zombie-detection.sh

echo "🔍 Buscando Zombie Resources en AWS..."
echo ""

# 1. EBS volumes no attached
echo "1️⃣ EBS Volumes Detached:"
aws ec2 describe-volumes \
    --filters Name=status,Values=available \
    --query 'Volumes[*].[VolumeId,Size,CreateTime]' \
    --output table

# 2. Elastic IPs no asociadas
echo ""
echo "2️⃣ Elastic IPs No Attached:"
aws ec2 describe-addresses \
    --query 'Addresses[?InstanceId==`null`].[PublicIp,AllocationId]' \
    --output table

# 3. Load Balancers sin targets activos
echo ""
echo "3️⃣ Load Balancers Sin Targets:"
for lb in $(aws elbv2 describe-load-balancers --query 'LoadBalancers[*].LoadBalancerArn' --output text); do
    targets=$(aws elbv2 describe-target-health \
        --target-group-arn $(aws elbv2 describe-target-groups \
            --load-balancer-arn $lb \
            --query 'TargetGroups[0].TargetGroupArn' \
            --output text) 2>/dev/null | grep -c "healthy")

    if [ "$targets" -eq 0 ]; then
        echo "⚠️  LB sin targets: $lb"
    fi
done

# 4. EC2 instances stopped (aún cobrando EBS)
echo ""
echo "4️⃣ EC2 Instances Stopped (cobrando storage):"
aws ec2 describe-instances \
    --filters Name=instance-state-name,Values=stopped \
    --query 'Reservations[*].Instances[*].[InstanceId,InstanceType,LaunchTime]' \
    --output table

echo ""
echo "✅ Scan completado. Revisa output y termina recursos innecesarios."

#!/usr/bin/env python3
"""
LLM Cost Optimization Wrapper
Implementa caching, routing, y token limits automáticos
"""

from openai import OpenAI
from functools import lru_cache
import hashlib
import tiktoken

client = OpenAI()
encoder = tiktoken.encoding_for_model("gpt-4")

# Configuration
MAX_OUTPUT_TOKENS = 300
CACHE_SIZE = 1000

MODEL_TIERS = {
    "simple": "gpt-4o-mini",     # $0.15/1M input
    "medium": "gpt-4o",          # $2.50/1M input
    "complex": "gpt-4-turbo"     # $10.00/1M input
}


@lru_cache(maxsize=CACHE_SIZE)
def cached_completion(prompt_hash, model, max_tokens):
    """
    Cache completions para prompts idénticos.
    Usa hash del prompt como key para evitar duplicates.
    """
    # Note: In production, deshacer hash para obtener prompt real
    # Aquí es simplified example
    return None  # Placeholder


def estimate_tokens(text):
    """Estimate token count para cost calculation."""
    return len(encoder.encode(text))


def classify_complexity(prompt):
    """
    Classify query complexity para routing.
    
    Returns:
        "simple" | "medium" | "complex"
    """
    token_count = estimate_tokens(prompt)

    # Simple rules (mejorar con ML classifier si necesario)
    keywords_complex = ["analyze", "compare", "explain why", "multi-step"]
    keywords_simple = ["what is", "define", "list", "hello"]

    prompt_lower = prompt.lower()

    if any(kw in prompt_lower for kw in keywords_simple):
        return "simple"
    elif any(kw in prompt_lower for kw in keywords_complex):
        return "complex"
    elif token_count > 500:
        return "complex"
    else:
        return "medium"


def optimized_completion(prompt, system_msg="", force_model=None):
    """
    Main wrapper con todas las optimizaciones:
    - Prompt caching
    - Model routing
    - Token limits
    - Cost tracking
    """
    # 1. Check cache
    prompt_hash = hashlib.md5(f"{system_msg}{prompt}".encode()).hexdigest()
    cached = cached_completion(prompt_hash, "gpt-4o", MAX_OUTPUT_TOKENS)

    if cached:
        print("✅ Cache hit - $0 cost")
        return cached

    # 2. Determine model tier
    if force_model:
        model = force_model
    else:
        complexity = classify_complexity(prompt)
        model = MODEL_TIERS[complexity]
        print(f"🎯 Routed to {model} (complexity: {complexity})")

    # 3. Call API con limits
    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": system_msg},
            {"role": "user", "content": prompt}
        ],
        max_tokens=MAX_OUTPUT_TOKENS,
        temperature=0.7
    )

    # 4. Track cost (simplified)
    input_tokens = response.usage.prompt_tokens
    output_tokens = response.usage.completion_tokens

    # Pricing (approximate)
    pricing = {
        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
        "gpt-4o": {"input": 2.50, "output": 10.00},
        "gpt-4-turbo": {"input": 10.00, "output": 30.00}
    }

    cost = (
        input_tokens / 1_000_000 * pricing[model]["input"] +
        output_tokens / 1_000_000 * pricing[model]["output"]
    )

    print(f"💰 Cost: ${cost:.4f} ({input_tokens} in + {output_tokens} out tokens)")

    return response.choices[0].message.content


# Example usage
if __name__ == "__main__":
    # Simple query → routes to gpt-4o-mini
    result1 = optimized_completion("What is your return policy?")

    # Complex query → routes to gpt-4-turbo
    result2 = optimized_completion(
        "Analyze the trade-offs between microservices and monolith architectures "
        "for a fintech startup with 50 engineers, considering scaling, costs, and "
        "team cognitive load."
    )