Ograde: preverjanje vhodov in izhodov
Na tej strani
Kaj je ograda?
Ograda je sloj za preverjanje veljavnosti, ki se nahaja med uporabnikom in modelom pri vhodu ali med modelom in uporabnikom pri izhodu. Razlika od moderiranja, obravnavanega v prejšnjem poglavju, je ostra in moraš jo dosledno upoštevati: moderiranje odgovarja na vprašanje „Ali je ta vsebina žaljiva?” – to je univerzalno vprašanje, katerega odgovor ni odvisen od tvoje dejavnosti. Ograde odgovarjajo na vprašanja, ki jih lahko oblikuješ samo ti: Ali je sporočilo v pričakovanem obsegu? Ali odgovor vsebuje prepovedane informacije? Ali je zahtevano dejanje za to vlogo avtorizirano? Bančni asistent in asistent v knjigarni si delita isto moderiranje, nimata pa nobenih skupnih ograd.
Do leta 2026 so ograde postale standardna komponenta arhitektur agentov z umetno inteligenco, nepogrešljive vedno, ko ima model dostop do orodij ali občutljivih podatkov.
Arhitektura cevovoda
Strukturna izbira je obravnava vsake ograje kot neodvisnega objekta z eno samo odgovornostjo, ki jih nato povežeš v izbranem vrstnem redu. Prednost se pokaže med vzdrževanjem: dodajanje poslovnega pravila ne zahteva sprememb obstoječe kode, pravilo, ki postane preveč hrupno, pa lahko odstraniš z eno samo vrstico.
Tretja odločitev se pridruži dovolitvi in blokiranju: sprememba. To spremeni naravo vaje. Številne situacije iz resničnega sveta ne upravičujejo zavrnitve – odgovor, ki vsebuje notranjo pot do strežnika, ostane uporaben, ko je ta pot skrita. Blokiranje bi povzročilo izgubo informacij; spreminjanje jih ohrani z odstranitvijo tistega, kar predstavlja težavo.
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)
Tri tipične ograde
Ograda za obseg ohranja pogovor znotraj njegove domene. Služi tako varnosti kot ugledu: asistent za storitve za stranke, usposobljen za odgovarjanje na vprašanja o dostavah, nima koristi od komentiranja političnih novic, posnetek zaslona takšnega odgovora pa hitro kroži. Seznam prepovedanih tem se mora obravnavati s poslovno stranjo, nikoli ga ne sme pripraviti samo tehnična ekipa.
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")
Ograda za format se zdi trivialna, vendar zagotavlja največjo dnevno vrednost. Stane nekaj mikrosekund, ni odvisna od omrežnih klicev in prekine predolga sporočila, uporabljena za volumetrične injekcije in poskuse izčrpavanja proračuna. Postavi jo na prvo mesto v verigi: ni smisla plačevati za API moderiranje sporočila z 200.000 znaki, ki ga boš tako ali tako zavrnil.
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")
Tretja spremlja izhod in ponazarja uporabo odločitve „spremeni”. Štiri družine, ki jih išče, imajo priročno lastnost: imajo prepoznavno obliko, neodvisno od pomena. Ključ API, notranji naslov, zasebni IP ali pot do strežnika so identificirani po svoji strukturi, brez potrebe po razumevanju stavka, ki jih vsebuje.
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")
Sestavljanje vsega skupaj
Popolna sestava pokaže, kam se prilegajo posamezni deli. Asimetrija je očitna: dve ogradi na vhodu, samo ena na izhodu. To je pogosto in zdravo – močno filtriraš pred klicem modela, ker so tam stroški izogibni, na izhodu pa obdržiš najmanj potrebno, da ne poškoduješ pravilnih odgovorov. Sporočilo, vrnjeno ob blokiranju na izhodu, sledi isti previdnosti: namerno nejasno je in ne pove, kaj je bilo zaznano, kar so informacije, ki bi koristile predvsem nekomu, ki poskuša preslikati tvojo obrambo.
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
Ko pravila ni mogoče zapisati z regularnim izrazom
Nekatera poslovna pravila se upirajo vsaki formalizaciji z vzorci. „Odgovor ne sme predstavljati investicijskega svetovanja”, „sporočilo ne sme vsebovati zdravstvenih podatkov”: tega ne zajame noben regularni izraz. Drug model, hiter in poceni, lahko nato deluje kot sodnik, z odgovorom, omejenim na format JSON, da ostane uporaben za klicno kodo. Kompromis je ekspliciten – pridobiš natančnost na račun zakasnitve in determinizma, kar ta pristop rezervira za pravila, ki to resnično upravičujejo.
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"])
Ključne ugotovitve
- Ograde preverjajo skladnost s poslovnimi pravili, ne le žaljive vsebine
- Arhitektura cevovoda omogoča kombiniranje več plasti za preverjanje
- Vsaka ograda ima eno samo odgovornost: obseg, format, preprečevanje izliva podatkov itd.
- Ograde za izhod so enako pomembne kot ograde za vhod
- Za kompleksne primere lahko hiter LLM služi kot validator