# Fórmula de Breakeven: API vs Self-Hosted
import math

def calcular_breakeven_tokens_diarios(
    coste_anual_selfhosted: float,      # TCO total self-hosted (GPU + engineer + infra)
    coste_api_por_millon_tokens: float, # Blended API cost (input+output promedio)
    utilizacion_gpu: float = 0.70       # Critical: >70% necesario para ROI
) -> dict:
    """
    Calcula cuántos tokens/día necesitas para que self-hosted sea más barato.
    
    Ejemplo:
    - Self-hosted TCO: $156,954/año (1 H100 + 1 engineer + infra)
    - API blended cost: $0.60/M tokens (DeepSeek promedio input+output)
    - Utilización GPU: 70%
    """
    # Ajuste por utilización (factor CRÍTICO)
    coste_efectivo_selfhosted = coste_anual_selfhosted / utilizacion_gpu

    # Breakeven en tokens/año
    tokens_anuales_breakeven = (coste_efectivo_selfhosted / coste_api_por_millon_tokens) * 1_000_000

    # Tokens/día
    tokens_diarios_breakeven = tokens_anuales_breakeven / 365

    # Coste por 1k tokens en self-hosted (para comparar con API)
    coste_por_1k_tokens_selfhosted = (coste_efectivo_selfhosted / tokens_anuales_breakeven) * 1000

    return {
        "tokens_diarios_breakeven": round(tokens_diarios_breakeven, 0),
        "tokens_mensuales_breakeven": round(tokens_diarios_breakeven * 30, 0),
        "utilizacion_necesaria": utilizacion_gpu,
        "coste_por_1k_tokens_selfhosted": round(coste_por_1k_tokens_selfhosted, 4),
        "coste_por_1k_tokens_api": coste_api_por_millon_tokens / 1000,
        "ahorro_porcentual_en_breakeven": 0  # En breakeven, ahorro = 0%
    }

# Escenario 1: DeepSeek API ($0.60/M blended) vs Self-hosted básico
resultado_deepseek = calcular_breakeven_tokens_diarios(
    coste_anual_selfhosted=156_954,      # TCO total del ejemplo anterior
    coste_api_por_millon_tokens=0.60,    # DeepSeek blended
    utilizacion_gpu=0.70
)

print(f"Breakeven con DeepSeek API:")
print(f"  Tokens/día necesarios: {resultado_deepseek['tokens_diarios_breakeven']:,.0f}")
print(f"  Tokens/mes necesarios: {resultado_deepseek['tokens_mensuales_breakeven']:,.0f}")
print(f"  Utilización GPU requerida: {resultado_deepseek['utilizacion_necesaria']*100}%")

# Output:
# Breakeven con DeepSeek API:
#   Tokens/día necesarios: 1,483,856
#   Tokens/mes necesarios: 44,515,685
#   Utilización GPU requerida: 70%

# Escenario 2: GPT-4o-mini ($0.375/M blended) vs Self-hosted básico
resultado_gpt4omini = calcular_breakeven_tokens_diarios(
    coste_anual_selfhosted=156_954,
    coste_api_por_millon_tokens=0.375,   # GPT-4o-mini blended (0.15 input + 0.60 output avg 50/50)
    utilizacion_gpu=0.70
)

print(f"\nBreakeven con GPT-4o-mini:")
print(f"  Tokens/día necesarios: {resultado_gpt4omini['tokens_diarios_breakeven']:,.0f}")

# Output: Tokens/día necesarios: 927,410 

#!/bin/bash
# Deployment script: DeepSeek R1 en AWS con vLLM

# Paso 1: Lanzar instancia GPU (spot para ahorro 70%)
aws ec2 run-instances \
    --instance-type p4d.24xlarge \
    --image-id ami-0abcdef1234567890 \  # Deep Learning AMI
    --spot-price "15.00" \
    --block-device-mappings DeviceName=/dev/sda1,Ebs={VolumeSize=200,VolumeType=gp3} \
    --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=deepseek-r1-prod}]'

# Paso 2: SSH a instancia y setup vLLM
ssh ubuntu@

# Instalar vLLM (>=0.8.4 requerido para DeepSeek)
pip install vllm==0.8.4 torch==2.1.0

# Paso 3: Download model weights (desde HuggingFace)
python -c "
from vllm import LLM
llm = LLM(model='deepseek-ai/deepseek-r1-32b', download_dir='/data/models')
print('Model downloaded successfully')
"

# Paso 4: Lanzar vLLM server con optimizaciones
python -m vllm.entrypoints.openai.api_server \
    --model /data/models/deepseek-r1-32b \
    --dtype bfloat16 \
    --gpu-memory-utilization 0.95 \
    --max-model-len 8192 \
    --tensor-parallel-size 8 \  # Usa las 8 A100
    --port 8000 \
    --host 0.0.0.0

# Paso 5: Test endpoint
curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-r1-32b",
        "prompt": "Explain quantum computing in simple terms:",
        "max_tokens": 150,
        "temperature": 0.7
    }'

# Paso 6: Setup monitoring con Prometheus
cat > /etc/prometheus/prometheus.yml <

#!/bin/bash
# Deployment Qwen 3 32B con vLLM + quantization AWQ

# Paso 1: Install dependencies (vLLM >=0.8.4 requerido)
pip install vllm>=0.8.4 autoawq transformers

# Paso 2: Download Qwen 3 32B quantized (AWQ 4-bit, reduce VRAM 75%)
python -c "
from vllm import LLM
llm = LLM(
    model='Qwen/Qwen3-32B-AWQ',  # Pre-quantized AWQ
    quantization='awq',
    dtype='float16',
    download_dir='/data/models'
)
print('Qwen 3 32B AWQ downloaded')
"

# Paso 3: Lanzar vLLM server (solo necesita 16GB VRAM con AWQ!)
python -m vllm.entrypoints.openai.api_server \
    --model /data/models/Qwen3-32B-AWQ \
    --quantization awq \
    --dtype float16 \
    --gpu-memory-utilization 0.90 \
    --max-model-len 8192 \
    --tensor-parallel-size 1 \  # Single GPU con quantization
    --port 8000

# Paso 4: Test con query multilingüe
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen3-32B-AWQ",
        "messages": [
            {"role": "system", "content": "You are a helpful multilingual assistant."},
            {"role": "user", "content": "Explica machine learning en español, luego en chino"}
        ],
        "max_tokens": 300,
        "temperature": 0.7
    }'

# Paso 5: KTransformers optimization (opcional, reduce VRAM 30% adicional)
# https://github.com/kvcache-ai/ktransformers
pip install ktransformers
python optimize_qwen3_ktransformers.py  # Custom script 

# Kubernetes deployment: Llama 3.3 70B con TGI (Text Generation Inference)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama33-70b-tgi
  namespace: llm-production
spec:
  replicas: 2  # Para HA (high availability)
  selector:
    matchLabels:
      app: llama33-70b
  template:
    metadata:
      labels:
        app: llama33-70b
    spec:
      nodeSelector:
        gpu: h100  # Selecciona nodos con H100
      containers:
        - name: tgi
          image: ghcr.io/huggingface/text-generation-inference:latest
          resources:
            limits:
              nvidia.com/gpu: 2  # Usa 2x H100 por pod
              memory: 200Gi
            requests:
              nvidia.com/gpu: 2
              memory: 180Gi
          env:
            - name: MODEL_ID
              value: "meta-llama/Llama-3.3-70B-Instruct"
            - name: NUM_SHARD
              value: "2"  # Tensor parallelism across 2 GPUs
            - name: MAX_TOTAL_TOKENS
              value: "8192"
            - name: QUANTIZE
              value: "bitsandbytes-nf4"  # 4-bit quantization
          ports:
            - containerPort: 8080
          volumeMounts:
            - name: model-cache
              mountPath: /data
      volumes:
        - name: model-cache
          persistentVolumeClaim:
            claimName: llama-models-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: llama33-70b-service
  namespace: llm-production
spec:
  type: LoadBalancer
  ports:
    - port: 8080
      targetPort: 8080
      protocol: TCP
  selector:
    app: llama33-70b
---
# HorizontalPodAutoscaler para auto-scaling basado en GPU utilization
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: llama33-70b-hpa
  namespace: llm-production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: llama33-70b-tgi
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Pods
      pods:
        metric:
          name: gpu_utilization
        target:
          type: AverageValue
          averageValue: "70"  # Scale up si GPU util >70%

# Calculadora de costes API LLM realista
def calcular_coste_mensual_api(
    requests_diarios: int,
    tokens_input_promedio: int,
    tokens_output_promedio: int,
    precio_input_por_millon: float,
    precio_output_por_millon: float
) -> dict:
    """
    Calcula el coste mensual real de una API LLM.
    
    Ejemplo: Chatbot customer support con GPT-4o-mini
    - 1M requests/día
    - 150 tokens input promedio (contexto + query)
    - 300 tokens output promedio (respuesta)
    - GPT-4o-mini: $0.15/M input, $0.60/M output
    """
    # Cálculo diario
    tokens_input_diarios = requests_diarios * tokens_input_promedio
    tokens_output_diarios = requests_diarios * tokens_output_promedio

    coste_input_diario = (tokens_input_diarios / 1_000_000) * precio_input_por_millon
    coste_output_diario = (tokens_output_diarios / 1_000_000) * precio_output_por_millon
    coste_total_diario = coste_input_diario + coste_output_diario

    # Proyección mensual (30 días)
    coste_mensual = coste_total_diario * 30
    coste_anual = coste_mensual * 12

    return {
        "coste_diario": round(coste_total_diario, 2),
        "coste_mensual": round(coste_mensual, 2),
        "coste_anual": round(coste_anual, 2),
        "tokens_diarios_total": tokens_input_diarios + tokens_output_diarios,
        "ratio_output_input": tokens_output_promedio / tokens_input_promedio
    }

# Ejemplo: Chatbot 1M requests/día con GPT-4o-mini
resultado = calcular_coste_mensual_api(
    requests_diarios=1_000_000,
    tokens_input_promedio=150,
    tokens_output_promedio=300,
    precio_input_por_millon=0.15,
    precio_output_por_millon=0.60
)

print(f"Coste mensual: ${resultado['coste_mensual']:,}")
print(f"Coste anual proyectado: ${resultado['coste_anual']:,}")

# Output: Coste mensual: $6,075 | Coste anual: $72,900 

# Router híbrido inteligente con model cascading
from litellm import completion
import re

def clasificar_complejidad_query(query: str) -> float:
    """
    Clasifica complejidad de query con heurísticas simples.
    Returns: float: Score 0-1 (0=simple, 1=complejo)
    """
    score = 0.0

    # Heurística 1: Longitud query
    if len(query.split()) > 50:
        score += 0.2

    # Heurística 2: Keywords complejos
    keywords_complejos = ['analiza', 'compara', 'explica por qué', 'diseña', 'optimiza']
    if any(kw in query.lower() for kw in keywords_complejos):
        score += 0.3

    # Heurística 3: Multi-step reasoning
    if re.search(r'\b(primero|luego|después|finalmente)\b', query.lower()):
        score += 0.2

    # Heurística 4: Código o math
    if re.search(r'[{}()\[\]=+\-*/]', query):
        score += 0.3

    return min(score, 1.0)

def rutear_query_hybrid(query: str) -> dict:
    """
    Rutea query al modelo óptimo según complejidad.
    """
    complexity = clasificar_complejidad_query(query)

    # Tier 1: Simple queries (60% tráfico esperado)
    if complexity < 0.4:
        response = completion(
            model="openai/llama-8b",  # Self-hosted Llama 8B via vLLM
            messages=[{"role": "user", "content": query}],
            api_base="http://10.0.1.50:8000/v1"
        )
        tier = "tier1_selfhosted_llama8b"
        coste_estimado = 0.005  # $/1k tokens

    # Tier 2: Standard queries (30% tráfico)
    elif complexity < 0.7:
        response = completion(
            model="openai/llama-70b",  # Self-hosted Llama 70B
            messages=[{"role": "user", "content": query}],
            api_base="http://10.0.1.51:8000/v1"
        )
        tier = "tier2_selfhosted_llama70b"
        coste_estimado = 0.015

    # Tier 3: Complex queries (10% tráfico)
    else:
        response = completion(
            model="gpt-4",  # Fallback a API para razonamiento complejo
            messages=[{"role": "user", "content": query}]
        )
        tier = "tier3_gpt4_api"
        coste_estimado = 2.50

    return {
        "response": response.choices[0].message.content,
        "tier_usado": tier,
        "complexity_score": complexity,
        "coste_estimado_per_1k": coste_estimado
    }

# Ejemplo de uso
query_simple = "¿Cuál es el horario de atención?"
query_compleja = "Analiza por qué el modelo Llama 70B es mejor que GPT-3.5 para summarization y diseña un pipeline optimizado"

resultado_simple = rutear_query_hybrid(query_simple)
resultado_compleja = rutear_query_hybrid(query_compleja)

print(f"Query simple → {resultado_simple['tier_usado']} (coste: ${resultado_simple['coste_estimado_per_1k']}/1k)")
print(f"Query compleja → {resultado_compleja['tier_usado']} (coste: ${resultado_compleja['coste_estimado_per_1k']}/1k)")