Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Guardrails: Validace vstupů a výstupů

Lekce 6 z 14 Aktualizováno 28. července 2026 Pokročilý
Na této stránce
  1. Co je to guardrail?
  2. Architektura pipeline
  3. Tři typické guardrails
  4. Všechno dohromady
  5. Když nelze pravidlo zapsat pomocí regexu
  6. Klíčové poznatky

Co je to guardrail?

Guardrail je validační vrstva, která sedí mezi uživatelem a modelem při vstupu, nebo mezi modelem a uživatelem při výstupu. Rozdíl oproti moderaci probírané v předchozí kapitole je ostrý a musíš si ho udržet: moderace odpovídá na otázku „Je tento obsah urážlivý?“ – univerzální otázka, jejíž odpověď nezávisí na tvém byznysu. Guardrails odpovídají na otázky, které můžeš formulovat pouze ty: Je zpráva v očekávaném rozsahu? Obsahuje odpověď zakázané informace? Je požadovaná akce pro tuto roli autorizována? Bankovní asistent a asistent knihkupectví sdílejí stejnou moderaci, ale nemají žádné společné guardrails.

Do roku 2026 se guardrails staly standardní součástí architektur AI agentů, nepostradatelné kdykoli má model přístup k nástrojům nebo citlivým datům.

Architektura pipeline

Strukturální volbou je treatovat každý guardrail jako nezávislý objekt s jedinou odpovědností a poté je řetězit ve zvoleném pořadí. Přínos se projeví při údržbě: přidání obchodního pravidla nevyžaduje žádné změny v existujícím kódu a pravidlo, které se stane příliš hlučným, lze odstranit jediným řádkem.

K rozhodnutím allow (povolit) a block (zablokovat) přibývá třetí verdikt: modify (upravit). To mění povahu cvičení. Mnoho reálných situací neospravedlňuje odmítnutí – odpověď obsahující interní cestu k serveru zůstává užitečná, jakmile je tato cesta maskována. Blokování by ztratilo informaci; úprava ji zachová odstraněním toho, co představuje 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)

Tři typické guardrails

Guardrail rozsahu udržuje konverzaci v rámci její domény. Slouží bezpečnosti i reputaci: asistent zákaznického servisu vycvičený k odpovídání na dotazy o doručení nemá žádný prospěch z komentování politických zpráv a screenshot takové odpovědi rychle oběhne svět. Seznam zakázaných témat musí být projednán s obchodní stranou, nikdy ho nesmí sestavovat pouze 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 se zdá být triviální, přesto poskytuje největší denní hodnotu. Stojí několik mikrosekund, nezávisí na žádných síťových voláních a utne přerostlé zprávy používané pro objemové injekce a pokusy o vyčerpání rozpočtu. Umísti jej jako první v řetězci: nemá smysl platit za API moderaci u zprávy o 200 000 znacích, kterou stejně odmítneš.

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

Třetí monitoruje výstup a ilustruje použití verdiktu „modify“. Čtyři rodiny, které hledá, sdílejí výhodnou vlastnost: mají rozpoznatelnou formu nezávislou na významu. API klíč, interní adresa, privátní IP nebo cesta k serveru jsou identifikovány svou strukturou, aniž by bylo třeba rozumět větě, která je obsahuje.

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šechno dohromady

Kompletní sestavení ukazuje, kam jednotlivé díly zapadají. Asymetrie bije do očí: dva guardrails na vstupu, pouze jeden na výstupu. To je časté a zdravé – před voláním modelu silně filtruješ, protože tam jsou náklady avoidovatelné, a na výstupu udržuješ nezbytné minimum, abys nepoškodil správné odpovědi. Zpráva vrácená při blokování na výstupu následuje stejnou opatrnost: záměrně vágní, neříká, co bylo detekováno, což jsou informace, které by primárně sloužily někomu, kdo se snaží zmapovat tvou 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

Když nelze pravidlo zapsat pomocí regexu

Některá obchodní pravidla odolávají jakékoli formalizaci pomocí vzorů. „Odpověď nesmí představovat investiční poradenství“, „zpráva nesmí obsahovat zdravotní data“: žádný regulární výraz toto nezachytí. Druhý model, rychlý a levný, pak může působit jako rozhodčí, přičemž odpověď je omezena na formát JSON, aby zůstala použitelná pro volající kód. Kompromis je explicitní – získáváš přesnost za cenu latence a determinismu, což vyhrazuje tento přístup pro pravidla, která si to skutečně zaslouží.

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

Klíčové poznatky

  • Guardrails validují soulad s obchodními pravidly, nejen urážlivý obsah
  • Architektura pipeline umožňuje kombinovat více validačních vrstev
  • Každý guardrail má jedinou odpovědnost: rozsah, formát, exfiltrace atd.
  • Výstupní guardrails jsou stejně důležité jako vstupní guardrails
  • Pro složité případy může jako validátor sloužit rychlý LLM