Guardrails: Validera in- och utdata
På denna sida
Vad är en guardrail?
En guardrail är ett valideringslager som placeras mellan användaren och modellen vid inmatning, eller mellan modellen och användaren vid utmatning. Skillnaden gentemot den moderering som diskuterades i föregående kapitel är skarp, och du måste upprätthålla den: moderering svarar på frågan “Är detta innehåll stötande?” – en universell fråga vars svar inte beror på din verksamhet. Guardrails svarar på frågor som bara du kan formulera: Ligger meddelandet inom förväntat omfång? Innehåller svaret förbjuden information? Är den begärda åtgärden auktoriserad för denna roll? En bankassistent och en bokhandelsassistent delar samma moderering men har inga gemensamma guardrails.
År 2026 har guardrails blivit en standardkomponent i arkitekturer för AI-agenter, oumbärliga närhelst en modell har tillgång till verktyg eller känslig data.
En pipeline-arkitektur
Det strukturella valet är att behandla varje guardrail som ett oberoende objekt med ett enda ansvarsområde, och sedan kedja ihop dem i valfri ordning. Fördelen visar sig vid underhåll: att lägga till en affärsregel kräver inga ändringar i befintlig kod, och en regel som blir för brusig kan tas bort på en enda rad.
En tredje dom förenar “tillåt” och “blockera”: modifiera. Detta ändrar övningens natur. Många situationer i verkligheten motiverar inte ett nekande – ett svar som innehåller en intern sökväg till en server förblir användbart när den sökvägen maskeras. Att blockera skulle förlora informationen; att modifiera bevarar den genom att ta bort det som utgör ett problem.
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)
Tre typiska guardrails
Guardrailen för omfång håller konversationen inom dess domän. Den tjänar både säkerhet och rykte: en kundtjänstassistent tränad för att svara på frågor om leveranser har inget att vinna på att kommentera politiska nyheter, och en skärmdump av ett sådant svar sprids snabbt. Listan över förbjudna ämnen måste diskuteras med affärsidan, aldrig utformas enbart av det tekniska teamet.
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")
Guardrailen för format verkar trivial men ger mest värde i det dagliga arbetet. Den kostar några mikrosekunder, beror inte på några nätverksanrop och stoppar de överdimensionerade meddelanden som används för volymetriska injektioner och försök att tömma budgeten. Placera den först i kedjan: det finns ingen poäng med att betala för API-moderering på ett meddelande med 200 000 tecken som du ändå kommer att avvisa.
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")
Den tredje övervakar utdata och illustrerar användningen av domen “modifiera”. De fyra familjer den söker efter delar en praktisk egenskap: de har en igenkännbar form oberoende av betydelse. En API-nyckel, en intern adress, en privat IP eller en sökväg till en server identifieras genom sin struktur, utan behov av att förstå meningen de ingår i.
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")
Sätt ihop allt
Den kompletta sammansättningen visar var bitarna passar in. Asymmetrin är slående: två guardrails vid inmatning, bara en vid utmatning. Detta är vanligt och sunt – du filtrerar kraftigt innan du anropar modellen eftersom det är där kostnader kan undvikas, och du behåller det absolut nödvändiga vid utmatning för att inte skada korrekta svar. Meddelandet som returneras vid blockering av utdata följer samma försiktighet: avsiktligt vagt säger det inte vad som upptäcktes, information som främst skulle gynna någon som försöker kartlägga dina försvar.
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
När regeln inte kan skrivas med regex
Vissa affärsregler motstår all formalisering genom mönster. “Svaret får inte utgöra investeringsrådgivning”, “meddelandet får inte innehålla hälsoinformation”: inget reguljärt uttryck fångar detta. En andra modell, snabb och billig, kan då agera som domare, med ett svar begränsat till JSON-format för att förbli användbart av den anropande koden. Avvägningen är explicit – du vinner precision till priset av latens och determinism, vilket reserverar detta tillvägagångssätt för regler som verkligen motiverar det.
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"])
Viktiga punkter
- Guardrails validerar efterlevnad av affärsregler, inte bara stötande innehåll
- Pipeline-arkitektur möjliggör kombination av flera valideringslager
- Varje guardrail har ett enda ansvarsområde: omfång, format, exfiltrering etc.
- Guardrails för utdata är lika viktiga som guardrails för indata
- För komplexa fall kan en snabb LLM fungera som validerare