Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Guardrails: sisendite ja väljundite valideerimine

Õppetund 6 / 14 Värskendatud 28. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Mis on guardrail?
  2. Torustiku arhitektuur
  3. Kolm tüüpilist guardraili
  4. Kõige kokkupanek
  5. Kui reeglit ei saa kirjutada regulaaravaldises
  6. Peamised punktid

Mis on guardrail?

Guardrail on valideerimiskiht, mis asub kasutaja ja mudeli vahel sisendi poolel või mudeli ja kasutaja vahel väljundi poolel. Erinevus eelmises peatükis käsitletud moderatsioonist on terav ja sa pead seda säilitama: moderatsioon vastab küsimusele „Kas see sisu on solvav?“ – universaalne küsimus, mille vastus ei sõltu sinu ärist. Guardrailid vastavad küsimustele, mida ainult sina saad formuleerida: kas sõnum jääb oodatud raamidesse? Kas vastus sisaldab keelatud teavet? Kas taotletud tegevus on sellele rollile lubatud? Pangandusabilisel ja raamatupoe abilisel on sama moderatsioon, kuid neil pole ühtegi ühist guardraili.

Aastaks 2026 on guardrailidest saanud tehisintellekti agentide arhitektuuride standardkomponent, mis on hädavajalik iga kord, kui mudelil on juurdepääs tööriistadele või tundlikele andmetele.

Torustiku arhitektuur

Struktuurne valik on käsitleda iga guardraili kui ühe vastutusega sõltumatut objekti ja seejärel ühendada need valitud järjekorras ahelaks. Kasu ilmneb hoolduse käigus: ärireegli lisamine ei nõua olemasolevas koodis muudatusi ja reegli, mis muutub liiga müraliseks, saab eemaldada ühe reaga.

Lubamisele ja blokeerimisele lisandub kolmas otsus: muutmine. See muudab harjutuse olemust. Paljud reaalsed olukorrad ei õigusta keeldumist – vastus, mis sisaldab sisemist serveri rada, jääb kasulikuks niipea, kui see rada on maskeeritud. Blokeerimine kaotaks info; muutmine säilitab selle, eemaldades probleemi tekitava osa.

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)

Kolm tüüpilist guardraili

Ulatus guardrail hoiab vestluse selle domeeni piires. See teenib nii turvalisust kui ka mainet: klienditeeninduse abilisel, kes on koolitatud vastama tarneid puudutavatele küsimustele, pole mingit kasu poliitiliste uudiste kommenteerimisest ja sellise vastuse ekraanitõmmis levib kiiresti. Keelatud teemade loetelu tuleb arutada äripoolega, seda ei tohi kunagi koostada ainult tehniline meeskond.

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

Formaadi guardrail tundub triviaalne, kuid pakub igapäevaselt suurimat väärtust. See maksab mõni mikrosekund, ei sõltu võrgupäringutest ja lõpetab enne tähtaega mahukate süstide ja eelarve ammendamise katseteks kasutatud ülemõõdulised sõnumid. Paiguta see ahela esimeseks kohaks: pole mõtet maksta API moderatsiooni eest 200 000 tähemärgi pikkuse sõnumi eest, mille sa niikuinii tagasi lükkad.

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

Kolmas jälgib väljundit ja illustreerib „muutmise“ otsuse kasutamist. Neljal perekonnal, mida see otsib, on mugav omadus: neil on äratuntav vorm, mis on sõltumatu tähendusest. API võti, sisemine aadress, privaatne IP või serveri rada tuvastatakse nende struktuuri põhjal, ilma et oleks vaja mõista lauset, milles need sisalduvad.

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

Kõige kokkupanek

Täielik kokkupanek näitab, kus tükid omavahel sobivad. Asümmeetria hüppab silma: sisendil on kaks guardraili, väljundil ainult üks. See on sage ja tervitatav – filtreerid enne mudeli kutsumist tugevalt, sest just seal on kulud vältitavad, ja hoiad väljundil vaid vajaliku miinimumi, et mitte rikkuda korrektseid vastuseid. Väljundi blokeerimisel tagastatav sõnum järgib sama ettevaatust: tahtlikult ebamäärane, see ei ütle, mida tuvastati – teave, mis teeniks peamiselt kedagi, kes püüab kaardistada sinu kaitsemeetmeid.

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

Kui reeglit ei saa kirjutada regulaaravaldises

Mõned ärireeglid ei allu mingile mustritega formaliseerimisele. „Vastus ei tohi kujutada endast investeerimisnõuannet“, „sõnum ei tohi sisaldada terviseandmeid“: ükski regulaaravaldis seda ei püüa. Siis võib teine mudel, kiire ja odav, toimida kohtunikuna, kusjuures vastus on piiratud JSON-vorminguga, et jääda kutsuva koodi jaoks kasutatavaks. Kompromiss on selge – võidad täpsuse arvelt, mida maksad latentsuse ja determinismi kaotusega, mis reserveerib selle lähenemise reeglitele, mis seda tõeliselt õigustavad.

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

Peamised punktid

  • Guardrailid valideerivad äri nõuetele vastavust, mitte ainult solvavat sisu
  • Torustiku arhitektuur võimaldab kombineerida mitut valideerimiskihti
  • Igal guardrailil on üks vastutus: ulatus, formaat, andmete lekete vältimine jne
  • Väljundi guardrailid on sama olulised kui sisendi guardrailid
  • Komplekssetel juhtudel võib kiire LLM toimida valideerijana