Observabilidade e Monitoramento para LLMs

Por Que Observabilidade em LLMs?

• *ebug:*LLMs são caixas pretas — ver o que entra e sai de cada camada da pipeline
• *ustos:*Monitorar gastos por API (tokens de entrada/saída por endpoint)
• *ualidade:*Rastrear latências, taxa de erros, qualidade das respostas
• *eedback:*Coletar thumbs-up/down do usuário para dados de preferência

Plataformas de LLM Observability

LangFuse

• *RL:*langfuse.com
• *pensource:*Sim (selfhostável)
• *eatures:*Traces, spans, prompts versionados, scores, datasets, playground
• *ntegração:*langfuse SDK para Python/JS; integrações com LangChain, LlamaIndex, OpenAI
• *uando usar:*Selfhosted; opensource; privacy-first
• *uto-host:*Docker compose; PostgreSQL

from langfuse.openai import openai  # drop-in replacement
response = openai.chat.completions.create(...)  # auto-traced

Phoenix (Arize)

• *RL:*phoenix.arize.com · github.comArize-aiphoenix
• *pen-source:*Sim
• *eatures:*Traces (OpenTelemetry), evals automáticos, datasets, embeddings explorer
• *ntegração:*OpenTelemetry-native; funciona com qualquer LLM
• *iferencial:*Evals integrados (hallucination, relevância, toxicidade)

Helicone

• *RL:*helicone.ai
• *odelo:*Proxy reverso — troca openai.com por oai.helicone.ai
• *eatures:*Custos, latências, rate limiting, caching, usuário tracking
• *ero-code:*Só muda a URL base
• *uando usar:*Monitoramento de custos de API sem código

Braintrust

• *RL:*braintrustdata.com
• *oco:*Evals + datasets + tracing integrados
• *iferencial:*CI/CD para evals — roda benchmark a cada PR

PromptLayer

• *RL:*promptlayer.com
• *oco:*Versionamento de prompts + tracing
• *uando usar:*Times com muitos prompts em produção

Weights & Biases (Wandb)

• *RL:*wandb.ai
• *oco primário:*Treino de modelos (curvas de loss, hiperparâmetros, artifacts)
• *LM features:*Prompt versioning, traces, evals, Weave framework
• *uando usar:*Já usa wandb para treino; também quer monitorar produção

MLflow

• *RL:*mlflow.org (Linux Foundation)
• *pensource:*Sim (selfhostável)
• *eatures:*Experiment tracking, model registry, serving, tracing (LLM)
• *ackend:*PostgreSQL + S3/MinIO para artifacts
• *uando usar:*Stack totalmente open-source; integração com Spark/Databricks

Pipeline de Dados

datatrove (HuggingFace)

• *RL:*github.comhuggingfacedatatrove
• *oco:*Processamento de dados de pré-treino em larga escala
• *eatures:*Leitores (Common Crawl, Parquet, JSON), filtros, deduplicação, writers
• *aralelismo:*Nativo; processa petabytes de dados
• *so:*FineWeb foi construído com datatrove

HuggingFace Datasets

• *RL:*huggingface.codocsdatasets
• *eatures:*Arrow format, streaming, map/filter paralelos, pushtohub
• *ntegração:*PyTorch DataLoader, JAX, Spark
• *eduplicação:*MinHash LSH via datasets.dedup

datasketch

• *RL:*github.comekzhudatasketch
• *lgoritmos:*MinHash LSH, HyperLogLog, TopK
• *so:*Deduplicação near-duplicate em datasets de texto/código

Profiling e Performance

PyTorch Profiler

with torch.profiler.profile(activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA]) as prof:
    model(x)
print(prof.key_averages().table(sort_by="cuda_time_total"))

• Identifica bottlenecks: qual op consome mais tempo/memória

NVIDIA Nsight Systems / Nsight Compute

• *sight Systems:*Timeline de CPU+GPU; visualização de streams e gaps
• *sight Compute:*Profiling por kernel; roofline analysis
• *so:*Identificar se estamos memorybound ou computebound

torch.cuda.memory_summary()

print(torch.cuda.memory_summary(device=None, abbreviated=False))

• Rastreia onde a VRAM está sendo consumida

Métricas de Produção

Latência

Throughput

Custo

OpenTelemetry para LLMs

• *adrão emergente:*OpenTelemetry Semantic Conventions for LLMs (OTEL SIG)
• *tributos:*gen_ai.system, gen_ai.model, gen_ai.input.tokens, gen_ai.output.tokens
• *xporters:*Jaeger, Zipkin, Prometheus, OTLP (para Phoenix, Grafana, etc.)

Stack de Observabilidade Recomendado para Kode

Desenvolvimento:    LangFuse self-hosted (traces + prompts versionados)
Treino:             W&B (loss curves, artifacts, evals)
Produção:           LangFuse (traces) + Prometheus/Grafana (métricas)
Custos:             Helicone (se usando API OpenAI/Anthropic)
Evals contínuos:    Phoenix (RAGAS score, hallucination detection)