Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Komplet sikkerhedsarkitektur

Lektion 12 af 12 Opdateret 3. november 2026 Udvikler
På denne side
  1. Samling af alle brikkerne
  2. Arkitekturoverblik
  3. Komplet implementering
  4. Brug i produktion
  5. Overvågning og alarmer
  6. Opsamling på kurset
  7. Vigtige pointer
  8. Test din viden

Opdateret 3. november 2026. Genereringslaget sendte tidligere et opfundet guardrails-format (enabled), og produktionspolitikken brugte ikke-eksisterende kategorier (hate, violence, unpredictable). Koden følger nu det officielle moderation_llm_v2-format og de elleve nøgler fra mistral-moderation-2603. Scores, som er valgfrie i SDK’et, læses med en fallback-værdi. Kode verificeret mod mistralai SDK-typer version 3.7.0. Kilder: Moderation & Guardrailing · Python SDK mistralai.

Samling af alle brikkerne

Gennem dette kursus har du udforsket guardrails, Moderation API’et, de 11 kategorier, tærskler, jailbreak-detektion, GDPR-overholdelse og indholdsretningslinjer. Denne sidste lektion samler alle disse byggesten til en komplet sikkerhedsarkitektur, der er klar til produktion.

Arkitekturoverblik

Der er fem lag, drevet af ét princip: Intet af dem er pålideligt alene. Et guardrail kan omgås ved en uventet formulering, en moderationsmodel har falske negativer, og en indholds politik dækker aldrig alle tilfælde. At stable dem fungerer, fordi hullerne ikke overlapper – det, der slipper gennem det første lag, har en god chance for at blive fanget af det andet.

Den praktiske konsekvens er en streng rækkefølge: Hvert lag skal være så billigt som muligt, før det næste køres. Du validerer formatet, før du kalder et guardrail, og du kalder guardrailet, før du genererer – fordi indhold, der afvises i trin 1, bruger nul tokens.

User
    ↓
[1. Input Validation] → Regex, patterns, rate limiting
    ↓
[2. Mistral Guardrails]  → Pre-generation blocking (403)
    ↓
[3. LLM Generation]      → safe_prompt + secure instructions
    ↓
[4. Output Moderation]   → Moderation API post-generation
    ↓
[5. Logging & Audit]     → Scores, decisions, GDPR audit trail
    ↓
User Response

Komplet implementering

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

# Configuration
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 security architecture for AI applications."""

    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}

    # --- Layer 1: Input Validation ---

    def validate_input(self, text: str) -> dict:
        """Fast validation before any API call."""
        # Maximum length
        if len(text) > 10000:
            return {"valid": False, "reason": "Message too long"}

        # Suspicious characters (Unicode injections)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Invalid characters"}

        # Obvious jailbreak patterns
        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": "Injection pattern detected"
                }

        return {"valid": True}

    # --- Layer 2: Input Moderation ---

    def moderate_input(self, text: str) -> dict:
        """Prompt moderation 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
        }

    # --- Layer 3: Secure Generation ---

    def generate(self, messages: list) -> str:
        """Generation with guardrails and 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 ""

    # --- Layer 4: Output Moderation ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Response moderation 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
        }

    # --- Layer 5: Logging ---

    def log_decision(self, decision: Decision, data: dict):
        """Records the decision for 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))

    # --- Main Pipeline ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Complete secure processing pipeline."""

        # Layer 1: Validation
        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": "Your message cannot be processed."
            }

        # Layer 2: Input Moderation
        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": "This content violates our policy."
            }

        # Layer 3: Generation
        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": "Request blocked by guardrails."
                }
            raise

        # Layer 4: Output Moderation
        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": "The response was filtered."
            }

        # Success
        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"]
            }
        }

    # --- Utilities ---

    def _check_thresholds(self, scores: dict) -> list:
        """Checks scores against policy thresholds."""
        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:
        """Generates a statistics report."""
        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
            )
        }

Brug i produktion

# Define the policy
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
    }
}

# Instantiate the architecture
arch = SecureArchitecture(prod_policy)

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

# Consult statistics
print(arch.report())

Overvågning og alarmer

To nøgletal er nok til at styre et moderationssystem, og du skal holde øje med dem i hver sin retning. Blokeringsraten bør forblive stabil: En pludselig stigning signalerer enten et angreb eller en tærskel, der er for streng og begynder at hæmme legitime brugere. Score-fordelingen er lige så vigtig – hvis dit indhold klumper sig lige under tærsklen, er tærsklen dårligt placeret, og den næste justering fra dine brugere vil bryde den.

def configure_alerts(arch: SecureArchitecture):
    """Configures alerts for monitoring."""
    report = arch.report()

    # Alert if block rate is abnormal
    if report["block_rate"] > 0.15:
        logger.warning(
            f"High block rate: "
            f"{report['block_rate']:.1%}"
        )

    # Alert if jailbreak spikes occur
    # Integrate with Prometheus, Grafana, Datadog, etc.

Opsamling på kurset

Ved slutningen af dette kursus har du mestret:

  • Brugerdefinerede Guardrails: Bloker farlige prompts før generering, konfigurér tærskler pr. kategori, anvend på agenter
  • Moderation API: Klassificér indhold med Mistral Moderation 2, fortolk scores på tværs af de 11 kategorier, træf automatiserede beslutninger
  • Produktionssikkerhed: Definér indholds politikker, detektér prompt-injektioner, sørg for GDPR-overholdelse
  • Komplet arkitektur: Saml guardrails + moderation + overvågning til en robust pipeline

Du har nu al den kode, der er nødvendig for at udrulle et komplet AI-moderationssystem med Mistral API.

Vigtige pointer

  • Sikkerhedsarkitekturen omfatter 5 lag: validering, guardrails, generering, moderation, logning
  • Hvert lag kompenserer for de andres svagheder – dette er forsvar i dybden
  • Overvåg blokeringsraten og scores i produktion
  • Hold din politik opdateret med regelmæssige gennemgange
  • Den komplette kode i denne lektion er et udgangspunkt – tilpas den til din kontekst

Test din viden

Guardrails, moderation, injektion: Er den defensive arkitektur klar?

1. Hvor griber brugerdefinerede guardrails ind?

Svar: Før modellen: De filtrerer inputs efter dine regler (forbudte emner, formater) – det første lag, som undgår at foretage selve kaldet, når anmodningen er uden for scope.

2. Hvad dækker Mistral Moderation API?

Svar: Elleve kategorier af risikabelt indhold med en score pr. kategori: Dine tærskler afgør, om der skal blokeres, flagges eller tillades – og gør dermed indholds politik til kode.

3. Hvordan defineres en god indholds politik?

Svar: Efter brugstilfælde: Hvad der er acceptabelt for applikationen, tærskler pr. kategori, tilknyttede handlinger (blokering, omskrivning, eskalering) – dokumenteret og testet, ikke implicit.

4. Hvordan detekterer du forsøg på prompt-injektion?

Svar: Ved at behandle alt eksternt indhold som mistænkeligt: Detektér instruktionsmønstre i data, isolér instruktioner fra data, valider outputs – og kør regelmæssige offensive tests.

5. Hvordan ser den komplette sikkerhedsarkitektur ud?

Svar: Lag: Input-guardrails, indholdsmoderation, output-kontrol, GDPR-overholdelse (minimering, rettigheder) og sporbarhed – intet enkelt lag er perfekt, men stablingen af dem kompenserer.

Forsvar i dybden er ikke bare et slogan: Hvert lag i dette kursus fanger det, som det foregående slipper igennem.