Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Conformità al GDPR e protezione dei dati

Lezione 11 di 12 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. IA e dati personali: un quadro normativo rigoroso
  2. La categoria PII nella moderazione Mistral
  3. Anonimizzazione prima dell’elaborazione
  4. Log di moderazione conformi al GDPR
  5. Traccia di audit per la conformità
  6. Checklist GDPR per la tua applicazione IA
  7. Punti chiave

Aggiornato il 3 novembre 2026. L’elenco degli elementi rilevati dalla categoria pii ora è allineato alla definizione di Mistral (i dati sanitari rientrano in normative diverse e la categoria health riguarda 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 deprecata datetime.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 pii di 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