Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Guardrails: Validering af input og output

Lektion 6 af 14 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Hvad er en guardrail?
  2. En pipeline-arkitektur
  3. Tre typiske guardrails
  4. Samling af det hele
  5. Når reglen ikke kan skrives i regex
  6. Vigtige pointer

Hvad er en guardrail?

En guardrail er et valideringslag, der sidder mellem brugeren og modellen ved input, eller mellem modellen og brugeren ved output. Forskellen fra den moderering, vi diskuterede i det foregående kapitel, er skarp, og du skal holde fast i den: Moderering svarer på spørgsmålet „Er dette indhold stødende?” – et universelt spørgsmål, hvis svar ikke afhænger af din forretning. Guardrails svarer på spørgsmål, som kun du kan formulere: Er beskeden inden for det forventede omfang? Indeholder svaret forbudte oplysninger? Er den anmodede handling autoriseret for denne rolle? En bankassistent og en boghandelsassistent deler den samme moderering, men har ingen fælles guardrails.

I 2026 er guardrails blevet en standardkomponent i arkitekturer for AI-agenter og er uundværlige, når en model har adgang til værktøjer eller følsomme data.

En pipeline-arkitektur

Det strukturelle valg er at behandle hver guardrail som et uafhængigt objekt med ét enkelt ansvar og derefter kæde dem sammen i en valgt rækkefølge. Fordelen viser sig under vedligeholdelse: Tilføjelse af en forretningsregel kræver ingen ændringer i eksisterende kode, og en regel, der bliver for støjende, kan fjernes med én enkelt linje.

En tredje kendelse slutter sig til „tillad” og „bloker”: „ændr”. Dette ændrer øvelsens natur. Mange virkelige situationer berettiger ikke et afslag – et svar, der indeholder en intern serversti, forbliver nyttigt, når stien er maskeret. Blokering ville miste informationen; ændring bevarer den ved at fjerne det, der udgør et 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 typiske guardrails

Omfangs-guardrailen holder samtalen inden for sit domæne. Den tjener både sikkerhed og omdømme: En kundeserviceassistent, der er trænet til at besvare spørgsmål om leverancer, har intet at vinde ved at kommentere politiske nyheder, og et screenshot af et sådant svar spreder sig hurtigt. Listen over forbudte emner skal diskuteres med forretningsdelen og aldrig udarbejdes af det tekniske team alene.

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

Format-guardrailen ser triviel ud, men giver den største daglige værdi. Den koster få mikrosekunder, afhænger af ingen netværkskald og afbryder de overdimensionerede beskeder, der bruges til volumetriske injektioner og forsøg på at udtømme budgettet. Placer den først i kæden: Der er ingen mening i at betale for API-moderering af en besked på 200.000 tegn, som du alligevel vil afvise.

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 overvåger output og illustrerer brugen af kendelsen „ændr”. De fire familier, den søger efter, deler en praktisk egenskab: De har en genkendelig form uafhængigt af betydningen. En API-nøgle, en intern adresse, en privat IP eller en serversti identificeres ved deres struktur uden behov for at forstå sætningen, der indeholder dem.

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

Samling af det hele

Den komplette samling viser, hvor brikkerne passer sammen. Asymmetrien springer i øjnene: To guardrails ved input, kun én ved output. Dette er hyppigt og sundt – du filtrerer kraftigt, før du kalder modellen, fordi det er her, omkostningerne kan undgås, og du holder det absolut nødvendige minimum ved output for at undgå at ødelægge korrekte svar. Beskeden, der returneres ved blokering af output, følger den samme forsigtighed: Den er bevidst vag og siger ikke, hvad der blev opdaget; oplysninger, der primært ville gavne nogen, der forsøger at kortlægge dine forsvarsværker.

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 reglen ikke kan skrives i regex

Nogle forretningsregler modstår enhver formalisering ved hjælp af mønstre. „Svaret må ikke udgøre investeringsrådgivning”, „beskeden må ikke indeholde sundhedsdata”: Intet regulært udtryk fanger dette. En anden model, hurtig og billig, kan derefter fungere som dommer, med et svar begrænset til JSON-format for at forblive brugbart for den kaldende kode. Afvejningen er eksplicit – du vinder præcision på bekostning af latenstid og determinisme, hvilket reserverer denne tilgang til regler, der virkelig berettiger den.

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

Vigtige pointer

  • Guardrails validerer overholdelse af forretningsregler, ikke kun stødende indhold
  • Pipeline-arkitektur muliggør kombination af flere valideringslag
  • Hver guardrail har ét enkelt ansvar: omfang, format, ekfiltrering osv.
  • Output-guardrails er lige så vigtige som input-guardrails
  • I komplekse tilfælde kan en hurtig LLM fungere som validator