Guardrail per LLM nella Pratica: Cosa Funziona Davvero
Controlla il rischio, non solo il modello.
I modelli di linguaggio di grandi dimensioni (LLM) sono imprevedibili. Possono allucinare, perdere dati, generare contenuti dannosi o rifiutare richieste legittime. I meccanismi di controllo (guardrails) vincolano il comportamento del modello senza sacrificare le sue capacità.
La chiave sta nel sapere quali meccanismi di controllo sono importanti e quali sono solo rumore.
I guardrails non servono a controllare il modello. Servono a controllare il rischio.
Validazione dell’input
Il meccanismo di controllo più importante. Un input scadente produce un output scadente, e un input scadente può anche iniettare prompt nel tuo sistema.
Strategia 1: Sanitizzazione del Prompt
Sanitizzare precocemente i pattern pericolosi:
import re
class PromptSanitizer:
def __init__(self):
self.dangerous_patterns = [
r"ignore\s+previous\s+instructions",
r"system\s+prompt",
r"you\s+are\s+now\s+free",
r"break\s+out\s+of",
]
def sanitize(self, prompt: str) -> str:
for pattern in self.dangerous_patterns:
prompt = re.sub(pattern, "[REDACTED]", prompt, flags=re.IGNORECASE)
return prompt
Questo non è a prova di proiettile. Gli input avversari sono creativi. Ma cattura quelli evidenti, e quelli evidenti sono i più comuni.
Strategia 2: Limiti di Lunghezza dell’Input
I limiti di lunghezza prevengono lo spreco di token e i timeout:
class InputValidator:
def __init__(self, max_length: int = 10000):
self.max_length = max_length
def validate(self, prompt: str) -> tuple[bool, str]:
if len(prompt) > self.max_length:
return False, f"Input too long: {len(prompt)} > {self.max_length}"
return True, "OK"
Strategia 3: Filtraggio dei Contenuti
Il filtraggio dei contenuti blocca le violazioni delle policy. I pattern qui dipendono dal tuo dominio:
class ContentFilter:
def __init__(self):
self.blocked_topics = [
"violence", "hate speech", "self-harm",
"sexual content", "illegal activities",
]
def filter(self, prompt: str) -> tuple[bool, str]:
prompt_lower = prompt.lower()
for topic in self.blocked_topics:
if topic in prompt_lower:
return False, f"Blocked: {topic}"
return True, "OK"
La semplice corrispondenza di stringhe è veloce ma imprecisa. Per la produzione, utilizzare un modello classificatore — anche uno piccolo come qwen3-1.7b — per rilevare le violazioni delle policy. È più accurato e più difficile da eludere.
Filtraggio dell’output
Anche l’output del modello deve essere verificato. Struttura, contenuto e fatti.
Strategia 1: Validazione della Risposta
Validare prima la struttura. Se ti aspetti JSON, controlla il JSON:
class ResponseValidator:
def __init__(self):
self.required_fields = ["answer", "confidence"]
def validate(self, response: dict) -> tuple[bool, str]:
for field in self.required_fields:
if field not in response:
return False, f"Missing field: {field}"
return True, "OK"
Strategia 2: Filtraggio dei Contenuti
Filtrare i contenuti dannosi:
class OutputFilter:
def __init__(self):
self.blocked_patterns = [
r"kill\s+someone",
r"bomb\s+recipe",
r"hate\s+speech",
r"self-harm",
]
def filter(self, response: str) -> tuple[bool, str]:
for pattern in self.blocked_patterns:
if re.search(pattern, response, re.IGNORECASE):
return False, f"Blocked: {pattern}"
return True, "OK"
Strategia 3: Verifica dei Fatti
La verifica dei fatti è più difficile. Non puoi validare ogni affermazione, quindi scegli quelle che contano:
class FactChecker:
def __init__(self):
self.known_facts = {
"capital of france": "Paris",
"population of usa": "330 million",
"speed of light": "299,792,458 m/s",
}
def check(self, claim: str) -> tuple[bool, str]:
claim_lower = claim.lower()
for fact, truth in self.known_facts.items():
if fact in claim_lower and truth not in claim_lower:
return False, f"Fact check failed: {fact}"
return True, "OK"
Per la vera verifica dei fatti, hai bisogno di una pipeline di recupero. Controlla le affermazioni contro una base di conoscenza, non contro un dizionario hardcoded.
Meccanismi di sicurezza
Strategia 1: Limitazione della Frequenza (Rate Limiting)
La limitazione della frequenza previene l’abuso:
import time
from collections import deque
class RateLimiter:
def __init__(self, max_requests: int = 10, window: int = 60):
self.max_requests = max_requests
self.window = window
self.requests = deque()
def allow(self) -> bool:
now = time.time()
while self.requests and self.requests[0] < now - self.window:
self.requests.popleft()
if len(self.requests) >= self.max_requests:
return False
self.requests.append(now)
return True
Strategia 2: Gestione del Budget Token
La gestione del budget dei token limita i costi per richiesta:
class TokenBudget:
def __init__(self, max_tokens: int = 1000):
self.max_tokens = max_tokens
def validate(self, response: str) -> tuple[bool, str]:
token_count = len(response.split())
if token_count > self.max_tokens:
return False, f"Token limit exceeded: {token_count} > {self.max_tokens}"
return True, "OK"
Strategia 3: Gestione della Finestra di Contesto
La gestione della finestra di contesto previene l’overflow:
class ContextManager:
def __init__(self, max_context: int = 4096):
self.max_context = max_context
self.context = []
def add(self, message: str):
self.context.append(message)
self.trim()
def trim(self):
while len(" ".join(self.context)) > self.max_context:
self.context.pop(0)
Il trimming a finestra scorrevole è semplice ma perde il contesto iniziale. Approcci migliori utilizzano la riassunzione o la compressione basata sull’attenzione, ma questi aggiungono latenza.
Conformità
I sistemi enterprise hanno bisogno di guardrails di conformità. Due che contano di più:
Pattern 1: Residenza dei Dati
Residenza dei dati — assicurarsi che i dati rimangano entro i confini geografici richiesti:
class DataResidency:
def __init__(self, allowed_regions: list[str]):
self.allowed_regions = allowed_regions
def validate(self, region: str) -> tuple[bool, str]:
if region not in self.allowed_regions:
return False, f"Region not allowed: {region}"
return True, "OK"
Pattern 2: Audit Logging
Audit logging — registrare tutte le interazioni del modello:
import json
from datetime import datetime
class AuditLogger:
def __init__(self, log_file: str = "audit.log"):
self.log_file = log_file
def log(self, request: dict, response: dict):
entry = {
"timestamp": datetime.now().isoformat(),
"request": request,
"response": response,
}
with open(self.log_file, "a") as f:
f.write(json.dumps(entry) + "\n")
I log di audit sono critici per il debug e la conformità. Rendili strutturati, in sola scrittura aggiuntiva (append-only) e archiviati in modo sicuro.
Mettere insieme i pezzi
Pattern 1: Guardrails Semplici
Una pipeline di guardrails semplice:
class SimpleGuardrails:
def __init__(self):
self.input_validator = InputValidator(max_length=10000)
self.output_filter = OutputFilter()
def process(self, prompt: str) -> str:
valid, message = self.input_validator.validate(prompt)
if not valid:
return f"Error: {message}"
response = self.call_model(prompt)
valid, message = self.output_filter.filter(response)
if not valid:
return f"Error: {message}"
return response
Pattern 2: Guardrails Avanzati
I guardrails avanzati aggiungono sanitizzazione, limitazione della frequenza e budget dei token:
class AdvancedGuardrails:
def __init__(self):
self.sanitizer = PromptSanitizer()
self.input_validator = InputValidator(max_length=10000)
self.content_filter = ContentFilter()
self.output_filter = OutputFilter()
self.rate_limiter = RateLimiter(max_requests=10)
self.token_budget = TokenBudget(max_tokens=1000)
def process(self, prompt: str) -> str:
prompt = self.sanitizer.sanitize(prompt)
valid, message = self.input_validator.validate(prompt)
if not valid:
return f"Error: {message}"
valid, message = self.content_filter.filter(prompt)
if not valid:
return f"Error: {message}"
if not self.rate_limiter.allow():
return "Error: Rate limit exceeded"
response = self.call_model(prompt)
valid, message = self.output_filter.filter(response)
if not valid:
return f"Error: {message}"
valid, message = self.token_budget.validate(response)
if not valid:
return f"Error: {message}"
return response
Quando i guardrails contano
I guardrails contano quando stai costruendo sistemi orientati all’utente, gestendo dati sensibili o operando in produzione. Contano anche quando hai requisiti di conformità — GDPR, HIPAA, SOC 2.
Non contano quando stai prototipando, usando modelli solo per strumenti interni o non gestendo dati sensibili. Saltali finché non ne hai bisogno.
Il compromesso è sempre capacità versus sicurezza. Più guardrails significano meno errori ma anche meno capacità. Trova l’equilibrio che funziona per il tuo sistema.
Compromessi
| Strategia | Sicurezza | Capacità | Latenza |
|---|---|---|---|
| Nessun guardrail | Minima | Massima | Minima |
| Validazione dell’input | Alta | Media | Bassa |
| Filtraggio dell’output | Alta | Media | Bassa |
| Meccanismi di sicurezza | Massima | Minima | Massima |
| Conformità | Massima | Minima | Massima |
Correlati
- Strategie di Routing dei Modelli — routing basato su capacità, costi e latenza
- Ottimizzazione dei Costi per Sistemi LLM — gestione del budget token, modelli di fallback, caching
- Progettazione di Sistemi Multi-Modello — architettura per più modelli
- Architettura LLM — pilastro della progettazione del sistema: routing, costi, guardrails e orchestrazione
