7. Compliance Basics: GDPR, CCPA y AI

Descripción

Has construido un pipeline técnico completo: detección de PII (cápsula 03), redacción (04), minimización (05), retención y encryption (06). Cada una de estas técnicas existe por una razón que va más allá de la ingeniería — existe porque hay marcos legales que requieren protección de datos personales, y las multas por incumplimiento son reales y sustanciales.

Esta cápsula te da el awareness técnico de los frameworks de compliance más relevantes para sistemas AI: GDPR (Europa), CCPA (California), y el EU AI Act. No pretende ser — ni reemplazar — asesoría legal. Tu equipo legal define las obligaciones específicas de tu organización. Pero como engineer que diseña e implementa sistemas AI, necesitas entender qué exigen estos frameworks para que tus decisiones técnicas estén alineadas con los requisitos legales.

La pregunta no es "¿debo cumplir con GDPR?" sino "¿mi sistema AI procesa datos de personas en la UE, California, o jurisdicciones con regulaciones similares?" Si la respuesta es sí — y en la mayoría de sistemas AI conectados a internet lo es — necesitas que tu PII Protection Layer esté diseñado con compliance en mente.

Disclaimer importante

Esta cápsula proporciona awareness técnico sobre frameworks de compliance. NO es asesoría legal. Las obligaciones específicas de tu organización dependen de tu jurisdicción, el tipo de datos que procesas, tu relación con los data subjects, y otros factores que solo un equipo legal puede evaluar. Consulta con abogados especializados en protección de datos antes de tomar decisiones de compliance.

GDPR: lo que un AI engineer necesita saber

El Reglamento General de Protección de Datos (GDPR) de la UE es el estándar de facto global para protección de datos personales. Si tu sistema AI procesa datos de personas en la UE — incluso si tu empresa está fuera de Europa — GDPR aplica.

Principios clave y su impacto técnico

gdpr_principles_for_ai = {
    "lawfulness_fairness_transparency": {
        "article": "Art. 5(1)(a)",
        "principle": "Lawfulness, fairness and transparency",
        "ai_impact": (
            "Necesitas una base legal para procesar datos con AI. "
            "El consentimiento o el interés legítimo son las bases más comunes. "
            "Debes informar al usuario que sus datos serán procesados por AI."
        ),
        "technical_action": [
            "Implementar mecanismo de consentimiento antes del procesamiento AI",
            "Registrar la base legal de cada procesamiento",
            "Proveer información clara sobre el uso de AI en la política de privacidad",
        ],
    },
    "purpose_limitation": {
        "article": "Art. 5(1)(b)",
        "principle": "Purpose limitation",
        "ai_impact": (
            "Los datos recopilados para customer support no pueden usarse "
            "para fine-tuning sin consentimiento adicional. Cada uso de los "
            "datos necesita un propósito específico y documentado."
        ),
        "technical_action": [
            "Documentar el propósito de cada flujo de datos a través del LLM",
            "No reutilizar datos de producción para training sin autorización",
            "Implementar controles de acceso por propósito",
        ],
    },
    "data_minimization": {
        "article": "Art. 5(1)(c)",
        "principle": "Data minimisation",
        "ai_impact": (
            "Solo envía al LLM los datos estrictamente necesarios. "
            "El DataMinimizer de la cápsula 05 implementa este principio."
        ),
        "technical_action": [
            "DataMinimizer con políticas por endpoint",
            "Excluir campos no necesarios del contexto del LLM",
            "Documentar qué datos se envían al LLM y por qué",
        ],
    },
    "accuracy": {
        "article": "Art. 5(1)(d)",
        "principle": "Accuracy",
        "ai_impact": (
            "Los datos personales procesados por AI deben ser precisos. "
            "Si el LLM genera información incorrecta sobre una persona, "
            "esto puede constituir una violación."
        ),
        "technical_action": [
            "Filtro post-LLM para verificar claims sobre personas",
            "Mecanismo para que usuarios corrijan datos incorrectos",
            "No presentar outputs del LLM como hechos verificados",
        ],
    },
    "storage_limitation": {
        "article": "Art. 5(1)(e)",
        "principle": "Storage limitation",
        "ai_impact": (
            "Los datos no deben guardarse más tiempo del necesario. "
            "El RetentionScheduler de la cápsula 06 implementa este principio."
        ),
        "technical_action": [
            "RetentionScheduler con políticas por tipo de dato",
            "Eliminación automática de logs y outputs expirados",
            "No almacenar prompts completos indefinidamente",
        ],
    },
    "integrity_confidentiality": {
        "article": "Art. 5(1)(f)",
        "principle": "Integrity and confidentiality",
        "ai_impact": (
            "Debes proteger los datos contra acceso no autorizado. "
            "Encryption at rest/transit y control de acceso son obligatorios."
        ),
        "technical_action": [
            "Encryption at rest para datos almacenados (cápsula 06)",
            "HTTPS/TLS para todas las conexiones",
            "Control de acceso basado en roles para datos de usuarios",
        ],
    },
}

print("Principios GDPR y su impacto en sistemas AI:\n")
for key, info in gdpr_principles_for_ai.items():
    print(f"  {info['article']}: {info['principle']}")
    print(f"    Impacto AI: {info['ai_impact'][:80]}...")
    for action in info['technical_action'][:2]:
        print(f"      → {action}")
    print()

Derechos de los data subjects

data_subject_rights = {
    "right_to_access": {
        "article": "Art. 15",
        "right": "Right of access",
        "what_it_means": (
            "El usuario puede pedir una copia de todos sus datos personales "
            "que procesas, incluyendo datos procesados por AI."
        ),
        "ai_challenge": (
            "¿Qué datos del usuario están en los logs del LLM? "
            "¿En el vector store? ¿En el chat history?"
        ),
        "implementation": [
            "Índice de datos por user_id en todos los almacenes",
            "Capacidad de exportar datos del usuario en formato legible",
            "Incluir datos procesados por AI en el access report",
        ],
    },
    "right_to_erasure": {
        "article": "Art. 17",
        "right": "Right to erasure (right to be forgotten)",
        "what_it_means": (
            "El usuario puede pedir que elimines todos sus datos personales."
        ),
        "ai_challenge": (
            "¿Puedes eliminar datos de un usuario del vector store? "
            "¿De los logs? ¿Del modelo fine-tuned que usó sus datos?"
        ),
        "implementation": [
            "Capacidad de eliminar datos por user_id de todos los almacenes",
            "Eliminación de embeddings del vector store",
            "Eliminación de chat history y logs asociados",
            "Si fine-tuneaste con datos del usuario: re-entrenar sin ellos",
        ],
    },
    "right_to_rectification": {
        "article": "Art. 16",
        "right": "Right to rectification",
        "what_it_means": (
            "El usuario puede pedir que corrijas datos personales incorrectos."
        ),
        "ai_challenge": (
            "Si el LLM genera información incorrecta sobre un usuario, "
            "¿cómo corriges eso en un modelo que no puedes editar directamente?"
        ),
        "implementation": [
            "Mecanismo para que usuarios reporten datos incorrectos",
            "Capacidad de actualizar/corregir datos en el contexto del LLM",
            "Si usas RAG: actualizar documentos fuente con datos corregidos",
        ],
    },
    "right_to_data_portability": {
        "article": "Art. 20",
        "right": "Right to data portability",
        "what_it_means": (
            "El usuario puede pedir sus datos en formato estructurado "
            "y legible por máquina para llevarlos a otro servicio."
        ),
        "ai_challenge": (
            "¿Puedes exportar el historial de conversaciones, "
            "preferencias aprendidas, y datos procesados por AI?"
        ),
        "implementation": [
            "Exportación en JSON de chat history",
            "Exportación de datos de usuario procesados por AI",
            "API de portabilidad de datos",
        ],
    },
    "right_to_object": {
        "article": "Art. 21",
        "right": "Right to object",
        "what_it_means": (
            "El usuario puede objetar al procesamiento de sus datos, "
            "incluyendo procesamiento por AI."
        ),
        "ai_challenge": (
            "¿Puedes ofrecer tu servicio sin procesamiento AI si el "
            "usuario lo objeta? ¿Hay una alternativa manual?"
        ),
        "implementation": [
            "Flag per-user para opt-out de procesamiento AI",
            "Ruta alternativa sin AI (si es viable)",
            "Registro de objeciones y acciones tomadas",
        ],
    },
}

print("Derechos de los data subjects y su implementación en AI:\n")
for key, info in data_subject_rights.items():
    print(f"  {info['article']}: {info['right']}")
    print(f"    {info['what_it_means'][:80]}...")
    print(f"    Desafío AI: {info['ai_challenge'][:60]}...")
    for impl in info['implementation'][:2]:
        print(f"      → {impl}")
    print()

Data Subject Access Request (DSAR) handler

from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Optional
from enum import Enum


class DSARType(Enum):
    ACCESS = "access"
    ERASURE = "erasure"
    RECTIFICATION = "rectification"
    PORTABILITY = "portability"
    OBJECTION = "objection"


@dataclass
class DSARRequest:
    request_id: str
    user_id: str
    request_type: DSARType
    submitted_at: datetime
    details: str = ""
    status: str = "pending"
    deadline: Optional[datetime] = None

    def __post_init__(self):
        if self.deadline is None:
            self.deadline = self.submitted_at + __import__("datetime").timedelta(days=30)


class DSARHandler:
    """Gestiona Data Subject Access Requests para compliance GDPR."""

    def __init__(self):
        self.requests: list[DSARRequest] = []
        self.data_sources = [
            "chat_history",
            "llm_logs",
            "vector_store",
            "user_database",
            "audit_logs",
        ]

    def submit_request(
        self,
        user_id: str,
        request_type: DSARType,
        details: str = "",
    ) -> DSARRequest:
        """Registra un nuevo DSAR."""
        request = DSARRequest(
            request_id=f"DSAR-{len(self.requests) + 1:04d}",
            user_id=user_id,
            request_type=request_type,
            submitted_at=datetime.now(timezone.utc),
            details=details,
        )
        self.requests.append(request)
        return request

    def process_access_request(self, request: DSARRequest) -> dict:
        """Procesa un request de acceso (Art. 15)."""
        report = {
            "request_id": request.request_id,
            "user_id": request.user_id,
            "data_found": {},
            "sources_checked": self.data_sources,
        }

        for source in self.data_sources:
            report["data_found"][source] = {
                "status": "checked",
                "records_found": 0,
                "note": f"Implement actual {source} query here",
            }

        request.status = "completed"
        return report

    def process_erasure_request(self, request: DSARRequest) -> dict:
        """Procesa un request de eliminación (Art. 17)."""
        report = {
            "request_id": request.request_id,
            "user_id": request.user_id,
            "deletions": {},
        }

        for source in self.data_sources:
            report["deletions"][source] = {
                "status": "deleted",
                "records_deleted": 0,
                "note": f"Implement actual {source} deletion here",
            }

        request.status = "completed"
        return report

    def get_overdue_requests(self) -> list[DSARRequest]:
        """Identifica requests que exceden el deadline de 30 días."""
        now = datetime.now(timezone.utc)
        return [
            r for r in self.requests
            if r.status == "pending" and r.deadline and r.deadline < now
        ]


# --- Demostración ---

handler = DSARHandler()

access_req = handler.submit_request(
    user_id="usr-456",
    request_type=DSARType.ACCESS,
    details="Quiero saber qué datos míos procesan con AI",
)

print(f"DSAR submitted: {access_req.request_id}")
print(f"  Type: {access_req.request_type.value}")
print(f"  Deadline: {access_req.deadline.strftime('%Y-%m-%d')}")
print(f"  Status: {access_req.status}")

report = handler.process_access_request(access_req)
print(f"\nAccess report:")
print(f"  Sources checked: {len(report['sources_checked'])}")
for source, info in report['data_found'].items():
    print(f"    {source}: {info['status']}")

CCPA: California Consumer Privacy Act

CCPA es la regulación de privacidad más relevante en Estados Unidos. Si tu sistema AI procesa datos de residentes de California (incluso si tu empresa está fuera de California), CCPA puede aplicar.

ccpa_key_requirements = {
    "right_to_know": {
        "section": "§1798.100",
        "right": "Right to know what personal information is collected",
        "ai_relevance": (
            "Los consumidores pueden pedir qué datos recopilas y cómo los usas, "
            "incluyendo datos procesados por AI."
        ),
        "implementation": "Similar a GDPR Art. 15 — exportar datos por usuario",
    },
    "right_to_delete": {
        "section": "§1798.105",
        "right": "Right to delete personal information",
        "ai_relevance": (
            "Los consumidores pueden pedir eliminación de sus datos. "
            "Incluye datos en vector stores, chat histories, y logs."
        ),
        "implementation": "Similar a GDPR Art. 17 — eliminar de todos los almacenes",
    },
    "right_to_opt_out": {
        "section": "§1798.120",
        "right": "Right to opt-out of sale of personal information",
        "ai_relevance": (
            "Si usas datos de consumidores para mejorar un servicio AI "
            "que vendes a terceros, esto podría constituir 'venta' de datos."
        ),
        "implementation": "Flag de opt-out, no usar datos para fine-tuning de modelos vendidos",
    },
    "non_discrimination": {
        "section": "§1798.125",
        "right": "Right to non-discrimination",
        "ai_relevance": (
            "No puedes discriminar contra usuarios que ejercen sus derechos "
            "de privacidad — por ejemplo, degradar la calidad del servicio AI."
        ),
        "implementation": "Misma calidad de servicio independientemente de opt-outs",
    },
    "private_right_of_action": {
        "section": "§1798.150",
        "right": "Private right of action for data breaches",
        "ai_relevance": (
            "Los consumidores pueden demandar directamente por data breaches. "
            "Un LLM que revela datos personales podría ser un breach."
        ),
        "implementation": "PII Protection Layer para prevenir disclosure por LLM",
    },
}

print("CCPA — Requisitos clave para AI:\n")
for key, info in ccpa_key_requirements.items():
    print(f"  {info['section']}: {info['right']}")
    print(f"    AI: {info['ai_relevance'][:80]}...")
    print(f"    Impl: {info['implementation']}")
    print()

Diferencias clave GDPR vs CCPA

comparison = {
    "scope": {
        "gdpr": "Cualquier persona en la UE (ciudadanos y residentes)",
        "ccpa": "Residentes de California (con umbrales de negocio)",
    },
    "consent_model": {
        "gdpr": "Opt-in: necesitas consentimiento antes de procesar",
        "ccpa": "Opt-out: puedes procesar hasta que el consumidor diga que no",
    },
    "penalties": {
        "gdpr": "Hasta €20M o 4% de facturación global anual",
        "ccpa": "Hasta $7,500 por violación intencional + private right of action",
    },
    "data_definition": {
        "gdpr": "'Personal data' — cualquier dato que identifique a una persona",
        "ccpa": "'Personal information' — similar, pero incluye datos de hogares",
    },
    "breach_notification": {
        "gdpr": "72 horas para notificar a la autoridad de protección de datos",
        "ccpa": "'Expeditiously' — sin deadline específico",
    },
    "ai_specific": {
        "gdpr": (
            "Art. 22: derecho a no ser sujeto a decisiones automatizadas. "
            "Requiere human oversight para decisiones significativas."
        ),
        "ccpa": (
            "No tiene provisiones AI-específicas, pero el procesamiento "
            "automatizado de datos personales está cubierto."
        ),
    },
}

print("GDPR vs CCPA — Comparación para AI:\n")
for aspect, info in comparison.items():
    print(f"  {aspect.upper().replace('_', ' ')}:")
    print(f"    GDPR: {info['gdpr'][:70]}...")
    print(f"    CCPA: {info['ccpa'][:70]}...")
    print()

EU AI Act: regulación específica para AI

El EU AI Act es la primera regulación del mundo específica para inteligencia artificial. Entró en vigor en etapas entre 2024 y 2026.

ai_act_risk_levels = {
    "unacceptable": {
        "description": "Sistemas AI prohibidos",
        "examples": [
            "Social scoring por gobiernos",
            "Manipulación subliminal que cause daño",
            "Explotación de vulnerabilidades de personas",
            "Identificación biométrica remota en tiempo real (con excepciones)",
        ],
        "relevance": "Si tu sistema AI hace algo de esta lista, detente.",
    },
    "high_risk": {
        "description": "Sistemas AI sujetos a requisitos estrictos",
        "examples": [
            "Sistemas de reclutamiento/empleo",
            "Scoring crediticio",
            "Sistemas de salud y diagnóstico",
            "Sistemas de educación y evaluación",
            "Gestión de infraestructura crítica",
        ],
        "relevance": (
            "Si tu sistema AI toma o influye en decisiones significativas "
            "sobre personas en estas áreas, es 'high risk'."
        ),
    },
    "limited_risk": {
        "description": "Sistemas AI con obligaciones de transparencia",
        "examples": [
            "Chatbots (deben informar que son AI)",
            "Generadores de contenido (deep fakes, imágenes AI)",
            "Sistemas de detección de emociones",
        ],
        "relevance": (
            "La mayoría de chatbots y asistentes AI caen aquí. "
            "Debes informar al usuario que interactúa con AI."
        ),
    },
    "minimal_risk": {
        "description": "Sistemas AI sin obligaciones adicionales",
        "examples": [
            "Filtros de spam",
            "AI en videojuegos",
            "Herramientas de productividad con AI",
        ],
        "relevance": "Buenas prácticas recomendadas, sin obligaciones legales.",
    },
}

print("EU AI Act — Niveles de riesgo:\n")
for level, info in ai_act_risk_levels.items():
    print(f"  {level.upper()} RISK")
    print(f"    {info['description']}")
    print(f"    Relevancia: {info['relevance'][:70]}...")
    for ex in info['examples'][:2]:
        print(f"      - {ex}")
    print()

Consent management para procesamiento AI

from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Optional
from enum import Enum


class ConsentType(Enum):
    AI_PROCESSING = "ai_processing"
    DATA_COLLECTION = "data_collection"
    ANALYTICS = "analytics"
    TRAINING_DATA = "training_data"
    THIRD_PARTY_SHARING = "third_party_sharing"


class ConsentStatus(Enum):
    GRANTED = "granted"
    DENIED = "denied"
    WITHDRAWN = "withdrawn"
    NOT_ASKED = "not_asked"


@dataclass
class ConsentRecord:
    user_id: str
    consent_type: ConsentType
    status: ConsentStatus
    granted_at: Optional[datetime] = None
    withdrawn_at: Optional[datetime] = None
    purpose: str = ""
    version: str = "1.0"


class ConsentManager:
    """Gestiona consentimiento de usuarios para procesamiento AI."""

    def __init__(self):
        self.consents: dict[str, dict[ConsentType, ConsentRecord]] = {}

    def request_consent(
        self,
        user_id: str,
        consent_type: ConsentType,
        purpose: str,
    ) -> ConsentRecord:
        """Registra que se solicitó consentimiento."""
        record = ConsentRecord(
            user_id=user_id,
            consent_type=consent_type,
            status=ConsentStatus.NOT_ASKED,
            purpose=purpose,
        )
        if user_id not in self.consents:
            self.consents[user_id] = {}
        self.consents[user_id][consent_type] = record
        return record

    def grant_consent(
        self,
        user_id: str,
        consent_type: ConsentType,
    ) -> ConsentRecord:
        """Registra que el usuario otorgó consentimiento."""
        record = self.consents.get(user_id, {}).get(consent_type)
        if not record:
            record = ConsentRecord(
                user_id=user_id, consent_type=consent_type,
                status=ConsentStatus.GRANTED,
            )
            if user_id not in self.consents:
                self.consents[user_id] = {}
            self.consents[user_id][consent_type] = record
        
        record.status = ConsentStatus.GRANTED
        record.granted_at = datetime.now(timezone.utc)
        return record

    def withdraw_consent(
        self,
        user_id: str,
        consent_type: ConsentType,
    ) -> ConsentRecord:
        """Registra que el usuario retiró consentimiento."""
        record = self.consents.get(user_id, {}).get(consent_type)
        if record:
            record.status = ConsentStatus.WITHDRAWN
            record.withdrawn_at = datetime.now(timezone.utc)
        return record

    def check_consent(
        self,
        user_id: str,
        consent_type: ConsentType,
    ) -> bool:
        """Verifica si el usuario tiene consentimiento activo."""
        record = self.consents.get(user_id, {}).get(consent_type)
        return record is not None and record.status == ConsentStatus.GRANTED

    def get_user_consents(self, user_id: str) -> list[dict]:
        """Retorna todos los consentimientos de un usuario."""
        user_consents = self.consents.get(user_id, {})
        return [
            {
                "type": ct.value,
                "status": cr.status.value,
                "purpose": cr.purpose,
                "granted_at": cr.granted_at.isoformat() if cr.granted_at else None,
            }
            for ct, cr in user_consents.items()
        ]


# --- Demostración ---

cm = ConsentManager()

cm.grant_consent("usr-123", ConsentType.AI_PROCESSING)
cm.grant_consent("usr-123", ConsentType.DATA_COLLECTION)
cm.request_consent("usr-123", ConsentType.TRAINING_DATA, "Mejorar modelo con tus conversaciones")

can_process = cm.check_consent("usr-123", ConsentType.AI_PROCESSING)
can_train = cm.check_consent("usr-123", ConsentType.TRAINING_DATA)

print(f"User usr-123:")
print(f"  Can process with AI: {can_process}")
print(f"  Can use for training: {can_train}")
print(f"\n  All consents:")
for consent in cm.get_user_consents("usr-123"):
    print(f"    {consent['type']}: {consent['status']}")

# Output esperado:
# User usr-123:
#   Can process with AI: True
#   Can use for training: False
#
#   All consents:
#     ai_processing: granted
#     data_collection: granted
#     training_data: not_asked

Compliance checklist para AI

compliance_checklist = {
    "data_inventory": {
        "item": "¿Tienes un inventario de todos los datos personales que tu AI procesa?",
        "gdpr_article": "Art. 30 — Record of processing activities",
        "implementation": "Documentar qué datos, de quién, para qué, y dónde se almacenan",
        "module_reference": "DataMinimizer (cápsula 05) + audit logs",
    },
    "legal_basis": {
        "item": "¿Tienes base legal para cada tipo de procesamiento de datos con AI?",
        "gdpr_article": "Art. 6 — Lawfulness of processing",
        "implementation": "ConsentManager + documentación de base legal por flujo",
        "module_reference": "ConsentManager (esta cápsula)",
    },
    "privacy_notice": {
        "item": "¿Tu política de privacidad menciona el uso de AI y LLMs?",
        "gdpr_article": "Art. 13-14 — Information to be provided",
        "implementation": "Actualizar privacy notice con detalles de procesamiento AI",
        "module_reference": "Documentación legal",
    },
    "pii_detection": {
        "item": "¿Detectas PII antes de enviarlo al LLM?",
        "gdpr_article": "Art. 25 — Data protection by design",
        "implementation": "PIIScanner integrado en el pipeline",
        "module_reference": "PIIScanner (cápsula 03)",
    },
    "pii_redaction": {
        "item": "¿Redactas PII antes y después del procesamiento AI?",
        "gdpr_article": "Art. 25 + Art. 32 — Security of processing",
        "implementation": "PreLLMRedactor + PostLLMRedactor",
        "module_reference": "Redactors (cápsula 04)",
    },
    "data_minimization": {
        "item": "¿Envías solo los datos necesarios al LLM?",
        "gdpr_article": "Art. 5(1)(c) — Data minimisation",
        "implementation": "DataMinimizer con políticas por endpoint",
        "module_reference": "DataMinimizer (cápsula 05)",
    },
    "retention_policy": {
        "item": "¿Tienes políticas de retención para logs y datos de AI?",
        "gdpr_article": "Art. 5(1)(e) — Storage limitation",
        "implementation": "RetentionScheduler con eliminación automática",
        "module_reference": "RetentionScheduler (cápsula 06)",
    },
    "encryption": {
        "item": "¿Los datos están cifrados at rest y in transit?",
        "gdpr_article": "Art. 32 — Security of processing",
        "implementation": "DataEncryptor + HTTPS para todas las conexiones",
        "module_reference": "Encryption (cápsula 06)",
    },
    "dsar_handling": {
        "item": "¿Puedes procesar requests de acceso/eliminación de datos?",
        "gdpr_article": "Art. 15-22 — Rights of the data subject",
        "implementation": "DSARHandler + capacidad de eliminar por user_id",
        "module_reference": "DSARHandler (esta cápsula)",
    },
    "breach_response": {
        "item": "¿Tienes un plan de respuesta a data breaches de AI?",
        "gdpr_article": "Art. 33-34 — Notification of data breach",
        "implementation": "Procedimiento documentado + monitoreo de disclosure",
        "module_reference": "Audit logging + monitoring (cápsula 06)",
    },
    "ai_transparency": {
        "item": "¿Informas a los usuarios que interactúan con AI?",
        "gdpr_article": "EU AI Act — Art. 52",
        "implementation": "Disclaimer en la interfaz de usuario",
        "module_reference": "UI implementation",
    },
    "vendor_assessment": {
        "item": "¿Has evaluado a tu proveedor de LLM (OpenAI, etc.) como data processor?",
        "gdpr_article": "Art. 28 — Processor",
        "implementation": "Data Processing Agreement (DPA) con el proveedor de AI",
        "module_reference": "Legal + procurement",
    },
}

print("Compliance Checklist para AI:\n")
completed = 0
total = len(compliance_checklist)

for key, item in compliance_checklist.items():
    has_implementation = "cápsula" in item["module_reference"].lower()
    status = "✅" if has_implementation else "⬜"
    if has_implementation:
        completed += 1
    print(f"  {status} {item['item'][:70]}...")
    print(f"     GDPR: {item['gdpr_article']}")
    print(f"     Ref: {item['module_reference']}")
    print()

print(f"\n  Score: {completed}/{total} items con implementación técnica")

# Output esperado:
#   ✅ ¿Detectas PII antes de enviarlo al LLM?...
#      GDPR: Art. 25 — Data protection by design
#      Ref: PIIScanner (cápsula 03)
# ...

Data Protection Impact Assessment (DPIA)

GDPR Art. 35 requiere un DPIA para procesamientos de alto riesgo, incluyendo procesamiento automatizado a gran escala de datos personales.

@dataclass
class DPIASection:
    section: str
    description: str
    ai_considerations: list[str]
    your_answers: list[str] = field(default_factory=list)


dpia_template = [
    DPIASection(
        section="1. Descripción del procesamiento",
        description="¿Qué datos procesas, de quién, y para qué?",
        ai_considerations=[
            "Inputs del usuario que envías al LLM",
            "Documentos de RAG que contienen PII",
            "Outputs del modelo que pueden contener PII",
            "Logs y auditoría del procesamiento",
        ],
    ),
    DPIASection(
        section="2. Necesidad y proporcionalidad",
        description="¿El procesamiento AI es necesario para lograr el objetivo?",
        ai_considerations=[
            "¿Podrías lograr lo mismo sin AI?",
            "¿Envías solo los datos necesarios al LLM (data minimization)?",
            "¿El beneficio justifica el riesgo de procesamiento AI?",
        ],
    ),
    DPIASection(
        section="3. Riesgos para los data subjects",
        description="¿Qué riesgos enfrenta la persona cuyos datos procesas?",
        ai_considerations=[
            "Riesgo de disclosure por el LLM (LLM02)",
            "Riesgo de datos incorrectos generados por AI",
            "Riesgo de re-identificación por combinación de datos",
            "Riesgo de discriminación por decisiones automatizadas",
        ],
    ),
    DPIASection(
        section="4. Medidas de mitigación",
        description="¿Qué medidas implementas para reducir los riesgos?",
        ai_considerations=[
            "PII detection y redaction (cápsulas 03-04)",
            "Data minimization (cápsula 05)",
            "Retention policies y encryption (cápsula 06)",
            "Consent management (esta cápsula)",
            "Post-LLM filtering de outputs",
        ],
    ),
]

print("DPIA Template para sistemas AI:\n")
for section in dpia_template:
    print(f"  {section.section}")
    print(f"    {section.description}")
    for consideration in section.ai_considerations[:3]:
        print(f"      → {consideration}")
    print()

Conexión con el proyecto

La compliance awareness de esta cápsula informa el diseño del PII Protection Layer:

Troubleshooting

Problema 1: "No sé si GDPR aplica a mi sistema AI"

Si procesas datos de personas en la UE — incluso si tu empresa está fuera de Europa — GDPR probablemente aplica. Si tienes usuarios en la UE y procesas cualquier dato personal (incluido email para login), consulta con tu equipo legal.

Problema 2: "Un usuario pidió eliminación de sus datos pero no puedo eliminar de un modelo fine-tuned"

Este es uno de los problemas más difíciles de AI y compliance. Si fine-tuneaste un modelo con datos del usuario, la eliminación perfecta requiere re-entrenamiento sin sus datos. Documenta la situación y consulta con tu equipo legal sobre alternativas aceptables.

Problema 3: "¿Los datos enviados a OpenAI cuentan como transferencia de datos a terceros?"

Sí, bajo GDPR. OpenAI actúa como "data processor" para tus datos. Necesitas un Data Processing Agreement (DPA) con OpenAI. OpenAI ofrece un DPA estándar que puedes revisar con tu equipo legal.

Problema 4: "No tengo equipo legal — ¿cómo implemento compliance?"

Implementa las mejores prácticas técnicas de este módulo (PII detection, redaction, minimization, retention, encryption). Documenta lo que haces y por qué. Cuando crezcas, un equipo legal podrá auditar tu implementación técnica y ajustar lo necesario.

Ejercicios

Ejercicio 1: Compliance audit para tu sistema AI

Evalúa tu sistema AI actual contra el compliance checklist.

def run_compliance_audit(system_config: dict) -> dict:
    checks = {
        "pii_detection": system_config.get("has_pii_scanner", False),
        "pii_redaction": system_config.get("has_redactor", False),
        "data_minimization": system_config.get("has_minimizer", False),
        "retention_policy": system_config.get("has_retention", False),
        "encryption": system_config.get("has_encryption", False),
        "consent": system_config.get("has_consent_manager", False),
        "dsar_handling": system_config.get("has_dsar_handler", False),
        "ai_transparency": system_config.get("has_ai_disclosure", False),
    }
    
    passed = sum(1 for v in checks.values() if v)
    total = len(checks)
    
    return {
        "score": f"{passed}/{total}",
        "percentage": round(passed / total * 100),
        "status": "COMPLIANT" if passed >= 6 else "AT_RISK" if passed >= 3 else "NON_COMPLIANT",
        "checks": checks,
        "gaps": [k for k, v in checks.items() if not v],
    }


system = {
    "has_pii_scanner": True,
    "has_redactor": True,
    "has_minimizer": False,
    "has_retention": False,
    "has_encryption": True,
    "has_consent_manager": False,
    "has_dsar_handler": False,
    "has_ai_disclosure": True,
}

audit = run_compliance_audit(system)
print(f"Compliance Audit: {audit['score']} ({audit['percentage']}%)")
print(f"Status: {audit['status']}")
print(f"Gaps: {audit['gaps']}")

Ejercicio 2: Generador de privacy notice para AI

Crea una función que genere un template de privacy notice que incluya la sección de procesamiento AI.

def generate_ai_privacy_notice(config: dict) -> str:
    notice = f"""
PRIVACY NOTICE — AI PROCESSING

{config.get('company_name', 'Our Company')} uses artificial intelligence 
to provide and improve our services.

WHAT DATA WE PROCESS WITH AI:
- Your messages and queries submitted to our assistant
- Relevant context from our knowledge base to answer your questions

HOW WE PROTECT YOUR DATA:
- We detect and redact personal information before sending to AI models
- We minimize the data sent to only what's necessary
- All data is encrypted in transit and at rest
- We retain AI processing logs for {config.get('retention_days', 30)} days

YOUR RIGHTS:
- Access: Request a copy of your data processed by AI
- Deletion: Request removal of your data from our AI systems
- Opt-out: Request that your data not be processed by AI

AI PROVIDER: {config.get('ai_provider', 'Third-party AI provider')}
Data Processing Agreement in place: {config.get('has_dpa', 'Yes')}

Contact: {config.get('dpo_email', 'privacy@company.com')}
    """
    return notice.strip()


notice = generate_ai_privacy_notice({
    "company_name": "TechStore",
    "retention_days": 30,
    "ai_provider": "OpenAI",
    "has_dpa": "Yes",
    "dpo_email": "privacy@techstore.com",
})
print(notice[:300] + "...")

Ejercicio 3: DSAR tracker con deadline monitoring

Crea un sistema que trackee DSARs y alerte cuando se acercan al deadline.

from datetime import timedelta

class DSARTracker:
    def __init__(self):
        self.handler = DSARHandler()
        self.alerts: list[dict] = []

    def check_deadlines(self):
        now = datetime.now(timezone.utc)
        for req in self.handler.requests:
            if req.status != "pending":
                continue
            days_remaining = (req.deadline - now).days if req.deadline else 0
            if days_remaining <= 0:
                self.alerts.append({
                    "request_id": req.request_id,
                    "severity": "CRITICAL",
                    "message": f"DSAR {req.request_id} is OVERDUE",
                })
            elif days_remaining <= 7:
                self.alerts.append({
                    "request_id": req.request_id,
                    "severity": "WARNING",
                    "message": f"DSAR {req.request_id} due in {days_remaining} days",
                })

    def get_dashboard(self) -> dict:
        pending = sum(1 for r in self.handler.requests if r.status == "pending")
        completed = sum(1 for r in self.handler.requests if r.status == "completed")
        return {
            "total": len(self.handler.requests),
            "pending": pending,
            "completed": completed,
            "alerts": len(self.alerts),
        }


tracker = DSARTracker()
tracker.handler.submit_request("usr-1", DSARType.ACCESS, "Data access request")
tracker.handler.submit_request("usr-2", DSARType.ERASURE, "Delete my data")
tracker.check_deadlines()

dashboard = tracker.get_dashboard()
print(f"DSAR Dashboard: {dashboard}")

Ejercicio 4: Consent-aware pipeline gate

Crea un middleware que verifique consentimiento antes de procesar con AI.

class ConsentGate:
    """Middleware que verifica consentimiento antes de procesamiento AI."""
    
    def __init__(self, consent_manager: ConsentManager):
        self.cm = consent_manager
    
    def check(self, user_id: str, required_consents: list[ConsentType]) -> dict:
        missing = []
        for consent_type in required_consents:
            if not self.cm.check_consent(user_id, consent_type):
                missing.append(consent_type.value)
        
        return {
            "user_id": user_id,
            "allowed": len(missing) == 0,
            "missing_consents": missing,
            "action": "proceed" if not missing else "request_consent",
        }


cm = ConsentManager()
cm.grant_consent("usr-123", ConsentType.AI_PROCESSING)

gate = ConsentGate(cm)
result = gate.check("usr-123", [ConsentType.AI_PROCESSING, ConsentType.ANALYTICS])
print(f"Allowed: {result['allowed']}")
print(f"Missing: {result['missing_consents']}")
# Output: Allowed: False, Missing: ['analytics']

Resumen

• 🔑 GDPR aplica a cualquier sistema AI que procese datos de personas en la UE — los 6 principios (lawfulness, purpose limitation, data minimisation, accuracy, storage limitation, integrity) tienen impacto directo en el diseño del sistema
• 🔑 Los derechos de los data subjects (access, erasure, rectification, portability, objection) requieren capacidades técnicas específicas — el DSARHandler implementa el flujo de gestión
• 🔑 CCPA aplica a residentes de California y tiene un modelo opt-out (vs opt-in de GDPR) — incluye private right of action para breaches de datos
• 🔑 El EU AI Act clasifica sistemas AI por nivel de riesgo (unacceptable, high, limited, minimal) — la mayoría de chatbots son "limited risk" y requieren disclosure de transparencia
• 🔑 El consent management para procesamiento AI requiere consentimiento explícito por tipo de procesamiento, con capacidad de withdrawal en cualquier momento
• 🔑 El DPIA (Data Protection Impact Assessment) es obligatorio para procesamiento AI a gran escala de datos personales — documenta riesgos y mitigaciones
• 🔑 Cada componente técnico del PII Protection Layer mapea a un requisito legal específico: PIIScanner → Art. 25, DataMinimizer → Art. 5(1)(c), RetentionScheduler → Art. 5(1)(e)
• 🔑 Esta cápsula NO es asesoría legal — es awareness técnico para que tus decisiones de engineering estén alineadas con los frameworks de compliance. Consulta con tu equipo legal.

Recursos adicionales

1. GDPR Official Text — Texto completo del GDPR con comentarios y guías
2. CCPA Official Text — California Consumer Privacy Act texto oficial
3. EU AI Act Full Text — Texto completo del EU AI Act con análisis
4. ICO AI Guidance — Guía del regulador UK sobre AI y GDPR
5. CNIL AI Guidelines — Guía del regulador francés sobre AI
6. IAPP AI Governance Center — Recursos de la International Association of Privacy Professionals sobre AI
7. NIST AI Risk Management Framework — Framework de gestión de riesgos AI del NIST
8. OpenAI Data Processing Agreement — DPA de OpenAI para referencia

Creado: Marzo 2026 Versión: 1.0