Pseudonymisation des prompts LLM : le tutoriel RGPD/Loi 25 pour agents IA

Vous monitorez vos agents IA en production. Vos traces capturent automatiquement les prompts, les réponses du LLM, les arguments des appels d'outils, parfois même les fragments de documents passés au RAG. Et là, le problème vous saute au visage : ces traces contiennent des données personnelles. Adresses email de vos clients, numéros de dossier, fragments de contrats, identifiants internes, parfois même des numéros de carte ou de la donnée santé glissée dans un prompt système mal pensé.

Si vous êtes au Québec, la Loi 25 vous oblige à appliquer le principe de minimisation (article 12) et à pouvoir prouver vos finalités. Si vous êtes sous RGPD, l'article 25 ("Privacy by Design") et l'article 32 (sécurité des traitements) vous demandent de pseudonymiser ce qui peut l'être. Et dans les deux cas, le considérant 26 du RGPD est très clair : la pseudonymisation réduit le périmètre des données personnelles sans pour autant les sortir du champ du règlement (contrairement à l'anonymisation, qui elle, sort du champ — mais qui est techniquement quasi-impossible sur des prompts LLM).

Ce tutoriel est la mise en œuvre opérationnelle du principe énoncé dans notre pilier sur la conformité Loi 25 et RGPD pour agents IA. On va construire ensemble, en Python, le pipeline de pseudonymisation que ClawPulse recommande à ses clients en production : un module de moins de 200 lignes, testable, déterministe sur une fenêtre temporelle, qui transforme un prompt brut en une trace conforme RGPD/Loi 25 que vous pouvez stocker, agréger et analyser sans exposer la donnée source.

Pseudonymisation, anonymisation, chiffrement : ne confondez pas

Avant de coder, mettons un peu de rigueur juridique. Ces trois concepts sont régulièrement confondus dans la documentation des fournisseurs LLM, et la confusion coûte cher en cas d'audit CNIL ou Commission d'accès à l'information du Québec (CAI).

| Notion | Définition juridique | Donnée toujours « personnelle » ? | Réversibilité |

|---|---|---|---|

| Chiffrement (encryption) | Transformation cryptographique réversible avec clé. La clé existe, donc la donnée reste personnelle au sens RGPD. | Oui | Oui (avec clé) |

| Pseudonymisation | Remplacement des identifiants directs par des pseudonymes ; la ré-identification reste possible via une table de correspondance gardée séparément (RGPD art. 4.5). | Oui — mais avec un risque réduit. | Oui (avec table) |

| Anonymisation | Le risque de ré-identification est raisonnablement nul, même par recoupement (CNIL G29 WP216 : critères d'individualisation, corrélation, inférence). | Non — sortie du champ RGPD. | Non |

Pour des prompts LLM, l'anonymisation au sens juridique est quasi-impossible : un prompt contient assez de contexte (style d'écriture, sujet, mentions indirectes) pour permettre une corrélation. La CNIL a confirmé en 2024 que les LLM eux-mêmes peuvent re-personnaliser un texte anonymisé via inférence. C'est donc la pseudonymisation qui est votre cible : elle est réaliste, elle est exigée par l'article 32, et elle est valorisée par les autorités lors d'un contrôle.

Le considérant 28 du RGPD précise même que « l'application de la pseudonymisation aux données à caractère personnel peut réduire les risques pour les personnes concernées et aider les responsables du traitement et leurs sous-traitants à remplir leurs obligations en matière de protection des données ». Autrement dit : vous gagnez des points en cas d'incident.

Le périmètre exact à pseudonymiser dans une trace d'agent IA

Une trace produite par un agent IA en production contient typiquement quatre couches de données. Chacune appelle une stratégie de pseudonymisation différente.

Couche 1 : Identifiants conversationnels

`session_id`, `user_id`, `tenant_id`, `request_id`, `agent_run_id`. Ce sont les identifiants techniques que vous propagez à travers votre stack. Ils ne sont pas eux-mêmes des données personnelles mais combinés à votre base utilisateur, ils permettent une ré-identification triviale. Stratégie : HMAC déterministe avec sel rotatif, pour préserver l'agrégation tout en rendant la corrélation hors-périmètre impossible.

Couche 2 : Charge utile prompt/réponse

Le contenu textuel envoyé au LLM et reçu en retour. C'est la couche la plus risquée, car elle contient potentiellement n'importe quoi : email du client, numéro SIN/NAS, copie-coller de document RH, carte de crédit dans un test de support. Stratégie : scrubber regex strict + détection NER optionnelle appliqués avant l'émission de la trace.

Couche 3 : Arguments d'appels d'outils

Les `tool_calls` que votre agent émet (search, query DB, send email, etc.). Ces arguments contiennent souvent des PK utilisateur, des emails, des paramètres de filtre. Stratégie : typage strict des paramètres + redaction par champ basée sur un schéma JSON.

Couche 4 : Métriques dérivées

Tokens entrée, tokens sortie, latence, coût, succès/échec. Ce sont les seules données qu'on a besoin de garder en clair pour la supervision. Bonne nouvelle : elles sont déjà non-personnelles, à condition qu'on les calcule avant de jeter la charge utile, et qu'on ne stocke que les compteurs agrégés.

La règle directrice est simple : plus on remonte du LLM vers la trace stockée, plus on minimise. Idéalement, ce qui sort de votre processus émetteur vers ClawPulse (ou Langfuse self-hosted, ou votre propre ClickHouse) est déjà pseudonymisé — on ne déporte jamais la responsabilité de la pseudonymisation à un fournisseur tiers.

Le code complet : `clawpulse_pseudo.py`

Voici le module Python de référence. 180 lignes, zéro dépendance externe au-delà de la stdlib (pour la portabilité dans les environnements air-gapped clients sensibles). Vous pouvez le copier-coller dans votre projet, l'adapter à vos schémas, et le tester en isolation.

```python

# clawpulse_pseudo.py

# Pseudonymisation conforme RGPD / Loi 25 pour traces agents IA

# Licence : MIT

from __future__ import annotations

import hashlib

import hmac

import os

import re

import secrets

import time

from contextlib import contextmanager

from dataclasses import dataclass, field, asdict

from typing import Any, Iterator

# ----------------------------------------------------------------------------

# 1. Sel rotatif - pseudonymisation deterministe sur une fenetre temporelle

# ----------------------------------------------------------------------------

# Idee : un identifiant pseudonymise doit pouvoir etre agrege sur une session

# (ex : compter les requetes d'un meme utilisateur sur 24 h) sans rester

# correlable indefiniment. On utilise un sel qui change chaque jour a minuit

# UTC, stocke dans un secret manager (KMS, HashiCorp Vault, etc.).

#

# Effet : deux traces du meme user_id le meme jour donnent le meme pseudo.

# Le lendemain, le pseudo change : impossible de correler entre jours sans

# retourner a la table de correspondance gardee separement.

class RotatingSalt:

"""Sel rotatif quotidien (UTC). Backend env var en demo, KMS en prod."""

def __init__(self, window_seconds: int = 86400, env_var: str = "CLAWPULSE_PSEUDO_SALT"):

self._window = window_seconds

self._env_var = env_var

def current(self) -> bytes:

# En prod : recuperer depuis un secret manager indexe par window_index.

base = os.environ.get(self._env_var)

if not base:

raise RuntimeError(

f"Missing {self._env_var}. En prod, charger depuis Vault/KMS."

)

window_index = int(time.time() // self._window)

return hashlib.sha256(f"{base}:{window_index}".encode()).digest()

# ----------------------------------------------------------------------------

# 2. Pseudonymisation deterministe d'un identifiant

# ----------------------------------------------------------------------------

# HMAC-SHA256 + sel rotatif + tronque a 16 caracteres hex pour la lisibilite.

# Garanties : (a) deterministe sur la fenetre, (b) hors fenetre = nouveau

# pseudo, (c) impossible a inverser sans le sel courant.

def pseudonymize_id(value: str, salt: RotatingSalt, prefix: str = "u_") -> str:

if not value:

return ""

digest = hmac.new(salt.current(), value.encode(), hashlib.sha256).hexdigest()

return f"{prefix}{digest[:16]}"

# ----------------------------------------------------------------------------

# 3. Scrubber regex pour la charge utile prompt/reponse

# ----------------------------------------------------------------------------

# Cible les motifs les plus a risque selon le top des incidents AI Privacy

# (Stanford CRFM 2025 + ICO 2024) : email, telephone NA/EU, IBAN, carte de

# credit (Luhn passe en option), JWT, SIN canadien, NIR francais, IP v4/v6.

REDACTORS = [

# Email

(re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b"),

""),

# IBAN (loose)

(re.compile(r"\b[A-Z]{2}\d{2}[A-Z0-9]{10,30}\b"),

""),

# Carte bancaire 13-19 digits (avant filtre Luhn)

(re.compile(r"\b(?:\d[ -]?){13,19}\b"),

""),

# Telephone NA (+1) ou EU

(re.compile(r"\+?\d{1,3}[\s.-]?\(?\d{2,4}\)?[\s.-]?\d{2,4}[\s.-]?\d{2,4}"),

""),

# JWT

(re.compile(r"\beyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\b"),

""),

# SIN canadien (XXX-XXX-XXX)

(re.compile(r"\b\d{3}[\s-]\d{3}[\s-]\d{3}\b"),

""),

# IPv4

(re.compile(r"\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b"),

""),

# API keys generiques (sk-, pk_, ghp_, etc.)

(re.compile(r"\b(sk|pk|ghp|gho|ghs|github_pat|xoxb|xoxp)[_-][A-Za-z0-9_-]{20,}\b"),

""),

]

def scrub_payload(text: str):

"""Applique tous les redactors. Retourne le texte nettoye et un

compteur par categorie - utile pour alerter sur un pic de PII."""

if not text:

return "", {}

counters = {}

cleaned = text

for pattern, replacement in REDACTORS:

cleaned, n = pattern.subn(replacement, cleaned)

if n:

counters[replacement] = counters.get(replacement, 0) + n

return cleaned, counters

# ----------------------------------------------------------------------------

# 4. Calcul des metriques AVANT scrubbing

# ----------------------------------------------------------------------------

# Le seul moment ou on a besoin du payload brut, c'est pour calculer les

# metriques de cout et de qualite. On les calcule, puis on jette le payload.

@dataclass

class TraceMetrics:

prompt_chars: int = 0

completion_chars: int = 0

prompt_tokens_est: int = 0

completion_tokens_est: int = 0

pii_redactions: dict = field(default_factory=dict)

duration_ms: int = 0

error: str = None

def estimate_tokens(text: str) -> int:

"""Estimation rapide ~4 chars/token pour planning de cout.

En prod, remplacer par tiktoken si disponible."""

return max(1, len(text) // 4) if text else 0

def derive_metrics(prompt: str, completion: str) -> TraceMetrics:

return TraceMetrics(

prompt_chars=len(prompt or ""),

completion_chars=len(completion or ""),

prompt_tokens_est=estimate_tokens(prompt),

completion_tokens_est=estimate_tokens(completion),

)

# ----------------------------------------------------------------------------

# 5. Context manager pour instrumenter un appel agent IA

# ----------------------------------------------------------------------------

@dataclass

class TraceContext:

user_id: str

agent: str

salt: RotatingSalt

prompt: str = ""

completion: str = ""

tool_calls: list = field(default_factory=list)

started_at: float = field(default_factory=time.monotonic)

error: str = None

def emit_pseudonymized(trace: TraceContext) -> dict:

"""Transforme une trace brute en payload conforme RGPD/Loi 25."""

metrics = derive_metrics(trace.prompt, trace.completion)

metrics.duration_ms = int((time.monotonic() - trace.started_at) * 1000)

metrics.error = trace.error

_, prompt_pii = scrub_payload(trace.prompt)

_, completion_pii = scrub_payload(trace.completion)

pii_total = {}

for d in (prompt_pii, completion_pii):

for k, v in d.items():

pii_total[k] = pii_total.get(k, 0) + v

metrics.pii_redactions = pii_total

payload = {

"user_pseudo": pseudonymize_id(trace.user_id, trace.salt, prefix="u_"),

"agent": trace.agent,

"tools_used": [tc.get("name", "?") for tc in trace.tool_calls],

"metrics": asdict(metrics),

"schema_version": 1,

"ts": int(time.time()),

}

return payload

@contextmanager

def cp_trace(user_id: str, agent: str, salt: RotatingSalt):

trace = TraceContext(user_id=user_id, agent=agent, salt=salt)

try:

yield trace

except Exception as exc:

trace.error = exc.__class__.__name__

raise

finally:

payload = emit_pseudonymized(trace)

# En prod : push vers ClawPulse / Kafka / file locale chiffree.

print(payload)

```

Utilisation : un exemple bout-en-bout

Voici comment vous l'intégrez à un agent IA qui répond à un ticket support et qui a accès à un outil de recherche dans la base CRM.

```python

# my_support_agent.py

import os, secrets

from clawpulse_pseudo import RotatingSalt, cp_trace

from anthropic import Anthropic

# En demo seulement - en prod, charger depuis Vault.

os.environ.setdefault("CLAWPULSE_PSEUDO_SALT", secrets.token_hex(32))

salt = RotatingSalt()

client = Anthropic()

def handle_ticket(user_id: str, message: str) -> str:

with cp_trace(user_id=user_id, agent="support_v2", salt=salt) as trace:

trace.prompt = message

resp = client.messages.create(

model="claude-opus-4-7",

max_tokens=1024,

messages=[{"role": "user", "content": message}],

)

trace.completion = resp.content[0].text

trace.tool_calls = [{"name": "search_kb"}]

return trace.completion

handle_ticket(

user_id="cust_4521",

message="Bonjour, mon email est jean.dupont@exemple.fr, mon numero "

"514-555-0123, j'ai un probleme avec ma carte 4242 4242 4242 4242."

)

```

Sortie côté backend (ce qui part vers ClawPulse / votre stack) :

```json

{

"user_pseudo": "u_a4f2c91be8d76502",

"agent": "support_v2",

"tools_used": ["search_kb"],

"metrics": {

"prompt_chars": 142,

"completion_chars": 318,

"prompt_tokens_est": 35,

"completion_tokens_est": 79,

"pii_redactions": {

"": 1,

"": 1,

"": 1

},

"duration_ms": 1842,

"error": null

},

"schema_version": 1,

"ts": 1735238400

}

```

Notez ce qui n'est PAS émis : ni l'email, ni le téléphone, ni le numéro de carte, ni le contenu du message, ni la réponse du LLM, ni le `cust_4521` brut. Vous gardez la capacité de superviser (durée, tokens, taux d'erreur, alerte sur pic de PII), mais vous avez sorti la donnée personnelle du périmètre observabilité. C'est exactement ce que demande l'article 25 du RGPD ("Privacy by Design") et ce qui rend votre audit Loi 25 simple à défendre.