Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Kompletní architektura zabezpečení

Lekce 12 z 12 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Složení všech dílů dohromady
  2. Přehled architektury
  3. Kompletní implementace
  4. Produkční použití
  5. Monitorování a alerty
  6. Shrnutí kurzu
  7. Klíčové poznatky
  8. Ověř si své znalosti

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át moderation_llm_v2 a jedenáct klíčů z mistral-moderation-2603. Skóre, která jsou v SDK volitelná, se čtou s náhradní hodnotou. Kód ověřen proti typům SDK mistralai verze 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.