Salt la conținutul principal
Română— Alege o limbă
Meniu

Garduri de protecție: validarea intrărilor și ieșirilor

Lecția 6 din 14 Actualizată 28 iulie 2026 Avansat
Pe această pagină
  1. Ce este un gard de protecție?
  2. O arhitectură de tip pipeline
  3. Trei garduri de protecție tipice
  4. Asamblarea tuturor componentelor
  5. Când regula nu poate fi scrisă în regex
  6. Puncte cheie

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