RODO i ochrona danych z OpenAI
Na tej stronie
Sztuczna inteligencja a RODO: Ramy nienegocjowalne
Ogólne rozporządzenie o ochronie danych (RODO) ma zastosowanie do każdej aplikacji przetwarzającej dane osobowe mieszkańców Europy – w tym aplikacji opartych na dużych modelach językowych (LLM). Nie ma wyjątków dla sztucznej inteligencji. Często myli to zespoły techniczne: szukają przepisów specyficznych dla AI, podczas gdy właściwy akt prawny istnieje od lat i nie uległ zmianie. W 2026 roku działania egzekucyjne coraz częściej wymierzone są w systemy AI. Wykorzystanie API OpenAI w tym kontekście oznacza mniej nauki nowego prawa, a bardziej przełożenie znanych wymogów prawnych na nową architekturę.
Siedem zasad przełożonych na system LLM
RODO opiera się na siedmiu kluczowych zasadach, z których każda nabiera szczególnego znaczenia, gdy w łańcuchu przetwarzania pojawia się model językowy.
| Zasada | Zastosowanie w AI |
|---|---|
| Zgodność z prawem | Podstawa prawna wysyłania danych do API (zgoda, prawnie uzasadniony interes, umowa) |
| Minimalizacja danych | Wysyłaj tylko dane ściśle niezbędne dla modelu |
| Ograniczenie celu | Wysyłane dane muszą służyć wyłącznie zadeklarowanemu celowi |
| Prawidłowość | Wyjścia modelu mogą być niedokładne – poinformuj o tym użytkownika |
| Ograniczenie przechowywania | Sprawdź politykę retencji OpenAI i usuwaj dane po stronie klienta |
| Bezpieczeństwo | Szyfrowanie w tranzycie, kontrola dostępu, audyt logów |
| Rozliczalność | Dokumentuj wybory i bądź w stanie wykazać zgodność |
Dwie zasady regularnie zaskakują zespoły. Po pierwsze, prawidłowość: zamienia ona halucynacje z problemu jakościowego w problem regulacyjny. Gdy model generuje fałszywe informacje o zidentyfikowanej osobie, osoba ta ma prawo do sprostowania. Po drugie, rozliczalność: samo bycie zgodnym nie wystarczy – musisz być w stanie to udowodnić. Przekształca to dokumentację z dobrej praktyki w obowiązek prawny.
Minimalizacja: Środek rozwiązujący większość problemów
Spośród wszystkich dostępnych środków, pseudonimizacja przed wysłaniem danych oferuje najlepszy balans między nakładem pracy a redukcją ryzyka. Logika jest prosta: to, co nigdy nie opuszcza Twojego systemu, nie może wyciec do podmiotu przetwarzającego, nie rodzi pytań podczas transferów poza UE i nie komplikuje wniosków o usunięcie.
Poniższy mechanizm zastępuje każdy fragment danych identyfikujących stabilnym tokenem, przechowuje mapowanie w pamięci lokalnej i przywraca oryginalne wartości w odpowiedzi. Końcowy użytkownik widzi „Pan Dupont“, model widzi tylko „[PERSON_1]“, a funkcja serwisowa pozostaje w pełni sprawna – asystent nadal może sporządzić odpowiedź, ponieważ nigdy nie potrzebował rzeczywistego nazwiska.
Komentarz dotyczący nazwisk nie jest ozdobnikiem: wzorzec wychwytuje tylko formy poprzedzone tytułem. Gołe nazwisko prześlizgnie się niezauważone. W środowisku produkcyjnym przejmuje to model rozpoznawania encji nazwanych (NER), a posiadanie tego ostrzeżenia explicite w kodzie jest lepsze niż fałszywe poczucie bezpieczeństwa.
import re
class DataMinimizer:
"""Anonimizuje dane osobowe przed wysłaniem do API."""
def __init__(self):
self.mappings: dict[str, str] = {}
self.counter = 0
def anonymize(self, text: str) -> str:
"""Zastępuje dane osobowe symbolami zastępczymi."""
# Adresy e-mail
text = re.sub(
r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
lambda m: self._replace(m.group(), "EMAIL"),
text,
)
# Francuskie numery telefonów
text = re.sub(
r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
lambda m: self._replace(m.group(), "PHONE"),
text,
)
# Nazwiska (uproszczony wzorzec – użyj NER w produkcji)
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:
"""Przywraca oryginalne dane w odpowiedzi."""
reverse = {v: k for k, v in self.mappings.items()}
for placeholder, original in reverse.items():
text = text.replace(placeholder, original)
return text
# Użycie
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 odpowiedzi 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}")
Konfiguracja usługi i zbieranie zgód
Po stronie dostawcy zapamiętaj tę zasadę: dane wysyłane przez API domyślnie nie są wykorzystywane do trenowania modeli, wbrew temu, co wielu zakłada przez analogię do interfejsów konsumenckich. Nie zwalnia Cię to jednak ze sprawdzenia ustawień swojej organizacji na platformie i udokumentowania tej weryfikacji.
from openai import OpenAI
# W przypadku API Twoje dane NIE są domyślnie używane do trenowania
# Ale zweryfikuj ustawienia swojej organizacji na platform.openai.com
client = OpenAI()
# Punkt końcowy Responses API przestrzega polityki retencji
response = client.chat.completions.create(
model="gpt-5.6-sol",
messages=[{"role": "user", "content": "Hello"}],
# store=False wyłącza przechowywanie po stronie OpenAI, jeśli dostępne
)
Po stronie użytkownika zgoda jest zarządzana według celu, a nie globalnie, co wyjaśnia poniższą strukturę: użytkownik może zaakceptować pomoc konwersacyjną, odmawiając jednocześnie wykorzystania swoich wymian do ulepszania usługi. Wersja polityki jest rejestrowana wraz ze zgodą – to krytyczny szczegół na dzień aktualizacji tej polityki. Bez tego śladu nie będziesz wiedzieć, kto na co się zgodził. Wreszcie, cofnięcie zgody uruchamia natychmiastowe usunięcie, ponieważ przechowywanie danych po cofnięciu zgody to dokładnie scenariusz, który zamienia rutynowy audyt w działanie egzekucyjne.
class ConsentManager:
"""Zarządza zgodami użytkowników na przetwarzanie AI."""
def __init__(self):
self.consent_records: dict[str, dict] = {}
def record_consent(self, user_id: str, purposes: list[str]):
"""Rejestruje wyraźną zgodę użytkownika."""
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:
"""Sprawdza, czy użytkownik wyraził zgodę na konkretny cel."""
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):
"""Cofa zgodę i uruchamia usuwanie danych."""
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):
"""Usuwa wszystkie dane powiązane z użytkownikiem."""
# Usuń historię konwersacji
# Usuń logi zawierające dane osobowe
# Powiadom podmioty przetwarzające (OpenAI), jeśli dotyczy
print(f"Data deleted for {user_id}")
Odpowiadanie na wnioski osób, których dane dotyczą
Prawa dostępu, usunięcia i przenoszenia danych muszą być wdrożone przed nadejściem pierwszego wniosku, ponieważ miesięczny termin odpowiedzi znika błyskawicznie, gdy wciąż piszesz kod. Prawo dostępu wymaga więcej niż surowych danych: musisz podać cele, listę podmiotów przetwarzających i okresy przechowywania – informacje, które lepiej skonsolidować zawczasu.
Prawo do usunięcia wymaga starannego przeglądu kodu. Odpowiedź wyraźnie rozróżnia dane lokalne, usuwane natychmiast, od danych wysłanych do API, które podlegają polityce retencji dostawcy. Ta uczciwość jest obowiązkowa: obiecywanie całkowitego, natychmiastowego usunięcia, gdy kopia pozostaje u podmiotu przetwarzającego, naraża Cię bardziej niż jasne udokumentowanie obu reżimów.
class DataSubjectRights:
"""Wdraża prawa RODO dla użytkowników."""
def right_of_access(self, user_id: str) -> dict:
"""Zwraca wszystkie posiadane dane o użytkowniku."""
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:
"""Usuwa wszystkie dane użytkownika."""
# Usuń z lokalnej bazy danych
deleted_local = self._delete_local(user_id)
# Dane wysłane do API OpenAI podlegają
# ich polityce retencji (maks. 30 dni przez 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:
"""Eksportuje dane w ustrukturyzowanym formacie."""
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
Sformalizuj ocenę skutków
Dla każdej aplikacji AI przetwarzającej dane osobowe na dużą skalę obowiązkowa jest Ocena Skutków dla Ochrony Danych (DPIA). Poniższa struktura pokazuje oczekiwane sekcje, a przykład ilustruje, jak wygląda wypełniona DPIA dla chatbota obsługi klienta.
Dwa pola przyciągają największą uwagę organu nadzorczego. Po pierwsze, transfery poza UE: gdy przetwarzanie odbywa się przez dostawcę z USA, musisz wskazać odbiorcę, kraj i przywołane zabezpieczenie – tutaj są to Standardowe Klauzule Umowne (SCC) uzupełnione Umową o Przetwarzanie Danych (DPA) od OpenAI. Po drugie, analiza ryzyka, która musi być specyficzna dla opisywanego systemu. Ryzyko wybrane w przykładzie to wyciek danych osobowych poprzez iniekcję promptu, a środkami zaradczymi są zabezpieczenia przeciwko eksfiltracji i moderacja: wszystko, co zbudowałeś w poprzednich rozdziałach, znajduje tu swoje regulacyjne przełożenie.
@dataclass
class ImpactAssessment:
"""Struktura DPIA dla systemu 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",
}],
)
Kluczowe wnioski
- RODO ma zastosowanie, gdy tylko system AI przetwarza dane mieszkańców Europy
- Minimalizacja danych (anonimizacja przed wysłaniem do API) to pierwszy odruch
- Prawa osób, których dane dotyczą (dostęp, usunięcie, przenoszenie) muszą być wdrożone
- DPIA jest obowiązkowa dla przetwarzania AI na dużą skalę
- Transfery poza UE są dokumentowane poprzez DPA od OpenAI i wyraźne zabezpieczenia (SCC, ocena skutków transferu)