Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

GDPR in varstvo podatkov z OpenAI

Lekcija 13 od 14 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Umetna inteligenca in GDPR: Okvir, ki ni predmet pogajanj
  2. Sedem načel, prilagojenih za sistem LLM
  3. Minimizacija: Ukrepi, ki rešijo večino težav
  4. Konfiguracija storitve in zbiranje privolitve
  5. Odzivanje na zahteve posameznikov, na katere se nanašajo podatki
  6. Formalizacija ocene učinka
  7. Ključne ugotovitve

Umetna inteligenca in GDPR: Okvir, ki ni predmet pogajanj

Splošna uredba o varstvu podatkov (GDPR) velja za vsako aplikacijo, ki obdeluje osebne podatke evropskih prebivalcev – vključno z aplikacijami, zgrajenimi na velikih jezikovnih modelih (LLM). Za umetno inteligenco ni izjem. To pogosto zmede tehnične ekipe: iščejo predpise, specifične za AI, čeprav je veljavno besedilo obstajalo že leta in se ni spremenilo. Leta 2026 se izvršilni ukrepi vse bolj usmerjajo v sisteme umetne inteligence. Uporaba API-jev OpenAI v tem kontekstu pomeni manj učenja novih zakonov in več prevajanja znanih pravnih zahtev v novo arhitekturo.

Sedem načel, prilagojenih za sistem LLM

GDPR temelji na sedmih osnovnih načelih, od katerih vsako dobi specifičen pomen, ko v verigo obdelave vstopi jezikovni model.

Načelo Uporaba pri AI
Zakonitost Pravna podlaga za pošiljanje podatkov v API (privolitev, zakoniti interes, pogodba)
Minimizacija podatkov Pošljite le podatke, ki so strogo potrebni za model
Omejitev namena Poslani podatki smejo služiti le deklariranemu namenu
Točnost Izhodi modela so lahko netočni – obvestite uporabnika
Omejitev hrambe Preverite pravilnik o hrambi pri OpenAI in brišite na strani odjemalca
Varnost Šifriranje med prenosom, nadzor dostopa, revizija dnevnikov
Odgovornost Dokumentirajte izbire in bodite sposobni dokazati skladnost

Dve načeli ekipi pogosto presenetita. Prvo je točnost: halucinacije tako iz težave kakovosti postanejo regulativna težava. Ko model ustvari napačne informacije o identificirani osebi, ima ta oseba pravico do popravka. Drugo je odgovornost: skladnost ni dovolj – dokazati jo morate. To dokumentacijo spremeni iz dobre prakse v pravno obveznost.

Minimizacija: Ukrepi, ki rešijo večino težav

Med vsemi razpoložljivimi ukrepi psevdonimizacija pred pošiljanjem podatkov ponuja najboljše ravnovesje med vloženim trudom in zmanjšanjem tveganja. Logika je preprosta: kar nikoli ne zapusti vašega sistema, ne more uhajati podizvajalcem, ne more sprožati vprašanj med prenosi zunaj EU in ne bo zapletlo zahtevkov za izbris.

Spodnji mehanizem vsak kos identificirajočih podatkov nadomesti s stabilnim žetonom, preslikavo hrani v lokalnem pomnilniku in v odgovoru obnovi izvirne vrednosti. Končni uporabnik vidi „g. Dupont”, model vidi le „[OSEBA_1]”, storitvena funkcija pa ostane popolnoma nedotaknjena – asistent lahko še vedno sestavi odgovor, saj dejanskega priimka nikoli ni potreboval.

Komentar pri imenih ni okrasen: vzorec zajema le oblike, ki jim sledi naslov. Golo ime bo ušlo. V produkcijskem okolju prevzame model za prepoznavanje poimenovanih entitet (NER), in having to opozorilo eksplicitno v kodi je bolje od lažnega zaupanja.

import re

class DataMinimizer:
    """Anonimizira osebne podatke pred pošiljanjem v API."""

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

    def anonymize(self, text: str) -> str:
        """Nadomesti osebne podatke z nadomestki."""
        # E-poštni naslovi
        text = re.sub(
            r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
            lambda m: self._replace(m.group(), "EMAIL"),
            text,
        )
        # Francoske telefonske številke
        text = re.sub(
            r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
            lambda m: self._replace(m.group(), "PHONE"),
            text,
        )
        # Imena (poenostavljen vzorec – v produkciji uporabite 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:
        """Obnovi izvirne podatke v odgovoru."""
        reverse = {v: k for k, v in self.mappings.items()}
        for placeholder, original in reverse.items():
            text = text.replace(placeholder, original)
        return text

# Uporaba
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 odgovoru modela
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}")

Konfiguracija storitve in zbiranje privolitve

Na strani ponudnika si zapomni to pravilo: podatki, poslani prek API-ja, se privzeto ne uporabljajo za usposabljanje, kar je v nasprotju s tem, kar mnogi domnevajo po analogiji z uporabniškimi vmesniki za potrošnike. To te ne odvezuje preverjanja nastavitev tvoje organizacije na platformi in dokumentiranja tega preverjanja.

from openai import OpenAI

# Z API-jem vaši podatki PRIVZETO NISO uporabljeni za usposabljanje
# Vendar preverite nastavitve svoje organizacije na platform.openai.com

client = OpenAI()

# Končna točka Responses API spoštuje pravilnik o hrambi
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Hello"}],
    # store=False onemogoči shranjevanje na strani OpenAI, če je na voljo
)

Na strani uporabnika se privolitev upravlja po namenu, ne globalno, kar pojasnjuje tukajšnjo strukturo: uporabnik lahko sprejme konverzacijsko pomoč, medtem ko zavrne uporabo svojih izmenjav za izboljšavo storitve. Različica pravilnika se zabeleži skupaj s privolitvijo – kritična podrobnost za dan, ko posodobite ta pravilnik. Brez te sledi ne boste vedeli, kdo se je s čim strinjal. Končno, umik sproži takojšen izbris, saj je hramba podatkov po umiku točno scenarij, ki rutinsko revizijo spremeni v izvršilni ukrep.

class ConsentManager:
    """Upravlja uporabniško privolitev za obdelavo z AI."""

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

    def record_consent(self, user_id: str, purposes: list[str]):
        """Zabeleži izrecno uporabniško privolitev."""
        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:
        """Preveri, ali je uporabnik privolil v določen namen."""
        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):
        """Umakne privolitev in sproži izbris podatkov."""
        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):
        """Izbriše vse podatke, povezane z uporabnikom."""
        # Izbriši zgodovino pogovorov
        # Izbriši dnevnike, ki vsebujejo osebne podatke
        # Obvesti podizvajalce (OpenAI), če je potrebno
        print(f"Data deleted for {user_id}")

Odzivanje na zahteve posameznikov, na katere se nanašajo podatki

Pravice do dostopa, izbrisa in prenosljivosti morajo biti implementirane, preden prispe prva zahteva, saj enomesečni rok za odgovor hitro mine, ko še vedno pišete kodo. Pravica do dostopa zahteva več kot surove podatke: zagotoviti morate namene, seznam podizvajalcev in obdobja hrambe – informacije, ki jih je bolje konsolidirati vnaprej.

Pravica do izbrisa zahteva previden pregled kode. Odgovor eksplicitno razlikuje med lokalnimi podatki, ki se izbrišejo takoj, in podatki, poslanimi v API, ki spadajo pod pravilnik o hrambi ponudnika. Ta poštenost je obvezna: obljuba popolnega, takojšnjega izbrisa, medtem ko kopija ostane pri podizvajalcu, vas izpostavi bolj kot jasna dokumentacija obeh režimov.

class DataSubjectRights:
    """Implementira pravice GDPR za uporabnike."""

    def right_of_access(self, user_id: str) -> dict:
        """Vrne vse podatke, ki jih hranimo o uporabniku."""
        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:
        """Izbriše vse uporabniške podatke."""
        # Izbriši iz lokalne baze podatkov
        deleted_local = self._delete_local(user_id)
        # Podatki, poslani v API OpenAI, so predmet
        # njihovega pravilnika o hrambi (največ 30 dni prek API-ja)
        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:
        """Izvozi podatke v strukturirani obliki."""
        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

Formalizacija ocene učinka

Za vsako aplikacijo umetne inteligence, ki obdeluje osebne podatke v velikem obsegu, je ocena učinka na varstvo podatkov (DPIA) obvezna. Spodnja struktura prikazuje pričakovane razdelke, primer pa ilustrira, kako izgleda izpolnjena DPIA za klepetalnega bota za podporo strankam.

Dve polji pritegneta največ pozornosti nadzornega organa. Prvo so prenosi zunaj EU: kadar koli obdelava poteka prek ameriškega ponudnika, morate navesti prejemnika, državo in invoked zaščito – tukaj standardne pogodbene določbe (SCC), dopolnjene s pogodbo o obdelavi podatkov (DPA) pri OpenAI. Drugo je analiza tveganj, ki mora biti specifična za opisani sistem. Tveganje, izbrano v primeru, je uhajanje osebnih podatkov prek vbrizgavanja pozivov (prompt injection), ukrepi za ublažitev pa so zaščitne ograje proti izločanju podatkov in moderiranje: vse, kar ste zgradili v prejšnjih poglavjih, tu najde svoj regulativni prevod.

@dataclass
class ImpactAssessment:
    """Struktura DPIA za sistem 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",
    }],
)

Ključne ugotovitve

  • GDPR velja takoj, ko sistem AI obdeluje podatke evropskih prebivalcev
  • Minimizacija podatkov (anonimizacija pred pošiljanjem v API) je prvi refleks
  • Pravice posameznikov, na katere se nanašajo podatki (dostop, izbris, prenosljivost), morajo biti implementirane
  • DPIA je obvezna za obdelavo z AI v velikem obsegu
  • Prenosi zunaj EU so dokumentirani prek DPA pri OpenAI in eksplicitnih zaščitnih ukrepov (SCC, ocena učinka prenosa)