Conformità al GDPR e protezione dei dati
In questa pagina
Aggiornato il 3 novembre 2026. L’elenco degli elementi rilevati dalla categoria
piiora è allineato alla definizione di Mistral (i dati sanitari rientrano in normative diverse e la categoriahealthriguarda le richieste di consigli medici). Il logger conforme calcolava erroneamente la data di fine conservazione, causando la cancellazione di tutto durante le operazioni di pulizia; utilizzava inoltre una chiave di salatura predefinita hardcoded per la pseudonimizzazione e la funzione deprecatadatetime.utcnow(). La pseudonimizzazione ora utilizza HMAC-SHA-256 con una chiave obbligatoria. Fonti: Moderation & Guardrailing · GDPR, Considerando 26 e Articoli 4 e 22 · Python hmac.
IA e dati personali: un quadro normativo rigoroso
C’è un paradosso al centro di questa lezione e vederlo chiaramente ti evita molti errori di progettazione: il tuo sistema di moderazione è esso stesso un’operazione di trattamento di dati personali. Per proteggere i tuoi utenti, analizzi i loro testi, generi punteggi e conservi i log: tutte operazioni che il GDPR regola esattamente come qualsiasi altra attività di trattamento.
La conformità, quindi, non significa aggiungere uno strato di protezione sopra la moderazione. Significa progettare il sistema di moderazione stesso affinché elabori la quantità minima di dati, per il minor tempo possibile, mantenendo al contempo una traccia delle sue decisioni. Questo è il filo conduttore delle sezioni seguenti.
Il GDPR (Regolamento Generale sulla Protezione dei Dati) si applica pienamente alle applicazioni di IA che trattano dati di residenti europei. La moderazione dei contenuti genera essa stessa dati che rientrano nel campo di applicazione del GDPR. Devi comprendere i tuoi obblighi per evitare sanzioni che possono arrivare fino al 4% del fatturato annuo globale.
La categoria PII nella moderazione Mistral
La categoria pii del classificatore di Mistral rileva richieste o divulgazioni di informazioni personali. Va fatto subito un punto architetturale fondamentale: questo classificatore è una rete di sicurezza, non una garanzia. Intercetta formulazioni varie che una regex mancherebbe (“il mio numero è…”), ma come qualsiasi modello, ha falsi negativi. Al contrario, una regex intercetta affidabilmente formati strutturati (IBAN, numeri di sicurezza sociale, carte di credito), ma nient’altro. La best practice combina entrambi: regex per i formati noti, classificatore per il resto. I tipi rilevati includono:
- Nomi e cognomi completi
- Indirizzi
- Numeri di telefono
- Numeri di sicurezza sociale
- Dettagli di conti finanziari
La definizione di Mistral si concentra sulla richiesta, sulla condivisione o sul tentativo di ottenere queste informazioni identificative.
from mistralai.client import Mistral
import os
import re
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def detect_pii(text: str) -> dict:
"""Detects personal data in text."""
# Layer 1: Mistral Classifier
response = client.classifiers.moderate(
model="mistral-moderation-2603",
inputs=[text]
)
pii_score = (response.results[0].category_scores or {}).get("pii", 0)
# Layer 2: Regex for common patterns
pii_patterns = {
"email": r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
"telephone_fr": r"(?:0|\+33)[1-9](?:\d{2}){4}",
"secu_sociale": r"\d{13,15}",
"carte_bancaire": r"\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}",
"iban": r"FR\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{3}"
}
detected_pii = {}
for name, pattern in pii_patterns.items():
matches = re.findall(pattern, text)
if matches:
detected_pii[name] = len(matches)
return {
"score_classifieur": round(pii_score, 3),
"pii_regex": detected_pii,
"contient_pii": pii_score > 0.2 or len(detected_pii) > 0
}
Anonimizzazione prima dell’elaborazione
L’anonimizzazione a monte è la misura più efficace in termini di costi in tutta questa lezione, perché cambia la natura del problema: i dati che non lasciano mai la tua infrastruttura non sollevano problemi di trasferimento. Sostituire nomi, email e numeri con token ([PERSON_1], [EMAIL_1]) prima di chiamare il modello preserva quasi sempre il significato per l’analisi e, se mantieni la tabella di mappatura localmente, puoi reiniettare i valori reali nella risposta. Finché questa tabella esiste, si tratta legalmente di pseudonimizzazione, non di anonimizzazione: i dati rimangono personali, ma i dati inviati al modello non consentono più di identificare la persona da soli.
def anonymize_text(text: str) -> tuple:
"""Anonymizes text and keeps a restoration mapping."""
mapping = {}
anonymized_text = text
# Anonymize emails
emails = re.findall(
r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
text
)
for i, email in enumerate(set(emails)):
placeholder = f"[EMAIL_{i+1}]"
mapping[placeholder] = email
anonymized_text = anonymized_text.replace(email, placeholder)
# Anonymize phones
phones = re.findall(
r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
text
)
for i, tel in enumerate(set(phones)):
placeholder = f"[TEL_{i+1}]"
mapping[placeholder] = tel
anonymized_text = anonymized_text.replace(tel, placeholder)
# Anonymize names (if detected by upstream NER)
# Add your own NER logic here
return anonymized_text, mapping
def restore_text(anonymized_text: str, mapping: dict) -> str:
"""Restores anonymized data after processing."""
restored_text = anonymized_text
for placeholder, value in mapping.items():
restored_text = restored_text.replace(placeholder, value)
return restored_text
# Usage in pipeline
original_text = "Contactez [email protected] au 06 12 34 56 78"
anonymized_text, mapping = anonymize_text(original_text)
# → "Contactez [EMAIL_1] au [TEL_1]"
# Send anonymized text to model
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": anonymized_text}]
)
Log di moderazione conformi al GDPR
I log sono il classico punto cieco: pensi ai “dati personali” riguardo ai messaggi degli utenti, ma raramente riguardo alle tracce tecniche che li copiano. Eppure, un log di moderazione che conserva il testo analizzato è un database personale, con tutti gli obblighi che ne conseguono. La regola empirica: registra il testo solo per i contenuti bloccati (ne avrai bisogno in caso di controversia) e registra solo i punteggi per i contenuti accettati.
import hashlib
import hmac
from datetime import datetime, timedelta, timezone
class LogModerationRGPD:
"""GDPR-compliant moderation logger."""
def __init__(self, retention_jours: int = 90):
self.retention_jours = retention_jours
# Mandatory secret key, kept out of code (vault or environment variable)
self.key = os.environ["PII_HMAC_KEY"].encode()
def _pseudonymiser(self, user_id: str) -> str:
"""Pseudonymizes a user identifier (HMAC-SHA-256)."""
return hmac.new(self.key, user_id.encode(), hashlib.sha256).hexdigest()[:16]
def log_moderation(self, user_id: str, scores: dict, decision: str,
text: str | None = None) -> dict:
"""Records a moderation decision."""
maintenant = datetime.now(timezone.utc)
entry = {
"timestamp": maintenant.isoformat(),
"user_hash": self._pseudonymiser(user_id),
"scores": scores,
"decision": decision,
# Do NOT store full text by default
"texte_longueur": len(text) if text else 0,
"conserver_jusqu_au": (maintenant + timedelta(days=self.retention_jours)).isoformat(),
}
# Store text excerpt only if blocked (for audit)
if decision == "blocked" and text:
entry["texte_tronque"] = text[:200]
return entry
def purger_anciens_logs(self, logs: list[dict]) -> list[dict]:
"""Keeps logs whose retention end date has not passed."""
maintenant = datetime.now(timezone.utc)
return [
log for log in logs
if datetime.fromisoformat(log["conserver_jusqu_au"]) > maintenant
]
Due precauzioni in questo codice meritano di essere menzionate. La chiave di pseudonimizzazione non ha alcun valore predefinito: una chiave scritta nel codice, nota a tutti, permetterebbe di ricalcolare l’hash di qualsiasi identificativo. Inoltre, i dati pseudonimizzati rimangono dati personali ai sensi del GDPR (Considerando 26): questo log rimane soggetto ai periodi di conservazione e ai diritti degli interessati.
Traccia di audit per la conformità
La traccia di audit risponde a una domanda specifica che un utente o un’autorità potrebbe porti: “Perché questo contenuto è stato bloccato?”. Senza una traccia, la tua unica risposta onesta è “Non lo so più”, il che è insostenibile dato che il GDPR richiede, per le decisioni completamente automatizzate ai sensi dell’articolo 22, di informare la persona sulla logica sottostante (articoli da 13 a 15), e l’AI Act aggiunge i propri obblighi di trasparenza. La traccia di audit conserva la decisione, i punteggi che l’hanno motivata e la versione della politica applicata, senza necessariamente conservare il testo stesso.
class AuditTrail:
"""Audit trail for moderation decisions."""
def __init__(self, storage_path: str):
self.storage_path = storage_path
def record_decision(self, data: dict) -> str:
"""Records a decision with a unique identifier."""
import uuid
audit_id = str(uuid.uuid4())
entry = {
"audit_id": audit_id,
"timestamp": datetime.now(timezone.utc).isoformat(),
"type_decision": data.get("decision"),
"modele_moderation": "mistral-moderation-2603",
"scores": data.get("scores"),
"seuils_appliques": data.get("seuils"),
"politique_version": data.get("politique_version"),
"action_prise": data.get("action"),
"base_legale": "interet_legitime",
"responsable": "systeme_automatise"
}
# Write to audit file
import json
with open(self.storage_path, "a") as f:
f.write(json.dumps(entry, ensure_ascii=False) + "\n")
return audit_id
Checklist GDPR per la tua applicazione IA
Ecco i punti da verificare per assicurarti che il tuo sistema di moderazione sia conforme:
Base giuridica
- Interesse legittimo documentato per la moderazione dei contenuti
- Notifica all’utente riguardo al trattamento automatizzato
- Possibilità di contestare una decisione automatizzata
Minimizzazione dei dati
- Conservare solo i dati strettamente necessari
- Anonimizzare o pseudonimizzare gli identificativi degli utenti
- Troncare il testo nei log di moderazione
- Non conservare i testi accettati (solo i punteggi)
Periodo di conservazione
- Definire un periodo di conservazione per ogni tipo di dato
- Log di moderazione: massimo 90 giorni (salvo obbligo legale diverso)
- Traccia di audit: secondo la regolamentazione settoriale
- Cancellazione automatica programmata
Diritti degli utenti
- Diritto di accesso alle decisioni di moderazione che li riguardano
- Diritto di rettifica se la decisione è contestata
- Diritto alla spiegazione della decisione automatizzata
Punti chiave
- Il GDPR si applica pienamente ai tuoi sistemi di moderazione IA
- Usa la categoria
piidi Mistral E le regex per rilevare i dati personali - Anonimizza i testi prima di inviarli al modello quando possibile
- Pseudonimizza gli identificativi degli utenti nei log
- Implementa una traccia di audit per la tracciabilità delle decisioni
- Definisci un periodo di conservazione ed elimina automaticamente i log