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

GDPR a ochrana osobních údajů s OpenAI

Lekce 13 z 14 Aktualizováno 28. července 2026 Pokročilý
Na této stránce
  1. AI a GDPR: Nenegotiovatelný rámec
  2. Sedm principů přeložených pro systém LLM
  3. Minimalizace: Opatření, které řeší většinu problémů
  4. Konfigurace služby a sběr souhlasu
  5. Reakce na žádosti subjektů údajů
  6. Formalizace posouzení dopadů
  7. Klíčové poznatky

AI a GDPR: Nenegotiovatelný rámec

Obecné nařízení o ochraně osobních údajů (GDPR) se vztahuje na jakoukoli aplikaci zpracovávající osobní údaje evropských rezidentů – včetně aplikací postavených na velkých jazykových modelech (LLM). Pro umělou inteligenci neexistují žádné výjimky. To často mate technické týmy: hledají specifické předpisy pro AI, přičemž příslušný text existuje již roky a nezměnil se. V roce 2026 se donucovací opatření stále častěji zaměřují na systémy AI. Používání API OpenAI v tomto kontextu znamená méně učení se novým zákonům a více překladu známých právních požadavků do nové architektury.

Sedm principů přeložených pro systém LLM

GDPR stojí na sedmi základních principech, z nichž každý nabývá specifického významu, když se do řetězce zpracování zapojí jazykový model.

Princip Aplikace v AI
Zákonnost Právní základ pro odeslání dat do API (souhlas, oprávněný zájem, smlouva)
Minimalizace údajů Odesílejte pouze data nezbytně nutná pro model
Omezení účelu Odeslaná data musí sloužit pouze deklarovanému účelu
Přesnost Výstupy modelu mohou být nepřesné – informujte uživatele
Omezení uložení Zkontrolujte zásady uchovávání OpenAI a mažte data na straně klienta
Bezpečnost Šifrování při přenosu, řízení přístupu, audit logů
Odpovědnost Dokumentujte svá rozhodnutí a buďte schopni prokázat soulad

Dva principy týmy pravidelně zaskočí. Zaprvé přesnost: ta mění halucinace z problému kvality na problém regulace. Když model vygeneruje nepravdivé informace o identifikované osobě, má tato osoba právo na opravu. Zadruhé odpovědnost: nestačí být v souladu s předpisy – musíte to umět prokázat. To mění dokumentaci z osvědčeného postupu na právní povinnost.

Minimalizace: Opatření, které řeší většinu problémů

Ze všech dostupných opatření nabízí pseudonymizace před odesláním dat nejlepší rovnováhu mezi vynaloženým úsilím a snížením rizika. Logika je jednoduchá: to, co nikdy neopustí váš systém, nemůže uniknout subdodavateli, nevyvolá otázky při přenosech mimo EU a nezkomplicuje žádosti o výmaz.

Níže uvedený mechanismus nahrazuje každý identifikační údaj stabilním tokenem, udržuje mapování v lokální paměti a obnovuje původní hodnoty v odpovědi. Koncový uživatel vidí „pan Dupont“, model vidí pouze „[PERSON_1]“ a servisní funkce zůstává plně funkční – asistent může stále formulovat svou odpověď, protože nikdy nepotřeboval skutečné příjmení.

Komentář u jmen není dekorativní: vzorec zachycuje pouze tvary předcházené titulem. Holé jméno projde. V produkčním prostředí převezme práci model rozpoznávání pojmenovaných entit (NER) a mít toto varování explicitně v kódu je lepší než falešná jistota.

import re

class DataMinimizer:
    """Anonymizes personal data before sending to the API."""

    def __init__(self):
        self.mappings: dict[str, str] = {}
        self.counter = 0

    def anonymize(self, text: str) -> str:
        """Replaces personal data with placeholders."""
        # Emails
        text = re.sub(
            r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
            lambda m: self._replace(m.group(), "EMAIL"),
            text,
        )
        # French phone numbers
        text = re.sub(
            r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
            lambda m: self._replace(m.group(), "PHONE"),
            text,
        )
        # Names (simplified pattern—use NER in production)
        text = re.sub(
            r"\b(Mr\.|Ms\.|Dr\.)\s+[A-Z][a-zéèêë]+\s+[A-Z][a-zéèêë]+\b",
            lambda m: self._replace(m.group(), "PERSON"),
            text,
        )
        # IBAN
        text = re.sub(
            r"\b[A-Z]{2}\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{0,4}\b",
            lambda m: self._replace(m.group(), "IBAN"),
            text,
        )
        return text

    def _replace(self, value: str, type_: str) -> str:
        if value not in self.mappings:
            self.counter += 1
            self.mappings[value] = f"[{type_}_{self.counter}]"
        return self.mappings[value]

    def deanonymize(self, text: str) -> str:
        """Restores original data in the response."""
        reverse = {v: k for k, v in self.mappings.items()}
        for placeholder, original in reverse.items():
            text = text.replace(placeholder, original)
        return text

# Usage
minimizer = DataMinimizer()

original_message = "Mr. Dupont ([email protected], 06 12 34 56 78) requests a refund."
anonymized_message = minimizer.anonymize(original_message)
print(f"Sent to API: {anonymized_message}")
# "[PERSON_1] ([EMAIL_1], [PHONE_1]) requests a refund."

# After model response
model_response = "The file for [PERSON_1] has been processed. An email was sent to [EMAIL_1]."
final_response = minimizer.deanonymize(model_response)
print(f"Final response: {final_response}")

Konfigurace služby a sběr souhlasu

Na straně poskytovatele platí toto pravidlo: data odeslaná přes API se ve výchozím nastavení nepoužívají pro trénování, na rozdíl od toho, co si mnozí myslí podle analogie se spotřebitelskými rozhraními. To vás však nezbavuje povinnosti zkontrolovat nastavení vaší organizace na platformě a tuto kontrolu zdokumentovat.

from openai import OpenAI

# With the API, your data is NOT used for training by default
# But verify your organization settings on platform.openai.com

client = OpenAI()

# The Responses API endpoint respects the retention policy
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Hello"}],
    # store=False disables storage on OpenAI's side if available
)

Na straně uživatele se souhlas spravuje podle účelu, nikoliv globálně, což vysvětluje zdejší strukturu: uživatel může přijmout konverzační asistenci, ale odmítnout využití svých výměn ke zlepšení služby. Verze zásad se ukládá společně se souhlasem – což je kritický detail pro den, kdy tyto zásady aktualizujete. Bez této stopy nebudete vědět, kdo s čím souhlasil. Nakonec odvolání souhlasu spouští okamžitý výmaz, protože uchovávání dat po odvolání je přesně scénář, který mění rutinní audit na donucovací akci.

class ConsentManager:
    """Manages user consent for AI processing."""

    def __init__(self):
        self.consent_records: dict[str, dict] = {}

    def record_consent(self, user_id: str, purposes: list[str]):
        """Records explicit user consent."""
        from datetime import datetime
        self.consent_records[user_id] = {
            "purposes": purposes,
            "date": datetime.now().isoformat(),
            "policy_version": "v2.1",
            "method": "explicit_checkbox",
        }

    def verify_consent(self, user_id: str, purpose: str) -> bool:
        """Checks if the user has consented to a specific purpose."""
        if user_id not in self.consent_records:
            return False
        return purpose in self.consent_records[user_id]["purposes"]

    def withdraw_consent(self, user_id: str):
        """Withdraws consent and triggers data deletion."""
        if user_id in self.consent_records:
            del self.consent_records[user_id]
            self._delete_data(user_id)

    def _delete_data(self, user_id: str):
        """Deletes all data associated with the user."""
        # Delete conversation history
        # Delete logs containing personal data
        # Notify subprocessors (OpenAI) if applicable
        print(f"Data deleted for {user_id}")

Reakce na žádosti subjektů údajů

Práva na přístup, výmaz a přenositelnost musíte implementovat dříve, než dorazí první žádost, protože měsíční lhůta pro odpověď rychle uběhne, pokud teprve píšete kód. Právo na přístup vyžaduje více než jen raw data: musíte poskytnout účely, seznam subdodavatelů a doby uchovávání – informace, které je lepší konsolidovat předem.

Právo na výmaz vyžaduje pečlivou revizi kódu. Odpověď explicitně rozlišuje mezi lokálními daty, která se mažou okamžitě, a daty odeslanými do API, která podléhají zásadám uchovávání poskytovatele. Tato upřímnost je povinná: slibovat totální, okamžitý výmaz, zatímco kopie zůstává u subdodavatele, vás vystavuje většímu riziku než jasné zdokumentování obou režimů.

class DataSubjectRights:
    """Implements GDPR rights for users."""

    def right_of_access(self, user_id: str) -> dict:
        """Returns all data held on the user."""
        return {
            "personal_data": self._collect_data(user_id),
            "processing_purposes": ["customer_support", "service_improvement"],
            "subprocessors": ["OpenAI (LLM API)", "PostgreSQL (storage)"],
            "retention_period": "12 months after last activity",
            "source": "Direct user input",
        }

    def right_to_erasure(self, user_id: str) -> dict:
        """Deletes all user data."""
        # Delete from local database
        deleted_local = self._delete_local(user_id)
        # Data sent to OpenAI API is subject
        # to their retention policy (max 30 days via API)
        return {
            "status": "deleted",
            "local_data": "deleted",
            "openai_data": "subject to 30-day retention",
            "date": datetime.now().isoformat(),
        }

    def right_to_portability(self, user_id: str) -> dict:
        """Exports data in a structured format."""
        data = self._collect_data(user_id)
        return {
            "format": "JSON",
            "data": data,
            "export_date": datetime.now().isoformat(),
        }

    def _collect_data(self, user_id: str) -> dict:
        return {"user_id": user_id, "conversations": [], "profile": {}}

    def _delete_local(self, user_id: str) -> int:
        return 0

Formalizace posouzení dopadů

Pro jakoukoli aplikaci AI zpracovávající osobní údaje ve velkém rozsahu je povinné provedení posouzení dopadů na ochranu osobních údajů (DPIA). Níže uvedená struktura ukazuje očekávané sekce a příklad ilustruje, jak vypadá dokončené DPIA pro chatbot zákaznické podpory.

Dvě pole přitahují největší pozornost dozorového úřadu. Zaprvé přenosy mimo EU: kdykoli zpracování prochází přes poskytovatele z USA, musíte uvést příjemce, zemi a invoked záruku – zde Standardní smluvní doložky (SCC) doplněné Dohodou o zpracování údajů (DPA) od OpenAI. Zadruhé analýza rizik, která musí být specifická pro popisovaný systém. Riziko vybrané v příkladu je únik osobních údajů prostřednictvím injektáže promptu, přičemž zmírňujícími opatřeními jsou ochranné mechanismy proti exfiltraci a moderování: vše, co jste vybudovali v předchozích kapitolách, zde nachází svůj regulační překlad.

@dataclass
class ImpactAssessment:
    """Structure of a DPIA for an AI system."""
    processing_name: str
    description: str
    legal_basis: str
    data_processed: list[str]
    recipients: list[str]
    transfers_outside_eu: list[dict]
    security_measures: list[str]
    risks: list[dict]
    dpo_opinion: str = ""

dpia_chatbot = ImpactAssessment(
    processing_name="Customer Service Chatbot with AI",
    description="Conversational assistant using GPT-5.6 Sol via OpenAI API",
    legal_basis="Legitimate interest (customer support)",
    data_processed=["first_name", "email", "order_history", "chat_messages"],
    recipients=["Support team", "OpenAI (API subprocessor)"],
    transfers_outside_eu=[{
        "recipient": "OpenAI Inc.",
        "country": "United States",
        "safeguard": "Standard Contractual Clauses (SCCs) + OpenAI DPA",
    }],
    security_measures=[
        "Anonymization before sending to API",
        "TLS encryption in transit",
        "Access logs with 90-day retention",
        "Right to erasure implemented",
    ],
    risks=[{
        "description": "Personal data leakage via prompt injection",
        "likelihood": "medium",
        "severity": "high",
        "mitigation": "Anti-exfiltration guardrails + moderation",
    }],
)

Klíčové poznatky

  • GDPR se uplatní, jakmile systém AI zpracovává data evropských rezidentů
  • Minimalizace údajů (anonymizace před odesláním do API) je první reflexí
  • Práva subjektů údajů (přístup, výmaz, přenositelnost) musí být implementována
  • DPIA je povinné pro zpracování AI ve velkém rozsahu
  • Přenosy mimo EU jsou dokumentovány prostřednictvím DPA od OpenAI a explicitních záruk (SCC, posouzení dopadu přenosu)