Belajar AI Engineer - Guardrails & Moderation

#Pendahuluan

Di episode 18 kalian mengamankan sistem dari serangan. Episode ini melengkapi dengan lapisan kedua: guardrails — mekanisme yang memastikan produk AI hanya melakukan yang diizinkan, pada input maupun output. Ini bukan tentang penyerang; ini tentang kegagalan biasa: model yang menjawab di luar kebijakan, output beracun, atau tool yang terpanggil tanpa izin.

Mengapa penting? Karena model tidak punya "kebijakan produk" — ia punya preferensi yang dipelajari dari data, bukan aturan yang ditetapkan tim. Guardrail adalah tempat kebijakan produk ditulis sebagai kode: tegas, deterministik, dan bisa diuji — tidak bergantung pada suasana hati model.

#Prinsip: Jangan Percaya Model Seutuhnya

Aturan pertama guardrails: input tidak tepercaya, output juga tidak tepercaya. Model adalah komponen yang bisa saja melanggar kebijakan — tugas kalian menyaring di kedua arah:

100%

• Input guardrails: sanitasi (episode 18), limitasi, deteksi injeksi.
• Output guardrails: validasi format, filter konten, cek kebijakan.

#Validasi Output: Benteng Terakhir Format

Output model harus lolos validasi sebelum dipakai. Pola yang benar: parse dulu, validasi, baru aksi:

Validasi output terstruktur

from pydantic import BaseModel, ValidationError
from openai import OpenAI
 
client = OpenAI()
 
class Rekomendasi(BaseModel):
    produk: str
    alasan: str
    harga_max: int
 
def aman_parse(rekomendasi_raw: str) -> Rekomendasi | None:
    try:
        return Rekomendasi.model_validate_json(rekomendasi_raw)
    except ValidationError as e:
        # output tidak valid -> coba ulang sekali, lalu tolak
        print("guardrail: output tidak valid", e.errors())
        return None
 
def call_with_guard(prompt: str) -> Rekomendasi | None:
    r = client.beta.chat.completions.parse(
        model="gpt-4o-mini", messages=[{"role": "user", "content": prompt}],
        response_format=Rekomendasi,
    )
    return aman_parse(r.choices[0].message.content)

Validasi skema menolak output yang tidak sesuai format — output yang tidak bisa diparse tidak boleh sampai ke UI atau database.

#Validasi Bisnis: Aturan Logis

Selain format, validasi isi terhadap aturan produk. Contoh nyata: produk e-commerce dengan aturan "diskon maksimal 50%".

Aturan bisnis sebagai guardrail

def check_policy(rek: Rekomendasi, MAX_DISKON: int = 50) -> bool:
    if rek.harga_max <= 0:
        return False
    # klaim diskon > 50% selalu ditolak
    if rek.alasan and "diskon" in rek.alasan.lower():
        return False  # contoh: fitur rekomendasi tidak boleh menawarkan diskon
    return True
 
rekomendasi = call_with_guard("Rekomendasikan produk di bawah 200 ribu")
if rekomendasi and check_policy(rekomendasi):
    apply(rekomendasi)
else:
    fallback_response()  # episode 25

Perhatikan pola penting: aturan bisnis ditulis eksplisit sebagai kode — bukan sebagai instruksi dalam prompt yang bisa dilanggar model.

#Toxicity Filter dan Moderasi Konten

Untuk produk dengan konten publik (komentar, review, chat terbuka), filter toxic wajib. Pendekatan berlapis:

1. API moderasi (OpenAI Moderation, Perspective): klasifikasi cepat untuk toxic/sexual/hate.
2. Filter keyword + regex untuk pola eksplisit.
3. Human review untuk kasus yang tidak yakin.

Moderasi berlapis

from openai import OpenAI
 
client = OpenAI()
 
def moderate(text: str) -> str:
    r = client.moderations.create(input=text)
    kategori = r.results[0].categories
    flagged = r.results[0].flagged
 
    if flagged:
        return "blokir"  # terbukti toxic
    if any(k for k, v in kategori.model_dump().items() if v):
        return "tinjau"  # tidak yakin -> human review
    return "izinkan"

Hasil tinjau penting: jangan memblokir otomatis hal yang ambigu — kirim ke human review, dan catat datanya untuk evaluasi (episode 9).

#Policy Enforcement: Kebijakan sebagai Kode

Produk AI membutuhkan kebijakan yang dieksekusi, bukan sekadar "diharapkan": kebijakan tentang topik yang boleh dibahas, tool yang boleh dipanggil, data yang boleh diakses. Implementasinya memakai pola decision layer — semua keputusan penting melalui satu lapisan terpusat:

Policy engine terpusat

POLICIES = {
    "no_pii_output": lambda x: not contains_pii(x),
    "no_internal_refs": lambda x: "internal" not in x.lower(),
    "max_len": lambda x: len(x) <= 1000,
}
 
def enforce_policies(output: str, allowed: set[str]) -> tuple[bool, str]:
    for name, check in POLICIES.items():
        if name in allowed and not check(output):
            return False, name
    return True, ""

Dengan policy engine terpusat, menambah/mengubah kebijakan = mengubah satu file + menguji — bukan mengubah prompt di 10 tempat.

#Guardrail Framework dan Self-Check

Framework seperti NeMo Guardrails dan Guardrails AI menyediakan validators siap pakai. Ada juga pola self-check — minta model menilai outputnya sendiri:

Self-check output

SELFCHECK = """Output di bawah tidak boleh: mengandung data pribadi,
memberi saran medis/legal, atau membantu tindakan ilegal.
Balas hanya dengan JAWABAN_AMAN atau JAWABAN_BERISIKO.
Output: {output}"""
 
def self_check(output: str) -> str:
    r = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": SELFCHECK.format(output=output)}],
        max_tokens=10, temperature=0)
    return r.choices[0].message.content

Self-check menambah biaya dan latensi, tapi berguna untuk output bernilai tinggi. Kombinasi terbaik: rules deterministik (murah) dulu, self-check LLM (mahal) untuk kasus yang lolos rules.

#Common Pitfalls

• Guardrail sebagai prompt: instruksi "jangan bicara X" di system prompt bukan guardrail — ia bisa dilanggar. Guardrail = kode deterministik.
• Satu lapis saja: filter input tanpa validasi output (atau sebaliknya) menyisakan celah.
• Blocking tanpa fallback: produk macet total saat guardrail menolak.
• Guardrail tidak diuji: tambahkan kasus pelanggaran kebijakan ke golden dataset (episode 9) agar regresi terdeteksi.

#Penutup

Inti yang harus dibawa pulang:

• Input dan output sama-sama tidak tepercaya — pasang guardrail di kedua arah.
• Validasi format (pydantic) + isi (aturan bisnis) + kebijakan (policy engine).
• Moderasi berlapis: API moderasi → rules → human review.
• Guardrail adalah kode deterministik dengan fallback wajib.

Di episode 20 selanjutnya kita melindungi data pribadi: privacy & compliance AI — data governance, GDPR & EU AI Act, redaction PII, dan membuat aplikasi AI patuh regulasi. Sampai jumpa di episode 20!