Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Conformité au RGPD et protection des données

Les 11 van 12 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. L’IA et les données personnelles : un cadre strict
  2. La catégorie PII dans la modération Mistral
  3. Anonymisation avant traitement
  4. Journaux de modération conformes au RGPD
  5. Piste d’audit pour la conformité
  6. Liste de contrôle RGPD pour votre application d’IA
  7. Belangrijkste punten

Mis à jour le 3 novembre 2026. La liste des éléments détectés par la catégorie pii s’aligne désormais sur la définition de Mistral (les données de santé relèvent de règles différentes, et la catégorie health cible les demandes de conseils médicaux). Le journal de conformité calculait auparavant incorrectement sa date de fin de rétention, entraînant la suppression de toutes les données lors des purges ; il utilisait également une clé de salage par défaut codée en dur pour la pseudonymisation et la méthode obsolète datetime.utcnow(). La pseudonymisation utilise désormais HMAC-SHA-256 avec une clé obligatoire. Sources : Modération et garde-fous · RGPD, considérant 26 et articles 4 et 22 · Python hmac.

L’IA et les données personnelles : un cadre strict

Un paradoxe se trouve au cœur de cette leçon, et le comprendre clairement permet d’éviter de nombreuses erreurs de conception : votre système de modération constitue lui-même une opération de traitement de données à caractère personnel. Pour protéger vos utilisateurs, vous analysez leurs textes, générez des scores et conservez des journaux ; toutes ces opérations sont régulées par le RGPD exactement comme toute autre activité de traitement.

La conformité ne signifie donc pas l’ajout d’une couche de protection par-dessus la modération. Elle implique de concevoir le système de modération lui-même pour qu’il traite le minimum de données nécessaire, pendant la durée la plus courte possible, tout en conservant une trace de ses décisions. C’est le fil conducteur des sections suivantes.

Le RGPD (Règlement général sur la protection des données) s’applique intégralement aux applications d’IA traitant des données de résidents européens. La modération de contenu génère elle-même des données entrant dans le champ d’application du RGPD. Vous devez comprendre vos obligations pour éviter des sanctions pouvant atteindre 4 % du chiffre d’affaires annuel mondial.

La catégorie PII dans la modération Mistral

La catégorie pii du classifieur de Mistral détecte les demandes ou les divulgations d’informations personnelles. Un point architectural doit être souligné immédiatement : ce classifieur est un filet de sécurité, pas une garantie. Il intercepte des formulations variées qu’une expression régulière manquerait (« mon numéro est… »), mais comme tout modèle, il présente des faux négatifs. À l’inverse, une expression régulière capture fiablement les formats structurés — IBAN, numéros de sécurité sociale, cartes de crédit — mais rien d’autre. La meilleure pratique combine les deux : expressions régulières pour les formats connus, classifieur pour le reste. Les types détectés incluent :

  • Noms complets
  • Adresses
  • Numéros de téléphone
  • Numéros de sécurité sociale
  • Coordonnées de comptes financiers

La définition de Mistral se concentre sur la demande, le partage ou la tentative d’obtention de ces informations identifiantes.

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
    }

Anonymisation avant traitement

L’anonymisation en amont est la mesure la plus rentable de toute cette leçon, car elle change la nature du problème : des données qui ne quittent jamais votre infrastructure ne soulèvent aucun problème de transfert. Remplacer les noms, e-mails et numéros par des jetons ([PERSON_1], [EMAIL_1]) avant d’appeler le modèle préserve presque toujours le sens pour l’analyse — et si vous conservez la table de correspondance localement, vous pouvez réinjecter les valeurs réelles dans la réponse. Tant que cette table existe, il s’agit juridiquement de pseudonymisation, et non d’anonymisation : les données restent personnelles, mais les données envoyées au modèle ne permettent plus, à elles seules, d’identifier la personne.

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}]
)

Journaux de modération conformes au RGPD

Les journaux constituent le point aveugle classique : on pense « données personnelles » concernant les messages des utilisateurs, mais rarement concernant les traces techniques qui les copient. Pourtant, un journal de modération conservant le texte analysé est une base de données personnelle, avec toutes les obligations qui en découlent. La règle empirique : ne journaliser le texte que pour les contenus bloqués — vous en aurez besoin en cas de litige — et ne journaliser que les scores pour les contenus acceptés.

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
        ]

Deux précautions dans ce code méritent d’être mentionnées. La clé de pseudonymisation n’a aucune valeur par défaut : une clé écrite dans le code, connue de tous, permettrait de recalculer le hachage de n’importe quel identifiant. De plus, les données pseudonymisées restent des données à caractère personnel au sens du RGPD (considérant 26) : ce journal reste soumis aux délais de conservation et aux droits des personnes concernées.

Piste d’audit pour la conformité

La piste d’audit répond à une question précise qu’un utilisateur ou une autorité peut vous poser : « Pourquoi ce contenu a-t-il été bloqué ? ». Sans trace, votre seule réponse honnête est « Je ne sais plus » — ce qui est intenable étant donné que le RGPD exige, pour les décisions entièrement automatisées en vertu de l’article 22, d’informer la personne de la logique sous-jacente (articles 13 à 15), et que la loi sur l’IA ajoute ses propres obligations de transparence. La piste d’audit conserve la décision, les scores qui l’ont motivée et la version de la politique appliquée — sans nécessairement conserver le texte lui-même.

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

Liste de contrôle RGPD pour votre application d’IA

Voici les points à vérifier pour garantir la conformité de votre système de modération :

Base légale

  • Intérêt légitime documenté pour la modération de contenu
  • Notification de l’utilisateur concernant le traitement automatisé
  • Possibilité de contester une décision automatisée

Minimisation des données

  • Stocker uniquement les données strictement nécessaires
  • Anonymiser ou pseudonymiser les identifiants utilisateurs
  • Tronquer le texte dans les journaux de modération
  • Ne pas conserver les textes acceptés (uniquement les scores)

Durée de conservation

  • Définir une durée de conservation pour chaque type de données
  • Journaux de modération : 90 jours maximum (sauf obligation légale contraire)
  • Piste d’audit : selon la réglementation sectorielle
  • Purge automatique planifiée

Droits des utilisateurs

  • Droit d’accès aux décisions de modération les concernant
  • Droit de rectification si la décision est contestée
  • Droit à l’explication de la décision automatisée

Belangrijkste punten

  • Le RGPD s’applique intégralement à vos systèmes de modération par IA
  • Utilisez la catégorie pii de Mistral ET des expressions régulières pour détecter les données personnelles
  • Anonymisez les textes avant de les envoyer au modèle lorsque c’est possible
  • Pseudonymisez les identifiants utilisateurs dans les journaux
  • Mettez en œuvre une piste d’audit pour la traçabilité des décisions
  • Définissez une durée de conservation et purgez automatiquement les journaux