Cumplimiento del RGPD y protección de datos
En esta página
Actualizado el 3 de noviembre de 2026. La lista de elementos detectados por la categoría
piise alinea ahora con la definición de Mistral (los datos de salud se rigen por normas distintas y la categoríahealthse centra en solicitudes de consejo médico). El registrador conforme calculaba erróneamente su fecha de fin de retención, lo que provocaba que las purgas eliminasen todo; además, usaba una clave de salting predeterminada codificada para la seudonimización y la función obsoletadatetime.utcnow(). La seudonimización emplea ahora HMAC-SHA-256 con una clave obligatoria. Fuentes: Moderación y barreras de seguridad · RGPD, Considerando 26 y artículos 4 y 22 · Python hmac.
IA y datos personales: un marco estricto
Existe una paradoja en el corazón de esta lección y, si la ves con claridad, evitarás muchos errores de diseño: tu sistema de moderación es en sí mismo una operación de tratamiento de datos personales. Para proteger a tus usuarios, analizas su texto, generas puntuaciones y conservas registros; todas ellas son operaciones que el RGPD regula exactamente igual que cualquier otra actividad de tratamiento.
Por tanto, el cumplimiento no significa añadir una capa de protección sobre la moderación. Significa diseñar el propio sistema de moderación para que trate la mínima cantidad de datos posible, durante el menor tiempo posible, manteniendo al mismo tiempo un registro de sus decisiones. Este es el hilo conductor de las siguientes secciones.
El RGPD (Reglamento General de Protección de Datos) se aplica plenamente a las aplicaciones de IA que procesan datos de residentes europeos. La propia moderación de contenidos genera datos que entran en el ámbito de aplicación del RGPD. Debes entender tus obligaciones para evitar sanciones que pueden alcanzar hasta el 4 % de la facturación anual mundial.
La categoría PII en la moderación de Mistral
La categoría pii del clasificador de Mistral detecta solicitudes o divulgaciones de información personal. Hay que hacer inmediatamente una precisión arquitectónica: este clasificador es una red de seguridad, no una garantía. Captura formulaciones variadas que una expresión regular pasaría por alto («mi número es…»), pero, como cualquier modelo, tiene falsos negativos. Por el contrario, una expresión regular detecta de forma fiable formatos estructurados (IBAN, números de seguridad social, tarjetas de crédito), pero nada más. La mejor práctica combina ambos: expresiones regulares para formatos conocidos y el clasificador para el resto. Los tipos detectados incluyen:
- Nombres completos
- Direcciones
- Números de teléfono
- Números de seguridad social
- Datos de cuentas financieras
La definición de Mistral se centra en la solicitud, el intercambio o el intento de obtener esta información identificativa.
from mistralai.client import Mistral
import os
import re
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
def detect_pii(text: str) -> dict:
"""Detecta datos personales en el texto."""
# Capa 1: Clasificador de Mistral
response = client.classifiers.moderate(
model="mistral-moderation-2603",
inputs=[text]
)
pii_score = (response.results[0].category_scores or {}).get("pii", 0)
# Capa 2: Expresiones regulares para patrones comunes
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
}
Anonimización antes del procesamiento
La anonimización aguas arriba es la medida más rentable de toda esta lección, porque cambia la naturaleza del problema: los datos que nunca salen de tu infraestructura no plantean problemas de transferencia. Sustituir nombres, correos electrónicos y números por tokens ([PERSON_1], [EMAIL_1]) antes de llamar al modelo casi siempre preserva el significado para el análisis; y, si mantienes la tabla de correspondencia localmente, puedes reinyectar los valores reales en la respuesta. Mientras exista esta tabla, esto es legalmente seudonimización, no anonimización: los datos siguen siendo personales, pero los datos enviados al modelo ya no permiten identificar a la persona por sí solos.
def anonymize_text(text: str) -> tuple:
"""Anonimiza el texto y mantiene un mapeo de restauración."""
mapping = {}
anonymized_text = text
# Anonimizar correos electrónicos
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)
# Anonimizar teléfonos
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)
# Anonimizar nombres (si son detectados por un NER previo)
# Añade aquí tu propia lógica de NER
return anonymized_text, mapping
def restore_text(anonymized_text: str, mapping: dict) -> str:
"""Restaura los datos anonimizados después del procesamiento."""
restored_text = anonymized_text
for placeholder, value in mapping.items():
restored_text = restored_text.replace(placeholder, value)
return restored_text
# Uso en la canalización
original_text = "Contactez [email protected] au 06 12 34 56 78"
anonymized_text, mapping = anonymize_text(original_text)
# → "Contactez [EMAIL_1] au [TEL_1]"
# Enviar texto anonimizado al modelo
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": anonymized_text}]
)
Registros de moderación conformes con el RGPD
Los registros son el punto ciego clásico: pensamos en «datos personales» respecto a los mensajes de los usuarios, pero rara vez respecto a las trazas técnicas que los copian. Sin embargo, un registro de moderación que conserve el texto analizado es una base de datos personal, con todas las obligaciones que ello conlleva. La regla general: registra el texto solo para contenidos bloqueados (lo necesitarás en caso de disputa) y registra solo las puntuaciones para los contenidos aceptados.
import hashlib
import hmac
from datetime import datetime, timedelta, timezone
class LogModerationRGPD:
"""Registrador de moderación conforme al RGPD."""
def __init__(self, retention_jours: int = 90):
self.retention_jours = retention_jours
# Clave secreta obligatoria, mantenida fuera del código (bóveda o variable de entorno)
self.key = os.environ["PII_HMAC_KEY"].encode()
def _pseudonymiser(self, user_id: str) -> str:
"""Seudonimiza un identificador de usuario (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:
"""Registra una decisión de moderación."""
maintenant = datetime.now(timezone.utc)
entry = {
"timestamp": maintenant.isoformat(),
"user_hash": self._pseudonymiser(user_id),
"scores": scores,
"decision": decision,
# NO almacenar el texto completo por defecto
"texte_longueur": len(text) if text else 0,
"conserver_jusqu_au": (maintenant + timedelta(days=self.retention_jours)).isoformat(),
}
# Almacenar extracto del texto solo si está bloqueado (para auditoría)
if decision == "blocked" and text:
entry["texte_tronque"] = text[:200]
return entry
def purger_anciens_logs(self, logs: list[dict]) -> list[dict]:
"""Mantiene los registros cuya fecha de fin de retención no ha pasado."""
maintenant = datetime.now(timezone.utc)
return [
log for log in logs
if datetime.fromisoformat(log["conserver_jusqu_au"]) > maintenant
]
Dos precauciones en este código merecen mención. La clave de seudonimización no tiene valor predeterminado: una clave escrita en el código, conocida por todos, permitiría recalcular el hash de cualquier identificador. Además, los datos seudonimizados siguen siendo datos personales según el RGPD (Considerando 26): este registro sigue sujeto a plazos de retención y a los derechos de los interesados.
Pista de auditoría para el cumplimiento
La pista de auditoría responde a una pregunta concreta que un usuario o una autoridad puede hacerte: «¿Por qué se bloqueó este contenido?». Sin una traza, tu única respuesta honesta es «Ya no lo sé», algo insostenible dado que el RGPD exige, para las decisiones totalmente automatizadas del artículo 22, informar a la persona sobre la lógica subyacente (artículos 13 a 15), y la Ley de IA añade sus propias obligaciones de transparencia. La pista de auditoría conserva la decisión, las puntuaciones que la motivaron y la versión de la política aplicada, sin necesidad de conservar necesariamente el texto en sí.
class AuditTrail:
"""Pista de auditoría para decisiones de moderación."""
def __init__(self, storage_path: str):
self.storage_path = storage_path
def record_decision(self, data: dict) -> str:
"""Registra una decisión con un identificador único."""
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"
}
# Escribir en el archivo de auditoría
import json
with open(self.storage_path, "a") as f:
f.write(json.dumps(entry, ensure_ascii=False) + "\n")
return audit_id
Lista de comprobación del RGPD para tu aplicación de IA
Estos son los puntos que debes verificar para asegurarte de que tu sistema de moderación es conforme:
Base jurídica
- Interés legítimo documentado para la moderación de contenidos
- Notificación al usuario sobre el procesamiento automatizado
- Capacidad para impugnar una decisión automatizada
Minimización de datos
- Almacenar solo los datos estrictamente necesarios
- Anonimizar o seudonimizar los identificadores de usuario
- Truncar el texto en los registros de moderación
- No conservar los textos aceptados (solo las puntuaciones)
Plazo de retención
- Definir un plazo de retención para cada tipo de dato
- Registros de moderación: 90 días como máximo (salvo que una obligación legal exija lo contrario)
- Pista de auditoría: según la regulación sectorial
- Purga automática programada
Derechos de los usuarios
- Derecho de acceso a las decisiones de moderación que les afecten
- Derecho de rectificación si se impugna la decisión
- Derecho a una explicación de la decisión automatizada
Puntos clave
- El RGPD se aplica plenamente a tus sistemas de moderación con IA
- Usa la categoría
piide Mistral Y expresiones regulares para detectar datos personales - Anonimiza los textos antes de enviarlos al modelo cuando sea posible
- Seudonimiza los identificadores de usuario en los registros
- Implementa una pista de auditoría para la trazabilidad de las decisiones
- Define un plazo de retención y purga los registros automáticamente