Celovita varnostna arhitektura
Na tej strani
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 oblikimoderation_llm_v2in enajstim ključem izmistral-moderation-2603. Rezultati, ki so v SDK opcijski, se berejo z nadomestno vrednostjo. Koda preverjena glede na tipe SDKmistralairazlič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.