Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

GDPR a ochrana údajov s OpenAI

Lekcia 13 z 14 Aktualizované 28. júla 2026 Pokročilý
Na tejto strane
  1. AI a GDPR: Rámec, ktorý nie je možné obísť
  2. Sedem zásad preložených pre systém LLM
  3. Minimalizácia: Opatrenie, ktoré rieši väčšinu problémov
  4. Konfigurácia služby a získanie súhlasu
  5. Reagovanie na žiadosti dotknutých osôb
  6. Formalizácia posúdenia vplyvu
  7. Kľúčové poznatky

AI a GDPR: Rámec, ktorý nie je možné obísť

Všeobecné nariadenie o ochrane údajov (GDPR) sa vzťahuje na každú aplikáciu spracúvajúcu osobné údaje európskych rezidentov – vrátane aplikácií postavených na veľkých jazykových modeloch (LLM). Pre umelú inteligenciu neexistujú žiadne výnimky. To často mätie technické tímy: hľadajú špecifické predpisy pre AI, hoci príslušný text existuje už roky a nezmenil sa. V roku 2026 sa donucovacie opatrenia čoraz častejšie zameriavajú na systémy umelej inteligencie. Používanie API od OpenAI v tomto kontexte znamená menej učenia sa nových zákonov a skôr preklad známych právnych požiadaviek do novej architektúry.

Sedem zásad preložených pre systém LLM

GDPR stojí na siedmich základných zásadách, z ktorých každá nadobúda špecifický význam, keď sa do reťazca spracovania zapojí jazykový model.

Zásada Aplikácia v AI
Zákonnosť Právny základ pre odoslanie údajov do API (súhlas, oprávnený záujem, zmluva)
Minimalizácia údajov Odoslať iba údaje striktne potrebné pre model
Obmedzenie účelu Odoslané údaje musia slúžiť iba deklarovanému účelu
Správnosť Výstupy modelu môžu byť nepresné – informujte používateľa
Obmedzenie uchovávania Skontrolujte zásady uchovávania OpenAI a údaje mažte na strane klienta
Bezpečnosť Šifrovanie počas prenosu, kontrola prístupu, audit logov
Zodpovednosť Dokumentujte svoje rozhodnutia a buďte schopní preukázať súlad

Dve zásady tímy pravidelne zaskočia. Po prvé, správnosť: tá mení halucinácie z problému kvality na regulačný problém. Keď model vygeneruje nepravdivé informácie o identifikovanej osobe, táto osoba má právo na opravu. Po druhé, zodpovednosť: byť v súlade nestačí – musíte to vedieť aj preukázať. To mení dokumentáciu z odporúčanej praxe na právnu povinnosť.

Minimalizácia: Opatrenie, ktoré rieši väčšinu problémov

Zo všetkých dostupných opatrení ponúka pseudonymizácia pred odoslaním údajov najlepšiu rovnováhu medzi vynaloženým úsilím a znížením rizika. Logika je jednoduchá: to, čo nikdy neopustí váš systém, nemôže uniknúť k subdodávateľovi, nespôsobí otázky pri prenosoch mimo EÚ a nekomplikuje žiadosti o vymazanie.

Nižšie uvedený mechanizmus nahradí každý kus identifikujúcich údajov stabilným tokenom, uchováva mapovanie v lokálnej pamäti a obnoví pôvodné hodnoty v odpovedi. Koncový používateľ vidí „pán Dupont“, model vidí iba „[PERSON_1]“ a servisná funkcia zostáva plne funkčná – asistent môže stále zostaviť svoju odpoveď, pretože nikdy nepotreboval skutočné priezvisko.

Komentár k menám nie je dekoratívny: vzor zachytáva iba formy predchádzané titulom. Holé meno prejde cez filter. V produkcii preberá úlohu model rozpoznávania pomenovaných entít (NER) a mať toto varovanie explicitne v kóde je lepšie než falošná istota.

import re

class DataMinimizer:
    """Anonymizuje osobné údaje pred odoslaním do API."""

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

    def anonymize(self, text: str) -> str:
        """Nahradí osobné údaje zástupnými symbolmi."""
        # E-maily
        text = re.sub(
            r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
            lambda m: self._replace(m.group(), "EMAIL"),
            text,
        )
        # Francúzske telefónne čísla
        text = re.sub(
            r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
            lambda m: self._replace(m.group(), "PHONE"),
            text,
        )
        # Mená (zjednodušený vzor – v produkcii použite NER)
        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:
        """Obnoví pôvodné údaje v odpovedi."""
        reverse = {v: k for k, v in self.mappings.items()}
        for placeholder, original in reverse.items():
            text = text.replace(placeholder, original)
        return text

# Použitie
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."

# Po odpovedi modelu
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}")

Konfigurácia služby a získanie súhlasu

Na strane poskytovateľa si zapamätaj toto pravidlo: údaje odoslané cez API sa predvolene nepoužívajú na trénovanie, na rozdiel od toho, čo si mnohí myslia podľa analógie so spotrebiteľskými rozhraniami. To ťa však neoslobodzuje od kontroly nastavení tvojej organizácie na platforme a zdokumentovania tejto overenia.

from openai import OpenAI

# S API sa vaše údaje predvolene NEPOUŽÍVAJÚ na trénovanie
# Overte si však nastavenia svojej organizácie na platform.openai.com

client = OpenAI()

# Koncový bod Responses API rešpektuje zásady uchovávania
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Hello"}],
    # store=False vypne ukladanie na strane OpenAI, ak je dostupné
)

Na strane používateľa sa súhlas spravuje podľa účelu, nie globálne, čo vysvetľuje túto štruktúru: používateľ môže prijať konverzačnú asistenciu, ale odmietnuť, aby sa jeho výmeny použili na zlepšenie služby. Verzia zásad sa zaznamenáva spolu so súhlasom – kritický detail pre deň, keď tieto zásady aktualizujete. Bez tejto stopy nebudete vedieť, kto s čím súhlasil. Nakoniec, odvolanie súhlasu spúšťa okamžité vymazanie, pretože uchovávanie údajov po odvolaní je presne scenár, ktorý mení bežný audit na donucovacie konanie.

class ConsentManager:
    """Spravuje súhlas používateľa so spracovaním AI."""

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

    def record_consent(self, user_id: str, purposes: list[str]):
        """Zaznamená výslovný súhlas používateľa."""
        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:
        """Skontroluje, či používateľ súhlasil s konkrétnym účelom."""
        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):
        """Odvolá súhlas a spustí vymazanie údajov."""
        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):
        """Vymaže všetky údaje spojené s používateľom."""
        # Vymazať históriu konverzácií
        # Vymazať logy obsahujúce osobné údaje
        # Upovedomiť subdodávateľov (OpenAI), ak je to vhodné
        print(f"Data deleted for {user_id}")

Reagovanie na žiadosti dotknutých osôb

Práva na prístup, vymazanie a prenosnosť musia byť implementované skôr, než príde prvá žiadosť, pretože jednomesačná lehota na odpoveď rýchlo ubehne, keď ešte len píšete kód. Právo na prístup si vyžaduje viac než len surové údaje: musíte poskytnúť účely, zoznam subdodávateľov a lehoty uchovávania – informácie, ktoré je lepšie konsolidovať vopred.

Právo na vymazanie si vyžaduje starostlivú kontrolu kódu. Odpoveď explicitne rozlišuje medzi lokálnymi údajmi, ktoré sa vymažú okamžite, a údajmi odoslanými do API, ktoré podliehajú zásadám uchovávania poskytovateľa. Táto úprimnosť je povinná: sľubovať úplné, okamžité vymazanie, zatiaľ čo kópia zostáva u subdodávateľa, vás vystavuje väčšiemu riziku než jasné zdokumentovanie oboch režimov.

class DataSubjectRights:
    """Implementuje práva GDPR pre používateľov."""

    def right_of_access(self, user_id: str) -> dict:
        """Vráti všetky údaje uchovávané o používateľovi."""
        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:
        """Vymaže všetky údaje používateľa."""
        # Vymazať z lokálnej databázy
        deleted_local = self._delete_local(user_id)
        # Údaje odoslané do OpenAI API podliehajú
        # ich zásadám uchovávania (max. 30 dní cez 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:
        """Exportuje údaje v štruktúrovanom formáte."""
        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

Formalizácia posúdenia vplyvu

Pre každú aplikáciu umelej inteligencie spracúvajúcu osobné údaje vo veľkom rozsahu je povinné posúdenie vplyvu na ochranu údajov (DPIA). Nižšie uvedená štruktúra ukazuje očakávané sekcie a príklad ilustruje, ako vyzerá dokončené DPIA pre chatbot zákazníckej podpory.

Dve polia priťahujú väčšinu pozornosti dozorného orgánu. Po prvé, prenosy mimo EÚ: kedykoľvek sa spracovanie realizuje cez poskytovateľa z USA, musíte uviesť príjemcu, krajinu a uplatnenú záruku – v tomto prípade štandardné zmluvné doložky (SCC) doplnené o zmluvu o spracovaní údajov (DPA) od OpenAI. Po druhé, analýza rizík, ktorá musí byť špecifická pre opisovaný systém. Riziko vybrané v príklade je únik osobných údajov cez vstrekovanie promptov (prompt injection), pričom zmierňujúcimi opatreniami sú ochranné mechanizmy proti exfiltrácii a moderovanie: všetko, čo ste vybudovali v predchádzajúcich kapitolách, tu nachádza svoj regulačný preklad.

@dataclass
class ImpactAssessment:
    """Štruktúra DPIA pre systém AI."""
    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",
    }],
)

Kľúčové poznatky

  • GDPR sa uplatňuje hneď, ako systém AI spracúva údaje európskych rezidentov
  • Minimalizácia údajov (anonymizácia pred odoslaním do API) je prvým reflexom
  • Práva dotknutých osôb (prístup, vymazanie, prenosnosť) musia byť implementované
  • DPIA je povinné pre spracovanie AI vo veľkom rozsahu
  • Prenosy mimo EÚ sú dokumentované prostredníctvom DPA od OpenAI a explicitných záruk (SCC, posúdenie vplyvu prenosu)