Ir al contenido principal
Español— Elegir un idioma
Menú

Cumplimiento del RGPD y protección de datos

Lección 11 de 12 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. IA y datos personales: un marco estricto
  2. La categoría PII en la moderación de Mistral
  3. Anonimización antes del procesamiento
  4. Registros de moderación conformes con el RGPD
  5. Pista de auditoría para el cumplimiento
  6. Lista de comprobación del RGPD para tu aplicación de IA
  7. Puntos clave

Actualizado el 3 de noviembre de 2026. La lista de elementos detectados por la categoría pii se alinea ahora con la definición de Mistral (los datos de salud se rigen por normas distintas y la categoría health se 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 obsoleta datetime.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 pii de 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