0Pricing
AI Prompt Engineering · Aula

Monitorando o desempenho dos prompts em produção

Acompanhamento da latência, do custo, das pontuações de qualidade e das taxas de falha por versão do prompt.

Monitorando o desempenho dos prompts em produção é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

Por que monitorar o desempenho das instruções

Uma instrução implantada em produção não está "concluída". O comportamento do modelo muda com as atualizações, as entradas dos usuários mudam ao longo do tempo e os custos podem aumentar inesperadamente. O monitoramento contínuo detecta regressões antes que prejudiquem os usuários e mantém os gastos previsíveis.

Principais métricas por versão da instrução

Acompanhe estas cinco métricas por versão da instrução em produção:

  • Latência média: tempo entre a solicitação e a resposta completa (P50, P95, P99)
  • Custo por chamada: tokens de entrada × preço de entrada + tokens de saída × preço de saída
  • Pontuação de qualidade: avaliação automatizada (LLM como avaliador ou métrica da tarefa)
  • Taxa de erros: erros de API + falhas de análise de saídas malformadas
  • Satisfação do usuário: avaliação por polegar, taxa de repetição e abandono da sessão

Instrumentação: registro de métricas

Envolva cada chamada de LLM com uma instrumentação que registre todas as métricas principais em um armazenamento de séries temporais ou banco de dados para análise e alertas posteriores.

import time
import openai

client = openai.OpenAI(api_key='YOUR_API_KEY')

def instrumented_call(prompt_id, version, messages, model):
    start = time.time()
    error = False
    response = None
    try:
        response = client.chat.completions.create(
            model=model,
            messages=messages
        )
    except Exception as e:
        error = True
        raise
    finally:
        latency_ms = (time.time() - start) * 1000
        usage = response.usage if response else None
        record_metric({
            'prompt_id': prompt_id,
            'version': version,
            'latency_ms': latency_ms,
            'input_tokens': usage.prompt_tokens if usage else 0,
            'output_tokens': usage.completion_tokens if usage else 0,
            'error': error,
            'timestamp': time.time()
        })
    return response

Cálculo do custo por chamada

Custo por chamada = tokens de entrada × preço de entrada + tokens de saída × preço de saída. Armazenar as contagens brutas de tokens permite recalcular o custo sempre que os preços mudarem.

# pricing.py — model pricing table (per 1M tokens)
PRICING = {
    'gpt-4o': {'input': 2.50, 'output': 10.00},
    'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
    'claude-3-5-sonnet-20241022': {'input': 3.00, 'output': 15.00},
}

def cost_usd(model, input_tokens, output_tokens):
    p = PRICING.get(model)
    if not p:
        return None
    cost = (input_tokens / 1_000_000) * p['input'] \
         + (output_tokens / 1_000_000) * p['output']
    return round(cost, 6)

# Example
c = cost_usd('gpt-4o-mini', input_tokens=800, output_tokens=200)
print(f'Cost per call: ${c}')   # Cost per call: $0.000240

# Daily cost estimate
calls_per_day = 50_000
print(f'Daily cost: ${round(c * calls_per_day, 2)}')  # $12.00

Pontuação automatizada de qualidade

Use um LLM como avaliador para pontuar automaticamente a qualidade das saídas em escala de produção. Selecione uma amostra de 5-10% das chamadas para pontuação de qualidade, mantendo os custos sob controle.

import random

JUDGE_SAMPLE_RATE = 0.05  # score 5% of calls

JUDGE_PROMPT = '''Rate the quality of this AI response on a scale of 1-5.
1=Very poor, 3=Acceptable, 5=Excellent.
Return only the integer score.

User input: {input}
AI response: {output}'''

def maybe_score_quality(user_input, ai_output, model='gpt-4o-mini'):
    if random.random() > JUDGE_SAMPLE_RATE:
        return None  # not sampled

    judge_messages = [{'role': 'user', 'content':
        JUDGE_PROMPT.format(input=user_input, output=ai_output)}]
    response = client.chat.completions.create(
        model=model, messages=judge_messages, max_tokens=5
    )
    try:
        score = int(response.choices[0].message.content.strip())
        return max(1, min(5, score))  # clamp to 1-5
    except ValueError:
        return None

Armazenamento de métricas em um banco de dados de séries temporais

Bancos de dados de séries temporais (InfluxDB, TimescaleDB ou até mesmo uma tabela simples do PostgreSQL com um índice de carimbo de data e hora) armazenam métricas por chamada com eficiência e oferecem suporte a consultas de agregação para painéis.

-- TimescaleDB / PostgreSQL schema for prompt metrics
CREATE TABLE prompt_metrics (
  ts              TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  prompt_id       VARCHAR(100),
  version         VARCHAR(20),
  model           VARCHAR(50),
  latency_ms      FLOAT,
  input_tokens    INT,
  output_tokens   INT,
  cost_usd        FLOAT,
  quality_score   FLOAT,   -- NULL if not sampled
  error           BOOLEAN DEFAULT FALSE
);

-- Convert to hypertable (TimescaleDB)
SELECT create_hypertable('prompt_metrics', 'ts');

-- Query: hourly P95 latency by version
SELECT
  date_trunc('hour', ts) AS hour,
  version,
  PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY latency_ms) AS p95_latency
FROM prompt_metrics
WHERE prompt_id = 'summarize-article'
  AND ts > NOW() - INTERVAL '24 hours'
GROUP BY 1, 2
ORDER BY 1;

Construção de um painel de métricas

Os painéis apresentam as cinco métricas principais em tempo real. Use o Grafana (com TimescaleDB como fonte de dados) ou um painel web personalizado. Principais painéis:

  • Latência P50/P95/P99 ao longo do tempo, por versão
  • Tendência do custo por chamada (diária/semanal)
  • Percentual da taxa de erros
  • Média móvel da pontuação de qualidade
  • Pontuação de satisfação do usuário
# Simple dashboard query aggregation in Python
def get_dashboard_stats(conn, prompt_id, hours=24):
    with conn.cursor() as cur:
        cur.execute('''
            SELECT
              version,
              COUNT(*) AS calls,
              AVG(latency_ms) AS avg_latency,
              PERCENTILE_CONT(0.95)
                WITHIN GROUP (ORDER BY latency_ms) AS p95_latency,
              AVG(cost_usd) AS avg_cost,
              AVG(quality_score) FILTER (WHERE quality_score IS NOT NULL) AS avg_quality,
              SUM(error::int)::float / COUNT(*) AS error_rate
            FROM prompt_metrics
            WHERE prompt_id = %s
              AND ts > NOW() - INTERVAL %s
            GROUP BY version
            ORDER BY MAX(ts) DESC
        ''', (prompt_id, f'{hours} hours'))
        return cur.fetchall()

Detecção de anomalias em regressões das instruções

A análise manual dos painéis não detecta regressões lentas. A detecção automatizada de anomalias compara uma janela móvel com uma linha de base histórica e dispara um alerta quando o desvio excede um limiar.

import statistics

def detect_anomaly(recent_values, baseline_values, threshold_std=2.0):
    if len(baseline_values) < 10:
        return False  # not enough data
    baseline_mean = statistics.mean(baseline_values)
    baseline_std = statistics.stdev(baseline_values)
    recent_mean = statistics.mean(recent_values)

    if baseline_std == 0:
        return False
    z_score = abs(recent_mean - baseline_mean) / baseline_std
    return z_score > threshold_std

# Example: detect quality regression
baseline_quality = [4.1, 4.0, 4.2, 4.1, 4.0, 3.9, 4.1, 4.2, 4.0, 4.1]
recent_quality   = [3.2, 3.1, 3.4, 3.0]

if detect_anomaly(recent_quality, baseline_quality):
    print('ALERT: Quality score anomaly detected!')
    # fire_pagerduty_alert(...)
else:
    print('Quality within normal range')

Regras e limiares de alerta

Defina regras de alerta como código para que tenham controle de versões e possam ser revisadas. Alertas comuns do monitoramento de instruções:

  • Taxa de erros > 5% por 5 minutos consecutivos
  • Latência P95 > 10s por 3 minutos
  • Custo por dia > 2× a média semanal (pico de custo)
  • Pontuação de qualidade cai > 20% em relação à linha de base
# alerts.yaml (Grafana alerting or custom)
alerts:
  - name: HighErrorRate
    condition: error_rate > 0.05
    for: 5m
    severity: critical
    message: 'Prompt {prompt_id} error rate {error_rate:.1%} exceeds 5%'

  - name: HighLatencyP95
    condition: p95_latency_ms > 10000
    for: 3m
    severity: warning
    message: 'P95 latency {p95_latency_ms}ms exceeds 10s for {prompt_id}'

  - name: CostSpike
    condition: daily_cost_usd > weekly_avg_daily_cost * 2
    for: 1h
    severity: warning
    message: 'Daily cost ${daily_cost_usd:.2f} is 2x the weekly average'

  - name: QualityRegression
    condition: rolling_quality_avg < baseline_quality_avg * 0.80
    for: 15m
    severity: critical
    message: 'Quality dropped {pct_drop:.0%} for prompt {prompt_id}'

Sinais de satisfação do usuário

As métricas automatizadas não capturam tudo. Colete sinais explícitos e implícitos dos usuários para complementar as pontuações de qualidade:

  • Avaliação por polegar: 👍/👎 explícito nas respostas da IA
  • Taxa de repetição: o usuário envia imediatamente a mesma consulta novamente (insatisfação implícita)
  • Taxa de cópia/uso: o usuário copia a saída da IA (satisfação implícita)
  • Taxa de correção: o usuário edita a saída da IA antes de utilizá-la
# feedback_collector.py
def record_feedback(prompt_id, version, call_id, signal_type, value):
    '''
    signal_type: 'thumbs' | 'retry' | 'copy' | 'edit'
    value: for thumbs: 1 (up) or -1 (down); others: 1 (occurred)
    '''
    db.execute(
        'INSERT INTO prompt_feedback '
        '(prompt_id, version, call_id, signal_type, value, ts) '
        'VALUES (%s, %s, %s, %s, %s, NOW())',
        (prompt_id, version, call_id, signal_type, value)
    )

# Aggregate satisfaction score
def satisfaction_score(prompt_id, version):
    rows = db.fetch(
        'SELECT signal_type, AVG(value) as avg_val FROM prompt_feedback '
        'WHERE prompt_id=%s AND version=%s GROUP BY signal_type',
        (prompt_id, version)
    )
    return {r['signal_type']: round(r['avg_val'], 3) for r in rows}

Relatórios de comparação de versões

Ao avaliar se deve promover ou reverter uma versão canário, gere uma comparação lado a lado de todas as métricas entre a nova versão e a linha de base. Esse relatório orienta a decisão de promoção.

def version_comparison_report(prompt_id, version_a, version_b, hours=48):
    stats_a = get_dashboard_stats_for_version(prompt_id, version_a, hours)
    stats_b = get_dashboard_stats_for_version(prompt_id, version_b, hours)

    print(f'=== Comparison: {version_a} vs {version_b} ===')
    metrics = ['avg_latency', 'p95_latency', 'avg_cost', 'avg_quality', 'error_rate']
    for m in metrics:
        va = stats_a.get(m, 0)
        vb = stats_b.get(m, 0)
        delta = vb - va
        pct = (delta / va * 100) if va else 0
        direction = '+' if delta > 0 else ''
        print(f'{m:20s}: {va:.4f} -> {vb:.4f}  ({direction}{pct:.1f}%)')

# Example output:
# avg_latency         : 1234.5000 -> 1189.2000  (-3.7%)
# p95_latency         : 3210.0000 -> 3050.0000  (-5.0%)
# avg_cost            : 0.000240 -> 0.000255  (+6.2%)
# avg_quality         : 4.1000 -> 4.3000  (+4.9%)
# error_rate          : 0.0120 -> 0.0080  (-33.3%)

Verificação rápida

Você deseja detectar automaticamente regressões de qualidade sem verificar os painéis manualmente. Qual abordagem realiza isso melhor?

Resumo do monitoramento

O monitoramento de instruções em produção exige acompanhar cinco dimensões por versão:

  • Latência (P50/P95/P99) — experiência do usuário
  • Custo por chamada — saúde financeira
  • Pontuação de qualidade — amostragem automatizada avaliada por LLM
  • Taxa de erros — confiabilidade
  • Satisfação do usuário — avaliações por polegar, repetições e sinais de cópia

Armazene as métricas em um banco de dados de séries temporais, visualize-as em painéis e dispare alertas quando os limiares forem ultrapassados. Os relatórios de comparação de versões orientam as decisões de promoção e reversão.

Perguntas Frequentes

A aula “Monitorando o desempenho dos prompts em produção” é grátis?

Sim — o texto completo de “Monitorando o desempenho dos prompts em produção” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “Monitorando o desempenho dos prompts em produção”?

Acompanhamento da latência, do custo, das pontuações de qualidade e das taxas de falha por versão do prompt. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Monitorando o desempenho dos prompts em produção”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Arquitetura de registro de prompts
  2. Controle de versões para prompts
  3. Estratégias de implantação e reversão
  4. Monitorando o desempenho dos prompts em produção
← Voltar para AI Prompt Engineering