Garduri de protecție: validarea intrărilor și ieșirilor
Pe această pagină
Ce este un gard de protecție?
Un gard de protecție este un strat de validare situat între utilizator și model la intrare, sau între model și utilizator la ieșire. Distincția față de moderarea discutată în capitolul anterior este clară și trebuie menținută: moderarea răspunde la întrebarea „Este acest conținut ofensiv?“—o întrebare universală al cărei răspuns nu depinde de afacerea dumneavoastră. Gardurile de protecție răspund la întrebări pe care doar dumneavoastră le puteți formula: Se încadrează mesajul în domeniul așteptat? Conține răspunsul informații interzise? Este acțiunea solicitată autorizată pentru acest rol? Un asistent bancar și un asistent pentru o librărie partajează aceeași moderare, dar nu au niciun gard de protecție în comun.
Până în 2026, gardurile de protecție au devenit o componentă standard a arhitecturilor agenților de IA, indispensabile ori de câte ori un model are acces la instrumente sau date sensibile.
O arhitectură de tip pipeline
Alegerea structurală constă în tratarea fiecărui gard de protecție ca un obiect independent cu o singură responsabilitate, apoi înlănțuirea lor într-o ordine aleasă. Beneficiul apare în timpul mentenanței: adăugarea unei reguli de afaceri nu necesită modificări ale codului existent, iar o regulă care devine prea zgomotoasă poate fi eliminată într-o singură linie.
Un al treilea verdict se alătură lui „allow“ (permite) și „block“ (blochează): „modify“ (modifică). Acest lucru schimbă natura exercițiului. Multe situații din lumea reală nu justifică un refuz—un răspuns care conține o cale internă a serverului rămâne util odată ce acea cale este mascată. Blocarea ar duce la pierderea informației; modificarea o păstrează prin eliminarea a ceea ce pune o 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)
Trei garduri de protecție tipice
Gardul de protecție al domeniului menține conversația în cadrul său. Acesta servește atât securității, cât și reputației: un asistent de servicii pentru clienți instruit să răspundă la întrebări despre livrări nu are nimic de câștigat comentând știri politice, iar o captură de ecran a unui astfel de răspuns circulă rapid. Lista subiectelor interzise trebuie discutată cu partea de afaceri, niciodată redactată doar de echipa tehnică.
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")
Gardul de protecție al formatului pare trivial, dar oferă cea mai mare valoare zilnică. Costă câțiva microsecunde, nu depinde de apeluri de rețea și taie scurt mesajele supradimensionate utilizate pentru injecții volumetrice și tentative de epuizare a bugetului. Plasați-l primul în lanț: nu are rost să plătiți pentru moderarea API-ului unui mesaj de 200.000 de caractere pe care oricum îl veți respinge.
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")
Al treilea monitorizează ieșirea și ilustrează utilizarea verdictului „modify“. Cele patru familii pe care le caută partajează o proprietate convenabilă: au o formă recognoscibilă independent de sens. O cheie API, o adresă internă, un IP privat sau o cale de server sunt identificate prin structura lor, fără a fi nevoie să înțelegeți propoziția care le conține.
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")
Asamblarea tuturor componentelor
Asamblarea completă arată unde se potrivesc piesele. Asimetria sare în ochi: două garduri de protecție la intrare, doar unul la ieșire. Acest lucru este frecvent și sănătos—filtrați intens înainte de a apela modelul, deoarece acolo sunt evitabile costurile, și păstrați minimul necesar la ieșire pentru a nu deteriora răspunsurile corecte. Mesajul returnat la blocarea pe ieșire urmează aceeași prudență: intenționat vag, nu spune ce a fost detectat, informație care ar servi în primul rând cuiva care încearcă să cartografieze apărările dumneavoastră.
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
Când regula nu poate fi scrisă în regex
Unele reguli de afaceri rezistă oricărei formalizări prin tipare. „Răspunsul nu trebuie să constituie un sfat de investiții“, „mesajul nu trebuie să conțină date despre sănătate“: nicio expresie regulată nu surprinde acest lucru. Un al doilea model, rapid și ieftin, poate acționa apoi ca judecător, cu un răspuns constrâns la formatul JSON pentru a rămâne utilizabil de către codul apelant. Compromisul este explicit—câștigați precizie în schimbul latenței și determinismului, ceea ce rezervă această abordare pentru regulile care o justifică cu adevărat.
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"])
Puncte cheie
- Gardurile de protecție validează conformitatea cu regulile de afaceri, nu doar conținutul ofensiv
- Arhitectura de tip pipeline permite combinarea mai multor straturi de validare
- Fiecare gard de protecție are o singură responsabilitate: domeniu, format, exfiltrare etc.
- Gardurile de protecție la ieșire sunt la fel de importante ca cele de la intrare
- Pentru cazurile complexe, un LLM rapid poate servi drept validator