LLM-beveiligingsmaatregelen in de praktijk: wat daadwerkelijk werkt

Controleer het risico, niet alleen het model.

Inhoud

LLM’s zijn onvoorspelbaar. Ze hallucineren, lekken data, genereren schadelijke inhoud of weigeren legitieme verzoeken. Guardrails beperken het gedrag van het model zonder de capaciteit in te perken.

De sleutel ligt in het weten welke guardrails belangrijk zijn en welke alleen maar ruis zijn.

Guardrails gaan niet over het controleren van het model. Ze gaan over het beheersen van het risico.

LLM guardrails in de praktijk

Validatie van invoer

De belangrijkste guardrail. Slechte invoer geeft slechte uitvoer, en slechte invoer kan ook leiden tot prompt-injectie in uw systeem.

Strategie 1: Prompt-sanitisatie

Sanitiseer gevaarpatronen vroeg:

import re

class PromptSanitizer:
    def __init__(self):
        self.dangerous_patterns = [
            r"ignore\s+previous\s+instructions",
            r"system\s+prompt",
            r"you\s+are\s+now\s+free",
            r"break\s+out\s+of",
        ]

    def sanitize(self, prompt: str) -> str:
        for pattern in self.dangerous_patterns:
            prompt = re.sub(pattern, "[REDACTED]", prompt, flags=re.IGNORECASE)
        return prompt

Dit is niet onbreekbaar. Adversariële invoer is creatief. Maar het vangt de voor de hand liggende gevallen, en die zijn het meest voorkomend.

Strategie 2: Invoergrenzen voor lengte

Lengtegrenzen voorkomen tokenverbruik en time-outs:

class InputValidator:
    def __init__(self, max_length: int = 10000):
        self.max_length = max_length

    def validate(self, prompt: str) -> tuple[bool, str]:
        if len(prompt) > self.max_length:
            return False, f"Invoer te lang: {len(prompt)} > {self.max_length}"
        return True, "OK"

Strategie 3: Contentfiltering

Contentfiltering blokkeert overtredingen van het beleid. De patronen hier zijn afhankelijk van uw domein:

class ContentFilter:
    def __init__(self):
        self.blocked_topics = [
            "geweld", "hate speech", "zelfbeschadiging",
            "seksuele inhoud", "illegale activiteiten",
        ]

    def filter(self, prompt: str) -> tuple[bool, str]:
        prompt_lower = prompt.lower()
        for topic in self.blocked_topics:
            if topic in prompt_lower:
                return False, f"Geblokkeerd: {topic}"
        return True, "OK"

Eenvoudige stringmatching is snel maar onnauwkeurig. Gebruik voor productie een classificatiemodel — zelfs een klein model zoals Qwen2.5-1.5B — om overtredingen van het beleid te detecteren. Het is nauwkeuriger en moeilijker te omzeilen.

Uitvoerfiltering

Ook de uitvoer van het model moet worden gecontroleerd. Structuur, inhoud en feiten.

Strategie 1: Validatie van antwoorden

Valideer eerst de structuur. Als u JSON verwacht, controleer dan op JSON:

class ResponseValidator:
    def __init__(self):
        self.required_fields = ["answer", "confidence"]

    def validate(self, response: dict) -> tuple[bool, str]:
        for field in self.required_fields:
            if field not in response:
                return False, f"Ontbrekend veld: {field}"
        return True, "OK"

Strategie 2: Contentfiltering

Filter schadelijke inhoud:

class OutputFilter:
    def __init__(self):
        self.blocked_patterns = [
            r"kill\s+someone",
            r"bomb\s+recipe",
            r"hate\s+speech",
            r"self-harm",
        ]

    def filter(self, response: str) -> tuple[bool, str]:
        for pattern in self.blocked_patterns:
            if re.search(pattern, response, re.IGNORECASE):
                return False, f"Geblokkeerd: {pattern}"
        return True, "OK"

Strategie 3: Feitencontrole

Feitencontrole is moeilijker. U kunt niet elke bewering valideren, dus kies degenen die belangrijk zijn:

class FactChecker:
    def __init__(self):
        self.known_facts = {
            "capital of france": "Paris",
            "population of usa": "330 million",
            "speed of light": "299,792,458 m/s",
        }

    def check(self, claim: str) -> tuple[bool, str]:
        claim_lower = claim.lower()
        for fact, truth in self.known_facts.items():
            if fact in claim_lower and truth not in claim_lower:
                return False, f"Feitencontrole mislukt: {fact}"
        return True, "OK"

Voor echte feitencontrole heeft u een retrievingspipeline nodig. Controleer beweringen tegen een kennisbank, niet tegen een hardgecodeerde dictionary.

Veiligheidsmechanismen

Strategie 1: Rate Limiting

Rate limiting voorkomt misbruik:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests: int = 10, window: int = 60):
        self.max_requests = max_requests
        self.window = window
        self.requests = deque()

    def allow(self) -> bool:
        now = time.time()
        while self.requests and self.requests[0] < now - self.window:
            self.requests.popleft()

        if len(self.requests) >= self.max_requests:
            return False

        self.requests.append(now)
        return True

Strategie 2: Token Budgettering

Token budgettering legt een plafond op kosten per verzoek:

class TokenBudget:
    def __init__(self, max_tokens: int = 1000):
        self.max_tokens = max_tokens

    def validate(self, response: str) -> tuple[bool, str]:
        token_count = len(response.split())
        if token_count > self.max_tokens:
            return False, f"Tokenlimiet overschreden: {token_count} > {self.max_tokens}"
        return True, "OK"

Strategie 3: Contextvensterbeheer

Contextvensterbeheer voorkomt overloop:

class ContextManager:
    def __init__(self, max_context: int = 4096):
        self.max_context = max_context
        self.context = []

    def add(self, message: str):
        self.context.append(message)
        self.trim()

    def trim(self):
        while len(" ".join(self.context)) > self.max_context:
            self.context.pop(0)

Sliding window trimming is eenvoudig, maar verliest vroeg context. Betere benaderingen gebruiken samenvatting of compressie op basis van attention, maar dit voegt latentie toe.

Compliance

Enterprise-systemen hebben compliance-guardrails nodig. Twee die het meest belangrijk zijn:

Patroon 1: Data Residency

Data residency — zorg ervoor dat data binnen de vereiste geografische grenzen blijft:

class DataResidency:
    def __init__(self, allowed_regions: list[str]):
        self.allowed_regions = allowed_regions

    def validate(self, region: str) -> tuple[bool, str]:
        if region not in self.allowed_regions:
            return False, f"Regio niet toegestaan: {region}"
        return True, "OK"

Patroon 2: Audit Logging

Audit logging — log alle modelinteracties:

import json
from datetime import datetime

class AuditLogger:
    def __init__(self, log_file: str = "audit.log"):
        self.log_file = log_file

    def log(self, request: dict, response: dict):
        entry = {
            "timestamp": datetime.now().isoformat(),
            "request": request,
            "response": response,
        }
        with open(self.log_file, "a") as f:
            f.write(json.dumps(entry) + "\n")

Auditlogs zijn cruciaal voor debugging en compliance. Houd ze gestructureerd, alleen append-only en veilig opgeslagen.

Samenbrengen

Patroon 1: Eenvoudige Guardrails

Een eenvoudige guardrail-pipeline:

class SimpleGuardrails:
    def __init__(self):
        self.input_validator = InputValidator(max_length=10000)
        self.output_filter = OutputFilter()

    def process(self, prompt: str) -> str:
        valid, message = self.input_validator.validate(prompt)
        if not valid:
            return f"Fout: {message}"

        response = self.call_model(prompt)

        valid, message = self.output_filter.filter(response)
        if not valid:
            return f"Fout: {message}"

        return response

Patroon 2: Geavanceerde Guardrails

Geavanceerde guardrails voegen sanitization, rate limiting en token budgets toe:

class AdvancedGuardrails:
    def __init__(self):
        self.sanitizer = PromptSanitizer()
        self.input_validator = InputValidator(max_length=10000)
        self.content_filter = ContentFilter()
        self.output_filter = OutputFilter()
        self.rate_limiter = RateLimiter(max_requests=10)
        self.token_budget = TokenBudget(max_tokens=1000)

    def process(self, prompt: str) -> str:
        prompt = self.sanitizer.sanitize(prompt)

        valid, message = self.input_validator.validate(prompt)
        if not valid:
            return f"Fout: {message}"

        valid, message = self.content_filter.filter(prompt)
        if not valid:
            return f"Fout: {message}"

        if not self.rate_limiter.allow():
            return "Fout: Rate limit overschreden"

        response = self.call_model(prompt)

        valid, message = self.output_filter.filter(response)
        if not valid:
            return f"Fout: {message}"

        valid, message = self.token_budget.validate(response)
        if not valid:
            return f"Fout: {message}"

        return response

Wanneer guardrails belangrijk zijn

Guardrails zijn belangrijk wanneer u systeemvoor gebruikers bouwt, gevoelige data verwerkt of in productie draait. Ze zijn ook belangrijk wanneer u vereisten voor compliance heeft — AVG, HIPAA, SOC 2.

Ze zijn niet belangrijk wanneer u prototype, modellen alleen voor interne tools gebruikt of geen gevoelige data verwerkt. Sla ze over tot u ze nodig heeft.

De afweging is altijd capaciteit versus veiligheid. Meer guardrails betekenen minder falen, maar ook minder capaciteit. Vind de balans die werkt voor uw systeem.

Afwegingen

Strategie Veiligheid Capaciteit Latentie
Geen guardrails Laagst Hoogst Laagst
Validatie van invoer Hoog Middel Laag
Uitvoerfiltering Hoog Middel Laag
Veiligheidsmechanismen Hoogst Laagst Hoogst
Compliance Hoogst Laagst Hoogst

Gerelateerd

Abonneren

Ontvang nieuwe berichten over systemen, infrastructuur en AI-engineering.