Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

GDPR un datu aizsardzība, izmantojot OpenAI

Nodarbība 13 no 14 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Mākslīgais intelekts un GDPR: Nepārkāpjams regulējums
  2. Septiņi principi, pielāgoti LLM sistēmai
  3. Minimālais daudzums: Pasākums, kas atrisina lielāko daļu problēmu
  4. Konfigurē servisu un vāc piekrišanu
  5. Atbildēšana uz datu subjektu pieprasījumiem
  6. Formalizē ietekmes novērtējumu
  7. Galvenās atziņas

Mākslīgais intelekts un GDPR: Nepārkāpjams regulējums

Vispārīgā datu aizsardzības regula (GDPR) attiecas uz jebkuru lietojumprogrammu, kas apstrādā Eiropas iedzīvotāju personas datus, tostarp uz lielo valodu modeļu (LLM) bāzētām programmām. Mākslīgajam intelektam nav izņēmumu. Tas bieži mulsina tehniskās komandas: tās meklē īpašus AI noteikumus, lai gan piemērojamais tiesību akts pastāv jau gadiem un nav mainījies. 2026. gadā izpildes darbības arvien biežāk vērstas pret AI sistēmām. OpenAI API izmantošana šajā kontekstā nozīmē nevis jaunu likumu apguvi, bet gan zināmu juridisko prasību pielāgošanu jaunai arhitektūrai.

Septiņi principi, pielāgoti LLM sistēmai

GDPR balstās uz septiņiem pamatprincipiem, un katrs no tiem iegūst specifisku nozīmi, kad apstrādes ķēdē iesaistās valodu modelis.

Princips Pielietojums AI
Likumīgums Juridiskais pamats datu nosūtīšanai uz API (piekrišana, leģitīmas intereses, līgums)
Datu minimizēšana Nosūtīt tikai datus, kas modelim ir stingri nepieciešami
Mērķa ierobežojums Nosūtītajiem datiem jākalpo tikai deklarētajam mērķim
Precizitāte Modeļa izvades var būt neprecīzas – informē lietotāju
Glabāšanas ierobežojums Pārbaudi OpenAI glabāšanas politiku un dzēs datus klienta pusē
Drošība Šifrēšana pārsūtīšanas laikā, piekļuves kontrole, žurnālu auditēšana
Pārskatatbildība Dokumentē izvēles un spēj pierādīt atbilstību

Divi principi regulāri pārsteidz komandas. Pirmkārt, precizitāte: tā pārvērš halucinācijas no kvalitātes problēmas regulatīvā jautājumā. Ja modelis ģenerē nepatiesu informāciju par identificētu personu, šai personai ir tiesības uz labojumu. Otrkārt, pārskatatbildība: ar atbilstību nepietiek – tev tas ir jāspēj pierādīt. Tas pārvērš dokumentāciju no labas prakses juridiskā pienākumā.

Minimālais daudzums: Pasākums, kas atrisina lielāko daļu problēmu

No visiem pieejamajiem pasākumiem pseidonimizācija pirms datu nosūtīšanas piedāvā vislabāko līdzsvaru starp piepūli un riska mazināšanu. Loģika ir vienkārša: tas, kas nekad neatstāj tavu sistēmu, nevar noplūdt pie apakšuzņēmēja, nerada jautājumus pārsūtīšanas laikā ārpus ES un nesarežģī dzēšanas pieprasījumus.

Zemāk esošais mehānisms aizstāj katru identificējošo datu gabalu ar stabilu token, uztur kartējumu lokālajā atmiņā un atjauno sākotnējās vērtības atbildē. Galalietotājs redz „kungs Dupont”, modelis redz tikai „[PERSON_1]”, un servisa funkcija paliek pilnībā intacta – asistents joprojām var sagatavot savu atbildi, jo tam nekad nebija vajadzīgs īstais uzvārds.

Komentārs par vārdiem nav dekoratīvs: šablons uztver tikai formas, kam priekšā ir tituls. Kails vārds izslīdēs cauri. Produkcijā pārņem nosaukto entīšu atpazīšanas (NER) modelis, un šī brīdinājuma tieša klātbūtne kodā ir labāka par viltus pārliecību.

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

Konfigurē servisu un vāc piekrišanu

Sniedzēja pusē zini šo noteikumu: dati, kas nosūtīti, izmantojot API, pēc noklusējuma netiek izmantoti apmācībai, pretēji tam, ko daudzi pieņem, veicot analoģiju ar patērētāja saskarnēm. Tas neatbrīvo tevi no pienākuma pārbaudīt savas organizācijas iestatījumus platformā un dokumentēt šo pārbaudi.

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
)

Lietotāja pusē piekrišana tiek pārvaldīta pēc mērķa, nevis globāli, kas izskaidro šeit redzamo struktūru: lietotājs var piekrist sarunu asistēšanai, vienlaikus atsakoties no tā, lai viņa apmaiņas tiktu izmantotas servisa uzlabošanai. Politikas versija tiek reģistrēta kopā ar piekrišanu – kritiska detaļa dienā, kad atjaunini šo politiku. Bez šīs pēdas tu nezini, kas kam ir piekritis. Visbeidzot, atsaukšana izraisa tūlītēju dzēšanu, jo datu saglabāšana pēc atsaukšanas ir tieši tas scenārijs, kas pārvērš ikdienas auditu izpildes darbībā.

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

Atbildēšana uz datu subjektu pieprasījumiem

Tiesībām uz piekļuvi, dzēšanu un pārnesamību ir jābūt ieviestām pirms pirmā pieprasījuma saņemšanas, jo viena mēneša atbildes logs pazūd ātri, kad tu vēl raksti kodu. Tiesības uz piekļuvi prasa vairāk nekā tikai neapstrādātus datus: tev ir jāsniedz mērķi, apakšuzņēmēju saraksts un glabāšanas periodi – informācija, ko ir labāk konsolidēt iepriekš.

Tiesības uz dzēšanu prasa rūpīgu koda pārskatīšanu. Atbilde skaidri nošķir lokālos datus, kas tiek dzēsti nekavējoties, no datiem, kas nosūtīti uz API un uz kuriem attiecas sniedzēja glabāšanas politika. Šī godīgums ir obligāts: solot pilnīgu, tūlītēju dzēšanu, kamēr kopija paliek pie apakšuzņēmēja, tas tevi pakļauj lielākam riskam nekā abu režīmu skaidra dokumentēšana.

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

Formalizē ietekmes novērtējumu

Jebkurai AI lietojumprogrammai, kas apstrādā personas datus lielā apjomā, ir obligāts datu aizsardzības ietekmes novērtējums (DPIA). Zemāk esošā struktūra paraida paredzētās sadaļas, un piemērs ilustrē, kā izskatās pabeigts DPIA klientu apkalpošanas čatbotam.

Divi lauki piesaista vislielāko uzraudzības iestādes uzmanību. Pirmkārt, pārsūtīšana ārpus ES: kad apstrāde notiek caur ASV sniedzēju, tev ir jānosauc saņēmējs, valsts un izmantotā aizsardzība – šeit Standarta līguma klauzulas (SCC), ko papildina OpenAI datu apstrādes līgums. Otrkārt, risku analīzei ir jābūt specifiskai aprakstītajai sistēmai. Piemērā izvēlētais risks ir personas datu noplūde, izmantojot prompt injection, un mazināšanas pasākumi ir anti-eksfiltrācijas aizsardzības mehānismi un moderācija: viss, ko izveidoji iepriekšējās nodaļās, šeit iegūst savu regulatīvo tulkojumu.

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

Galvenās atziņas

  • GDPR attiecas tiklīdz AI sistēma apstrādā Eiropas iedzīvotāju datus
  • Datu minimizēšana (anonimizācija pirms nosūtīšanas uz API) ir pirmais reflekss
  • Datu subjektu tiesības (piekļuve, dzēšana, pārnesamība) ir jāievieš
  • DPIA ir obligāts AI apstrādei lielā apjomā
  • Pārsūtīšana ārpus ES tiek dokumentēta, izmantojot OpenAI DPA un skaidrus aizsardzības pasākumus (SCC, pārsūtīšanas ietekmes novērtējums)