# Estrutura de prompt típica
system_prompt = """
Você é um assistente útil de suporte ao cliente para AcmeCorp.

Diretrizes:
- Sempre seja educado e profissional
- Se não souber a resposta, diga
- Nunca revele informações confidenciais
- ... (15 mais diretrizes)

Conhecimento da empresa:
- Oferecemos garantia de 30 dias
- Envio leva 3-5 dias úteis
- ... (30 mais fatos)

Exemplos:
P: Como devolver um produto?
R: Para devolver...
... (10 mais exemplos)
"""

# Contagem de tokens: 1.847 tokens
# Query do usuário: "Como reseto minha senha?"
# Contagem de tokens: 8 tokens

# Total de tokens de input: 1.855
# Você está pagando por 1.847 tokens de contexto em toda requisição

# Antes (348 tokens)
"""
Você é um assistente útil. Você deve ser útil, amigável e profissional.
Sempre forneça respostas úteis. Seja muito útil.
"""

# Depois (12 tokens)
"""
Você é um assistente útil, amigável e profissional.
"""

# Economia: 336 tokens por requisição
# Em 1M requisições: 336M tokens × $15 = $5.040/mês

# Antes: Inclui todos os 10 exemplos em todo prompt
all_examples_tokens = 1200

# Depois: Recupera exemplos relevantes por query
@cached
def get_relevant_examples(query, k=2):
    # Busca semântica para exemplos mais relevantes
    examples = vector_index.search(query, k=k)
    return examples

# Tokens médios com 2 exemplos: 240 tokens

# Economia: 960 tokens por requisição
# Em 1M requisições: 960M tokens × $15 = $14.400/mês

# Antes (125 tokens)
"""
Por favor analise o código a seguir e identifique quaisquer bugs potenciais,
vulnerabilidades de segurança ou problemas de performance. Forneça
recomendações específicas para melhoria.
"""

# Depois (45 tokens)
"""
Analise código. Identifique: bugs, issues de segurança, problemas de performance.
Recomende fixes.
"""

# Impacto na qualidade: Nenhum. Output é idêntico.
# Economia: 80 tokens por requisição

# Síncrono (usuário esperando)
@app.post("/api/chat")
async def chat(query: str):
    response = await llm.generate(query)  # 500-2000ms
    return {"response": response}

# Usuário espera por LLM. Deve usar modelo caro e rápido.
model_choice = "gpt-4-turbo"  # $30/1M tokens

# Assíncrono (usuário pode esperar)
@app.post("/api/analyze")
async def analyze(document: str):
    task_id = queue.enqueue(llm_task, document)
    return {"task_id": task_id, "status": "processing"}

# Usuário faz polling do resultado. Pode usar modelo mais barato e lento ou batch.
model_choice = "gpt-3.5-turbo"  # $2/1M tokens

class BatchProcessor:
    def __init__(self, batch_size=10, max_wait_seconds=2):
        self.batch_size = batch_size
        self.max_wait = max_wait_seconds
        self.pending = []

    async def add_request(self, request):
        self.pending.append(request)

        # Inicia timer na primeira requisição
        if len(self.pending) == 1:
            self.timer = asyncio.create_task(
                self._wait_and_process()
            )

        # Processa imediatamente se batch está cheio
        if len(self.pending) >= self.batch_size:
            await self._process_batch()

    async def _process_batch(self):
        if not self.pending:
            return

        batch = self.pending[:self.batch_size]
        self.pending = self.pending[self.batch_size:]

        # Cria prompt em batch
        batched_prompt = self._create_batch_prompt(batch)

        # Chamada única de LLM para múltiplas requisições
        response = await llm.generate(batched_prompt)

        # Parse e distribui respostas
        individual_responses = self._parse_batch_response(response)

        for request, response in zip(batch, individual_responses):
            request.future.set_result(response)

# Sem batching: 10 requisições
individual_costs = 10 × 2000_tokens × $2/1M = $0.04

# Com batching: 1 requisição com 10 sub-queries
batched_cost = 12000_tokens × $2/1M = $0.024

# Economia: 40% em overhead fixo

class CostMonitor:
    def __init__(self, metrics_client):
        self.metrics = metrics_client

    def record_request(self, model, input_tokens, output_tokens, user_id, endpoint):
        # Registra métricas brutas
        self.metrics.counter("llm.requests", {
            "model": model,
            "endpoint": endpoint
        })

        self.metrics.counter("llm.tokens.input", input_tokens, {
            "model": model,
            "endpoint": endpoint,
            "user_id": user_id
        })

        # Calcula custo
        cost = self._calculate_cost(model, input_tokens, output_tokens)

        self.metrics.counter("llm.cost.dollars", cost, {
            "model": model,
            "endpoint": endpoint,
            "user_id": user_id
        })

class BudgetAlertSystem:
    def __init__(self, monthly_budget=10000):
        self.monthly_budget = monthly_budget
        self.alert_thresholds = [0.5, 0.75, 0.9, 1.0]

    def check_budget(self):
        # Obtém gasto month-to-date
        mtd_spend = metrics.sum("llm.cost.dollars", since=start_of_month())

        budget_used = mtd_spend / self.monthly_budget

        # Alerta nos thresholds
        for threshold in self.alert_thresholds:
            if budget_used >= threshold and not self.alerted_at(threshold):
                self.alert(
                    level="high" if threshold >= 0.9 else "medium",
                    message=f"Orçamento de LLM em {budget_used:.0%}"
                )

        # Throttle se acima do orçamento
        if budget_used >= 1.0:
            self.enable_emergency_throttle()

# 1. Instrumente tudo
monitor = CostMonitor()

# 2. Analise gasto atual
report = analyzer.analyze_last_30_days()

# 1. Implemente exact-match caching (2-4 horas)
cache = ExactMatchCache(redis_client)
# Impacto esperado: 8-12% redução de custo

# 2. Adicione roteamento básico de requisições (4-8 horas)
router = BasicRouter()
# Impacto esperado: 30-40% redução de custo

# Combinado: ~45% redução total

# 1. Caching semântico (1-2 dias)
semantic_cache = SemanticCache(redis_client, threshold=0.95)
# Impacto adicional esperado: +20-25% redução

# 2. Compressão de prompt (2-3 dias)
compressed_prompts = compress_all_prompts()
# Impacto adicional esperado: +10-15% redução

# Combinado com semana 2: ~70-75% redução total

# 1. Configure dashboards
dashboard.add_panel("Cost over time")
dashboard.add_panel("Cost by model")
dashboard.add_panel("Cache hit rate")

# 2. Configure alertas
alert_config = {
    "daily_budget_exceeded": 1000,
    "unusual_spike_threshold": 2.0,
    "cache_hit_rate_drop": 0.10,
}

original_cost = 100

# Depois de roteamento (40% para modelos baratos)
after_routing = 100 × 0.6 + (100 × 0.4 × 0.1) = 64

# Depois de caching (40% hit rate)
after_caching = 64 × 0.6 = 38

# Depois de compressão de prompt (30% redução)
after_compression = 38 × 0.7 = 27

# Custo final: $27 (73% redução)
# Tempo para implementar: 2-3 semanas
# Complexidade: Moderada