Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Volledige beveiligingsarchitectuur

Les 12 van 12 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Alle onderdelen samenvoegen
  2. Overzicht van de architectuur
  3. Complete implementatie
  4. Gebruik in productie
  5. Monitoring en waarschuwingen
  6. Samenvatting van de cursus
  7. Belangrijkste punten
  8. Test uw kennis

Bijgewerkt op 3 november 2026. De generatielaag gaf eerder een verzonnen guardrails-formaat door (enabled), en het productiebeleid gebruikte niet-bestaande categorieën (hate, violence, unpredictable). De code volgt nu het officiële moderation_llm_v2-formaat en de elf sleutels van mistral-moderation-2603. Scores, die optioneel zijn in de SDK, worden uitgelezen met een fallback-waarde. Code geverifieerd tegen mistralai SDK-types versie 3.7.0. Bronnen: Moderation & Guardrailing · Python SDK mistralai.

Alle onderdelen samenvoegen

Tijdens deze cursus heeft u kennisgemaakt met guardrails, de Moderation API, de 11 categorieën, drempelwaarden, jailbreak-detectie, AVG-naleving en inhoudsbeleid. Deze laatste les voegt al deze bouwstenen samen tot een complete beveiligingsarchitectuur die klaar is voor productie.

Overzicht van de architectuur

Er zijn vijf lagen, gedreven door één principe: geen enkele laag is op zichzelf betrouwbaar. Een guardrail kan worden omzeild door een onverwachte formulering, een moderatiemodel heeft false negatives, en een inhoudsbeleid dekt nooit elk geval. Stapelen werkt omdat de hiaten niet overlappen; wat door de eerste laag glipt, heeft een grote kans om door de tweede te worden opgepikt.

Het praktische gevolg is een strikte volgorde: elke laag moet zo goedkoop mogelijk zijn voordat de volgende draait. U valideert het formaat voordat u een guardrail aanroept, en u roept de guardrail aan voordat u genereert, omdat inhoud die in stap 1 wordt geweigerd nul tokens verbruikt.

Gebruiker
    ↓
[1. Invoervalidatie] → Regex, patronen, rate limiting
    ↓
[2. Mistral Guardrails]  → Blokkeren vóór generatie (403)
    ↓
[3. LLM-generatie]       → safe_prompt + veilige instructies
    ↓
[4. Output-moderatie]    → Moderation API na generatie
    ↓
[5. Loggen & Audit]      → Scores, beslissingen, AVG-audittrail
    ↓
Gebruikersreactie

Complete implementatie

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import re
import json
import logging
from datetime import datetime, timezone
from enum import Enum

# Configuratie
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("moderation")


class Decision(Enum):
    ALLOWED = "allowed"
    BLOCKED_INPUT = "blocked_input"
    BLOCKED_GUARDRAIL = "blocked_guardrail"
    BLOCKED_OUTPUT = "blocked_output"
    ERROR = "error"


class SecureArchitecture:
    """Complete beveiligingsarchitectuur voor AI-toepassingen."""

    def __init__(self, policy: dict, model: str = "mistral-large-latest"):
        self.policy = policy
        self.model = model
        self.stats = {d.value: 0 for d in Decision}

    # --- Laag 1: Invoervalidatie ---

    def validate_input(self, text: str) -> dict:
        """Snelle validatie vóór enige API-aanroep."""
        # Maximale lengte
        if len(text) > 10000:
            return {"valid": False, "reason": "Bericht te lang"}

        # Verdachte tekens (Unicode-injecties)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Ongeldige tekens"}

        # Voor de hand liggende jailbreak-patronen
        patterns = [
            r"ignore\s+(all\s+)?(previous|prior|above)",
            r"you\s+are\s+now\s+(DAN|unfiltered)",
            r"oublie\s+(toutes?\s+)?(tes|vos)\s+instructions",
            r"system\s*prompt",
        ]
        for pattern in patterns:
            if re.search(pattern, text, re.IGNORECASE):
                return {
                    "valid": False,
                    "reason": "Injectiepatroon gedetecteerd"
                }

        return {"valid": True}

    # --- Laag 2: Invoermoderatie ---

    def moderate_input(self, text: str) -> dict:
        """Prompt-moderatie via API."""
        response = client.classifiers.moderate(
            model="mistral-moderation-2603",
            inputs=[text]
        )
        scores = response.results[0].category_scores or {}
        violations = self._check_thresholds(scores)

        return {
            "allowed": len(violations) == 0,
            "scores": scores,
            "violations": violations
        }

    # --- Laag 3: Veilige generatie ---

    def generate(self, messages: list) -> str:
        """Generatie met guardrails en safe_prompt."""
        response = client.chat.complete(
            model=self.model,
            messages=messages,
            safe_prompt=True,
            guardrails=[
                {
                    "block_on_error": True,
                    "moderation_llm_v2": {
                        "custom_category_thresholds": self.policy["thresholds"],
                        "action": "block",
                    },
                }
            ],
        )
        content = response.choices[0].message.content
        return content if isinstance(content, str) else ""

    # --- Laag 4: Output-moderatie ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Respons-moderatie in context."""
        response = client.classifiers.moderate_chat(
            model="mistral-moderation-2603",
            inputs=[[
                {"role": "user", "content": prompt},
                {"role": "assistant", "content": response_text}
            ]]
        )
        scores = response.results[0].category_scores or {}
        violations = self._check_thresholds(scores)

        return {
            "allowed": len(violations) == 0,
            "scores": scores,
            "violations": violations
        }

    # --- Laag 5: Loggen ---

    def log_decision(self, decision: Decision, data: dict):
        """Legt de beslissing vast voor auditing."""
        self.stats[decision.value] += 1
        entry = {
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "decision": decision.value,
            "policy": self.policy["name"],
            **data
        }
        logger.info(json.dumps(entry, ensure_ascii=False))

    # --- Hoofdpijplijn ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Complete veilige verwerkingspijplijn."""

        # Laag 1: Validatie
        validation = self.validate_input(user_message)
        if not validation["valid"]:
            self.log_decision(Decision.BLOCKED_INPUT, {
                "reason": validation["reason"]
            })
            return {
                "status": Decision.BLOCKED_INPUT.value,
                "message": "Uw bericht kan niet worden verwerkt."
            }

        # Laag 2: Invoermoderatie
        check_input = self.moderate_input(user_message)
        if not check_input["allowed"]:
            self.log_decision(Decision.BLOCKED_INPUT, {
                "violations": check_input["violations"]
            })
            return {
                "status": Decision.BLOCKED_INPUT.value,
                "message": "Deze inhoud is in strijd met ons beleid."
            }

        # Laag 3: Generatie
        messages = []
        if system_prompt:
            messages.append({"role": "system",
                           "content": system_prompt})
        messages.append({"role": "user",
                        "content": user_message})

        try:
            response_text = self.generate(messages)
        except SDKError as e:
            if e.status_code == 403:
                self.log_decision(Decision.BLOCKED_GUARDRAIL, {})
                return {
                    "status": Decision.BLOCKED_GUARDRAIL.value,
                    "message": "Verzoek geblokkeerd door guardrails."
                }
            raise

        # Laag 4: Output-moderatie
        check_output = self.moderate_output(user_message, response_text)
        if not check_output["allowed"]:
            self.log_decision(Decision.BLOCKED_OUTPUT, {
                "violations": check_output["violations"]
            })
            return {
                "status": Decision.BLOCKED_OUTPUT.value,
                "message": "De respons is gefilterd."
            }

        # Succes
        self.log_decision(Decision.ALLOWED, {
            "input_max_score": max(check_input["scores"].values(), default=0.0),
            "output_max_score": max(check_output["scores"].values(), default=0.0),
        })

        return {
            "status": Decision.ALLOWED.value,
            "content": response_text,
            "moderation": {
                "input": check_input["scores"],
                "output": check_output["scores"]
            }
        }

    # --- Hulpprogramma's ---

    def _check_thresholds(self, scores: dict) -> list:
        """Controleert scores tegen beleidsdrempels."""
        violations = []
        for cat, threshold in self.policy["thresholds"].items():
            score = scores.get(cat, 0)
            if score > threshold:
                violations.append({
                    "category": cat,
                    "score": round(score, 3),
                    "threshold": threshold
                })
        return violations

    def report(self) -> dict:
        """Genereert een statistiekenrapport."""
        total = sum(self.stats.values())
        return {
            "policy": self.policy["name"],
            "total_requests": total,
            "decisions": self.stats,
            "block_rate": round(
                (self.stats["blocked_input"] +
                 self.stats["blocked_guardrail"] +
                 self.stats["blocked_output"]) / max(total, 1),
                3
            )
        }

Gebruik in productie

# Definieer het beleid
prod_policy = {
    "name": "Production v1.2",
    "thresholds": {
        "sexual": 0.15, "hate_and_discrimination": 0.1, "violence_and_threats": 0.2,
        "dangerous": 0.1, "criminal": 0.1, "selfharm": 0.1, "health": 0.4,
        "financial": 0.4, "law": 0.4, "pii": 0.15,
        "jailbreaking": 0.1
    }
}

# Instantiateer de architectuur
arch = SecureArchitecture(prod_policy)

# Verwerk verzoeken
result = arch.process(
    "Explain how transformers work",
    system_prompt="You are an AI instructor."
)
print(result["status"])   # verwacht: "allowed"
print(result["content"])

# Raadpleeg statistieken
print(arch.report())

Monitoring en waarschuwingen

Twee metrieken volstaan om een moderatiesysteem te sturen, en u moet ze in tegenovergestelde richtingen bewaken. Het blokkeerpercentage moet stabiel blijven: een plotselinge piek wijst op een aanval of op een drempel die te streng is en legitieme gebruikers begint te hinderen. De scoreverdeling is minstens zo belangrijk; als uw inhoud zich net onder de drempel ophoopt, is de drempel slecht geplaatst en zal de volgende aanpassing door uw gebruikers het systeem doen falen.

def configure_alerts(arch: SecureArchitecture):
    """Configureert waarschuwingen voor monitoring."""
    report = arch.report()

    # Waarschuwing bij abnormaal blokkeerpercentage
    if report["block_rate"] > 0.15:
        logger.warning(
            f"Hoog blokkeerpercentage: "
            f"{report['block_rate']:.1%}"
        )

    # Waarschuwing bij pieken in jailbreaks
    # Integreer met Prometheus, Grafana, Datadog, enz.

Samenvatting van de cursus

Aan het einde van deze cursus beheerst u:

  • Aangepaste guardrails: Blokkeer gevaarlijke prompts vóór generatie, configureer drempels per categorie, pas toe op agents
  • Moderation API: Classificeer inhoud met Mistral Moderation 2, interpreteer scores over de 11 categorieën, neem geautomatiseerde beslissingen
  • Productiebeveiliging: Definieer inhoudsbeleid, detecteer prompt-injecties, zorg voor AVG-naleving
  • Complete architectuur: Voeg guardrails + moderatie + monitoring samen tot een robuuste pijplijn

U beschikt nu over alle code die nodig is om een compleet AI-moderatiesysteem met de Mistral API te implementeren.

Belangrijkste punten

  • De beveiligingsarchitectuur omvat 5 lagen: validatie, guardrails, generatie, moderatie, loggen
  • Elke laag compenseert de zwaktes van de andere; dit is defense in depth
  • Monitor het blokkeerpercentage en de scores in productie
  • Houd uw beleid up-to-date met regelmatige evaluaties
  • De complete code in deze les is een startpunt; pas deze aan uw context aan

Test uw kennis

Guardrails, moderatie, injectie: is de defensieve architectuur duidelijk?

1. Waar grijpen aangepaste guardrails in?

Antwoord: Vóór het model: ze filteren invoer volgens uw regels (verboden onderwerpen, formaten) – de eerste laag, die voorkomt dat de aanroep überhaupt plaatsvindt wanneer het verzoek buiten scope valt.

2. Wat dekt de Mistral Moderation API?

Antwoord: Elf categorieën risicovolle inhoud, met een score per categorie: uw drempels bepalen of wordt geblokkeerd, gemarkeerd of toegestaan – zo zet u inhoudsbeleid om in code.

3. Hoe definieert u een goed inhoudsbeleid?

Antwoord: Per use case: wat is aanvaardbaar voor de applicatie, drempels per categorie, gekoppelde acties (blokkeren, herschrijven, escaleren) – gedocumenteerd en getest, niet impliciet.

4. Hoe detecteert u pogingen tot prompt-injectie?

Antwoord: Door alle externe inhoud als verdacht te behandelen: instructiepatronen in data detecteren, instructies isoleren van data, outputs valideren – en regelmatig offensieve tests uitvoeren.

5. Hoe ziet de complete beveiligingsarchitectuur eruit?

Antwoord: Lagen: input guardrails, inhoudsmoderatie, output-controles, AVG-naleving (minimalisatie, rechten) en traceerbaarheid – geen enkele laag is perfect, maar stapelen compenseert dit.

Defense in depth is geen slogan: elke laag in deze cursus vangt op wat de vorige heeft laten passeren.