Compliance en Audit Trail
Op deze pagina
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.