Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Soulad s GDPR a ochrana údajů

Lekce 11 z 12 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. AI a osobní údaje: Přísný rámec
  2. Kategorie PII v moderaci Mistral
  3. Anonymizace před zpracováním
  4. Záznamy moderace v souladu s GDPR
  5. Auditní stopa pro soulad s předpisy
  6. Kontrolní seznam GDPR pro tvou aplikaci AI
  7. Klíčové poznatky

Aktualizováno 3. listopadu 2026. Seznam položek detekovaných kategorií pii je nyní v souladu s definicí společnosti Mistral (údaje o zdraví spadají pod jiná pravidla a kategorie health cílí na žádosti o lékařské rady). Dříve vyhovující systém záznamů chybně počítal datum konce uchovávání, což způsobovalo, že čištění mazalo vše; používal také natvrdo zakódovaný výchozí klíč pro solení při pseudonymizaci a zastaralou funkci datetime.utcnow(). Pseudonymizace nyní využívá HMAC-SHA-256 s povinným klíčem. Zdroje: Moderation & Guardrailing · GDPR, 26. bod odůvodnění a články 4 a 22 · Python hmac.

AI a osobní údaje: Přísný rámec

V srdci této lekce leží paradox a jeho jasné pochopení ti pomůže vyhnout se mnoha chybám v návrhu: tvůj systém moderace je sám o sobě operací zpracování osobních údajů. Abychom chránili uživatele, analyzujeme jejich text, generujeme skóre a uchováváme záznamy – všechny tyto operace GDPR reguluje přesně jako jakoukoli jinou činnost zpracování.

Shoda s předpisy tedy neznamená přidat vrstvu ochrany navíc k moderaci. Znamená to navrhnout samotný systém moderace tak, aby zpracovával minimální množství údajů, po co nejkratší možnou dobu, a přitom udržoval záznam o svých rozhodnutích. To je červená nit procházející následujícími sekcemi.

Nařízení GDPR (Obecné nařízení o ochraně osobních údajů) se plně vztahuje na aplikace AI zpracovávající data evropských obyvatel. Samotná moderace obsahu generuje data, která spadají do působnosti GDPR. Musíš pochopit své povinnosti, abys předešel sankcím dosahujícím až 4 % celosvětového ročního obratu.

Kategorie PII v moderaci Mistral

Klasifikátor kategorie pii od společnosti Mistral detekuje žádosti o osobní informace nebo jejich zveřejnění. Okamžitě je třeba zdůraznit jeden architektonický bod: tento klasifikátor je bezpečnostní síť, nikoli záruka. Zachytí různé formulace, které by regulární výraz (regex) minul („moje číslo je…“), ale jako každý model má i falešně negativní výsledky. Naopak regex spolehlivě zachytí strukturované formáty – IBAN, rodná čísla, kreditní karty – ale nic jiného. Nejlepší praxe kombinuje obojí: regex pro známé formáty a klasifikátor pro zbytek. Mezi detekované typy patří:

  • Celá jména
  • Adresy
  • Telefonní čísla
  • Rodná čísla (nebo ekvivalenty sociálního pojištění)
  • Údaje o finančních účtech

Definice společnosti Mistral se zaměřuje na žádost, sdílení nebo pokus o získání těchto identifikujících informací.

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
    }

Anonymizace před zpracováním

Anonymizace na vstupu je nejefektivnějším opatřením v celé této lekci, protože mění povahu problému: data, která nikdy neopustí tvou infrastrukturu, nevyvolávají žádné problémy s přenosem. Nahrazení jmen, e-mailů a čísel tokeny ([PERSON_1], [EMAIL_1]) před voláním modelu téměř vždy zachová význam pro analýzu – a pokud si lokálně ponecháš mapovací tabulku, můžeš skutečné hodnoty znovu vložit do odpovědi. Dokud tato tabulka existuje, jde právně o pseudonymizaci, nikoli anonymizaci: data zůstávají osobními údaji, ale data odeslaná modelu již sama o sobě neumožňují identifikaci osoby.

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}]
)

Záznamy moderace v souladu s GDPR

Záznamy (logy) jsou klasickým slepým místem: myslíme na „osobní údaje“ v souvislosti se zprávami uživatelů, ale zřídka v souvislosti s technickými stopami, které je kopírují. Přitom záznam moderace uchovávající analyzovaný text je osobní databází se všemi z toho vyplývajícími povinnostmi. Zlaté pravidlo zní: ukládej text pouze pro blokovaný obsah – budeš ho potřebovat v případě sporu – a pro přijatý obsah ukládej pouze skóre.

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
        ]

V tomto kódu stojí za zmínku dvě opatření. Klíč pro pseudonymizaci nemá žádnou výchozí hodnotu: klíč zapsaný přímo v kódu, známý všem, by umožňoval přepočítat hash jakéhokoli identifikátoru. Dále platí, že pseudonymizovaná data zůstávají podle GDPR (26. bod odůvodnění) osobními údaji: tento záznam podléhá lhůtám uchovávání a právům subjektů údajů.

Auditní stopa pro soulad s předpisy

Auditní stopa odpovídá na konkrétní otázku, kterou se tě může zeptat uživatel nebo úřad: „Proč byl tento obsah zablokován?“ Bez stopy je tvou jedinou upřímnou odpovědí „Už to nevím“ – což je neudržitelné vzhledem k tomu, že GDPR vyžaduje u plně automatizovaných rozhodnutí podle článku 22 informovat osobu o underlying logice (články 13 až 15) a nařízení o AI přidává vlastní povinnosti týkající se transparentnosti. Auditní stopa uchovává rozhodnutí, skóre, která je motivovala, a verzi použitých zásad – aniž by nutně uchovávala samotný text.

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

Kontrolní seznam GDPR pro tvou aplikaci AI

Zde jsou body, které musíš ověřit, aby byl tvůj systém moderace v souladu s předpisy:

Právní základ

  • Zdokumentovaný oprávněný zájem pro moderaci obsahu
  • Upozornění uživatele na automatizované zpracování
  • Možnost napadnout automatizované rozhodnutí

Minimalizace údajů

  • Ukládej pouze nezbytně nutná data
  • Anonymizuj nebo pseudonymizuj identifikátory uživatelů
  • Zkrať text v záznamech moderace
  • Neuchovávej přijaté texty (pouze skóre)

Doba uchovávání

  • Definuj dobu uchovávání pro každý typ údajů
  • Záznamy moderace: maximálně 90 dní (pokud právní povinnost nevyžaduje jinak)
  • Auditní stopa: podle odvětvových předpisů
  • Naplánované automatické čištění

Práva uživatelů

  • Právo na přístup k rozhodnutím o moderaci týkajícím se dané osoby
  • Právo na opravu, pokud je rozhodnutí napadeno
  • Právo na vysvětlení automatizovaného rozhodnutí

Klíčové poznatky

  • GDPR se plně vztahuje na tvé systémy moderace AI
  • Používej kategorii pii od Mistralu A SOUČASNĚ regex pro detekci osobních údajů
  • Anonymizuj texty před jejich odesláním modelu, kdykoli je to možné
  • Pseudonymizuj identifikátory uživatelů v záznamech
  • Implementuj auditní stopu pro sledovatelnost rozhodnutí
  • Definuj dobu uchovávání a automaticky maž staré záznamy