Conformité au RGPD et protection des données
På denna sida
Mis à jour le 3 novembre 2026. La liste des éléments détectés par la catégorie
piis’aligne désormais sur la définition de Mistral (les données de santé relèvent de règles différentes, et la catégoriehealthcible les demandes de conseils médicaux). Le journaliseur conforme calculait auparavant incorrectement sa date de fin de conservation, entraînant la suppression de tout le contenu lors des purges ; il utilisait également une clé de salage par défaut codée en dur pour la pseudonymisation et la fonction obsolètedatetime.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
Il existe un paradoxe au cœur de cette leçon, et le voir clairement évite de nombreuses erreurs de conception : votre système de modération est 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 — autant d’opérations que le RGPD réglemente exactement comme toute autre activité de traitement.
La conformité ne signifie donc pas ajouter une couche de protection par-dessus la modération. Elle consiste à concevoir le système de modération lui-même pour qu’il traite le minimum de données, 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 pleinement aux applications d’IA traitant des données de résidents européens. La modération de contenu elle-même génère des données qui relèvent du 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 attrape 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 attrape 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
- Détails 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 vraies valeurs dans la réponse. Tant que cette table existe, il s’agit légalement de pseudonymisation, et non d’anonymisation : les données restent personnelles, mais les données envoyées au modèle ne permettent plus d’identifier la personne par elles-mêmes.
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 sont 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 d’or : 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 pas de 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 durées 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 sur la logique sous-jacente (articles 13 à 15), et que l’AI Act 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
Checklist 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
Viktiga punkter
- Le RGPD s’applique pleinement à vos systèmes de modération par IA
- Utilisez la catégorie
piide 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 place une piste d’audit pour la traçabilité des décisions
- Définissez une durée de conservation et purgez automatiquement les journaux