Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Ograde: Validacija ulaza i izlaza

Lekcija 6 od 14 Ažurirano 28. srpnja 2026. Napredno
Na ovoj stranici
  1. Što je ograda?
  2. Arhitektura cjevovoda
  3. Tri tipične ograde
  4. Sastavljanje cjeline
  5. Kada se pravilo ne može zapisati regexom
  6. Ključne točke

Što je ograda?

Ograda je sloj za validaciju koji se nalazi između korisnika i modela pri ulazu ili između modela i korisnika pri izlazu. Razlika u odnosu na moderaciju obrađenu u prethodnom poglavlju je oštra i moraš je održavati: moderacija odgovara na pitanje „Je li ovaj sadržaj uvredljiv?“ – univerzalno pitanje čiji odgovor ne ovisi o tvom poslovanju. Ograde odgovaraju na pitanja koja samo ti možeš formulirati: Je li poruka unutar očekivanog opsega? Sadrži li odgovor zabranjene informacije? Je li zatražena radnja autorizirana za tu ulogu? Bankarski asistent i asistent knjižare dijele istu moderaciju, ali nemaju zajedničkih ograda.

Do 2026. godine ograde su postale standardna komponenta arhitektura AI agenata, neophodne kad god model ima pristup alatima ili osjetljivim podacima.

Arhitektura cjevovoda

Strukturni izbor je tretirati svaku ogradu kao neovisni objekt s jednom odgovornošću, a zatim ih povezati u odabranom redoslijedu. Prednost se očituje tijekom održavanja: dodavanje poslovnog pravila ne zahtijeva promjene u postojećem kodu, a pravilo koje postane previše bučno može se ukloniti u jednom retku.

Treća presuda pridružuje se dopuštanju i blokiranju: izmijeni. To mijenja prirodu vježbe. Mnoge situacije iz stvarnog svijeta ne opravdavaju odbijanje – odgovor koji sadrži interni put do poslužitelja ostaje koristan jednom kada se taj put maskira. Blokiranje bi izgubilo informaciju; izmjena je čuva uklanjanjem onoga što predstavlja 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)

Tri tipične ograde

Ograda opsega održava razgovor unutar njegove domene. Služi i sigurnosti i ugledu: asistent korisničke službe obučen za odgovaranje na pitanja o isporukama nema što gainirati komentiranjem političkih vijesti, a snimka zaslona takvog odgovora brzo kruži. Popis zabranjenih tema mora se raspraviti s poslovnom stranom, nikada ga ne smije sastaviti samo tehnički tim.

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

Ograda formata čini se trivijalnom, no pruža najveću dnevnu vrijednost. Košta nekoliko mikrosekundi, ne ovisi o mrežnim pozivima i prekida prevelike poruke korištene za volumetrijske injekcije i pokušaje iscrpljivanja proračuna. Postavi je prvu u lanac: nema smisla plaćati API moderaciju za poruku od 200.000 znakova koju ćeš ionako odbiti.

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ća prati izlaz i ilustrira upotrebu presude „izmijeni“. Četiri obitelji koje traži dijele pogodno svojstvo: imaju prepoznatljiv oblik neovisan o značenju. API ključ, interna adresa, privatna IP ili put do poslužitelja identificiraju se svojom strukturom, bez potrebe za razumijevanjem rečenice koja ih sadrži.

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

Sastavljanje cjeline

Potpuni sastav pokazuje gdje se dijelovi uklapaju. Asimetrija je očita: dvije ograde na ulazu, samo jedna na izlazu. To je često i zdravo – jako filtriraš prije pozivanja modela jer su tamo troškovi izbjegivi, a na izlazu zadržavaš samo nužni minimum kako ne bi oštetio ispravne odgovore. Poruka vraćena pri blokiranju na izlazu slijedi isti oprez: namjerno nejasna, ne govori što je otkriveno, informacija koja bi prvenstveno koristila nekome tko pokušava mapirati tvoje obrambene mehanizme.

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

Kada se pravilo ne može zapisati regexom

Neka poslovna pravila odupiru se svakoj formalizaciji putem uzoraka. „Odgovor ne smije predstavljati investicijski savjet“, „poruka ne smije sadržavati zdravstvene podatke“: nijedan regularni izraz to ne hvata. Drugi model, brz i jeftin, tada može djelovati kao sudac, s odgovorom ograničenim na JSON format kako bi ostao upotrebljiv za kod koji ga poziva. Kompromis je eksplicitan – dobivaš preciznost po cijenu latencije i determinizma, što ovaj pristup rezervira za pravila koja to doista opravdavaju.

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

Ključne točke

  • Ograde validiraju usklađenost s poslovnim pravilima, a ne samo uvredljiv sadržaj
  • Arhitektura cjevovoda omogućuje kombiniranje više slojeva validacije
  • Svaka ograda ima jednu odgovornost: opseg, format, eksfiltracija itd.
  • Ograde izlaza jednako su važne kao i ograde ulaza
  • Za složene slučajeve, brzi LLM može poslužiti kao validator