Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Guardrails: Syötteiden ja tulosteiden validointi

Oppitunti 6 / 14 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Mikä on guardrail?
  2. Putkiarkkitehtuuri
  3. Kolme tyypillistä guardrailia
  4. Kokonaisuuden kokoaminen
  5. Kun sääntöä ei voi kirjoittaa regexillä
  6. Keskeiset asiat

Mikä on guardrail?

Guardrail on validointikerros, joka sijaitsee käyttäjän ja mallin välillä syötteen puolella tai mallin ja käyttäjän välillä tulosteen puolella. Ero edellisessä luvussa käsiteltyyn moderointiin on jyrkkä, ja sinun on pidettävä se mielessäsi: moderointi vastaa kysymykseen “Onko tämä sisältö loukkaavaa?” – tämä on universaali kysymys, jonka vastaus ei riipu liiketoiminnastasi. Guardrailit vastaavat kysymyksiin, jotka vain sinä voit muotoilla: Onko viesti odotetun aihepiirin sisällä? Sisältääkö vastaus kiellettyä tietoa? Onko pyydetty toiminto sallittu tälle roolille? Pankkiavustajalla ja kirjakaupan avustajalla on sama moderointi, mutta ei yhteisiä guardraileja.

Vuoteen 2026 mennessä guardraileista on tullut vakio-osa tekoälyagenttien arkkitehtuureja, ja ne ovat välttämättömiä aina, kun mallilla on pääsy työkaluihin tai arkaluonteiseen dataan.

Putkiarkkitehtuuri

Rakenteellinen valinta on käsitellä jokainen guardrail itsenäisenä objektina, jolla on yksi vastuualue, ja ketjuttaa ne valittuun järjestykseen. Hyöty näkyy ylläpidossa: liiketoimintasäännön lisääminen ei vaadi muutoksia olemassa olevaan koodiin, ja liian häiritsevä sääntö voidaan poistaa yhdellä rivillä.

Sallimisen ja estämisen rinnalle liittyy kolmas tuomio: muokkaus. Tämä muuttaa harjoituksen luonnetta. Monet todellisen maailman tilanteet eivät oikeuta kieltäytymiseen – vastaus, joka sisältää sisäisen palvelinpolun, pysyy hyödyllisenä, kun polku peitetään. Estäminen menettäisi tiedon; muokkaus säilyttää sen poistamalla ongelmallisen osan.

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)

Kolme tyypillistä guardrailia

Aihepiirin guardrail pitää keskustelun määritellyn domainin sisällä. Se palvelee sekä turvallisuutta että mainetta: asiakaspalveluavustaja, joka on koulutettu vastaamaan toimituksia koskeviin kysymyksiin, ei hyödy kommentoimalla poliittisia uutisia, ja tällaisen vastauksen kuvakaappaus leviää nopeasti. Kiellettyjen aiheiden lista tulee sopia liiketoiminnan edustajien kanssa; teknisen tiimin ei tule laatia sitä yksin.

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

Muotoilun guardrail vaikuttaa triviaalilta, mutta tuottaa eniten arvoa päivittäisessä käytössä. Se maksaa muutaman mikrosekunnin, ei riipu verkkopyynnöistä ja katkaisee liian suuret viestit, joita käytetään volumetrisiin injektioihin ja budjetin tyhjentämisyrityksiin. Sijoita se ketjun ensimmäiseksi: API-moderoinnista ei kannata maksaa 200 000 merkin viestille, jonka hylkäät joka tapauksessa.

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 valvoo tulostetta ja havainnollistaa “muokkaus”-tuomion käyttöä. Neljä ryhmää, joita se etsii, jakavat kätevän ominaisuuden: niillä on tunnistettava muoto merkityksestä riippumatta. API-avain, sisäinen osoite, yksityinen IP tai palvelinpolku tunnistetaan niiden rakenteen perusteella ilman tarvetta ymmärtää lausetta, jossa ne esiintyvät.

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

Kokonaisuuden kokoaminen

Täydellinen kokoonpano näyttää, miten palaset sopivat yhteen. Epäsymmetria pistää silmään: kaksi guardrailia syötteelle, vain yksi tulosteelle. Tämä on yleistä ja tervettä – suodatat voimakkaasti ennen mallin kutsumista, koska siellä kustannukset ovat vältettävissä, ja pidät tulosteessa vain välttämättömän minimoimaan oikeiden vastausten vahingoittumisen. Estettäessä tulostetta palautettava viesti noudattaa samaa varovaisuutta: se on tarkoituksellisen epämääräinen eikä kerro, mitä havaittiin, sillä tieto palvelisi ensisijaisesti puolustuksesi kartoittamista yrittävää henkilöä.

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

Kun sääntöä ei voi kirjoittaa regexillä

Jotkin liiketoimintasäännöt vastustavat kaikkea kaavojen avulla formalisointia. “Vastauksen ei tule muodostaa sijoitusneuvontaa”, “viestin ei tule sisältää terveystietoja”: mikään säännöllinen lauseke ei sieppaa tätä. Tällöin toinen malli, nopea ja edullinen, voi toimia tuomarina, ja sen vastaus rajoitetaan JSON-muotoon, jotta kutsuva koodi voi käyttää sitä. Kompromissi on selkeä: saat tarkkuutta latenssin ja determinismin kustannuksella, mikä varaa tämän lähestymistavan vain säännöille, jotka todella oikeuttavat sen.

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

Keskeiset asiat

  • Guardrailit validoivat liiketoiminnan vaatimustenmukaisuutta, eivät vain loukkaavaa sisältöä
  • Putkiarkkitehtuuri mahdollistaa useiden validointikerrosten yhdistämisen
  • Jokaisella guardraililla on yksi vastuualue: aihepiiri, muotoilu, tietovuoto jne.
  • Tulosteen guardrailit ovat yhtä tärkeitä kuin syötteen guardrailit
  • Monimutkaisissa tapauksissa nopea LLM voi toimia validaattorina