Turvallisuusarkkitehtuuri kokonaisuudessaan
Tällä sivulla
Päivitetty 3. marraskuuta 2026. Generointikerros välitti aiemmin keksityn suodatusmuodon (
enabled), ja tuotantokäytäntö käytti olemattomia kategorioita (hate,violence,unpredictable). Koodi noudattaa nyt virallistamoderation_llm_v2-muotoa jamistral-moderation-2603:n yhdeksäätoista avainta. SDK:ssa valinnaiset pisteytykset luetaan varoarvolla. Koodi on varmennettumistralai-SDK-tyyppien versiota 3.7.0 vasten. Lähteet: Moderation & Guardrailing · Python SDK mistralai.
Kaikkien palasten kokoaminen
Olet tämän kurssin aikana tutustunut suodatusmekanismeihin, Moderation APIiin, 11 kategoriaan, kynnysarvoihin, jailbreak-tunnistukseen, GDPR-vaatimustenmukaisuuteen ja sisältöpolitiikkoihin. Tämä viimeinen oppitunti kokoaa kaikki nämä rakennuspalikat yhtenäiseksi, tuotantovalmiiksi turvallisuusarkkitehtuuriksi.
Arkkitehtuurin yleiskatsaus
Järjestelmä koostuu viidestä kerroksesta, joita ohjaa yksi periaate: mikään niistä ei ole luotettava yksinään. Suodatusmekanismi voidaan kiertää odottamattomalla formuloinnilla, moderointimalli tuottaa vääriä negatiivisia tuloksia, eikä sisältöpolitiikka kata koskaan jokaista tapausta. Kerrosten pinnoittaminen toimii, koska aukot eivät ole päällekkäisiä – mitä ensimmäinen kerros päästää läpi, toinen kerros todennäköisesti havaitsee.
Käytännön seuraus on tiukka järjestys: jokaisen kerroksen on oltava mahdollisimman kevyt ennen seuraavan suorittamista. Tarkistat muodon ennen suodatusmekanismin kutsumista, ja kutsut suodatusmekanismin ennen generointia – koska vaiheessa 1 hylätty sisältö ei kuluta lainkaan tokeneita.
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
Täydellinen toteutus
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
)
}
Käyttö tuotannossa
# 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())
Valvonta ja hälytykset
Kahden mittarin seuraaminen riittää moderointijärjestelmän ohjaamiseen, ja sinun on tarkkailtava niitä vastakkaisiin suuntiin. Estosuhdetteen tulee pysyä vakaana: äkillinen piikki kertoo joko hyökkäyksestä tai liian tiukasta kynnysarvosta, joka alkaa haitata legitiimejä käyttäjiä. Myös pistejakauma on yhtä tärkeä – jos sisältösi keskittyy juuri kynnysarvon alapuolelle, kynnys on sijoitettu huonosti, ja käyttäjiesi seuraava säätö rikkoo sen.
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.
Kurssin yhteenveto
Kurssin päätteeksi olet hallinnut seuraavat asiat:
- Mukautetut suodatusmekanismit: Estä vaaralliset kehotteet ennen generointia, määritä kynnysarvot kategorioittain ja sovella niitä agenteille.
- Moderation API: Luokittele sisältöä Mistral Moderation 2:lla, tulkitse pisteitä 11 kategoriassa ja tee automatisoituja päätöksiä.
- Tuotantoturvallisuus: Määritä sisältöpolitiikat, tunnista kehotteiden injektioyritykset ja varmista GDPR-vaatimustenmukaisuus.
- Kokonaisarkkitehtuuri: Yhdistä suodatusmekanismit, moderointi ja valvonta robustiksi putkeksi.
Sinulla on nyt kaikki koodi, jota tarvitset täydellisen AI-moderointijärjestelmän käyttöönottoon Mistral API:n avulla.
Keskeiset asiat
- Turvallisuusarkkitehtuuri sisältää 5 kerrosta: validointi, suodatusmekanismit, generointi, moderointi ja lokitus.
- Jokainen kerros kompensoi muiden heikkouksia – tämä on syvyyssuuntainen puolustus (defense in depth).
- Valvo estosuhdetta ja pisteitä tuotannossa.
- Pidä politiikkasi ajan tasalla säännöllisillä katselmuksilla.
- Tämän oppitunnin täydellinen koodi on lähtökohta – sovita se omaan kontekstiisi.
Testaa tietosi
Ovatko suodatusmekanismit, moderointi ja injektio selkeitä osana puolustusarkkitehtuuria?
1. Missä vaiheessa mukautetut suodatusmekanismit puuttuvat peliin?
Vastaus: Ennen mallia: ne suodattavat syötteet sääntöjesi mukaan (kielletyt aiheet, muodot) – tämä on ensimmäinen kerros, joka estää pyynnön tekemisen ollenkaan, jos se ei kuulu aihepiiriin.
2. Mitä Mistral Moderation API kattaa?
Vastaus: Yksitoista riskialtista sisältökategoriaa, joista jokaiselle annetaan pistemäärä: kynnysarvosi päättävät, estetäänkö sisältö, merkitäänkö se vai sallitaanko – näin sisältöpolitiikka muutetaan koodiksi.
3. Miten hyvä sisältöpolitiikka määritellään?
Vastaus: Käyttötapauksen perusteella: mikä on sovellukselle hyväksyttävää, kynnysarvot kategorioittain ja niihin liittyvät toimet (esto, uudelleenkirjoitus, eskalointi) – dokumentoituna ja testattuna, ei implisiittisenä.
4. Miten havaitset kehotteiden injektioyritykset?
Vastaus: Kohtelemalla kaikkea ulkoista sisältöä epäilyttävänä: tunnistamalla ohjekuvioita datasta, erottamalla ohjeet datasta, validoimalla tulosteet ja suorittamalla säännöllisiä hyökkäystestejä.
5. Miltä täydellinen turvallisuusarkkitehtuuri näyttää?
Vastaus: Kerrokset: syötteen suodatusmekanismit, sisältömoderointi, tulosteen valvonta, GDPR-vaatimustenmukaisuus (minimointi, oikeudet) ja jäljitettävyys – mikään yksittäinen kerros ei ole täydellinen, mutta niiden pinnoittaminen kompensoi puutteet.
Syvyyssuuntainen puolustus ei ole vain iskulause: tämän kurssin jokainen kerros nappaa kiinni sen, minkä edellinen kerros päästi läpi.