Lähe põhisisu juurde
Eesti— Vali keel
Menüü

GDPR ja andmekaitse OpenAI-ga

Õppetund 13 / 14 Värskendatud 28. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Tehisintellekt ja GDPR: Mitte läbiräägitav raamistik
  2. Seitse põhimõtet, kohandatud LLM-süsteemile
  3. Minimeerimine: meede, mis lahendab enamiku probleeme
  4. Teenuse konfigureerimine ja nõusoleku kogumine
  5. Andmesubjekti taotlustele vastamine
  6. Mõjuhinnangu formaliseerimine
  7. Peamised punktid

Tehisintellekt ja GDPR: Mitte läbiräägitav raamistik

Üldine andmekaitsemäärus (GDPR) kehtib iga rakenduse suhtes, mis töötleb Euroopa elanike isikuandmeid – sealhulgas suurte keelemudelite (LLM) baasil loodud rakenduste puhul. Tehisintellekti jaoks erandeid ei ole. See tekitab tehnilistes meeskondades sageli segadust: nad otsivad spetsiifilisi AI-määrusi, kuigi kohaldatav õigusakt on olnud jõus juba aastaid ja pole muutunud. 2026. aastal on jõustamismeetmed üha sagedamini suunatud just tehisintellekti süsteemidele. OpenAI API-de kasutamine selles kontekstis tähendab vähem uue seaduse õppimist ja rohkem tuntud õigusnõuete tõlkimist uude arhitektuuri.

Seitse põhimõtet, kohandatud LLM-süsteemile

GDPR tugineb seitsmele põhipõhimõttele, millest igaüks omandab keelemudeli töötlusahelasse kaasamisel spetsiifilise tähenduse.

Põhimõte Rakendamine AI-s
Seaduslikkus Andmete API-le saatmise õiguslik alus (nõusolek, õigustatud huvi, leping)
Andmete minimeerimine Saada ainult mudeli jaoks hädavajalikud andmed
Eesmärgi piiritletus Saadetud andmed tohivad teenida ainult deklareeritud eesmärki
Täpsus Mudeli väljundid võivad olla ebatäpsed – teavita kasutajat
Säilitamise piirang Kontrolli OpenAI säilitamispoliitikat ja kustuta andmed kliendi poolel
Turvalisus Krüpteerimine edastamisel, juurdepääsu kontroll, logide auditeerimine
Vastutus Dokumenteeri tehtud valikud ja ole võimeline tõendama vastavust

Kaks põhimõtet tabavad meeskondi sageli üllatusena. Esiteks täpsus: see muudab hallutsinatsioonid kvaliteediprobleemist regulatiivseks probleemiks. Kui mudel genereerib tuvastatud isiku kohta valeinformatsiooni, on sellel isikul õigus andmete parandamisele. Teiseks vastutus: vastavusest üksi ei piisa – sa pead olema võimeline seda tõendama. See muudab dokumentatsiooni heast tavast seaduslikuks kohustuseks.

Minimeerimine: meede, mis lahendab enamiku probleeme

Kõigist võimalikest meetmetest pakub pseudonümiseerimine enne andmete saatmist parimat tasakaalu pingutuse ja riski vähendamise vahel. Loogika on lihtne: see, mis sinu süsteemist kunagi ei lahku, ei saa lekkida alltöövõtjale, ei tekita küsimusi ülekannetel väljaspool ELi ega raskenda kustutamistaotluste täitmist.

Allpool toodud mehhanism asendab iga tuvastava andmeosa stabiilse tokeniga, hoiab vastendust kohalikus mälus ja taastab algväärtused vastuses. Lõppkasutaja näeb „hr Dupont’i“, mudel näeb ainult „[PERSON_1]“ ja teenusefunktsioon jääb täielikult toimivaks – assistent saab endiselt koostada oma vastuse, sest tal polnud tegelikku perekonnanime vaja.

Kommentaar nimede kohta pole dekoratiivne: muster püüab ainult vorme, millele eelneb tiitel. Paljas nimi libiseb läbi. Tootmiskeskkonnas võtab üle nimega üksuste tuvastamise (NER) mudel ja selle hoiatuse olemasolu koodis on parem kui vale enesekindlus.

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

Teenuse konfigureerimine ja nõusoleku kogumine

Teenusepakkuja poolel kehtib reegel: API kaudu saadetud andmeid vaikimisi koolitamiseks ei kasutata, vastupidiselt sellele, mida paljud tarbijaliideste analoogia põhjal eeldavad. See ei vabasta sind kohustusest kontrollida oma organisatsiooni seadeid platvormil ja seda kontrolli dokumenteerida.

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
)

Kasutaja poole hallatakse nõusolekut eesmärgipõhiselt, mitte globaalselt, mis selgitab siinset struktuuri: kasutaja võib nõustuda vestlusabi kasutamisega, keeldudes samal ajal oma vahetuste kasutamisest teenuse parandamiseks. Poliitika versioon salvestatakse koos nõusolekuga – kriitiline detail päeval, kui seda poliitikat uuendad. Ilma selle jäljeta ei tea sa, kes millega nõustus. Lõpuks põhjustab nõusoleku tagasivõtmine viivitamatu kustutamise, sest andmete säilitamine pärast nõusoleku tagasivõtmist on täpselt see stsenaarium, mis muudab rutiinse auditi jõustamismeetmeks.

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

Andmesubjekti taotlustele vastamine

Juurdepääsu, kustutamise ja ülekantavuse õigused tuleb rakendada enne esimese taotluse saabumist, sest ühe kuu pikkune vastamistähtaeg kaob kiiresti, kui sa alles kirjutad koodi. Juurdepääsuõigus nõuab rohkemat kui tooreid andmeid: sa pead esitama eesmärgid, alltöövõtjate loetelu ja säilitamisperioodid – info, mille konsolideerimine ette on mõistlikum.

Kustutamisõigus nõuab hoolikat koodi ülevaatust. Vastuses tehakse selge vahetus kohalike andmete vahel, mis kustutatakse viivitamatult, ja API-le saadetud andmete vahel, mille suhtes kehtib teenusepakkuja säilitamispoliitika. See ausus on kohustuslik: totaalse ja kohese kustutamise lubamine, samal ajal kui koopia jääb alltöövõtjale, seab sind suuremasse ohtu kui mõlema režiimi selge dokumenteerimine.

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

Mõjuhinnangu formaliseerimine

Iga isikuandmeid suures mahus töötleva tehisintellekti rakenduse jaoks on andmekaitse mõjuhinnang (DPIA) kohustuslik. Allpool toodud struktuur näitab oodatavaid jaotisi ja näide illustreerib, kuidas välja näeb valminud DPIA klienditeeninduse vestlusroboti jaoks.

Kaks välja tõmbavad järelevalveasutuse tähelepanu kõige rohkem. Esiteks ülekanded väljaspool ELi: kui töötlemine läbib USA teenusepakkujat, pead nimetama saaja, riigi ja rakendatud kaitsemeetme – siin on selleks tüüptingimused (SCCs), mida täiendab OpenAI andmetöötluse leping. Teiseks riskianalüüs, mis peab olema konkreetne kirjeldatud süsteemi jaoks. Näites valitud riskiks on isikuandmete lekkimine sisendi süstimise (prompt injection) kaudu, leevendusmeetmeteks andmete väljaviimise vastased tõkked ja modereerimine: kõik, mida ehitasid eelmistes peatükkides, leiab siin oma regulatiivse väljenduse.

@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",
    }],
)

Peamised punktid

  • GDPR kehtib niipea, kui AI-süsteem töötleb Euroopa elanike andmeid
  • Andmete minimeerimine (anonümiseerimine enne API-le saatmist) on esimene refleks
  • Andmesubjekti õigused (juurdepääs, kustutamine, ülekantavus) tuleb rakendada
  • Suuremahulise AI-töötluse jaoks on DPIA kohustuslik
  • Ülekanded väljaspool ELi dokumenteeritakse OpenAI DPA ja selgete kaitsemeetmete (SCCs, ülekande mõjuhinnang) kaudu