Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Celovita varnostna arhitektura

Lekcija 12 od 12 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Sestavljanje vseh delov
  2. Pregled arhitekture
  3. Celovita implementacija
  4. Uporaba v proizvodnji
  5. Nadzor in opozorila
  6. Povzetek tečaja
  7. Ključne ugotovitve
  8. Preveri svoje znanje

Posodobljeno 3. novembra 2026. Plast za generiranje je prej uporabljala izmišljeno obliko varoval (enabled), proizvodna pravila pa so uporabljala neobstoječe kategorije (hate, violence, unpredictable). Koda zdaj sledi uradni obliki moderation_llm_v2 in enajstim ključem iz mistral-moderation-2603. Rezultati, ki so v SDK opcijski, se berejo z nadomestno vrednostjo. Koda preverjena glede na tipe SDK mistralai različice 3.7.0. Viri: Moderation & Guardrailing · Python SDK mistralai.

Sestavljanje vseh delov

Med tem tečajem si raziskal varovala, API za moderiranje, 11 kategorij, pragove, zaznavanje vdorov (jailbreak), skladnost z GDPR in pravila o vsebini. Ta zadnja lekcija združuje vse te gradnike v celovito varnostno arhitekturo, pripravljeno za proizvodno okolje.

Pregled arhitekture

Obstaja pet plasti, ki jih vodi eno načelo: nobena od njih sama po sebi ni zanesljiva. Varovalo lahko obideš z nepričakovano formulacijo, model za moderiranje ima lažno negativne rezultate, pravila o vsebini pa nikoli ne pokrijejo vsakega primera. Njihovo skladiščenje deluje, ker se vrzeli ne prekrivajo – kar uide prvi plasti, ima veliko možnosti, da ga ujame druga.

Praktična posledica je strog vrstni red: vsaka plast mora biti čim cenejša, preden se zažene naslednja. Obliko preveriš pred klicem varovala, varovalo pa pokličeš pred generiranjem – ker vsebina, zavrnjena v 1. koraku, ne porabi nič žetonov.

Uporabnik
    ↓
[1. Preverjanje vnosa] → Regex, vzorci, omejevanje hitrosti
    ↓
[2. Mistral Guardrails]  → Blokada pred generiranjem (403)
    ↓
[3. Generiranje LLM]      → safe_prompt + varna navodila
    ↓
[4. Moderiranje izhoda]   → Moderation API po generiranju
    ↓
[5. Beleženje in revizija]     → Rezultati, odločitve, sled revizije GDPR
    ↓
Odgovor uporabniku

Celovita implementacija

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

# Konfiguracija
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:
    """Celovita varnostna arhitektura za AI aplikacije."""

    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}

    # --- Plast 1: Preverjanje vnosa ---

    def validate_input(self, text: str) -> dict:
        """Hitro preverjanje pred vsakim klicem API."""
        # Največja dolžina
        if len(text) > 10000:
            return {"valid": False, "reason": "Sporočilo je predolgo"}

        # Sumljivi znaki (vstavitve Unicode)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Neveljavni znaki"}

        # Očitni vzorci vdorov (jailbreak)
        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": "Zaznan vzorec vstavitve"
                }

        return {"valid": True}

    # --- Plast 2: Moderiranje vnosa ---

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

    # --- Plast 3: Varno generiranje ---

    def generate(self, messages: list) -> str:
        """Generiranje z varovali in 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 ""

    # --- Plast 4: Moderiranje izhoda ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Moderiranje odgovora v kontekstu."""
        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
        }

    # --- Plast 5: Beleženje ---

    def log_decision(self, decision: Decision, data: dict):
        """Zabeleži odločitev za revizijo."""
        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))

    # --- Glavni potek ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Celovit varen potek obdelave."""

        # Plast 1: Preverjanje
        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šega sporočila ni mogoče obdelati."
            }

        # Plast 2: Moderiranje vnosa
        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": "Ta vsebina krši naša pravila."
            }

        # Plast 3: Generiranje
        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": "Zahtevo so blokirala varovala."
                }
            raise

        # Plast 4: Moderiranje izhoda
        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": "Odgovor je bil filtriran."
            }

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

    # --- Pripomočki ---

    def _check_thresholds(self, scores: dict) -> list:
        """Preveri rezultate glede na pragove pravil."""
        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:
        """Ustvari statistično poročilo."""
        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
            )
        }

Uporaba v proizvodnji

# Definiraj pravila
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
    }
}

# Ustvari arhitekturo
arch = SecureArchitecture(prod_policy)

# Obdelaj zahteve
result = arch.process(
    "Explain how transformers work",
    system_prompt="You are an AI instructor."
)
print(result["status"])   # pričakovano: "allowed"
print(result["content"])

# Poglej statistiko
print(arch.report())

Nadzor in opozorila

Za usmerjanje sistema za moderiranje sta dovolj dva kazalnika, ki ju moraš spremljati v nasprotnih smereh. Stopnja blokiranja mora ostati stabilna: nenaden skok signalizira bodisi napad bodisi prag, ki je prestrog in začne ovirati legitimne uporabnike. Enako pomembna je porazdelitev rezultatov – če se tvoja vsebina kopiči tik pod pragom, je prag slabo postavljen in ga bo naslednja sprememba tvojih uporabnikov prelomila.

def configure_alerts(arch: SecureArchitecture):
    """Konfigurira opozorila za nadzor."""
    report = arch.report()

    # Opozori, če je stopnja blokiranja nenormalna
    if report["block_rate"] > 0.15:
        logger.warning(
            f"Visoka stopnja blokiranja: "
            f"{report['block_rate']:.1%}"
        )

    # Opozori, če pride do skokov vdorov (jailbreak)
    # Integriraj s Prometheus, Grafana, Datadog itd.

Povzetek tečaja

Do konca tega tečaja si obvladal:

  • Prilagodljiva varovala: Blokiraj nevarne pozive pred generiranjem, konfiguriraj pragove na kategorijo, uporabi za agente
  • API za moderiranje: Razvrsti vsebino z Mistral Moderation 2, interpretiraj rezultate v 11 kategorijah, sprejemaj avtomatizirane odločitve
  • Proizvodna varnost: Definiraj pravila o vsebini, zaznaj vstavitve pozivov, zagotovi skladnost z GDPR
  • Celovita arhitektura: Združi varovala + moderiranje + nadzor v robusten potek

Zdaj imaš vso kodo, potrebno za uvedbo celovitega sistema za moderiranje AI z API-jem Mistral.

Ključne ugotovitve

  • Varnostna arhitektura vključuje 5 plasti: preverjanje, varovala, generiranje, moderiranje, beleženje
  • Vsaka plast nadomešča slabosti drugih – to je obrana v globino
  • V proizvodnji nadzoruj stopnjo blokiranja in rezultate
  • Svoja pravila redno posodabljaj z rednimi pregledi
  • Celotna koda v tej lekciji je izhodišče – prilagodi jo svojemu kontekstu

Preveri svoje znanje

Varovala, moderiranje, vstavitve: ali je obrambna arhitektura jasna?

1. Kje posežejo prilagodljiva varovala?

Odgovor: Pred modelom: filtrirajo vnose glede na tvoja pravila (prepovedane teme, oblike) – to je prva plast, ki prepreči celo klic, ko je zahteva izven okvira.

2. Kaj pokriva API Mistral Moderation?

Odgovor: Enajst kategorij tvegane vsebine z rezultatom na kategorijo: tvoji pragovi odločajo, ali blokirati, označiti ali dovoliti – s tem pravila o vsebini pretvoriš v kodo.

3. Kako je opredeljena dobra politika vsebine?

Odgovor: Po primeru uporabe: kaj je sprejemljivo za aplikacijo, pragovi na kategorijo, povezana dejanja (blokiranje, prepis, eskalacija) – dokumentirano in testirano, ne implicitno.

4. Kako zaznaš poskuse vstavitve poziva (prompt injection)?

Odgovor: Tako, da vso zunanjo vsebino obravnavaš kot sumljivo: zaznavanje vzorcev navodil v podatkih, ločevanje navodil od podatkov, preverjanje izhodov in izvajanje rednih ofenzivnih testov.

5. Kako izgleda celovita varnostna arhitektura?

Odgovor: Plasti: varovala vnosa, moderiranje vsebine, kontrole izhoda, skladnost z GDPR (minimizacija, pravice) in sledljivost – nobena plast ni popolna, a njihovo skladiščenje to nadomesti.

Obramba v globino ni le slogan: vsaka plast v tem tečaju ujame tisto, kar je prejšnja spustila skozi.