Definisci la tua politica dei contenuti
In questa pagina
Aggiornato il 3 novembre 2026. Le politiche precedenti utilizzavano tre categorie inesistenti (
hate,violence,unpredictable) e omettevanodangerous. Ora sono allineate alle undici chiavi dimistral-moderation-2603. Un metodo converte ora una politica nel formato ufficiale del parametroguardrails, garantendo l’applicazione di soglie coerenti prima della generazione. Fonti: Moderation & Guardrailing · SDKmistralai3.7.0.
Perché hai bisogno di una politica dei contenuti formale
Le soglie di moderazione non sono scelte tecniche arbitrarie. Riflettono una politica dei contenuti: un insieme di regole che definisce ciò che la tua applicazione consente e vieta. Senza una politica formale, ogni sviluppatore prende decisioni autonome e il tuo sistema di sicurezza perde coerenza: due servizi della stessa azienda finiscono per bloccare contenuti diversi, senza che nessuno sappia perché.
Una politica scritta ti permette di giustificare le decisioni di moderazione sia agli utenti che ai regolatori, di armonizzare le soglie tra team e applicazioni, di auditare la conformità del sistema e di iterare in modo strutturato al variare delle esigenze. Il giorno in cui un utente contesta un blocco, la differenza tra «la soglia è impostata a 0,1» e «la nostra Politica Pubblica v1.2 imposta questa soglia per questo motivo» è enorme.
Adattare le soglie al contesto dell’applicazione
Lo stesso contenuto potrebbe essere accettabile in un contesto e pericoloso in un altro. La tua politica deve riflettere queste sfumature. Il modo migliore per ottenere questo risultato è descrivere ogni profilo come un oggetto nominato, datato e documentato, piuttosto che come un dizionario anonimo perso nel codice.
Per un chatbot rivolto al pubblico, la regola è semplice: severo ovunque, con la sicurezza come priorità. Non sai nulla della persona dall’altra parte e potrebbero essere presenti minori.
# Policy: Severo su tutto, sicurezza prima di tutto
POLICY_PUBLIC = {
"name": "Public-Facing",
"description": "Chatbot accessibile a tutti, inclusi i minori",
"thresholds": {
"sexual": 0.1,
"hate_and_discrimination": 0.1,
"violence_and_threats": 0.1,
"dangerous": 0.1,
"criminal": 0.1,
"selfharm": 0.1,
"health": 0.2,
"financial": 0.2,
"law": 0.2,
"pii": 0.1,
"jailbreaking": 0.1,
},
"block_action": "generic_message",
"logging": "full"
}
Un assistente interno cambia le regole del gioco su un punto: gli utenti sono autenticati, quindi identificabili e responsabili. Questo consente soglie più flessibili, in particolare su financial e law impostate a 0,6, poiché un dipendente che interroga l’assistente sulla struttura di un contratto sta semplicemente svolgendo il proprio lavoro.
# Policy: Bilanciata, utenti identificati
POLICY_INTERNAL = {
"name": "Internal B2B",
"description": "Assistente per dipendenti autenticati",
"thresholds": {
"sexual": 0.2,
"hate_and_discrimination": 0.15,
"violence_and_threats": 0.3,
"dangerous": 0.2,
"criminal": 0.15,
"selfharm": 0.15,
"health": 0.5,
"financial": 0.6,
"law": 0.6,
"pii": 0.3,
"jailbreaking": 0.15,
},
"block_action": "detailed_message",
"logging": "full"
}
Uno strumento specializzato (medico, legale o finanziario) porta questa logica alla sua conclusione: molto permissivo nel suo dominio, severo ovunque else. Nell’esempio medico, health sale a 0,85 perché discutere di diagnosi è proprio la funzione dello strumento, mentre pii scende a 0,15 perché i dati dei pazienti non devono mai circolare. Qui vengono aggiunti due elementi assenti nelle politiche precedenti: una modalità di blocco con reindirizzamento e un disclaimer esplicito.
# Policy: Permissivo sul dominio, severo altrove
POLICY_MEDICAL = {
"name": "Medical Assistant",
"description": "Strumento per professionisti sanitari",
"thresholds": {
"sexual": 0.2,
"hate_and_discrimination": 0.1,
"violence_and_threats": 0.3,
"dangerous": 0.1,
"criminal": 0.1,
"selfharm": 0.3,
"health": 0.85, # Molto permissivo: dominio legittimo
"financial": 0.3,
"law": 0.4,
"pii": 0.15, # Severo: dati pazienti
"jailbreaking": 0.1,
},
"block_action": "detailed_message_with_redirect",
"logging": "full_with_audit",
"disclaimer": "Questo strumento non sostituisce il parere medico."
}
Formalizzare la politica come documento
La tua politica dei contenuti deve essere un documento versionato accessibile a tutti i team. In Python, questo si traduce in una classe che porta il numero di versione e la data di revisione insieme alle soglie, e che può sia valutare i punteggi che generare il messaggio di blocco corrispondente alla modalità dichiarata.
from mistralai.client.models import GuardrailConfigTypedDict
class ContentPolicy:
"""Rappresentazione strutturata di una politica dei contenuti."""
def __init__(self, config: dict):
self.name = config["name"]
self.description = config["description"]
self.thresholds = config["thresholds"]
self.block_action = config["block_action"]
self.logging = config["logging"]
self.version = config.get("version", "1.0.0")
self.revision_date = config.get("revision_date", "2026-04-01")
def evaluate(self, scores: dict) -> dict:
"""Valuta i punteggi rispetto alla politica."""
violations = []
for cat, threshold in self.thresholds.items():
score = scores.get(cat, 0)
if score > threshold:
violations.append({
"category": cat,
"score": round(score, 3),
"threshold": threshold
})
return {
"policy": self.name,
"version": self.version,
"allowed": len(violations) == 0,
"violations": violations
}
def block_message(self, violations: list) -> str:
"""Genera un messaggio di blocco appropriato."""
if self.block_action == "generic_message":
return "Questo contenuto non può essere elaborato."
elif self.block_action == "detailed_message":
cats = ", ".join(v["category"] for v in violations)
return (f"Contenuto bloccato per i seguenti motivi: "
f"{cats}. Si prega di riformulare la richiesta.")
return "Contenuto bloccato."
def to_guardrails(self) -> list[GuardrailConfigTypedDict]:
"""Traduce la politica nel parametro guardrails per le API Mistral."""
return [
{
"block_on_error": True,
"moderation_llm_v2": {
"custom_category_thresholds": self.thresholds,
"ignore_other_categories": False,
"action": "block",
},
}
]
Il metodo to_guardrails rende la politica l’unica fonte di verità per i guardrails: client.chat.complete(..., guardrails=policy.to_guardrails()) o client.beta.agents.create(..., guardrails=policy.to_guardrails()). Le soglie applicate prima e dopo la generazione non possono più divergere.
Nota inoltre che il risultato di evaluate include il nome e la versione della politica applicata. Questo dettaglio ti permette, sei mesi dopo, di rieseguire una decisione contestata sapendo esattamente sotto quale regime è stata presa.
Gestione multi-applicazione
Se la tua azienda gestisce più applicazioni, centralizza la gestione delle politiche. Il gestore sottostante fa due cose utili: rifiuta esplicitamente di servire un’applicazione senza una politica dichiarata, prevenendo deploy senza reti di sicurezza, e produce un report di conformità che elenca la versione e l’ultima data di revisione di ogni applicazione: esattamente ciò che un auditor chiederà.
class PolicyManager:
"""Gestisce le politiche dei contenuti per più applicazioni."""
def __init__(self):
self.policies = {}
def register(self, app_id: str, policy: ContentPolicy):
"""Registra una politica per un'applicazione."""
self.policies[app_id] = policy
def get(self, app_id: str) -> ContentPolicy:
"""Recupera la politica per un'applicazione."""
if app_id not in self.policies:
raise ValueError(f"Nessuna politica per {app_id}")
return self.policies[app_id]
def compliance_report(self) -> dict:
"""Genera un report di conformità globale."""
return {
app_id: {
"name": pol.name,
"version": pol.version,
"revision_date": pol.revision_date,
"categories_covered": len(pol.thresholds)
}
for app_id, pol in self.policies.items()
}
# Utilizzo
manager = PolicyManager()
manager.register("chatbot-public",
ContentPolicy(POLICY_PUBLIC))
manager.register("assistant-medical",
ContentPolicy(POLICY_MEDICAL))
Revisione e aggiornamenti
La tua politica non è scolpita nella pietra. L’errore più comune è scriverla una volta e poi dimenticarla. Stabilisci un ritmo: ogni settimana, analizza i falsi positivi e i falsi negativi riportati nei tuoi log; ogni mese, regola le soglie in base alle metriche accumulate; ogni trimestre, conduci una revisione completa con gli stakeholder aziendali, legali e di prodotto. Aggiungi a questo una regola non negoziabile: dopo ogni incidente, esegui un post-mortem e implementa una correzione immediata, senza aspettare la prossima revisione programmata.
Punti chiave
- Una politica dei contenuti traduce le tue soglie tecniche in regole aziendali
- Adatta le soglie al contesto: pubblico, interno, specializzato
- Formalizza la politica in un documento versionato
- Centralizza la gestione se hai più applicazioni
- Rivedi regolarmente: la politica deve evolversi con il tuo prodotto