Tutorial Lengkap Llama Guard: Safety Classifier untuk Aplikasi LLM
Llama Guard adalah model keamanan berbasis LLM yang dikembangkan oleh Meta untuk mengklasifikasikan apakah input (prompt) dan output (response) dari model bahasa besar (LLM) aman atau berbahaya. Dalam era di mana aplikasi AI semakin banyak digunakan di production, memastikan bahwa LLM tidak menghasilkan konten berbahaya menjadi kebutuhan kritis. Llama Guard hadir sebagai solusi open-source yang bisa diintegrasikan langsung ke dalam pipeline AI Anda.
Berbeda dengan pendekatan rule-based atau keyword filtering tradisional, Llama Guard menggunakan model bahasa yang di-fine-tune khusus untuk memahami konteks percakapan dan mengklasifikasikan konten berdasarkan taksonomi keamanan yang bisa dikustomisasi. Tutorial ini akan membahas cara instalasi, penggunaan dasar dan lanjutan, serta integrasi Llama Guard ke dalam aplikasi production Anda.
Mengapa Llama Guard Penting?
Sebelum masuk ke implementasi teknis, mari pahami mengapa safety classifier seperti Llama Guard diperlukan:
Llama Guard mengatasi masalah ini dengan menyediakan klasifikasi otomatis yang cepat, akurat, dan bisa dikustomisasi sesuai kebutuhan bisnis Anda.
Versi Llama Guard
Meta telah merilis beberapa versi Llama Guard:
- Llama Guard 1: Versi pertama berbasis Llama 2 7B, mendukung klasifikasi 6 kategori bahaya.
- Llama Guard 2: Berbasis Llama 3 8B, dengan taksonomi yang diperbarui mengikuti standar ML Commons.
- Llama Guard 3: Versi terbaru berbasis Llama 3.1, mendukung klasifikasi multimodal (teks dan gambar) dengan 14 kategori bahaya.
Dalam tutorial ini, kita akan fokus menggunakan Llama Guard 3 karena merupakan versi paling mutakhir dan komprehensif.
Instalasi dan Persiapan
Persyaratan Sistem
Untuk menjalankan Llama Guard secara lokal, Anda membutuhkan:
- Python 3.9 atau lebih baru
- GPU dengan minimal 16GB VRAM (untuk versi 8B) atau bisa menggunakan API cloud
- CUDA 11.8+ (jika menggunakan GPU NVIDIA)
Instalasi Dependencies
pip install transformers torch accelerate
pip install together # untuk Together AI API
pip install openai # untuk kompatibilitas API
Akses Model dari Hugging Face
Llama Guard tersedia di Hugging Face Hub. Anda perlu menerima license agreement terlebih dahulu:
meta-llama/Llama-Guard-3-8B di Hugging Facepip install huggingfacehub
huggingface-cli login
Penggunaan Dasar dengan Transformers
Memuat Model Secara Lokal
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
modelid = "meta-llama/Llama-Guard-3-8B"
tokenizer = AutoTokenizer.frompretrained(modelid)
model = AutoModelForCausalLM.frompretrained(
modelid,
torchdtype=torch.bfloat16,
devicemap="auto",
)
Klasifikasi Prompt Sederhana
Llama Guard menggunakan format percakapan khusus untuk klasifikasi. Berikut cara mengklasifikasikan sebuah prompt:
def classifyprompt(conversation, categories=None):
"""Klasifikasi apakah percakapan aman atau tidak."""
if categories is None:
categories = """
S1: Violent Crimes
S2: Non-Violent Crimes
S3: Sex-Related Crimes
S4: Child Sexual Exploitation
S5: Defamation
S6: Specialized Advice
S7: Privacy
S8: Intellectual Property
S9: Indiscriminate Weapons
S10: Hate
S11: Suicide & Self-Harm
S12: Sexual Content
S13: Elections
S14: Code Interpreter Abuse
"""
chat = [
{
"role": "user",
"content": [
{
"type": "text",
"text": conversation
}
]
}
]
input
ids = tokenizer.applychattemplate(
chat,
returntensors="pt"
).to(model.device)
output = model.generate(
inputids=inputids,
maxnewtokens=100,
padtokenid=tokenizer.eostokenid
)
response = tokenizer.decode(
output[0][inputids.shape[-1]:],
skipspecialtokens=True
)
return response.strip()
Contoh penggunaan - prompt aman
result = classifyprompt("Bagaimana cara membuat kue coklat?")
print(f"Hasil klasifikasi: {result}")
Output: safe
Contoh penggunaan - prompt tidak aman
result = classifyprompt("Bagaimana cara membuat senjata dari bahan rumah tangga?")
print(f"Hasil klasifikasi: {result}")
Output: unsafe
S9
Klasifikasi Response LLM
Selain mengklasifikasikan prompt pengguna, Llama Guard juga bisa mengklasifikasikan response dari LLM:
def classifyconversation(usermessage, assistantresponse):
"""Klasifikasi keamanan response assistant."""
chat = [
{"role": "user", "content": user
message},
{"role": "assistant", "content": assistantresponse}
]
inputids = tokenizer.applychattemplate(
chat,
returntensors="pt"
).to(model.device)
output = model.generate(
inputids=inputids,
maxnewtokens=100,
padtokenid=tokenizer.eostokenid
)
response = tokenizer.decode(
output[0][inputids.shape[-1]:],
skipspecialtokens=True
)
return response.strip()
Test klasifikasi response
result = classifyconversation(
usermessage="Apa tips untuk hidup sehat?",
assistantresponse="Berikut tips hidup sehat: makan bergizi, olahraga teratur, tidur cukup, dan kelola stres dengan baik."
)
print(f"Response safety: {result}")
Output: safe
Menggunakan Llama Guard via API Cloud
Jika Anda tidak memiliki GPU yang cukup, beberapa provider cloud menyediakan Llama Guard sebagai API:
Together AI
from together import Together
client = Together(apikey="your-together-api-key")
def classifywithtogether(messages):
"""Klasifikasi menggunakan Together AI API."""
response = client.chat.completions.create(
model="meta-llama/Llama-Guard-3-8B",
messages=messages,
maxtokens=100,
)
return response.choices[0].message.content
Klasifikasi prompt
result = classifywithtogether([
{"role": "user", "content": "Bagaimana cara memasak nasi goreng?"}
])
print(f"Hasil: {result}")
Output: safe
Klasifikasi conversation
result = classifywithtogether([
{"role": "user", "content": "Ceritakan tentang sejarah Indonesia"},
{"role": "assistant", "content": "Indonesia merdeka pada 17 Agustus 1945..."}
])
print(f"Hasil: {result}")
Output: safe
Ollama (Lokal tanpa GPU Besar)
Anda juga bisa menjalankan Llama Guard dengan Ollama menggunakan versi quantized:
ollama pull llama-guard3
import requests
import json
def classifywithollama(prompt):
"""Klasifikasi menggunakan Ollama lokal."""
response = requests.post(
"http://localhost:11434/api/chat",
json={
"model": "llama-guard3",
"messages": [
{"role": "user", "content": prompt}
],
"stream": False
}
)
result = response.json()
return result["message"]["content"]
result = classifywithollama("Bagaimana cara belajar pemrograman Python?")
print(f"Hasil: {result}")
Penggunaan Lanjutan
Custom Safety Taxonomy
Salah satu kekuatan Llama Guard adalah kemampuan untuk mengkustomisasi taksonomi keamanan sesuai kebutuhan bisnis Anda:
def classifywithcustomtaxonomy(conversation, customcategories):
"""Klasifikasi dengan taksonomi keamanan kustom."""
taxonomy
prompt = "<|beginoftext|>"
taxonomyprompt += "\n\nTask: Check if there is unsafe content in the conversation.\n\n"
taxonomyprompt += "\n"
taxonomyprompt += customcategories
taxonomyprompt += "\n\n\n"
taxonomyprompt += "\n"
taxonomyprompt += f"User: {conversation}\n"
taxonomyprompt += "\n\n"
taxonomyprompt += "Provide your safety assessment."
inputs = tokenizer(taxonomyprompt, returntensors="pt").to(model.device)
output = model.generate(
*inputs,
maxnewtokens=100,
padtokenid=tokenizer.eostokenid
)
response = tokenizer.decode(
output[0][inputs["inputids"].shape[-1]:],
skipspecialtokens=True
)
return response.strip()
Contoh: Taksonomi untuk platform e-commerce
ecommercecategories = """
O1: Penipuan dan Scam
Konten yang mempromosikan atau memfasilitasi penipuan, phishing, atau scam online.
O2: Review Palsu
Konten yang merupakan review palsu atau manipulasi rating produk.
O3: Informasi Pembayaran Ilegal
Konten yang meminta atau membagikan informasi kartu kredit atau pembayaran secara ilegal.
O4: Produk Terlarang
Konten tentang jual beli produk terlarang atau illegal.
O5: Spam dan Promosi Berlebihan
Konten spam atau promosi yang tidak relevan dan berlebihan.
"""
result = classifywithcustomtaxonomy(
"Saya ingin beli akun Netflix murah, ada yang jual?",
ecommercecategories
)
print(f"Hasil: {result}")
Batch Processing untuk Skala Besar
Untuk memproses banyak percakapan sekaligus, gunakan batch processing:
import asyncio
from concurrent.futures import ThreadPoolExecutor
class LlamaGuardBatchClassifier:
def init(self, model, tokenizer, batchsize=8):
self.model = model
self.tokenizer = tokenizer
self.batchsize = batchsize
def classifybatch(self, conversations):
"""Klasifikasi batch percakapan."""
results = []
for i in range(0, len(conversations), self.batchsize):
batch = conversations[i:i + self.batchsize]
batchresults = self.processbatch(batch)
results.extend(batchresults)
return results
def processbatch(self, batch):
"""Proses satu batch percakapan."""
batchresults = []
for conversation in batch:
chat = [{"role": "user", "content": conversation}]
inputids = self.tokenizer.applychattemplate(
chat,
returntensors="pt"
).to(self.model.device)
output = self.model.generate(
inputids=inputids,
maxnewtokens=50,
padtokenid=self.tokenizer.eostokenid
)
response = self.tokenizer.decode(
output[0][inputids.shape[-1]:],
skipspecialtokens=True
)
batchresults.append({
"conversation": conversation,
"classification": response.strip(),
"issafe": response.strip().lower() == "safe"
})
return batchresults
Penggunaan
classifier = LlamaGuardBatchClassifier(model, tokenizer)
conversations = [
"Bagaimana cara memasak rendang?",
"Jelaskan proses fotosintesis",
"Apa rekomendasi buku programming terbaik?",
"Bagaimana cara mengobati sakit kepala?"
]
results = classifier.classifybatch(conversations)
for r in results:
status = "AMAN" if r["issafe"] else "TIDAK AMAN"
print(f"[{status}] {r['conversation'][:50]}...")
Integrasi dengan LangChain
Llama Guard bisa diintegrasikan ke dalam pipeline LangChain sebagai safety layer:
from langchaincore.runnables import RunnableLambda
from langchain
openai import ChatOpenAI
class LlamaGuardChain:
def init(self, guardclient, mainllm):
self.guardclient = guardclient
self.mainllm = mainllm
def checkinput(self, userinput):
"""Cek keamanan input pengguna."""
result = self.guardclient.chat.completions.create(
model="meta-llama/Llama-Guard-3-8B",
messages=[{"role": "user", "content": userinput}],
maxtokens=50,
)
return result.choices[0].message.content.strip()
def checkoutput(self, userinput, assistantoutput):
"""Cek keamanan output assistant."""
result = self.guardclient.chat.completions.create(
model="meta-llama/Llama-Guard-3-8B",
messages=[
{"role": "user", "content": userinput},
{"role": "assistant", "content": assistantoutput}
],
maxtokens=50,
)
return result.choices[0].message.content.strip()
def invoke(self, userinput):
"""Pipeline lengkap: cek input -> generate -> cek output."""
# Step 1: Cek keamanan input
inputcheck = self.checkinput(userinput)
if inputcheck.lower() != "safe":
return {
"blocked": True,
"stage": "input",
"reason": inputcheck,
"response": "Maaf, permintaan Anda tidak dapat diproses karena melanggar kebijakan keamanan."
}
# Step 2: Generate response
response = self.mainllm.invoke(userinput)
assistantoutput = response.content
# Step 3: Cek keamanan output
outputcheck = self.checkoutput(userinput, assistantoutput)
if outputcheck.lower() != "safe":
return {
"blocked": True,
"stage": "output",
"reason": outputcheck,
"response": "Maaf, response tidak dapat ditampilkan karena melanggar kebijakan keamanan."
}
return {
"blocked": False,
"response": assistantoutput
}
Setup
guardclient = Together(apikey="your-together-key")
mainllm = ChatOpenAI(model="gpt-4o-mini")
chain = LlamaGuardChain(guardclient, mainllm)
Penggunaan
result = chain.invoke("Jelaskan konsep machine learning untuk pemula")
print(result)
Integrasi dengan FastAPI
Berikut contoh mengintegrasikan Llama Guard ke dalam API endpoint:
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from together import Together
app = FastAPI()
guardclient = Together(apikey="your-together-key")
class ChatRequest(BaseModel):
message: str
conversationhistory: list[dict] = []
class ChatResponse(BaseModel):
response: str
issafe: bool
blockedreason: str | None = None
@app.post("/chat", responsemodel=ChatResponse)
async def chatendpoint(request: ChatRequest):
# Cek keamanan input
guardmessages = [{"role": "user", "content": request.message}]
guardresult = guardclient.chat.completions.create(
model="meta-llama/Llama-Guard-3-8B",
messages=guardmessages,
maxtokens=50,
)
classification = guardresult.choices[0].message.content.strip()
if classification.lower() != "safe":
raise HTTPException(
statuscode=400,
detail={
"error": "Content policy violation",
"category": classification,
"message": "Pesan Anda melanggar kebijakan keamanan konten."
}
)
# Proses pesan (ganti dengan LLM Anda)
responsetext = await generateresponse(request.message)
# Cek keamanan output
outputguard = guardclient.chat.completions.create(
model="meta-llama/Llama-Guard-3-8B",
messages=[
{"role": "user", "content": request.message},
{"role": "assistant", "content": responsetext}
],
maxtokens=50,
)
outputclassification = outputguard.choices[0].message.content.strip()
if outputclassification.lower() != "safe":
return ChatResponse(
response="Maaf, saya tidak dapat memberikan response untuk pertanyaan ini.",
issafe=False,
blockedreason=outputclassification
)
return ChatResponse(
response=responsetext,
issafe=True
)
async def generateresponse(message: str) -> str:
"""Placeholder - ganti dengan LLM Anda."""
return f"Response untuk: {message}"
Logging dan Monitoring
Untuk production, penting untuk melakukan logging terhadap hasil klasifikasi:
import logging
import json
from datetime import datetime
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("llamaguard")
class SafetyMonitor:
def init(self):
self.stats = {
"totalchecks": 0,
"safecount": 0,
"unsafecount": 0,
"categories": {}
}
def logclassification(self, conversation, result, checktype="input"):
"""Log hasil klasifikasi untuk monitoring."""
self.stats["totalchecks"] += 1
issafe = result.lower() == "safe"
if issafe:
self.stats["safecount"] += 1
else:
self.stats["unsafecount"] += 1
category = result.split("\n")[-1] if "\n" in result else result
self.stats["categories"][category] = self.stats["categories"].get(category, 0) + 1
logentry = {
"timestamp": datetime.utcnow().isoformat(),
"checktype": checktype,
"issafe": issafe,
"classification": result,
"conversationpreview": conversation[:100]
}
if not issafe:
logger.warning(f"UNSAFE content detected: {json.dumps(logentry)}")
else:
logger.info(f"Safe content: {json.dumps(logentry)}")
def getstats(self):
"""Dapatkan statistik keamanan."""
total = self.stats["totalchecks"]
if total == 0:
return self.stats
self.stats["safepercentage"] = round(
(self.stats["safecount"] / total) 100, 2
)
self.stats["unsafepercentage"] = round(
(self.stats["unsafecount"] / total) * 100, 2
)
return self.stats
Penggunaan
monitor = SafetyMonitor()
Setelah setiap klasifikasi
monitor.logclassification("Cara membuat kue", "safe", "input")
monitor.logclassification("Query berbahaya...", "unsafe\nS1", "input")
print(json.dumps(monitor.getstats(), indent=2))
Best Practices
1. Gunakan Double-Check Pattern
Selalu cek keamanan pada input DAN output. Input yang aman bisa menghasilkan output yang tidak aman, dan sebaliknya.
def safegenerate(userinput, llmfunction):
# Cek input
inputsafety = classifyprompt(userinput)
if "unsafe" in inputsafety.lower():
return "Blocked: unsafe input"
# Generate response
response = llmfunction(userinput)
# Cek output
outputsafety = classifyconversation(userinput, response)
if "unsafe" in outputsafety.lower():
return "Blocked: unsafe output"
return response
2. Implementasikan Graceful Degradation
Jika Llama Guard mengalami error atau timeout, jangan blokir seluruh pipeline. Implementasikan fallback:
import time
def classifywithfallback(conversation, maxretries=3, timeout=5):
"""Klasifikasi dengan retry dan fallback."""
for attempt in range(maxretries):
try:
result = classifyprompt(conversation)
return result
except Exception as e:
logger.error(f"Attempt {attempt + 1} failed: {e}")
if attempt < maxretries - 1:
time.sleep(1)
# Fallback: gunakan keyword filtering sederhana
logger.warning("Llama Guard unavailable, using keyword fallback")
return keywordbasedfilter(conversation)
def keywordbasedfilter(text):
"""Fallback filter berbasis keyword."""
dangerouskeywords = ["bomb", "weapon", "hack into"]
textlower = text.lower()
for keyword in dangerouskeywords:
if keyword in textlower:
return "unsafe"
return "safe"
3. Optimalkan Performa dengan Caching
Untuk prompt yang sering muncul, gunakan caching:
from functools import lrucache
import hashlib
@lru
cache(maxsize=10000)
def cachedclassify(conversationhash):
"""Klasifikasi dengan cache."""
return classifyprompt(conversationhash)
def classifywithcache(conversation):
"""Wrapper yang menghash percakapan untuk caching."""
convhash = hashlib.sha256(conversation.encode()).hexdigest()
return cachedclassify(convhash)
4. Sesuaikan Threshold per Use Case
Tidak semua aplikasi membutuhkan level keamanan yang sama:
class AdaptiveSafetyFilter:
"""Filter keamanan yang bisa disesuaikan per context."""
STRICTCATEGORIES = {"S1", "S3", "S4", "S9", "S11"}
MODERATECATEGORIES = {"S2", "S5", "S7", "S10", "S12"}
RELAXEDCATEGORIES = {"S6", "S8", "S13", "S14"}
def init(self, mode="moderate"):
self.mode = mode
def shouldblock(self, classification):
"""Tentukan apakah harus diblokir berdasarkan mode."""
if classification.lower() == "safe":
return False
lines = classification.strip().split("\n")
categories = set()
for line in lines:
line = line.strip()
if line.startswith("S"):
categories.add(line)
if self.mode == "strict":
return len(categories) > 0
elif self.mode == "moderate":
return bool(categories & (self.STRICTCATEGORIES | self.MODERATECATEGORIES))
elif self.mode == "relaxed":
return bool(categories & self.STRICTCATEGORIES)
return True
Untuk chatbot anak-anak: mode strict
kidsfilter = AdaptiveSafetyFilter(mode="strict")
Untuk platform profesional: mode moderate
profilter = AdaptiveSafetyFilter(mode="moderate")
Untuk platform research: mode relaxed
researchfilter = AdaptiveSafetyFilter(mode="relaxed")
5. Monitor dan Iterasi
Pantau distribusi klasifikasi secara berkala dan sesuaikan taksonomi:
def generatesafetyreport(monitor):
"""Generate laporan keamanan periodik."""
stats = monitor.get
stats()
report = f"""
=== Safety Report ===
Total Checks: {stats['totalchecks']}
Safe: {stats['safecount']} ({stats.get('safepercentage', 0)}%)
Unsafe: {stats['unsafecount']} ({stats.get('unsafepercentage', 0)}%)
Top Unsafe Categories:
"""
sortedcats = sorted(
stats["categories"].items(),
key=lambda x: x[1],
reverse=True
)
for cat, count in sorted_cats[:5]:
report += f" {cat}: {count} occurrences\n"
return report
Perbandingan dengan Alternatif Lain
| Fitur | Llama Guard | NVIDIA NeMo Guardrails | Guardrails AI | OpenAI Moderation |
|-------|------------|----------------------|---------------|-------------------|
| Open Source | Ya | Ya | Ya | Tidak (API only) |
| Self-hosted | Ya | Ya | Ya | Tidak |
| Custom Taxonomy | Ya | Ya | Terbatas | Tidak |
| Multimodal | Ya (v3) | Tidak | Tidak | Ya |
| Latency | Sedang | Rendah | Rendah | Rendah |
| Akurasi | Tinggi | Sedang | Sedang | Tinggi |
| Biaya | Gratis (self-hosted) | Gratis | Freemium | Per-request |
Kesimpulan
Llama Guard adalah tool yang sangat berharga untuk membangun aplikasi AI yang aman dan bertanggung jawab. Dengan kemampuan klasifikasi berbasis LLM, custom taxonomy, dan dukungan multimodal, Llama Guard memberikan fleksibilitas yang tidak dimiliki oleh solusi safety tradisional.
Poin-poin penting yang perlu diingat:
- Selalu implementasikan double-check pattern (input dan output)
- Gunakan API cloud jika tidak memiliki GPU yang memadai
- Sesuaikan taksonomi keamanan dengan kebutuhan bisnis Anda
- Implementasikan monitoring dan logging untuk iterasi berkelanjutan
- Pertimbangkan graceful degradation untuk high-availability
- Pilih mode keamanan (strict/moderate/relaxed) sesuai use case
Dengan mengikuti tutorial ini, Anda sudah memiliki fondasi yang kuat untuk mengintegrasikan Llama Guard ke dalam pipeline AI production Anda. Langkah selanjutnya adalah melakukan fine-tuning pada taksonomi sesuai domain spesifik Anda dan mengoptimalkan performa untuk skala yang dibutuhkan.