Komplet sikkerhedsarkitektur
På denne side
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 officiellemoderation_llm_v2-format og de elleve nøgler framistral-moderation-2603. Scores, som er valgfrie i SDK’et, læses med en fallback-værdi. Kode verificeret modmistralaiSDK-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.