Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Compliance en Audit Trail

Les 22 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Compliance en Audit Trail
  2. Waarom een Audit Trail?
  3. Structuur van een Audit Record
  4. Compleet Auditsysteem
  5. Audit Queries
  6. Bewaring en Archivering
  7. Europese AI-wet: Wat Verandert
  8. Compliance Checklist
  9. Belangrijkste punten
  10. Test Uw Kennis

Compliance en Audit Trail

Voor AI-toepassingen in productie is traceerbaarheid essentieel. Een compleet audit trail beschermt u tijdens een inspectie, een geschil of een incident. Deze les laat u zien hoe u een robuust auditsysteem implementeert en sluit de cursus af door alles wat u tot nu toe hebt opgebouwd—logging, moderatie en databescherming—samen te brengen in één enkel, verdedigbaar framework.

Waarom een Audit Trail?

Vier verschillende behoeften komen samen in dezelfde infrastructuur. Ten eerste, regulatory compliance: de AVG, de Europese AI-wet en industriestandaarden vereisen allemaal dat u aantoont wat uw systeem doet, en een demonstratie zonder logs is waardeloos. Ten tweede, traceerbaarheid in strikte zin—weten wie wat deed, wanneer, met welk resultaat, zelfs zes maanden later. Debugging profiteert hier dagelijks van, omdat het begrijpen van onverwacht modelgedrag vereist dat de exacte omstandigheden van de oproep worden hersteld. Tot slot, aansprakelijkheid: het documenteren van beslissingen die door de AI zijn genomen, is wat u in staat zal stellen, wanneer de tijd daar is, aan te tonen dat een betwiste aanbeveling berustte op een gecontroleerd proces.

Structuur van een Audit Record

De onderstaande dataclass is evenzeer een contract als een datastructuur. Het groepeert identificatoren, applicatiecontext, het verzoek, het antwoord, het moderatie-oordeel en technische metadata. Twee keuzes verdienen uw aandacht. De gebruikersidentificatie verschijnt alleen in gehashte vorm, nooit als platte tekst. En de prompt wordt niet opgeslagen: alleen de hash en de lengte ervan. Dit behoudt uw vermogen om te bewijzen dat twee oproepen dezelfde inhoud betroffen, zonder ooit een archief aan te leggen van wat uw gebruikers hebben geschreven.

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

@dataclass
class AuditRecord:
    """Audit record for an API call."""
    # Identifiers
    audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    timestamp: str = field(
        default_factory=lambda: datetime.now().isoformat()
    )

    # Context
    user_id_hash: str = ""  # Never the plain ID
    session_id: str = ""
    application: str = ""

    # Request (no sensitive data)
    model: str = ""
    prompt_hash: str = ""  # Hash of the prompt, not the prompt itself
    prompt_length: int = 0

    # Response
    response_id: str = ""
    output_length: int = 0
    input_tokens: int = 0
    output_tokens: int = 0

    # Moderation
    input_flagged: bool = False
    output_flagged: bool = False

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

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

Compleet Auditsysteem

De client die deze structuur benut, koppelt input-moderatie, de API-oproep, output-moderatie en schrijft in elk geval. Het belangrijke woord is append-only: het JSONL-bestand wordt geopend in toevoegmodus, nooit herschreven, wat de voorwaarde is voor een log om bewijskracht te hebben. Let op het pad van een gemarkeerde entry—het record wordt opgeslagen voordat de exceptie wordt opgeworpen, met de status blocked_input. Een blokkering laat dus net zo goed een spoor na als een succes, en het laatste except-blok garandeert dat geen enkele fout, wat de oorsprong ook is, onder de radar blijft.

import time
from openai import OpenAI

class AuditedClient:
    """OpenAI client with integrated audit trail."""

    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:
        """Truncated SHA-256 hash for auditing."""
        return hashlib.sha256(text.encode()).hexdigest()[:16]

    def _save_audit(self, record: AuditRecord):
        """Saves an audit record (append-only)."""
        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:
        """API call with automatic auditing."""

        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:
            # Input moderation
            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("Inappropriate input content")

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

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

            # Fill metrics
            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

# Usage
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)

In dit voorbeeld bereikt het e-mailadres dat als user_id wordt doorgegeven nooit het bestand: het wordt gehasht zodra het record wordt geconstrueerd. Een JSONL-bestand werkt prima om mee te beginnen en voor een enkele instantie; zodra meerdere processen parallel schrijven, stuurt u deze stream dan naar een database of een log-collector.

Audit Queries

Een log die u niet kunt bevragen, dient alleen om schijfruimte in beslag te nemen. Regel-voor-regel lezen van het JSONL-formaat maakt exploitatie triviaal, en het onderstaande rapport vat de gedekte periode samen, de verdeling tussen successen, fouten en blokkeringen, tokenverbruik en gemiddelde latentie. Het aantal unieke gebruikers is gebaseerd op hashes, wat overigens bewijst dat een gepseudonimiseerde log perfect analyseerbaar blijft.

import json

def read_audit(file: str = "audit.jsonl") -> list[dict]:
    """Reads all audit records."""
    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:
    """Generates an audit report."""
    records = read_audit(file)

    if not records:
        return {"message": "No records"}

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

Bewaring en Archivering

Het oneindig bewaren van data strijdt met het principe van opslagbeperking; te vroeg verwijderen ontneemt u het bewijs dat u misschien nodig hebt. Rotatie lost dit dilemma op: na een door u ingestelde duur—hier negentig dagen—verlaten records het actieve bestand voor een gedateerd archief, terwijl het huidige log alleen met de recente wordt herschreven. Plan deze functie in als een periodieke taak en stem retention_days af op het beleid dat door uw juridisch adviseur is gevalideerd, niet op een willekeurig gekozen waarde.

from datetime import datetime, timedelta
import shutil
import os

def archive_audit(file: str = "audit.jsonl",
                  retention_days: int = 90):
    """Archives and purges old records."""
    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:
        # Archive old ones
        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")

        # Rewrite main file with recent ones
        with open(file, "w", encoding="utf-8") as f:
            for record in recent:
                f.write(json.dumps(record, ensure_ascii=False) + "\n")

        print(f"Archived {len(archives)} records to {archive_name}")
        print(f"Kept {len(recent)} recent records")

Europese AI-wet: Wat Verandert

De Europese AI-wet (AI Act) legt verplichtingen op op basis van het risiconiveau van uw applicatie. De logica is gefaseerd: hoe meer uw systeem weegt op het leven van mensen, hoe strenger de eisen. Een FAQ-chatbot, een samenvatting of een vertaling valt onder minimaal risico en vereist alleen basis transparantie. Zodra er sprake is van conversatie of sentimentanalyse, gaat u over naar beperkt risico, met de verplichting om de gebruiker te informeren dat deze met een AI interacteert. De sprong is abrupt voor hoog risico—kredietscoring, werving, medische diagnose—waar conformiteitsbeoordeling, risicobeheer, documentatie van trainingsdata, volledige traceerbaarheid, menselijk toezicht en demonstratie van nauwkeurigheid bijkomen. Bepaalde toepassingen, zoals sociale scoring of subliminale manipulatie, zijn puur verboden.

# Assess the risk level of your application
RISK_LEVELS = {
    "minimal": {
        "examples": ["FAQ chatbot", "text summary", "translation"],
        "obligations": ["Basic transparency"]
    },
    "limited": {
        "examples": ["customer service chatbot", "sentiment analysis"],
        "obligations": ["Inform the user they are interacting with an AI"]
    },
    "high": {
        "examples": ["credit scoring", "recruitment", "medical diagnosis"],
        "obligations": [
            "Conformity assessment",
            "Risk management system",
            "Documented training data",
            "Logging and complete traceability",
            "Mandatory human supervision",
            "Demonstrated accuracy and robustness"
        ]
    },
    "unacceptable": {
        "examples": ["social scoring", "subliminal manipulation"],
        "obligations": ["PROHIBITED"]
    }
}

Positioneer uw project eerlijk in dit raster voordat u de eerste regel code schrijft: een applicatie die als hoog risico wordt geclassificeerd, legt architecturale beperkingen op—uitputtende logging, menselijk controlepunt—die niet achteraf kunnen worden opgeplakt op een systeem dat zonder deze elementen is ontworpen.

Compliance Checklist

  • Append-only audit trail met tijdstempel
  • Hash van persoonsgegevens in logs (nooit als platte tekst)
  • Systematische moderatie van inputs en outputs
  • Up-to-date AVG-register van verwerkingsactiviteiten
  • Gedefinieerd bewaar- en archiveringsbeleid
  • Uitgevoerde risiconiveaubeoordeling volgens de AI-wet
  • Gebruikers informeren dat ze met een AI interacteren
  • Menselijk toezicht bij impactvolle beslissingen

Belangrijkste punten

  • Een audit trail is verplicht voor regulatory compliance
  • Log in append-only modus: bestaande records nooit wijzigen
  • Hash alle persoonsgegevens in audit logs
  • De Europese AI-wet classificeert applicaties op risiconiveau
  • Implementeer automatische moderatie EN menselijk toezicht
  • Definieer een bewaarbeleid en archiveer regelmatig

Test Uw Kennis

Tweeëntwintig API-lessen: valideer de mechanismen die productie bij elkaar houden.

1. Waarom migreren naar de Responses API in plaats van te blijven bij Chat Completions?

Antwoord: Het is de moderne API van OpenAI: geïntegreerd beheer van conversatiestatus, native tools en evolutie daarop gericht—Chat Completions blijft ondersteund maar is verouderd.

2. Hoe kiest u tussen Sol, Terra en Luna aan de API-kant?

Antwoord: gpt-5.6-sol voor veeleisende taken, terra voor kosten/kwaliteit-balans, luna voor economisch volume—en het redeneerniveau (none→max) wordt vervolgens per verzoek aangepast.

3. Wat garandeert Structured Output?

Antwoord: Output die conform is aan het verstrekte JSON-schema—velden, typen, structuur—bruikbaar door een programma zonder defensieve parsing of reparatie.

4. Wat doet u bij een 429-fout?

Antwoord: Respecteer rate limits: probeer opnieuw met exponentiële backoff (en jitter), beperk het aantal pogingen en plan voor een circuit breaker—nooit een directe retry-lus.

5. Noem twee onmisbare beschermingen aan de kant van applicatiebeveiliging.

Antwoord: Moderatie van inkomende/uitgaande content via de dedicated API, en verdediging tegen prompt injection: isoleer instructies van data, valideer outputs, beperk blootgestelde mogelijkheden.

Productie, beveiliging, compliance: de laatste drie blokken van de cursus maken het verschil tussen een prototype en een dienst—houd ze als checklist.