Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Guardrails: Validácia vstupov a výstupov

Lekcia 6 z 14 Aktualizované 28. júla 2026 Pokročilý
Na tejto strane
  1. Čo je guardrail?
  2. Architektúra pipeline
  3. Tri typické guardrails
  4. Všetko dokopy
  5. Keď pravidlo nemožno zapísať pomocou regexu
  6. Kľúčové poznatky

Čo je guardrail?

Guardrail je validačná vrstva, ktorá sa nachádza medzi používateľom a modelom pri vstupe, alebo medzi modelom a používateľom pri výstupe. Rozdiel oproti moderácii, o ktorej sme hovorili v predchádzajúcej kapitole, je zásadný a musíš ho dodržiavať: moderácia odpovedá na otázku „Je tento obsah urážlivý?“ – čo je univerzálna otázka, ktorej odpoveď nezávisí od tvojho podnikania. Guardrails odpovedajú na otázky, ktoré môžeš formulovať len ty: Je správa v rámci očakávaného rozsahu? Obsahuje odpoveď zakázané informácie? Je požadovaná akcia pre túto rolu autorizovaná? Bankový asistent a asistent kníhkupectva zdieľajú rovnakú moderáciu, ale nemajú žiadne spoločné guardrails.

Do roku 2026 sa guardrails stali štandardnou súčasťou architektúr AI agentov, nepostrádateľnou všade tam, kde má model prístup k nástrojom alebo citlivým dátam.

Architektúra pipeline

Štrukturálnym rozhodnutím je zaobchádzať s každým guardrailom ako s nezávislým objektom s jedinou zodpovednosťou a následne ich reťaziť v zvolenom poradí. Výhoda sa prejaví pri údržbe: pridanie obchodného pravidla si nevyžaduje žiadne zmeny v existujúcom kóde a pravidlo, ktoré spôsobuje príliš veľa falošných poplachov, možno odstrániť jediným riadkom.

K možnostiam povoliť (allow) a zablokovať (block) pribúda tretí verdikt: upraviť (modify). To mení povahu celého cvičenia. Mnohé reálne situácie neoprávňujú k odmietnutiu – odpoveď obsahujúca internú cestu k serveru zostáva užitočná, akonáhle je táto cesta zamaskovaná. Blokovanie by znamenalo stratu informácie; úprava ju zachová odstránením toho, čo predstavuje problém.

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 typické guardrails

Guardrail rozsahu (scope) udržiava konverzáciu v rámci jej domény. Slúži bezpečnosti aj reputácii: asistent zákazníckej služby vyškolený na odpovede týkajúce sa doručenia nemá žiadny úžitok z komentovania politických správ a screenshot takejto odpovede sa rýchlo šíri. Zoznam zakázaných tém musí byť prediskutovaný s obchodnou stranou, nikdy ho nesmie zostavovať iba technický tím.

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")

Guardrail formátu sa zdá byť triviálny, no prináša najväčšiu dennú hodnotu. Stojí niekoľko mikrosekúnd, nezávisí od žiadnych volaní siete a prereže príliš veľké správy používané na volumetrické injekcie a pokusy o vyčerpanie rozpočtu. Umiestni ho na začiatok reťaze: nemá zmysel platiť za API moderáciu pri správe s 200 000 znakmi, ktorú aj tak odmietneš.

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")

Tretí guardrail monitoruje výstup a ilustruje použitie verdiktu „upraviť“. Štyri rodiny, ktoré vyhľadáva, zdieľajú vhodnú vlastnosť: majú rozpoznateľnú formu nezávislú od významu. API kľúč, interná adresa, súkromná IP alebo cesta k serveru sa identifikujú podľa ich štruktúry, bez potreby rozumieť vete, v ktorej sa nachádzajú.

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")

Všetko dokopy

Kompletná zostava ukazuje, ako do seba jednotlivé časti zapadajú. Asymetria je zrejmá: dva guardrails na vstupe, len jeden na výstupe. Je to časté a zdravé – pred volaním modelu filtruješ intenzívne, pretože tam sa dá vyhnúť nákladom, a na výstupe ponechávaš len nevyhnutné minimum, aby sa nepoškodili správne odpovede. Správa vrátená pri blokovaní na výstupe dodržiava rovnakú opatrnosť: zámerne je vágna, nehovorí, čo bolo detegované, čo sú informácie, ktoré by primárne slúžili niekomu, kto sa snaží zmapovať tvoju obranu.

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

Keď pravidlo nemožno zapísať pomocou regexu

Niektoré obchodné pravidlá odolávajú akejkoľvek formalizácii pomocou vzorov. „Odpoveď nesmie predstavovať investičné poradenstvo“, „správa nesmie obsahovať zdravotné údaje“: žiadny regulárny výraz toto nezachytí. Vtedy môže ako rozhodca konať druhý model, rýchly a lacný, pričom jeho odpoveď je obmedzená na formát JSON, aby zostala použiteľná pre volajúci kód. Kompromis je explicitný – získaš presnosť za cenu latencie a determinizmu, čo vyhradzuje tento prístup pre pravidlá, ktoré si to skutočne zaslúžia.

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"])

Kľúčové poznatky

  • Guardrails validujú súlad s obchodnými pravidlami, nielen urážlivý obsah
  • Architektúra pipeline umožňuje kombinovať viacero validačných vrstiev
  • Každý guardrail má jedinú zodpovednosť: rozsah, formát, exfiltrácia atď.
  • Výstupné guardrails sú rovnako dôležité ako vstupné
  • Pre zložité prípady môže ako validátor slúžiť rýchly LLM