Guardrails: A bemenetek és kimenetek érvényesítése
Ezen az oldalon
Mi az a guardrail?
A guardrail egy érvényesítési réteg, amely a felhasználó és a modell között helyezkedik el bemeneti oldalon, illetve a modell és a felhasználó között kimeneti oldalon. A különbség az előző fejezetben tárgyalt moderálástól éles, és ezt fenn kell tartanod: a moderálás arra a kérdésre válaszol, hogy „Ez a tartalom sértő-e?“ – ez egy univerzális kérdés, amelynek válasza nem függ a te üzletedtől. Ezzel szemben a guardrailek olyan kérdésekre adnak választ, amelyeket csak te tudsz megfogalmazni: Az üzenet a várt hatókörön belül marad? A válasz tartalmaz tiltott információt? A kért művelet engedélyezett ehhez a szerepkörhöz? Egy banki asszisztensnek és egy könyvesbolti asszisztensnek ugyanaz a moderációs szabályrendszere, de nincs közös guardrailjük.
2026-ra a guardrailek az AI-ügynök architektúrák szabványos komponensévé váltak, és nélkülözhetetlenné váltak minden olyan esetben, amikor a modell hozzáfér eszközökhöz vagy érzékeny adatokhoz.
Csővezeték-architektúra
A strukturális választás az, hogy minden guardrailt egyetlen felelősségű, független objektumként kezeljünk, majd ezeket egy választott sorrendben láncba rendezzük. Az előny a karbantartás során mutatkozik meg: egy üzleti szabály hozzáadása nem igényel módosítást a meglévő kódban, és egy túl zajossá vált szabály egyetlen sorral eltávolítható.
Egy harmadik ítélet csatlakozik az engedélyezéshez (allow) és a blokkoláshoz (block): a módosítás (modify). Ez megváltoztatja a feladat jellegét. Sok valós helyzet nem indokol elutasítást – egy belső szerverútvonalat tartalmazó válasz hasznos marad, ha ezt az útvonalat elmaszkoljuk. A blokkolás elveszítené az információt; a módosítás megőrzi azt azáltal, hogy eltávolítja a problémát okozó részt.
from dataclasses import dataclass
from enum import Enum
class Decision(Enum):
ALLOW = "allow"
BLOCK = "block"
MODIFY = "modify"
@dataclass
class ValidationResult:
decision: Decision
reason: str
modified_content: str | None = None
class Guardrail:
"""Base class for a guardrail."""
def validate(self, content: str, context: dict) -> ValidationResult:
raise NotImplementedError
class GuardrailPipeline:
"""Chains multiple guardrails in sequence."""
def __init__(self):
self.input_guardrails: list[Guardrail] = []
self.output_guardrails: list[Guardrail] = []
def add_input(self, guardrail: Guardrail):
self.input_guardrails.append(guardrail)
def add_output(self, guardrail: Guardrail):
self.output_guardrails.append(guardrail)
def validate_input(self, message: str, context: dict) -> ValidationResult:
for g in self.input_guardrails:
result = g.validate(message, context)
if result.decision == Decision.BLOCK:
return result
if result.decision == Decision.MODIFY:
message = result.modified_content
return ValidationResult(Decision.ALLOW, "All validations passed")
def validate_output(self, response: str, context: dict) -> ValidationResult:
for g in self.output_guardrails:
result = g.validate(response, context)
if result.decision == Decision.BLOCK:
return result
if result.decision == Decision.MODIFY:
response = result.modified_content
return ValidationResult(Decision.ALLOW, "OK", response)
Három tipikus guardrail
A hatókör-guardrail (scope guardrail) a beszélgetést a saját domainjén belül tartja. Ez egyszerre szolgálja a biztonságot és a hírnevet: egy ügyfélszolgálati asszisztensnek, akit kézbesítésekkel kapcsolatos kérdések megválaszolására képeztek ki, semmi haszna származik abból, ha politikai hírekről kommentárt fűz, és egy ilyen válasz képernyőmentése gyorsan terjed. A tiltott témák listáját az üzleti oldalakkal kell megvitatni, soha nem szabad kizárólag a technikai csapatnak kidolgoznia.
class ScopeGuardrail(Guardrail):
"""Checks that the message stays within the authorized scope."""
def __init__(self, allowed_topics: list[str], forbidden_topics: list[str]):
self.allowed_topics = allowed_topics
self.forbidden_topics = forbidden_topics
def validate(self, content: str, context: dict) -> ValidationResult:
content_lower = content.lower()
# Check forbidden topics
for topic in self.forbidden_topics:
if topic.lower() in content_lower:
return ValidationResult(
Decision.BLOCK,
f"Out-of-scope topic detected: {topic}"
)
return ValidationResult(Decision.ALLOW, "Within scope")
A formátum-guardrail triviálisnak tűnhet, mégis ez nyújtja a legtöbb napi értéket. Néhány mikroszekundumba kerül, nem függ hálózati hívásoktól, és véget vet a volumetrikus injektálásokhoz és költségkeret-kimerítési kísérletekhez használt túlméretezett üzeneteknek. Helyezd ezt a lánc elejére: nincs értelme API-moderációért fizetni egy 200 000 karakteres üzenet esetén, amelyet amúgy is elutasítasz.
class FormatGuardrail(Guardrail):
"""Validates message format and length."""
def __init__(self, max_tokens: int = 4000, max_lines: int = 100):
self.max_tokens = max_tokens
self.max_lines = max_lines
def validate(self, content: str, context: dict) -> ValidationResult:
# Rough token estimation (1 token ~ 4 characters in English)
estimated_tokens = len(content) // 4
if estimated_tokens > self.max_tokens:
return ValidationResult(
Decision.BLOCK,
f"Message too long: ~{estimated_tokens} tokens (max {self.max_tokens})"
)
line_count = content.count("\n") + 1
if line_count > self.max_lines:
return ValidationResult(
Decision.BLOCK,
f"Too many lines: {line_count} (max {self.max_lines})"
)
return ValidationResult(Decision.ALLOW, "Valid format")
A harmadik típus a kimenetet figyeli, és szemlélteti a „módosítás“ (modify) ítélet használatát. Az általa keresett négy családnak van egy közös, kényelmes tulajdonsága: felismerhető formátummal rendelkeznek, függetlenül a jelentésüktől. Egy API-kulcs, egy belső cím, egy privát IP-cím vagy egy szerverútvonal a szerkezete alapján azonosítható, anélkül, hogy meg kellene érteni a őket tartalmazó mondatot.
import re
class AntiExfiltrationGuardrail(Guardrail):
"""Prevents leakage of sensitive data in outputs."""
def __init__(self):
self.sensitive_patterns = {
"api_key": r"(sk|pk|api[_-]?key)[_-][a-zA-Z0-9]{16,}",
"internal_email": r"[a-zA-Z0-9.]+@(company|internal|corp)\.\w+",
"private_ip": r"\b(10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})\b",
"server_path": r"(/data/|/etc/|/home/|C:\\Users\\)",
}
def validate(self, content: str, context: dict) -> ValidationResult:
for data_type, pattern in self.sensitive_patterns.items():
if re.search(pattern, content):
# Mask instead of blocking
cleaned_content = re.sub(pattern, "[REDACTED]", content)
return ValidationResult(
Decision.MODIFY,
f"Sensitive data redacted: {data_type}",
cleaned_content,
)
return ValidationResult(Decision.ALLOW, "No leakage detected")
Az egész összeállítása
A teljes összeállítás megmutatja, hogyan illeszkednek össze a darabok. Az aszimmetria szembetűnő: két guardrail a bemeneten, csak egy a kimeneten. Ez gyakori és egészséges – erősen szűrsz a modell hívása előtt, mert ott kerülhetők el a költségek, míg a kimeneten a lehető legkisebb szükséges szintet tartod fenn, hogy ne rongáld meg a helyes válaszokat. A kimeneti blokkoláskor visszaadott üzenet ugyanazt az óvatosságot követi: szándékosan homályos, nem árulja el, mit észlelt, mivel ez az információ elsősorban azoknak hasznos, akik fel akarják térképezni a védelmedet.
from openai import OpenAI
def create_secure_assistant():
"""Creates an assistant with a complete guardrail pipeline."""
client = OpenAI()
pipeline = GuardrailPipeline()
# Input guardrails
pipeline.add_input(FormatGuardrail(max_tokens=2000))
pipeline.add_input(ScopeGuardrail(
allowed_topics=["products", "orders", "delivery", "returns"],
forbidden_topics=["politics", "religion", "competitors"],
))
# Output guardrails
pipeline.add_output(AntiExfiltrationGuardrail())
def process(message: str) -> str:
context = {"user_role": "customer"}
# Input validation
input_check = pipeline.validate_input(message, context)
if input_check.decision == Decision.BLOCK:
return f"I cannot process this request: {input_check.reason}"
valid_message = input_check.modified_content or message
# Model call
response = client.chat.completions.create(
model="gpt-5.6-sol",
messages=[
{"role": "system", "content": "Acme Corp customer service assistant."},
{"role": "user", "content": valid_message},
],
)
reply = response.choices[0].message.content
# Output validation
output_check = pipeline.validate_output(reply, context)
if output_check.decision == Decision.BLOCK:
return "I am unable to answer this question."
return output_check.modified_content or reply
return process
Amikor a szabály nem írható le regexszel
Egyes üzleti szabályok ellenállnak minden minták alapú formalizálásnak. „A válasz nem minősülhet befektetési tanácsadásnak“, „az üzenet nem tartalmazhat egészségügyi adatokat“: egyetlen reguláris kifejezés sem képes ezt lefedni. Ilyenkor egy második, gyors és olcsó modell működhet bíróságként, ahol a választ JSON formátumra kényszerítjük, hogy a hívó kód használható maradjon. A kompromisszum egyértelmű: pontosságot nyersz a késleltetés és a determinizmus rovására, ezért ezt a megközelítést csak olyan szabályokra tartogasd, amelyek ezt valóban indokolttá teszik.
def llm_guardrail(message: str, rule: str) -> ValidationResult:
"""Uses a fast model to validate compliance."""
client = OpenAI()
response = client.chat.completions.create(
model="gpt-5.6-terra",
messages=[
{"role": "system", "content": f"""You are a compliance validator.
Rule to check: {rule}
Respond ONLY with JSON: {{"compliant": true/false, "reason": "..."}}"""},
{"role": "user", "content": f"Message to validate:\n{message}"},
],
)
import json
result = json.loads(response.choices[0].message.content)
if result["compliant"]:
return ValidationResult(Decision.ALLOW, result["reason"])
return ValidationResult(Decision.BLOCK, result["reason"])
Főbb megállapítások
- A guardrailek az üzleti megfelelést érvényesítik, nem csupán a sértő tartalmat szűrik
- A csővezeték-architektúra lehetővé teszi több érvényesítési réteg kombinálását
- Minden guardrailnek egyetlen felelőssége van: hatókör, formátum, adatexfiltráció stb.
- A kimeneti guardrailek ugyanolyan fontosak, mint a bemenetiek
- Komplex esetekben egy gyors LLM szolgálhat érvényesítőként