Kompletní architektura zabezpečení
Na této stránce
Aktualizováno 3. listopadu 2026. Vrstva generování dříve předávala vymyšlený formát guardrails (
enabled) a produkční politika používala neexistující kategorie (hate,violence,unpredictable). Kód nyní dodržuje oficiální formátmoderation_llm_v2a jedenáct klíčů zmistral-moderation-2603. Skóre, která jsou v SDK volitelná, se čtou s náhradní hodnotou. Kód ověřen proti typům SDKmistralaiverze 3.7.0. Zdroje: Moderation & Guardrailing · Python SDK mistralai.
Složení všech dílů dohromady
Během tohoto kurzu jsi prozkoumal guardrails, API pro moderování, 11 kategorií, prahové hodnoty, detekci jailbreaku, soulad s GDPR a zásady obsahu. Tato závěrečná lekce skládá všechny tyto stavební kameny do kompletní architektury zabezpečení připravené pro produkci.
Přehled architektury
Existuje pět vrstev, řízených jedním principem: žádná z nich není sama o sobě spolehlivá. Guardrail lze obejít neočekávanou formulací, model pro moderování má falešně negativní výsledky a zásady obsahu nikdy nepokrývají každý případ. Vrstvení funguje, protože se mezery nepřekrývají – to, co proklouzne první vrstvou, má velkou šanci být zachyceno druhou.
Praktickým důsledkem je přísné pořadí: každá vrstva musí být co nejlevnější, než se spustí další. Nejprve ověříš formát před voláním guardrailu a guardrail zavoláš před generováním – protože obsah zamítnutý v kroku 1 nespotřebuje žádné tokeny.
Uživatel
↓
[1. Validace vstupu] → Regex, vzory, omezování rychlosti
↓
[2. Mistral Guardrails] → Blokování před generováním (403)
↓
[3. Generování LLM] → safe_prompt + bezpečné instrukce
↓
[4. Moderování výstupu] → Moderation API po generování
↓
[5. Logování a audit] → Skóre, rozhodnutí, auditní stopa GDPR
↓
Odpověď uživateli
Kompletní implementace
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
# Konfigurace
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:
"""Kompletní architektura zabezpečení pro AI aplikace."""
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}
# --- Vrstva 1: Validace vstupu ---
def validate_input(self, text: str) -> dict:
"""Rychlá validace před jakýmkoli voláním API."""
# Maximální délka
if len(text) > 10000:
return {"valid": False, "reason": "Zpráva je příliš dlouhá"}
# Podezřelé znaky (Unicode injekce)
if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
return {"valid": False, "reason": "Neplatné znaky"}
# Zřejmé vzory jailbreaku
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": "Detekován vzor injekce"
}
return {"valid": True}
# --- Vrstva 2: Moderování vstupu ---
def moderate_input(self, text: str) -> dict:
"""Moderování promptu přes 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
}
# --- Vrstva 3: Bezpečné generování ---
def generate(self, messages: list) -> str:
"""Generování s guardrails a 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 ""
# --- Vrstva 4: Moderování výstupu ---
def moderate_output(self, prompt: str, response_text: str) -> dict:
"""Moderování odpovědi v kontextu."""
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
}
# --- Vrstva 5: Logování ---
def log_decision(self, decision: Decision, data: dict):
"""Zaznamená rozhodnutí pro audit."""
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))
# --- Hlavní pipeline ---
def process(self, user_message: str,
system_prompt: str | None = None) -> dict:
"""Kompletní pipeline bezpečného zpracování."""
# Vrstva 1: Validace
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": "Vaši zprávu nelze zpracovat."
}
# Vrstva 2: Moderování vstupu
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": "Tento obsah porušuje naše zásady."
}
# Vrstva 3: Generování
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": "Požadavek byl zablokován guardrails."
}
raise
# Vrstva 4: Moderování výstupu
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": "Odpověď byla filtrována."
}
# Úspěch
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"]
}
}
# --- Pomocné funkce ---
def _check_thresholds(self, scores: dict) -> list:
"""Kontroluje skóre proti prahovým hodnotám politiky."""
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:
"""Generuje statistickou zprávu."""
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
)
}
Produkční použití
# Definice politiky
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
}
}
# Inicializace architektury
arch = SecureArchitecture(prod_policy)
# Zpracování požadavků
result = arch.process(
"Vysvětli, jak fungují transformery",
system_prompt="Jsi AI instruktor."
)
print(result["status"]) # očekáváno: "allowed"
print(result["content"])
# Konzultace statistik
print(arch.report())
Monitorování a alerty
K řízení systému moderování stačí dvě metriky a musíš je sledovat v opačných směrech. Míra blokování by měla zůstat stabilní: náhlý nárůst signalizuje buď útok, nebo příliš přísnou prahovou hodnotu, která začíná bránit legitimním uživatelům. Stejně důležité je rozložení skóre – pokud se tvůj obsah shlukuje těsně pod prahovou hodnotou, je tato hodnota špatně nastavena a další úprava ze strany tvých uživatelů ji prolomí.
def configure_alerts(arch: SecureArchitecture):
"""Konfiguruje alerty pro monitorování."""
report = arch.report()
# Alert, pokud je míra blokování abnormální
if report["block_rate"] > 0.15:
logger.warning(
f"Vysoká míra blokování: "
f"{report['block_rate']:.1%}"
)
# Alert, pokud dojde k nárůstu jailbreaků
# Integrace s Prometheus, Grafana, Datadog atd.
Shrnutí kurzu
Na konci tohoto kurzu jsi zvládl:
- Vlastní guardrails: Blokuj nebezpečné prompty před generováním, konfiguruj prahové hodnoty pro každou kategorii, aplikuj na agenty
- Moderation API: Klasifikuj obsah pomocí Mistral Moderation 2, interpretuj skóre napříč 11 kategoriemi, přijímej automatizovaná rozhodnutí
- Produkční zabezpečení: Definuj zásady obsahu, detekuj injekce promptů, zajisti soulad s GDPR
- Kompletní architektura: Slož guardrails + moderování + monitorování do robustní pipeline
Nyní máš veškerý kód potřebný k nasazení kompletního systému moderování AI s API Mistral.
Klíčové poznatky
- Architektura zabezpečení zahrnuje 5 vrstev: validaci, guardrails, generování, moderování, logování
- Každá vrstva kompenzuje slabiny těch ostatních – toto je obrana do hloubky
- Monitoruj míru blokování a skóre v produkci
- Udržuj svou politiku aktuální pomocí pravidelných revizí
- Kompletní kód v této lekci je výchozím bodem – přizpůsob jej svému kontextu
Ověř si své znalosti
Guardrails, moderování, injekce: je obranná architektura jasná?
1. Kde zasahují vlastní guardrails?
Odpověď: Před modelem: filtrují vstupy podle tvých pravidel (zakázaná témata, formáty) – první vrstva, která zabrání dokonce i provedení volání, když je požadavek mimo rozsah.
2. Co pokrývá Mistral Moderation API?
Odpověď: Jedenáct kategorií rizikového obsahu se skóre pro každou kategorii: tvé prahové hodnoty rozhodují, zda blokovat, označit nebo povolit – tím převádíš politiku obsahu do kódu.
3. Jak se definuje dobrá politika obsahu?
Odpověď: Podle případu použití: co je pro aplikaci přijatelné, prahové hodnoty pro každou kategorii, přidružené akce (blokování, přepis, eskalace) – zdokumentované a otestované, nikoli implicitní.
4. Jak detekuješ pokusy o injekci promptu?
Odpověď: Tím, že veškerý externí obsah považuješ za podezřelý: detekcí vzorů instrukcí v datech, izolací instrukcí od dat, validací výstupů – a prováděním pravidelných ofenzivních testů.
5. Jak vypadá kompletní architektura zabezpečení?
Odpověď: Vrstvy: guardrails vstupu, moderování obsahu, kontroly výstupu, soulad s GDPR (minimalizace, práva) a sledovatelnost – žádná jednotlivá vrstva není dokonalá, ale jejich vrstvení to kompenzuje.
Obrana do hloubky není jen slogan: každá vrstva v tomto kurzu zachytí to, co předchozí nechala projít.