Przejdź do głównej treści
Polski— Wybierz język
Menu

Zgodność i ścieżka audytowa

Lekcja 22 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Zgodność i ścieżka audytowa
  2. Dlaczego ścieżka audytowa?
  3. Struktura rekordu audytowego
  4. Kompletny system audytowy
  5. Zapytania audytowe
  6. Retencja i archiwizacja
  7. Europejska ustawa o AI (AI Act): co się zmienia
  8. Lista kontrolna zgodności
  9. Kluczowe wnioski
  10. Sprawdź swoją wiedzę

Zgodność i ścieżka audytowa

W aplikacjach AI działających w środowisku produkcyjnym możliwość śledzenia zdarzeń (traceability) jest kluczowa. Kompletna ścieżka audytowa chroni Cię podczas kontroli, sporu lub incydentu. Ta lekcja pokazuje, jak wdrożyć solidny system audytu, kończąc kurs poprzez połączenie wszystkiego, co do tej pory zbudowałeś – logowania, moderacji i ochrony danych – w jeden, dający się obronić framework.

Dlaczego ścieżka audytowa?

Cztery różne potrzeby schodzą się na tej samej infrastrukturze. Po pierwsze, zgodność z przepisami: RODO, europejska ustawa o sztucznej inteligencji (AI Act) oraz standardy branżowe wymagają od Ciebie wykazania, co robi Twój system, a demonstracja bez logów jest bezwartościowa. Po drugie, możliwość śledzenia w ścisłym sensie – wiedza o tym, kto, co, kiedy i z jakim rezultatem zrobił, nawet sześć miesięcy później. Debugowanie korzysta z tego na co dzień, ponieważ zrozumienie nieoczekiwanego zachowania modelu wymaga odtworzenia dokładnych warunków wywołania. Wreszcie, odpowiedzialność: dokumentowanie decyzji podejmowanych przez AI to właśnie to, co pozwoli Ci, gdy nadejdzie czas, wykazać, że kwestionowana rekomendacja opierała się na kontrolowanym procesie.

Struktura rekordu audytowego

Poniższa klasa dataclass jest zarówno kontraktem, jak i strukturą danych. Grupuje identyfikatory, kontekst aplikacji, żądanie, odpowiedź, werdykt moderacji i metadane techniczne. Dwa wybory zasługują na Twoją uwagę. Identyfikator użytkownika pojawia się wyłącznie w formie zahaszowanej, nigdy jako tekst jawny. Ponadto monit (prompt) nie jest przechowywany: zapisywany jest tylko jego hash i długość. Pozwala to udowodnić, że dwa wywołania dotyczyły tej samej treści, bez tworzenia archiwum tego, co napisali Twoi użytkownicy.

from dataclasses import dataclass, field, asdict
from datetime import datetime
from typing import Optional
import json
import uuid
import hashlib

@dataclass
class AuditRecord:
    """Rekord audytowy dla wywołania API."""
    # Identyfikatory
    audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    timestamp: str = field(
        default_factory=lambda: datetime.now().isoformat()
    )

    # Kontekst
    user_id_hash: str = ""  # Nigdy zwykły ID
    session_id: str = ""
    application: str = ""

    # Żądanie (brak danych wrażliwych)
    model: str = ""
    prompt_hash: str = ""  # Hash monitu, a nie sam monit
    prompt_length: int = 0

    # Odpowiedź
    response_id: str = ""
    output_length: int = 0
    input_tokens: int = 0
    output_tokens: int = 0

    # Moderacja
    input_flagged: bool = False
    output_flagged: bool = False

    # Metadane
    duration_ms: int = 0
    status: str = "success"
    error: Optional[str] = None

    def to_json(self) -> str:
        return json.dumps(asdict(self), ensure_ascii=False)

Kompletny system audytowy

Klient wykorzystujący tę strukturę łączy moderację wejścia, wywołanie API, moderację wyjścia i zapisuje dane w każdym przypadku. Kluczowym słowem jest tylko dopisywanie (append-only): plik JSONL jest otwierany w trybie dopisywania, nigdy nie jest nadpisywany, co jest warunkiem koniecznym, aby log miał wartość dowodową. Zwróć uwagę na ścieżkę wpisu oznaczonego flagą – rekord jest zapisywany przed zgłoszeniem wyjątku, ze statusem blocked_input. Blokada pozostawia więc ślad tak samo jak sukces, a końcowy blok except gwarantuje, że żaden błąd, niezależnie od jego źródła, nie umknie uwadze.

import time
from openai import OpenAI

class AuditedClient:
    """Klient OpenAI ze zintegrowaną ścieżką audytową."""

    def __init__(self, application: str, audit_store: str = "audit.jsonl"):
        self.client = OpenAI()
        self.application = application
        self.audit_store = audit_store

    def _hash(self, text: str) -> str:
        """Skrócony hash SHA-256 do celów audytowych."""
        return hashlib.sha256(text.encode()).hexdigest()[:16]

    def _save_audit(self, record: AuditRecord):
        """Zapisuje rekord audytowy (tylko dopisywanie)."""
        with open(self.audit_store, "a", encoding="utf-8") as f:
            f.write(record.to_json() + "\n")

    def create(self, user_id: str, session_id: str,
               model: str, input: str, **kwargs) -> object:
        """Wywołanie API z automatycznym audytem."""

        record = AuditRecord(
            user_id_hash=self._hash(user_id),
            session_id=session_id,
            application=self.application,
            model=model,
            prompt_hash=self._hash(input),
            prompt_length=len(input),
        )

        start = time.monotonic()

        try:
            # Moderacja wejścia
            mod = self.client.moderations.create(
                model="omni-moderation-latest",
                input=input
            )
            record.input_flagged = mod.results[0].flagged

            if record.input_flagged:
                record.status = "blocked_input"
                self._save_audit(record)
                raise ValueError("Nieodpowiednia treść wejściowa")

            # Wywołanie API
            response = self.client.responses.create(
                model=model,
                input=input,
                **kwargs
            )

            # Moderacja wyjścia
            mod_out = self.client.moderations.create(
                model="omni-moderation-latest",
                input=response.output_text
            )
            record.output_flagged = mod_out.results[0].flagged

            # Wypełnienie metryk
            record.response_id = response.id
            record.output_length = len(response.output_text)
            record.input_tokens = response.usage.input_tokens
            record.output_tokens = response.usage.output_tokens
            record.duration_ms = round((time.monotonic() - start) * 1000)
            record.status = "success"

            self._save_audit(record)
            return response

        except Exception as e:
            record.duration_ms = round((time.monotonic() - start) * 1000)
            record.status = "error"
            record.error = type(e).__name__
            self._save_audit(record)
            raise

# Użycie
audited = AuditedClient(application="support-chatbot")

response = audited.create(
    user_id="[email protected]",
    session_id="sess-abc123",
    model="gpt-5.6-terra",
    input="How do I return a product?"
)
print(response.output_text)

W tym przykładzie adres e-mail przekazany jako user_id nigdy nie trafia do pliku: jest hashowany natychmiast po skonstruowaniu rekordu. Plik JSONL sprawdza się na początek i w przypadku pojedynczej instancji; gdy tylko wiele procesów zaczyna zapisywać dane równolegle, przekieruj ten strumień do bazy danych lub kolektora logów.

Zapytania audytowe

Log, którego nie możesz odpytywać, służy jedynie do zajmowania miejsca na dysku. Odczyt formatu JSONL linia po linii czyni eksploatację trywialną, a poniższy raport podsumowuje objęty okres, rozkład między sukcesami, błędami i blokadami, zużycie tokenów oraz średnie opóźnienie. Liczba unikalnych użytkowników opiera się na hashach, co dowodzi przy okazji, że zanonimizowany log pozostaje w pełni analizowalny.

import json

def read_audit(file: str = "audit.jsonl") -> list[dict]:
    """Odczytuje wszystkie rekordy audytowe."""
    records = []
    try:
        with open(file, "r", encoding="utf-8") as f:
            for line in f:
                if line.strip():
                    records.append(json.loads(line))
    except FileNotFoundError:
        pass
    return records

def audit_report(file: str = "audit.jsonl") -> dict:
    """Generuje raport audytowy."""
    records = read_audit(file)

    if not records:
        return {"message": "Brak rekordów"}

    total = len(records)
    errors = sum(1 for r in records if r["status"] == "error")
    blocked = sum(1 for r in records if r["status"] == "blocked_input")
    tokens_total = sum(
        r.get("input_tokens", 0) + r.get("output_tokens", 0)
        for r in records
    )
    durations = [r["duration_ms"] for r in records if r["duration_ms"] > 0]

    return {
        "period": {
            "start": records[0]["timestamp"],
            "end": records[-1]["timestamp"],
        },
        "total_calls": total,
        "successes": total - errors - blocked,
        "errors": errors,
        "moderation_blocks": blocked,
        "tokens_consumed": tokens_total,
        "avg_latency_ms": round(sum(durations) / max(len(durations), 1)),
        "unique_users": len(set(r["user_id_hash"] for r in records)),
    }

print(json.dumps(audit_report(), indent=2, ensure_ascii=False))

Retencja i archiwizacja

Przechowywanie danych w nieskończoność stoi w sprzeczności z zasadą ograniczenia przechowywania; zbyt wczesne usuwanie pozbawia Cię dowodu, którego możesz potrzebować. Rotacja rozwiązuje ten dylemat: po upływie ustalonego przez Ciebie czasu – tutaj dziewięćdziesięciu dni – rekordy przenoszone są z aktywnego pliku do datowanego archiwum, podczas gdy bieżący log jest nadpisywany zawierając tylko najnowsze wpisy. Zaplanuj tę funkcję jako zadanie okresowe i dopasuj parametr retention_days do polityki zatwierdzonej przez Twojego doradcę prawnego, a nie do wartości wybranej losowo.

from datetime import datetime, timedelta
import shutil
import os

def archive_audit(file: str = "audit.jsonl",
                  retention_days: int = 90):
    """Archiwizuje i czyści stare rekordy."""
    records = read_audit(file)
    limit = datetime.now() - timedelta(days=retention_days)

    recent = []
    archives = []

    for record in records:
        date_record = datetime.fromisoformat(record["timestamp"])
        if date_record > limit:
            recent.append(record)
        else:
            archives.append(record)

    if archives:
        # Archiwizacja starych
        archive_name = f"audit_archive_{datetime.now().strftime('%Y%m%d')}.jsonl"
        with open(archive_name, "w", encoding="utf-8") as f:
            for record in archives:
                f.write(json.dumps(record, ensure_ascii=False) + "\n")

        # Nadpisanie głównego pliku nowszymi
        with open(file, "w", encoding="utf-8") as f:
            for record in recent:
                f.write(json.dumps(record, ensure_ascii=False) + "\n")

        print(f"Zarchiwizowano {len(archives)} rekordów do {archive_name}")
        print(f"Pozostawiono {len(recent)} najnowszych rekordów")

Europejska ustawa o AI (AI Act): co się zmienia

Europejska ustawa o sztucznej inteligencji (AI Act) nakłada obowiązki w zależności od poziomu ryzyka Twojej aplikacji. Logika jest stopniowana: im większy wpływ systemu na życie ludzi, tym surowsze wymagania. Chatbot FAQ, podsumowanie czy tłumaczenie mieszczą się w kategorii minimalnego ryzyka i wymagają jedynie podstawowej transparentności. Gdy pojawia się konwersacja lub analiza sentymentu, przechodzisz do ryzyka ograniczonego, z obowiązkiem poinformowania użytkownika, że interaguje z AI. Skok jest nagły w przypadku wysokiego ryzyka – scoring kredytowy, rekrutacja, diagnoza medyczna – gdzie dochodzą ocena zgodności, zarządzanie ryzykiem, dokumentacja danych treningowych, pełna możliwość śledzenia, nadzór człowieka i wykazanie dokładności. Pewne zastosowania, takie jak scoring społeczny czy manipulacja podprogowa, są całkowicie zakazane.

# Oceń poziom ryzyka swojej aplikacji
RISK_LEVELS = {
    "minimal": {
        "examples": ["chatbot FAQ", "podsumowanie tekstu", "tłumaczenie"],
        "obligations": ["Podstawowa transparentność"]
    },
    "limited": {
        "examples": ["chatbot obsługi klienta", "analiza sentymentu"],
        "obligations": ["Poinformuj użytkownika, że interaguje z AI"]
    },
    "high": {
        "examples": ["scoring kredytowy", "rekrutacja", "diagnoza medyczna"],
        "obligations": [
            "Ocena zgodności",
            "System zarządzania ryzykiem",
            "Udokumentowane dane treningowe",
            "Logowanie i pełna możliwość śledzenia",
            "Obowiązkowy nadzór człowieka",
            "Wykazana dokładność i odporność"
        ]
    },
    "unacceptable": {
        "examples": ["scoring społeczny", "manipulacja podprogowa"],
        "obligations": ["ZAKAZANE"]
    }
}

Szczerze umiejscowij swój projekt w tej macierzy przed napisaniem pierwszej linii kodu: aplikacja sklasyfikowana jako wysokie ryzyko narzuca ograniczenia architektoniczne – wyczerpujące logowanie, punkt kontrolny człowieka – których nie da się dorobić post factum do systemu zaprojektowanego bez nich.

Lista kontrolna zgodności

  • Ścieżka audytowa typu append-only z znacznikiem czasu
  • Hashowanie danych osobowych w logach (nigdy tekst jawny)
  • Systematyczna moderacja wejść i wyjść
  • Aktualny rejestr czynności przetwarzania zgodny z RODO
  • Zdefiniowana polityka retencji i archiwizacji
  • Przeprowadzona ocena poziomu ryzyka zgodnie z AI Act
  • Poinformowanie użytkowników, że interagują z AI
  • Nadzór człowieka przy decyzjach mających istotny wpływ

Kluczowe wnioski

  • Ścieżka audytowa jest obowiązkowa dla zgodności z przepisami
  • Loguj w trybie append-only: nigdy nie modyfikuj istniejących rekordów
  • Haszuj wszystkie dane osobowe w logach audytowych
  • Europejska ustawa o AI klasyfikuje aplikacje według poziomu ryzyka
  • Wdróż automatyczną moderację ORAZ nadzór człowieka
  • Zdefiniuj politykę retencji i regularnie archiwizuj dane

Sprawdź swoją wiedzę

Dwadzieścia dwie lekcje o API: zweryfikuj mechanizmy, które utrzymują środowisko produkcyjne w ryzach.

1. Dlaczego migrować do Responses API zamiast pozostać przy Chat Completions?

Odpowiedź: To nowoczesne API OpenAI: zintegrowane zarządzanie stanem konwersacji, natywne narzędzia i rozwój skupiony na tym rozwiązaniu – Chat Completions pozostaje wspierane, ale jest przestarzałe.

2. Jak wybrać między Sol, Terra i Luna po stronie API?

Odpowiedź: gpt-5.6-sol do zadań wymagających, terra dla balansu koszt/jakość, luna dla dużych wolumenów ekonomicznych – a poziom rozumowania (none→max) dostosowuje się następnie dla każdego żądania.

3. Co gwarantuje Structured Output?

Odpowiedź: Wyjście zgodne z dostarczonym schematem JSON – pola, typy, struktura – nadające się do wykorzystania przez program bez defensywnego parsowania czy napraw.

4. Co zrobić w obliczu błędu 429?

Odpowiedź: Szanuj limity速率 (rate limits): ponów próbę z wykładniczym opóźnieniem (i jitterem), ogranicz liczbę prób i zaplanuj mechanizm circuit breaker – nigdy natychmiastowej pętli ponawiania.

5. Wymień dwie niezbędne ochrony po stronie bezpieczeństwa aplikacji.

Odpowiedź: Moderacja treści przychodzących/wychodzących poprzez dedykowane API oraz obrona przed wstrzykiwaniem promptów (prompt injection): izoluj instrukcje od danych, waliduj wyjścia, ograniczaj eksponowane możliwości.

Produkcja, bezpieczeństwo, zgodność: ostatnie trzy bloki kursu stanowią różnicę między prototypem a usługą – traktuj je jako listę kontrolną.