Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Teljes biztonsági architektúra

12. lecke 12 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Az összes elem összeillesztése
  2. Architektúra áttekintés
  3. Teljes megvalósítás
  4. Production használat
  5. Monitorozás és riasztások
  6. Tanfolyam összefoglaló
  7. Főbb megállapítások
  8. Teszteld a tudásod!

Frissítve: 2026. november 3. A generációs réteg korábban egy kitalált guardrails formátumot (enabled) használt, a production szabályzat pedig nem létező kategóriákat (hate, violence, unpredictable) tartalmazott. A kód most már követi a hivatalos moderation_llm_v2 formátumot és a mistral-moderation-2603 tizenegy kulcsát. Az SDK-ban opcionális pontszámokat alapértelmezett értékkel olvassuk be. A kód ellenőrizve a mistralai SDK 3.7.0-s verziójának típusai alapján. Források: Moderation & Guardrailing · Python SDK mistralai.

Az összes elem összeillesztése

Ebben a tanfolyamban végigjártad a guardrailsek, a Moderation API, a 11 kategória, a küszöbértékek, a jailbreak-észlelés, a GDPR-megfelelés és a tartalmi szabályzatok témakörét. Ez az utolsó lecke ezeket az építőköveket egy teljes, productionra kész biztonsági architektúrává állítja össze.

Architektúra áttekintés

Öt réteg van, amelyet egyetlen elv vezérel: egyik sem megbízható önmagában. Egy guardrailt kijátszhat egy váratlan megfogalmazás, egy moderációs modell produkálhat hamis negatív eredményt, és egy tartalmi szabályzat sosem fed le minden esetet. A rétegezés azért működik, mert a hézagok nem fedik át egymást – ami az első rétegen átszűrődik, annak jó esélye van rá, hogy a második elkapja.

A gyakorlati következmény egy szigorú sorrend: minden rétegnek a lehető legolcsóbbnak kell lennie, mielőtt a következő futna. Ellenőrzöd a formátumot, mielőtt guardrailt hívnál, és a guardrailt hívod meg generálás előtt – mert az 1. lépésben elutasított tartalom nulla tokent fogyaszt.

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

Teljes megvalósítás

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
            )
        }

Production használat

# 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())

Monitorozás és riasztások

Két metrika elég egy moderációs rendszer irányításához, és ezeket ellentétes irányban kell figyelned. A blokkolási aránynak (block rate) stabilnak kell maradnia: egy hirtelen csúcs vagy támadást jelez, vagy azt, hogy egy küszöbérték túl szigorú, és már akadályozza a jogos felhasználókat. A pontszám-eloszlás ugyanilyen fontos – ha a tartalmad éppen a küszöbérték alatt csoportosul, akkor a küszöb rosszul van belőve, és a felhasználóid következő módosítása áttöri azt.

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.

Tanfolyam összefoglaló

A tanfolyam végére elsajátítottad:

  • Egyéni guardrailsek: Veszélyes promptok blokkolása generálás előtt, küszöbértékek konfigurálása kategóriánként, alkalmazás ügynökökre
  • Moderation API: Tartalom osztályozása Mistral Moderation 2-vel, pontszámok értelmezése a 11 kategóriában, automatizált döntések hozatala
  • Production biztonság: Tartalmi szabályzatok definiálása, prompt injection észlelése, GDPR-megfelelés biztosítása
  • Teljes architektúra: Guardrailsek + moderáció + monitorozás összeillesztése egy robusztus pipeline-ba

Most már rendelkezel minden szükséges kóddal egy teljes AI moderációs rendszer telepítéséhez a Mistral API segítségével.

Főbb megállapítások

  • A biztonsági architektúra 5 rétegből áll: validálás, guardrailsek, generálás, moderáció, naplózás
  • Minden réteg kompenzálja a többi gyengeségét – ez a többrétegű védelem (defense in depth)
  • Monitorozd a blokkolási arányt és a pontszámokat production környezetben
  • Tartsd naprakészen a szabályzatodat rendszeres felülvizsgálatokkal
  • Ebben a leckében található teljes kód egy kiindulópont – igazítsd a saját kontextusodhoz

Teszteld a tudásod!

Guardrailsek, moderáció, injection: világos a védelmi architektúra?

1. Hol avatkoznak be az egyéni guardrailsek?

Válasz: A modell előtt: a saját szabályaid alapján szűrik a bemeneteket (tiltott témák, formátumok) – ez az első réteg, amely elkerüli a hívás megtételét, ha a kérés hatókörön kívül esik.

2. Mit fed le a Mistral Moderation API?

Válasz: Tizenegy kockázatos tartalmi kategóriát, kategóriánkénti pontszámmal: a te küszöbértékeid döntik el, hogy blokkolj, megjelölj vagy engedélyezz – ezzel kódodá alakítva a tartalmi szabályzatot.

3. Hogyan definiálunk jó tartalmi szabályzatot?

Válasz: Használati eset alapján: mi elfogadható az alkalmazás számára, küszöbértékek kategóriánként, hozzárendelt műveletek (blokkolás, átírás, eszkalálás) – dokumentálva és tesztelve, nem implicit módon.

4. Hogyan észleled a prompt injection kísérleteket?

Válasz: Úgy, hogy minden külső tartalmat gyanúsként kezelsz: utasításminták észlelése az adatokban, utasítások és adatok izolálása, kimenetek validálása – és rendszeres offenzív tesztek futtatása.

5. Hogyan néz ki a teljes biztonsági architektúra?

Válasz: Rétegek: bemeneti guardrailsek, tartalmi moderáció, kimeneti kontrollok, GDPR-megfelelés (minimalizálás, jogok) és nyomon követhetőség – egyetlen réteg sem tökéletes, de a rétegezés kompenzálja ezt.

A többrétegű védelem nem csak egy szlogen: e tanfolyam minden egyes rétege elkapja azt, amit az előző átengedett.