Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Aizsargbarjeras: ievades un izvades validēšana

Nodarbība 6 no 14 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Kas ir aizsargbarjera?
  2. Konveijera arhitektūra
  3. Trīs tipiskas aizsargbarjeras
  4. Viss kopā
  5. Kad noteikumu nevar uzrakstīt ar regulāro izteiksmi
  6. Galvenās atziņas

Kas ir aizsargbarjera?

Aizsargbarjera ir validācijas slānis, kas atrodas starp lietotāju un modeli ievades posmā vai starp modeli un lietotāju izvades posmā. Atšķirība no iepriekšējā nodaļā apspriestās moderācijas ir asa, un tev tā ir jāievēro: moderācija atbild uz jautājumu „Vai šis saturs ir aizskarošs?” – tas ir universāls jautājums, kura atbilde nav atkarīga no tava biznesa. Aizsargbarjeras atbild uz jautājumiem, kurus vari formulēt tikai tu: vai ziņojums ir paredzētajā darbības jomā? Vai atbilde satur aizliegtu informāciju? Vai pieprasītā darbība ir atļauta šai lomai? Banku asistentam un grāmatnīcas asistentam ir vienāda moderācija, bet nav nevienas kopīgas aizsargbarjeras.

Līdz 2026. gadam aizsargbarjeras ir kļuvušas par standarta komponenti AI aģentu arhitektūrās, kas ir neaizstājamas, kad modelim ir piekļuve rīkiem vai sensitīviem datiem.

Konveijera arhitektūra

Strukturālā izvēle ir uzskatīt katru aizsargbarjeru kā neatkarīgu objektu ar vienu atbildību un pēc tam savienot tās izvēlētā secībā. Priekšrocība parādās uzturēšanas laikā: biznesa noteikuma pievienošana neprasa izmaiņas esošajā kodā, un noteikumu, kas kļūst pārāk trokšņains, var noņemt ar vienu rindiņu.

Trešais spriedums pievienojas „atļaut” un „bloķēt”: „modificēt”. Tas maina uzdevuma būtību. Daudzas reālās situācijas neattaisno atteikumu – atbilde, kas satur iekšēju servera ceļu, paliek noderīga, tiklīdz šis ceļš ir noslēpts. Bloķēšana zaudētu informāciju; modificēšana to saglabā, noņemot to, kas rada problēmu.

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)

Trīs tipiskas aizsargbarjeras

Darbības jomas aizsargbarjera uztur sarunu tās domēnā. Tā kalpo gan drošībai, gan reputācijai: klientu apkalpošanas asistentam, kas apmācīts atbildēt uz jautājumiem par piegādēm, nav nekāda labuma, komentējot politiskas ziņas, un šādas atbildes ekrānuzņēmums ātri izplatās. Aizliegto tēmu saraksts ir jāapspriež ar biznesa pusi, to nekad nedrīkst sastādīt tikai tehniskā komanda.

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

Formāta aizsargbarjera šķiet triviāla, tomēr sniedz vislielāko ikdienas vērtību. Tā maksā dažas mikrosekundes, nav atkarīga no tīkla izsaukumiem un pārtrauc pārmērīgi lielus ziņojumus, ko izmanto apjoma injekcijām un budžeta izsmelšanas mēģinājumiem. Novieto to konveijera sākumā: nav jēgas maksāt par API moderāciju 200 000 rakstzīmju ziņojumam, ko tu tāpat noraidīsi.

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

Trešā uzrauga izvadi un ilustrē „modificēt” sprieduma izmantošanu. Četras ģimenes, ko tā meklē, kopīgo ērtu īpašību: tām ir atpazīstama forma neatkarīgi no nozīmes. API atslēgu, iekšēju adresi, privātu IP vai servera ceļu identificē pēc to struktūras, bez nepieciešamības saprast teikumu, kurā tie atrodas.

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

Viss kopā

Pilnīga montāža parāda, kur detaļas iekļaujas. Asimetrija ir acīmredzama: divas aizsargbarjeras ievadē, tikai viena izvadē. Tas ir bieži sastopams un veselīgi – tu filtrē intensīvi pirms modeļa izsaukšanas, jo tur izmaksas ir novēršamas, un izvadi saglabā tikai nepieciešamo minimumu, lai nebojātu pareizas atbildes. Ziņojums, kas tiek atgriezts, bloķējot izvadi, ievēro to pašu piesardzību: apzināti neskaidrs, tas nesaka, kas tika atklāts – informācija, kas galvenokārt noderētu kādam, kurš mēģina kartēt tavu aizsardzību.

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

Kad noteikumu nevar uzrakstīt ar regulāro izteiksmi

Daži biznesa noteikumi pretojas jebkādai formalizēšanai ar šabloniem. „Atbilde nedrīkst būt ieguldījumu konsultācija”, „ziņojumā nedrīkst būt veselības dati”: neviena regulārā izteiksme to neaptver. Tad kā tiesnesis var darboties otrais modelis – ātrs un lēts, ar atbildi, kas ierobežota līdz JSON formātam, lai paliktu lietojams izsaucošajam kodam. Kompromiss ir skaidrs – tu iegūsti precizitāti par latences un determinisma cenu, kas šo pieeju rezervē noteikumiem, kuri to tiešām attaisno.

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

Galvenās atziņas

  • Aizsargbarjeras validē atbilstību biznesa noteikumiem, ne tikai aizskarošu saturu
  • Konveijera arhitektūra ļauj apvienot vairākus validācijas slāņus
  • Katrai aizsargbarjerai ir viena atbildība: darbības joma, formāts, eksfiltrācija u.c.
  • Izvades aizsargbarjeras ir tikpat svarīgas kā ievades aizsargbarjeras
  • Sarežģītos gadījumos ātrs LLM var kalpot kā validētājs