Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

GDPR ir duomenų apsauga naudojant „OpenAI“

Paskaita 13 iš 14 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. DI ir BDAR: nepraleidžiamas pagrindas
  2. Septyni principai, pritaikyti LLM sistemai
  3. Duomenų mažinimas: priemonė, išsprendžianti daugumą problemų
  4. Sukonfigūruokite paslaugą ir gaukite sutikimą
  5. Atsakymas į duomenų subjektų prašymus
  6. Formalizuokite poveikio vertinimą
  7. Svarbiausi punktai

DI ir BDAR: nepraleidžiamas pagrindas

Bendrasis duomenų apsaugos reglamentas (BDAR) taikomas bet kuriai programai, apdorojančiai Europos gyventojų asmens duomenis – įskaitant programas, sukurtas naudojant didžiuosius kalbos modelius (LLM). Dirbtiniam intelektui išimčių nėra. Tai dažnai klaidina technines komandas: jos ieško specialiai DI skirtų taisyklių, nors taikytinas teisės aktas galioja jau daugelį metų ir nesikeičia. 2026 m. vykdymo užtikrinimo veiksmai vis dažniau nukreipti į DI sistemas. „OpenAI“ API naudojimas šiuo atveju reiškia ne naujų įstatymų mokymąsi, o žinomų teisinių reikalavimų perkėlimą į naują architektūrą.

Septyni principai, pritaikyti LLM sistemai

BDAR grindžiamas septyniais pagrindiniais principais, kurių kiekvienas įgauna specifinę prasmę, kai į duomenų apdorojimo grandinę įtraukiamas kalbos modelis.

Principas Taikymas DI
Teisėtumas Teisinis pagrindas siųsti duomenis į API (sutikimas, teisėtas interesas, sutartis)
Duomenų mažinimas Siųsti tik modeliuoti būtiniausius duomenis
Tikslo apribojimas Siunčiami duomenys turi būti naudojami tik deklaruotam tikslui
Tikslumas Modelio atsakymai gali būti netikslūs – informuokite naudotoją
Saugojimo apribojimas Patikrinkite „OpenAI“ saugojimo politiką ir ištrinkite duomenis kliento pusėje
Saugumas Šifravimas perduodant, prieigos kontrolė, žurnalų auditas
Atskaitomybė Dokumentuokite sprendimus ir gebėkite įrodyti atitiktį

Du principai komandas dažnai nustebina. Pirma, tikslumas: dėl to haliucinacijos tampa ne tik kokybės, bet ir reguliavimo problema. Kai modelis sugeneruoja klaidingą informaciją apie identifikuotą asmenį, tas asmuo turi teisę į duomenų ištaisymą. Antra, atskaitomybė: nepakanka būti atitinkančiam reikalavimus – tai reikia įrodyti. Tai dokumentavimą paverčia iš gerosios praktikos į teisinę prievolę.

Duomenų mažinimas: priemonė, išsprendžianti daugumą problemų

Iš visų galimų priemonių pseudonimizavimas prieš siunčiant duomenis suteikia geriausią pusiausvyrą tarp pastangų ir rizikos mažinimo. Logika paprasta: tai, kas niekada neišeina iš jūsų sistemos, negali nutekėti subrangovui, nekyla klausimų perduodant duomenis už ES ribų ir nesudėtingina ištrynimo prašymų.

Toliau pateiktas mechanizmas kiekvieną identifikuojantį duomenį pakeičia stabiliu žymeniu, atvaizdavimą saugo vietinėje atmintyje ir atsakyme atkuria originalias reikšmes. Galutinis naudotojas mato „poną Dupont“, modelis mato tik „[ASMUO_1]“, o paslaugos funkcija lieka visiškai veikianti – asistentas vis tiek gali suformuluoti atsakymą, nes jam nereikėjo tikros pavardės.

Komentaras apie vardus nėra dekoratyvinis: šablonas fiksuoja tik formas, prieš kurias yra titulas. Vienas vardas praslys pro filtrą. Gamtinėje aplinkoje perima vardinų entitetų atpažinimo (NER) modelis, o šio įspėjimo buvimas kode yra geriau nei klaidingas pasitikėjimas.

import re

class DataMinimizer:
    """Anonimizuoja asmens duomenis prieš siunčiant į API."""

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

    def anonymize(self, text: str) -> str:
        """Pakeičia asmens duomenis vietiniais žymenimis."""
        # El. paštai
        text = re.sub(
            r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
            lambda m: self._replace(m.group(), "EMAIL"),
            text,
        )
        # Prancūzijos telefono numeriai
        text = re.sub(
            r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
            lambda m: self._replace(m.group(), "PHONE"),
            text,
        )
        # Vardai (supaprastintas šablonas – gamyboje naudokite 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:
        """Atkuria originalius duomenis atsakyme."""
        reverse = {v: k for k, v in self.mappings.items()}
        for placeholder, original in reverse.items():
            text = text.replace(placeholder, original)
        return text

# Naudojimas
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 modelio atsakymo
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}")

Sukonfigūruokite paslaugą ir gaukite sutikimą

Tiekėjo pusėje įsiminkite šią taisyklę: per API siunčiami duomenys pagal nutylėjimą nėra naudojami mokymui, priešingai nei daugelis mano, lygindami su vartotojo sąsajomis. Tai neatleidžia jūsų nuo pareigos patikrinti savo organizacijos nustatymų platformoje ir užfiksuoti tą patikrinimą.

from openai import OpenAI

# Naudojant API, jūsų duomenys pagal nutylėjimą NĖRA naudojami mokymui
# Bet patikrinkite savo organizacijos nustatymus platform.openai.com

client = OpenAI()

# „Responses“ API galinis taškas laikosi saugojimo politikos
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Hello"}],
    # store=False išjungia saugojimą „OpenAI“ pusėje, jei tai galima
)

Naudotojo pusėje sutikimas valdomas pagal tikslą, o ne globaliai, todėl čia matoma tokia struktūra: naudotojas gali sutikti su pokalbių pagalba, bet atsisakyti, kad jo susirašinėjimai būtų naudojami paslaugai gerinti. Politikos versija įrašoma kartu su sutikimu – tai kritinė detalė tą dieną, kai atnaujinsite tą politiką. Be šio pėdsako nežinosite, kas ir kam pritarė. Galiausiai, sutikimo atšaukimas sukelia neatidėliotiną duomenų ištrynimą, nes duomenų saugojimas po sutikimo atšaukimo yra būtent tas scenarijus, kuris įprastą auditą paverčia vykdymo užtikrinimo veiksmu.

class ConsentManager:
    """Valdo naudotojo sutikimą DI apdorojimui."""

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

    def record_consent(self, user_id: str, purposes: list[str]):
        """Įrašo aiškų naudotojo sutikimą."""
        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:
        """Patikrina, ar naudotojas davė sutikimą konkrečiam tikslui."""
        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):
        """Atšaukia sutikimą ir inicijuoja duomenų ištrynimą."""
        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):
        """Ištrina visus su naudotoju susijusius duomenis."""
        # Ištrinti pokalbių istoriją
        # Ištrinti žurnalus, kuriuose yra asmens duomenų
        # Pranešti subrangovams („OpenAI“), jei taikoma
        print(f"Data deleted for {user_id}")

Atsakymas į duomenų subjektų prašymus

Teisės į susipažinimą, ištrynimą ir duomenų perkeliamumą turi būti įgyvendintos dar prieš gaunant pirmąjį prašymą, nes mėnesio atsakymo terminas pralekia labai greitai, jei vis dar rašote kodą. Teisė į susipažinimą reikalauja daugiau nei tik žalių duomenų: turite pateikti tikslus, subrangovų sąrašą ir saugojimo laikotarpius – informaciją, kurią geriau sukonsoliduoti iš anksto.

Teisė į ištrynimą reikalauja kruopštaus kodo peržiūrėjimo. Atsakyme aiškiai atskiriami vietiniai duomenys, kurie ištrinami nedelsiant, nuo duomenų, išsiųstų į API, kuriems taikoma tiekėjo saugojimo politika. Šis sąžiningumas yra privalomas: žadėti visišką, momentinį ištrynimą, kai kopija lieka pas subrangovą, jus apkrauna daugiau nei aiškus abiejų režimų dokumentavimas.

class DataSubjectRights:
    """Įgyvendina BDAR teises naudotojams."""

    def right_of_access(self, user_id: str) -> dict:
        """Grąžina visus turimus naudotojo duomenis."""
        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:
        """Ištrina visus naudotojo duomenis."""
        # Ištrinti iš vietinės duomenų bazės
        deleted_local = self._delete_local(user_id)
        # Duomenys, išsiųsti į „OpenAI“ API, yra
        # jų saugojimo politikos objektas (maks. 30 dienų per 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:
        """Eksportuoja duomenis struktūruotu formatu."""
        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

Formalizuokite poveikio vertinimą

Bet kuriai DI programai, apdorojančiai asmens duomenis dideliu mastu, privaloma atlikti Duomenų apsaugos poveikio vertinimą (DPIA). Toliau pateikta struktūra rodo numatytus skyrius, o pavyzdys iliustruoja, kaip atrodo užpildytas DPIA klientų aptarnavimo pokalbių robotui.

Du laukai sulaukia daugiausia priežiūros institucijos dėmesio. Pirma, perdavimai už ES ribų: kai apdorojimas vyksta per JAV tiekėją, turite įvardyti gavėją, šalį ir taikomą apsaugos priemonę – šiuo atveju Standartines sutarties sąlygas (SCC), papildytas „OpenAI“ Duomenų apdorojimo susitarimu. Antra, rizikos analizė, kuri turi būti specifinė aprašytai sistemai. Pavyzdyje pasirinkta rizika yra asmens duomenų nutekėjimas per prompt injekciją, o švelninimo priemonės – anti-eksfiltracijos apsaugos mechanizmai ir moderavimas: viskas, ką sukūrėte ankstesniuose skyriuose, čia įgauna reguliacinę išraišką.

@dataclass
class ImpactAssessment:
    """DI sistemos DPIA struktūra."""
    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",
    }],
)

Svarbiausi punktai

  • BDAR taikomas, kai DI sistema apdoroja Europos gyventojų duomenis
  • Duomenų mažinimas (anonimizavimas prieš siunčiant į API) yra pirmasis refleksas
  • Duomenų subjektų teisės (susipažinimas, ištrynimas, perkeliamumas) turi būti įgyvendintos
  • DPIA yra privalomas didelio masto DI apdorojimui
  • Perdavimai už ES ribų dokumentuojami naudojant „OpenAI“ DPA ir aiškias apsaugos priemones (SCC, perdavimo poveikio vertinimas)