Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Guardrails: Validera in- och utdata

Lektion 6 av 14 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Vad är en guardrail?
  2. En pipeline-arkitektur
  3. Tre typiska guardrails
  4. Sätt ihop allt
  5. När regeln inte kan skrivas med regex
  6. Viktiga punkter

Vad är en guardrail?

En guardrail är ett valideringslager som placeras mellan användaren och modellen vid inmatning, eller mellan modellen och användaren vid utmatning. Skillnaden gentemot den moderering som diskuterades i föregående kapitel är skarp, och du måste upprätthålla den: moderering svarar på frågan “Är detta innehåll stötande?” – en universell fråga vars svar inte beror på din verksamhet. Guardrails svarar på frågor som bara du kan formulera: Ligger meddelandet inom förväntat omfång? Innehåller svaret förbjuden information? Är den begärda åtgärden auktoriserad för denna roll? En bankassistent och en bokhandelsassistent delar samma moderering men har inga gemensamma guardrails.

År 2026 har guardrails blivit en standardkomponent i arkitekturer för AI-agenter, oumbärliga närhelst en modell har tillgång till verktyg eller känslig data.

En pipeline-arkitektur

Det strukturella valet är att behandla varje guardrail som ett oberoende objekt med ett enda ansvarsområde, och sedan kedja ihop dem i valfri ordning. Fördelen visar sig vid underhåll: att lägga till en affärsregel kräver inga ändringar i befintlig kod, och en regel som blir för brusig kan tas bort på en enda rad.

En tredje dom förenar “tillåt” och “blockera”: modifiera. Detta ändrar övningens natur. Många situationer i verkligheten motiverar inte ett nekande – ett svar som innehåller en intern sökväg till en server förblir användbart när den sökvägen maskeras. Att blockera skulle förlora informationen; att modifiera bevarar den genom att ta bort det som utgör ett 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)

Tre typiska guardrails

Guardrailen för omfång håller konversationen inom dess domän. Den tjänar både säkerhet och rykte: en kundtjänstassistent tränad för att svara på frågor om leveranser har inget att vinna på att kommentera politiska nyheter, och en skärmdump av ett sådant svar sprids snabbt. Listan över förbjudna ämnen måste diskuteras med affärsidan, aldrig utformas enbart av det tekniska teamet.

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

Guardrailen för format verkar trivial men ger mest värde i det dagliga arbetet. Den kostar några mikrosekunder, beror inte på några nätverksanrop och stoppar de överdimensionerade meddelanden som används för volymetriska injektioner och försök att tömma budgeten. Placera den först i kedjan: det finns ingen poäng med att betala för API-moderering på ett meddelande med 200 000 tecken som du ändå kommer att avvisa.

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

Den tredje övervakar utdata och illustrerar användningen av domen “modifiera”. De fyra familjer den söker efter delar en praktisk egenskap: de har en igenkännbar form oberoende av betydelse. En API-nyckel, en intern adress, en privat IP eller en sökväg till en server identifieras genom sin struktur, utan behov av att förstå meningen de ingår 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")

Sätt ihop allt

Den kompletta sammansättningen visar var bitarna passar in. Asymmetrin är slående: två guardrails vid inmatning, bara en vid utmatning. Detta är vanligt och sunt – du filtrerar kraftigt innan du anropar modellen eftersom det är där kostnader kan undvikas, och du behåller det absolut nödvändiga vid utmatning för att inte skada korrekta svar. Meddelandet som returneras vid blockering av utdata följer samma försiktighet: avsiktligt vagt säger det inte vad som upptäcktes, information som främst skulle gynna någon som försöker kartlägga dina försvar.

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

När regeln inte kan skrivas med regex

Vissa affärsregler motstår all formalisering genom mönster. “Svaret får inte utgöra investeringsrådgivning”, “meddelandet får inte innehålla hälsoinformation”: inget reguljärt uttryck fångar detta. En andra modell, snabb och billig, kan då agera som domare, med ett svar begränsat till JSON-format för att förbli användbart av den anropande koden. Avvägningen är explicit – du vinner precision till priset av latens och determinism, vilket reserverar detta tillvägagångssätt för regler som verkligen motiverar det.

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

Viktiga punkter

  • Guardrails validerar efterlevnad av affärsregler, inte bara stötande innehåll
  • Pipeline-arkitektur möjliggör kombination av flera valideringslager
  • Varje guardrail har ett enda ansvarsområde: omfång, format, exfiltrering etc.
  • Guardrails för utdata är lika viktiga som guardrails för indata
  • För komplexa fall kan en snabb LLM fungera som validerare