Arhitectură completă de securitate
Pe această pagină
Actualizat la 3 noiembrie 2026. Stratul de generare transmitea anterior un format inventat de guardrails (
enabled), iar politica de producție folosea categorii inexistente (hate,violence,unpredictable). Codul respectă acum formatul oficialmoderation_llm_v2și cele unsprezece chei dinmistral-moderation-2603. Scorurile, care sunt opționale în SDK, sunt citite cu o valoare de rezervă (fallback). Cod verificat față de tipurile SDKmistralaiversiunea 3.7.0. Surse: Moderare și Guardrailing · Python SDK mistralai.
Asamblarea tuturor pieselor
De-a lungul acestui curs, ați explorat guardrails-urile, API-ul de Moderare, cele 11 categorii, pragurile, detectarea jailbreak-urilor, conformitatea GDPR și politicile de conținut. Această lecție finală asamblează toate aceste blocuri de construcție într-o arhitectură completă de securitate, gata pentru producție.
Prezentare generală a arhitecturii
Există cinci straturi, conduse de un singur principiu: niciunul dintre ele nu este fiabil de unul singur. Un guardrail poate fi ocolit printr-o formulare neașteptată, un model de moderare are fals-negative, iar o politică de conținut nu acoperă niciodată fiecare caz. Empilarea lor funcționează deoarece lacunele nu se suprapun—ceea ce scapă primului strat are șanse mari să fie prins de al doilea.
Consecința practică este o ordine strictă: fiecare strat trebuie să fie cât mai ieftin posibil înainte ca următorul să ruleze. Validați formatul înainte de a apela un guardrail și apelați guardrail-ul înainte de generare—deoarece conținutul respins la pasul 1 consumă zero tokeni.
Utilizator
↓
[1. Validare intrare] → Regex, modele, limitare rată
↓
[2. Mistral Guardrails] → Blocare pre-generare (403)
↓
[3. Generare LLM] → safe_prompt + instrucțiuni securizate
↓
[4. Moderare ieșire] → API Moderare post-generare
↓
[5. Jurnalizare și Audit] → Scoruri, decizii, traseu audit GDPR
↓
Răspuns Utilizator
Implementare completă
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
# Configurare
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:
"""Arhitectură completă de securitate pentru aplicațiile AI."""
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}
# --- Stratul 1: Validare intrare ---
def validate_input(self, text: str) -> dict:
"""Validare rapidă înainte de orice apel API."""
# Lungime maximă
if len(text) > 10000:
return {"valid": False, "reason": "Mesaj prea lung"}
# Caractere suspecte (injecții Unicode)
if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
return {"valid": False, "reason": "Caractere invalide"}
# Modele evidente de 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": "Model de injecție detectat"
}
return {"valid": True}
# --- Stratul 2: Moderare intrare ---
def moderate_input(self, text: str) -> dict:
"""Moderare prompt prin 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
}
# --- Stratul 3: Generare securizată ---
def generate(self, messages: list) -> str:
"""Generare cu guardrails și 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 ""
# --- Stratul 4: Moderare ieșire ---
def moderate_output(self, prompt: str, response_text: str) -> dict:
"""Moderare răspuns în 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
}
# --- Stratul 5: Jurnalizare ---
def log_decision(self, decision: Decision, data: dict):
"""Înregistrează decizia pentru 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))
# --- Pipeline principal ---
def process(self, user_message: str,
system_prompt: str | None = None) -> dict:
"""Pipeline complet de procesare securizată."""
# Stratul 1: Validare
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": "Mesajul dumneavoastră nu poate fi procesat."
}
# Stratul 2: Moderare intrare
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": "Acest conținut încalcă politica noastră."
}
# Stratul 3: Generare
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": "Solicitare blocată de guardrails."
}
raise
# Stratul 4: Moderare ieșire
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": "Răspunsul a fost filtrat."
}
# Succes
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"]
}
}
# --- Utilitare ---
def _check_thresholds(self, scores: dict) -> list:
"""Verifică scorurile față de pragurile politicii."""
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:
"""Generează un raport statistic."""
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
)
}
Utilizare în producție
# Definirea politicii
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
}
}
# Instanțierea arhitecturii
arch = SecureArchitecture(prod_policy)
# Procesarea solicitărilor
result = arch.process(
"Explain how transformers work",
system_prompt="You are an AI instructor."
)
print(result["status"]) # așteptat: "allowed"
print(result["content"])
# Consultarea statisticilor
print(arch.report())
Monitorizare și alerte
Două metrici sunt suficiente pentru a ghida un sistem de moderare și trebuie să le urmăriți în direcții opuse. Rata de blocare ar trebui să rămână stabilă: o creștere bruscă semnalează fie un atac, fie un prag prea strict care începe să îngreuneze utilizatorii legitimi. Distribuția scorurilor contează tout autant—dacă conținutul dumneavoastră se aglomerează chiar sub prag, atunci pragul este plasat prost, iar următoarea ajustare făcută de utilizatorii dumneavoastră îl va sparge.
def configure_alerts(arch: SecureArchitecture):
"""Configurează alertele pentru monitorizare."""
report = arch.report()
# Alertă dacă rata de blocare este anormală
if report["block_rate"] > 0.15:
logger.warning(
f"Rată mare de blocare: "
f"{report['block_rate']:.1%}"
)
# Alertă dacă apar vârfuri de jailbreak
# Integrați cu Prometheus, Grafana, Datadog, etc.
Recapitularea cursului
Până la sfârșitul acestui curs, ați stăpânit:
- Guardrails personalizate: Blocați prompt-urile periculoase înainte de generare, configurați praguri pe categorie, aplicați-le agenților
- API-ul de Moderare: Clasificați conținutul cu Mistral Moderation 2, interpretați scorurile pe cele 11 categorii, luați decizii automate
- Securitate în producție: Definiți politici de conținut, detectați injecțiile de prompt, asigurați conformitatea GDPR
- Arhitectură completă: Asamblați guardrails + moderare + monitorizare într-un pipeline robust
Aveți acum tot codul necesar pentru a implementa un sistem complet de moderare AI cu API-ul Mistral.
Puncte cheie
- Arhitectura de securitate include 5 straturi: validare, guardrails, generare, moderare, jurnalizare
- Fiecare strat compensează slăbiciunile celorlalte—aceasta este apărarea în profunzime
- Monitorizați rata de blocare și scorurile în producție
- Mențineți politica la zi cu revizuiri regulate
- Codul complet din această lecție este un punct de plecare—adaptați-l la contextul dumneavoastră
Testați-vă cunoștințele
Guardrails, moderare, injecție: este clară arhitectura defensivă?
1. Unde intervin guardrails-urile personalizate?
Răspuns: Înainte de model: acestea filtrează intrările conform regulilor dumneavoastră (subiecte interzise, formate)—primul strat, care evită chiar și efectuarea apelului atunci când solicitarea este în afara domeniului de aplicare.
2. Ce acoperă API-ul Mistral Moderation?
Răspuns: Unsprezece categorii de conținut riscant, cu un scor per categorie: pragurile dumneavoastră decid dacă să blocați, să semnalați sau să permiteți—transformând politica de conținut în cod.
3. Cum este definită o politică de conținut bună?
Răspuns: Prin caz de utilizare: ceea ce este acceptabil pentru aplicație, praguri pe categorie, acțiuni asociate (blocare, rescriere, escaladare)—documentate și testate, nu implicite.
4. Cum detectați tentativele de injecție de prompt?
Răspuns: Tratând tot conținutul extern ca suspect: detectarea modelelor de instrucțiuni în date, izolarea instrucțiunilor de date, validarea ieșirilor—și rularea de teste ofensive regulate.
5. Cum arată arhitectura completă de securitate?
Răspuns: Straturi: guardrails de intrare, moderare conținut, controale de ieșire, conformitate GDPR (minimizare, drepturi) și trasabilitate—niciun strat nu este perfect, dar empilarea lor compensează.
Apărarea în profunzime nu este un slogan: fiecare strat din acest curs prinde ceea ce cel precedent a lăsat să treacă.