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

Arkitektur för fullständig säkerhet

Lektion 12 av 12 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Sätta ihop alla delar
  2. Översikt över arkitekturen
  3. Kompletta implementeringen
  4. Användning i produktion
  5. Övervakning och varningar
  6. Sammanfattning av kursen
  7. Viktiga punkter
  8. Testa dina kunskaper

Uppdaterad 3 november 2026. Genereringslagret använde tidigare ett påhittat format för skyddsräcken (enabled), och produktionspolicyn använde kategorier som inte finns (hate, violence, unpredictable). Koden följer nu det officiella formatet moderation_llm_v2 och de elva nycklarna från mistral-moderation-2603. Poäng, som är valfria i SDK:t, läses med ett reservvärde. Koden verifierad mot mistralai SDK-typer version 3.7.0. Källor: Moderation & Guardrailing · Python SDK mistralai.

Sätta ihop alla delar

Under denna kurs har du utforskat skyddsräcken, Moderation API, de 11 kategorierna, tröskelvärden, upptäckt av jailbreak, GDPR-efterlevnad och innehållspolicyer. Denna sista lektion sätter ihop alla dessa byggstenar till en komplett säkerhetsarkitektur redo för produktion.

Översikt över arkitekturen

Det finns fem lager, drivna av en princip: inget av dem är tillförlitligt på egen hand. Ett skyddsräcke kan kringgås genom en oväntad formulering, en modereringsmodell har falska negativ, och en innehållspolicy täcker aldrig varje enskilt fall. Att stapla dem fungerar eftersom luckorna inte överlappar – det som smiter genom det första lagret har goda chanser att fångas av det andra.

Den praktiska konsekvensen är en strikt ordning: varje lager måste vara så billigt som möjligt innan nästa körs. Du validerar formatet innan du anropar ett skyddsräcke, och du anropar skyddsräcket innan generering – eftersom innehåll som nekas vid steg 1 förbrukar noll token.

Användare
    ↓
[1. Inmatningsvalidering] → Regex, mönster, hastighetsbegränsning
    ↓
[2. Mistral Guardrails]  → Blockering före generering (403)
    ↓
[3. LLM-generering]      → safe_prompt + säkra instruktioner
    ↓
[4. Utmatningsmoderering]   → Moderation API efter generering
    ↓
[5. Loggning & Granskning]     → Poäng, beslut, GDPR-granskningskedja
    ↓
Användarsvar

Kompletta implementeringen

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

# Konfiguration
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:
    """Komplett säkerhetsarkitektur för AI-applikationer."""

    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}

    # --- Lager 1: Inmatningsvalidering ---

    def validate_input(self, text: str) -> dict:
        """Snabb validering före alla API-anrop."""
        # Maximal längd
        if len(text) > 10000:
            return {"valid": False, "reason": "Meddelandet är för långt"}

        # Misstänkta tecken (Unicode-injektioner)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Ogiltiga tecken"}

        # Uppenbara jailbreak-mönster
        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": "Injektionsmönster upptäckt"
                }

        return {"valid": True}

    # --- Lager 2: Inmatningsmoderering ---

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

    # --- Lager 3: Säker generering ---

    def generate(self, messages: list) -> str:
        """Generering med skyddsräcken och 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 ""

    # --- Lager 4: Utmatningsmoderering ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Svarsmoderering i kontext."""
        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
        }

    # --- Lager 5: Loggning ---

    def log_decision(self, decision: Decision, data: dict):
        """Registrerar beslutet för granskning."""
        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))

    # --- Huvudpipeline ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Komplett säker bearbetningspipeline."""

        # Lager 1: Validering
        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": "Ditt meddelande kan inte bearbetas."
            }

        # Lager 2: Inmatningsmoderering
        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": "Detta innehåll bryter mot vår policy."
            }

        # Lager 3: Generering
        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": "Begäran blockerad av skyddsräcken."
                }
            raise

        # Lager 4: Utmatningsmoderering
        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": "Svaret filtrerades."
            }

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

    # --- Verktyg ---

    def _check_thresholds(self, scores: dict) -> list:
        """Kontrollerar poäng mot policytrösklar."""
        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:
        """Genererar en statistikrapport."""
        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
            )
        }

Användning i produktion

# Definiera policyn
prod_policy = {
    "name": "Produktion 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
    }
}

# Instansiera arkitekturen
arch = SecureArchitecture(prod_policy)

# Bearbeta begäranden
result = arch.process(
    "Förklara hur transformatorer fungerar",
    system_prompt="Du är en AI-instruktör."
)
print(result["status"])   # förväntat: "allowed"
print(result["content"])

# Konsultera statistik
print(arch.report())

Övervakning och varningar

Två mått räcker för att styra ett modereringssystem, och du måste hålla koll på dem i motsatta riktningar. Blockeringsfrekvensen bör förbli stabil: en plötslig topp signalerar antingen en attack eller ett tröskelvärde som är för strikt och börjar hindra legitima användare. Poängfördelningen är lika viktig – om ditt innehåll klumpar ihop sig strax under tröskeln är tröskeln dåligt placerad, och nästa justering från dina användare kommer att knäcka den.

def configure_alerts(arch: SecureArchitecture):
    """Konfigurerar varningar för övervakning."""
    report = arch.report()

    # Varna om blockeringsfrekvensen är onormal
    if report["block_rate"] > 0.15:
        logger.warning(
            f"Hög blockeringsfrekvens: "
            f"{report['block_rate']:.1%}"
        )

    # Varna om jailbreak-toppar inträffar
    # Integrera med Prometheus, Grafana, Datadog, etc.

Sammanfattning av kursen

Vid slutet av denna kurs har du bemästrat:

  • Anpassade skyddsräcken: Blockera farliga prompts före generering, konfigurera tröskelvärden per kategori, tillämpa på agenter
  • Moderation API: Klassificera innehåll med Mistral Moderation 2, tolka poäng över de 11 kategorierna, fatta automatiserade beslut
  • Produktionssäkerhet: Definiera innehållspolicyer, upptäcka prompt-injektioner, säkerställa GDPR-efterlevnad
  • Komplett arkitektur: Sätt ihop skyddsräcken + moderering + övervakning till en robust pipeline

Du har nu all kod som behövs för att distribuera ett komplett AI-modereringssystem med Mistral API.

Viktiga punkter

  • Säkerhetsarkitekturen inkluderar 5 lager: validering, skyddsräcken, generering, moderering, loggning
  • Varje lager kompenserar för de andras svagheter – detta är försvar på djupet
  • Övervaka blockeringsfrekvensen och poängen i produktion
  • Håll din policy uppdaterad med regelbundna granskningar
  • Den kompletta koden i denna lektion är en startpunkt – anpassa den till din kontext

Testa dina kunskaper

Skyddsräcken, moderering, injektion: är den defensiva arkitekturen tydlig?

1. Var ingriper anpassade skyddsräcken?

Svar: Före modellen: de filtrerar inmatningar enligt dina regler (förbjudna ämnen, format) – det första lagret, vilket undviker att ens göra anropet när begäran ligger utanför scope.

2. Vad täcker Mistral Moderation API?

Svar: Elva kategorier av riskfyllt innehåll, med ett poäng per kategori: dina tröskelvärden avgör om du ska blockera, flagga eller tillåta – och gör innehållspolicyn till kod.

3. Hur definieras en bra innehållspolicy?

Svar: Genom användningsfall: vad som är acceptabelt för applikationen, tröskelvärden per kategori, associerade åtgärder (blockering, omskrivning, eskalering) – dokumenterat och testat, inte implicit.

4. Hur upptäcker du försök till prompt-injektion?

Svar: Genom att behandla allt externt innehåll som misstänkt: upptäcka instruktionsmönster i data, isolera instruktioner från data, validera utmatningar – och köra regelbundna offensiva tester.

5. Hur ser den kompletta säkerhetsarkitekturen ut?

Svar: Lager: inmatningsskydd, innehållsmoderering, utmatningskontroller, GDPR-efterlevnad (minimering, rättigheter) och spårbarhet – inget enskilt lager är perfekt, men att stapla dem kompenserar.

Försvar på djupet är inte en slogan: varje lager i denna kurs fångar det som det föregående släpper igenom.