Guardrails: Validatie van invoer en uitvoer
Op deze pagina
Wat is een guardrail?
Een guardrail is een validatielaag die zich tussen de gebruiker en het model bevindt bij invoer, of tussen het model en de gebruiker bij uitvoer. Het onderscheid met de moderatie die in het vorige hoofdstuk aan bod kwam, is scherp en u moet dit handhaven: moderatie beantwoordt de vraag “Is deze inhoud aanstootgevend?”—een universele vraag waarvan het antwoord niet afhangt van uw bedrijfsactiviteiten. Guardrails beantwoorden vragen die alleen u kunt formuleren: Valgt het bericht binnen het verwachte domein? Bevat het antwoord verboden informatie? Is de gevraagde actie geautoriseerd voor deze rol? Een bankassistent en een boekhandelaarassistent delen dezelfde moderatie, maar hebben geen enkele guardrail gemeen.
In 2026 zijn guardrails uitgegroeid tot een standaardonderdeel van AI-agentarchitecturen, onmisbaar wanneer een model toegang heeft tot tools of gevoelige gegevens.
Een pijplijnarchitectuur
De structurele keuze bestaat erin elke guardrail te behandelen als een onafhankelijk object met één enkele verantwoordelijkheid, om ze vervolgens in een gekozen volgorde te koppelen. Het voordeel blijkt tijdens het onderhoud: het toevoegen van een bedrijfsregel vereist geen wijzigingen in bestaande code, en een regel die te veel ruis veroorzaakt, kan in één regel worden verwijderd.
Naast ‘toestaan’ en ‘blokkeren’ komt er een derde oordeel bij: ‘aanpassen’. Dit verandert de aard van de oefening. Veel reële situaties rechtvaardigen geen weigering—een antwoord dat een intern serverpad bevat, blijft nuttig zodra dat pad is gemaskeerd. Blokkeren zou de informatie verloren laten gaan; aanpassen behoudt deze door het problematische deel te verwijderen.
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)
Drie typische guardrails
De domein-guardrail houdt het gesprek binnen zijn vakgebied. Dit dient zowel de veiligheid als de reputatie: een klantenserviceassistent die is getraind om vragen over leveringen te beantwoorden, heeft niets te winnen bij commentaar op politiek nieuws, en een screenshot van zo’n reactie circuleert snel. De lijst met verboden onderwerpen moet worden besproken met de bedrijfskant, nooit alleen opgesteld door het technische team.
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")
De formaat-guardrail lijkt triviaal, maar levert dagelijks de meeste waarde op. Het kost enkele microseconden, is niet afhankelijk van netwerkaanroepen en maakt een einde aan de oversized berichten die worden gebruikt voor volumetrische injecties en pogingen tot budgetuitputting. Plaats deze als eerste in de keten: het heeft geen zin om te betalen voor API-moderatie van een bericht van 200.000 tekens dat u toch gaat afwijzen.
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")
De derde bewaakt de uitvoer en illustreert het gebruik van het oordeel “aanpassen”. De vier families waarnaar deze zoekt, delen een handige eigenschap: ze hebben een herkenbare vorm, onafhankelijk van de betekenis. Een API-sleutel, een intern adres, een privé-IP of een serverpad worden geïdentificeerd op basis van hun structuur, zonder dat het nodig is de zin waarin ze voorkomen te begrijpen.
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")
Alles samenvoegen
De volledige assemblage laat zien waar de onderdelen passen. De asymmetrie springt in het oog: twee guardrails bij invoer, slechts één bij uitvoer. Dit komt vaak voor en is gezond—u filtert zwaar voordat u het model aanroept, omdat daar kosten vermeden kunnen worden, en u houdt het minimum aan dat nodig is bij uitvoer om correcte antwoorden niet te beschadigen. Het bericht dat wordt teruggegeven bij blokkering op uitvoer volgt dezelfde voorzichtigheid: bewust vaag, het zegt niet wat er is gedetecteerd, informatie die voornamelijk iemand zou dienen die probeert uw verdediging in kaart te brengen.
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
Wanneer de regel niet in regex te vatten is
Sommige bedrijfsregels verzetten zich tegen elke formalisering door patronen. “Het antwoord mag geen beleggingsadvies vormen”, “het bericht mag geen gezondheidsgegevens bevatten”: geen reguliere expressie vat dit. Een tweede model, snel en goedkoop, kan dan optreden als rechter, met een antwoord dat beperkt is tot JSON-formaat om bruikbaar te blijven voor de aanroepende code. De afweging is expliciet—u wint aan precisie ten koste van latentie en determinisme, wat deze aanpak reserveert voor regels die dit echt rechtvaardigen.
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"])
Belangrijkste punten
- Guardrails valideren naleving van bedrijfsregels, niet alleen aanstootgevende inhoud
- Een pijplijnarchitectuur maakt het combineren van meerdere validatielagen mogelijk
- Elke guardrail heeft één enkele verantwoordelijkheid: domein, formaat, exfiltratie, enz.
- Guardrails voor uitvoer zijn net zo belangrijk als die voor invoer
- Voor complexe gevallen kan een snelle LLM als validator dienen