Belajar Generative AI - Observability & Monitoring

#Pendahuluan

Di episode 15 kalian belajar mengevaluasi kualitas LLM; episode ini menangani pertanyaan operasional yang sama pentingnya: bagaimana memantau aplikasi AI yang sudah berjalan? LLM menghadirkan dimensi monitoring yang tidak ada di aplikasi biasa — token, cost per request, hallucination, dan alur multi-langkah yang sulit dilacak.

Mengapa penting? Karena aplikasi AI bisa "berfungsi" tapi diam-diam membakar uang (token), melambat seiring konteks membesar, atau menurun kualitasnya tanpa crash apa pun. Di produksi, kalian butuh jawaban cepat untuk: berapa biaya request ini? kenapa lambat? model mana yang paling sering error? — dan itulah pekerjaan observability AI.

#Metrik yang Harus Dimonitor

Selain metrik aplikasi biasa (error rate, p95 latency, availability), sistem AI butuh metrik spesifik:

#Instrumentasi: Wrapper dan Callback

Mulai dari yang paling sederhana: bungkus pemanggilan LLM agar otomatis mencatat usage. SDK OpenAI menyediakan usage per respons:

MODEL_PRICING = {"gpt-4o-mini": (0.15, 0.60)}   # USD per 1M input/output
 
def call_and_track(prompt_messages):
    t0 = time.perf_counter()
    resp = client.chat.completions.create(
        model="gpt-4o-mini", messages=prompt_messages)
    elapsed = time.perf_counter() - t0
 
    usage = resp.usage
    in_price, out_price = MODEL_PRICING["gpt-4o-mini"]
    cost = usage.prompt_tokens / 1e6 * in_price + \
           usage.completion_tokens / 1e6 * out_price
 
    emit_metric("llm_request_total", 1)
    emit_metric("llm_latency_ms", elapsed * 1000)
    emit_metric("llm_tokens_in", usage.prompt_tokens)
    emit_metric("llm_tokens_out", usage.completion_tokens)
    emit_metric("llm_cost_usd", cost)
    return resp

Wrapper seperti ini adalah langkah pertama dan paling berdampak — bahkan sebelum memakai platform tracing.

#Tracing: Melihat Alur RAG & Agent

Aplikasi AI bukan satu panggilan — ia pipeline: retrieval → prompt → LLM → (agent: loop tool). Untuk men-debug "kenapa jawaban buruk", kalian butuh trace yang menghubungkan semuanya.

#LangSmith

Jika kalian memakai LangChain/LangGraph (episode 10), LangSmith memberi tracing out-of-the-box:

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=lsv2_...
export LANGSMITH_PROJECT=genai-prod

Setiap run agent otomatis tercatat: input, output, tool call, token, latency per node, dan bisa dihubungkan ke dataset evaluasi (episode 15).

#OpenLLMetry / OpenTelemetry GenAI

Untuk stack yang tidak berbasis LangChain, gunakan OpenTelemetry GenAI semantic conventions (kini diadopsi sebagai standar). Contoh dengan OpenLLMetry:

from traceloop.sdk import Traceloop
from traceloop.sdk.decorators import workflow, task
 
Traceloop.init(api_key="...")   # export ke OpenTelemetry collector
 
@workflow(name="rag_qa")
def rag_qa(question):
    docs = retrieve(question)            # task: retrieval
    answer = generate(question, docs)    # task: LLM
    return answer

Trace yang dihasilkan mengikuti konvensi gen_ai.* (model, tokens, embeddings) sehingga bisa dipakai dashboard OpenTelemetry standar.

#Alerting: Kenali yang Salah Sebelum Pengguna

Alert yang berguna untuk sistem AI:

1. Cost spike: cost per hari melonjak dari baseline (misal 2x). Sering menandakan loop agent atau retry yang tak terkendali.

- alert: LLMCostSpike
  expr: sum(rate(llm_cost_usd[1h])) > (baseline * 2)
  labels:
    severity: warning
  annotations:
    summary: "Cost LLM naik 2x dari baseline"

2. TTFT tinggi: streaming lambat = pengguna menunggu. Alert p95 TTFT melewati ambang (misal 5s).
3. Error provider naik: rate 429/5xx dari satu provider → failover atau investigasi.
4. Hallucination/drift: untuk sampel traffic, evaluasi otomatis (episode 15) mendeteksi penurunan faithfulness sebelum keluhan masuk.

#Logging yang Aman (untuk AI)

Logging AI punya dua aturan yang bertolak belakang dengan log biasa:

• Kita BUTUH prompt & response untuk debugging kualitas.
• Kita TIDAK BOLEH log PII (episode 17).

Resolusinya: log dengan redaksi otomatis di titik ingest — redact email, nomor telepon, token akses, sebelum ditulis ke store.

def redact_for_log(text):
    text = re.sub(r"[\w.+-]+@[\w-]+\.[\w.]+", "[EMAIL]", text)
    text = re.sub(r"\+?\d[\d\s\-]{8,}\d", "[PHONE]", text)
    text = re.sub(r"sk-[A-Za-z0-9]{20,}", "[API_KEY]", text)
    return text
 
logger.info("llm_call", extra={"prompt": redact_for_log(prompt),
                                "response": redact_for_log(response)})

#Common Pitfalls

• Hanya memonitor error rate — aplikasi AI bisa "200 OK" tapi berhalusinasi atau boros token.
• Tanpa baseline — alert cost/latency butuh baseline; catat sejak hari pertama.
• Logging raw PII — pelanggaran (episode 17) sekaligus risiko.
• Trace tanpa sample — trace semua request mahal; sample (misal 10-20%) sudah cukup untuk insight.

#Penutup

Inti yang harus dibawa pulang:

• Metrik kunci AI: token, cost, TTFT, latency, tool calls, error by provider.
• Wrapper pemanggilan LLM adalah langkah instrumentasi paling sederhana & berdampak.
• Tracing (LangSmith / OpenTelemetry GenAI) menghubungkan retrieval → prompt → LLM → tools dalam satu trace.
• Alerting: cost spike, TTFT, error provider, drift kualitas — dengan baseline yang dicatat sejak awal.

Di episode 19 selanjutnya kita akan membahas Advanced RAG & Reasoning Models — chain-of-thought, inference-time scaling (o-series/R1), hybrid reasoning, serta agentic RAG, adaptive retrieval, dan self-critique. Sampai jumpa di episode 19!