Guardrails: sisendite ja väljundite valideerimine
Sellel lehel
Mis on guardrail?
Guardrail on valideerimiskiht, mis asub kasutaja ja mudeli vahel sisendi poolel või mudeli ja kasutaja vahel väljundi poolel. Erinevus eelmises peatükis käsitletud moderatsioonist on terav ja sa pead seda säilitama: moderatsioon vastab küsimusele „Kas see sisu on solvav?“ – universaalne küsimus, mille vastus ei sõltu sinu ärist. Guardrailid vastavad küsimustele, mida ainult sina saad formuleerida: kas sõnum jääb oodatud raamidesse? Kas vastus sisaldab keelatud teavet? Kas taotletud tegevus on sellele rollile lubatud? Pangandusabilisel ja raamatupoe abilisel on sama moderatsioon, kuid neil pole ühtegi ühist guardraili.
Aastaks 2026 on guardrailidest saanud tehisintellekti agentide arhitektuuride standardkomponent, mis on hädavajalik iga kord, kui mudelil on juurdepääs tööriistadele või tundlikele andmetele.
Torustiku arhitektuur
Struktuurne valik on käsitleda iga guardraili kui ühe vastutusega sõltumatut objekti ja seejärel ühendada need valitud järjekorras ahelaks. Kasu ilmneb hoolduse käigus: ärireegli lisamine ei nõua olemasolevas koodis muudatusi ja reegli, mis muutub liiga müraliseks, saab eemaldada ühe reaga.
Lubamisele ja blokeerimisele lisandub kolmas otsus: muutmine. See muudab harjutuse olemust. Paljud reaalsed olukorrad ei õigusta keeldumist – vastus, mis sisaldab sisemist serveri rada, jääb kasulikuks niipea, kui see rada on maskeeritud. Blokeerimine kaotaks info; muutmine säilitab selle, eemaldades probleemi tekitava osa.
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)
Kolm tüüpilist guardraili
Ulatus guardrail hoiab vestluse selle domeeni piires. See teenib nii turvalisust kui ka mainet: klienditeeninduse abilisel, kes on koolitatud vastama tarneid puudutavatele küsimustele, pole mingit kasu poliitiliste uudiste kommenteerimisest ja sellise vastuse ekraanitõmmis levib kiiresti. Keelatud teemade loetelu tuleb arutada äripoolega, seda ei tohi kunagi koostada ainult tehniline meeskond.
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")
Formaadi guardrail tundub triviaalne, kuid pakub igapäevaselt suurimat väärtust. See maksab mõni mikrosekund, ei sõltu võrgupäringutest ja lõpetab enne tähtaega mahukate süstide ja eelarve ammendamise katseteks kasutatud ülemõõdulised sõnumid. Paiguta see ahela esimeseks kohaks: pole mõtet maksta API moderatsiooni eest 200 000 tähemärgi pikkuse sõnumi eest, mille sa niikuinii tagasi lükkad.
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")
Kolmas jälgib väljundit ja illustreerib „muutmise“ otsuse kasutamist. Neljal perekonnal, mida see otsib, on mugav omadus: neil on äratuntav vorm, mis on sõltumatu tähendusest. API võti, sisemine aadress, privaatne IP või serveri rada tuvastatakse nende struktuuri põhjal, ilma et oleks vaja mõista lauset, milles need sisalduvad.
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")
Kõige kokkupanek
Täielik kokkupanek näitab, kus tükid omavahel sobivad. Asümmeetria hüppab silma: sisendil on kaks guardraili, väljundil ainult üks. See on sage ja tervitatav – filtreerid enne mudeli kutsumist tugevalt, sest just seal on kulud vältitavad, ja hoiad väljundil vaid vajaliku miinimumi, et mitte rikkuda korrektseid vastuseid. Väljundi blokeerimisel tagastatav sõnum järgib sama ettevaatust: tahtlikult ebamäärane, see ei ütle, mida tuvastati – teave, mis teeniks peamiselt kedagi, kes püüab kaardistada sinu kaitsemeetmeid.
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
Kui reeglit ei saa kirjutada regulaaravaldises
Mõned ärireeglid ei allu mingile mustritega formaliseerimisele. „Vastus ei tohi kujutada endast investeerimisnõuannet“, „sõnum ei tohi sisaldada terviseandmeid“: ükski regulaaravaldis seda ei püüa. Siis võib teine mudel, kiire ja odav, toimida kohtunikuna, kusjuures vastus on piiratud JSON-vorminguga, et jääda kutsuva koodi jaoks kasutatavaks. Kompromiss on selge – võidad täpsuse arvelt, mida maksad latentsuse ja determinismi kaotusega, mis reserveerib selle lähenemise reeglitele, mis seda tõeliselt õigustavad.
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"])
Peamised punktid
- Guardrailid valideerivad äri nõuetele vastavust, mitte ainult solvavat sisu
- Torustiku arhitektuur võimaldab kombineerida mitut valideerimiskihti
- Igal guardrailil on üks vastutus: ulatus, formaat, andmete lekete vältimine jne
- Väljundi guardrailid on sama olulised kui sisendi guardrailid
- Komplekssetel juhtudel võib kiire LLM toimida valideerijana