Compliance och granskningsbarhet
På denna sida
Compliance och granskningsbarhet
För AI-applikationer i produktion är spårbarhet avgörande. En komplett granskningskedja skyddar dig vid en inspektion, en tvist eller en incident. Den här lektionen visar hur du implementerar ett robust granskningssystem och avslutar kursen genom att sammanföra allt du byggt hittills – loggning, moderering och dataskydd – till ett enda, försvarbart ramverk.
Varför en granskningskedja?
Fyra olika behov konvergerar mot samma infrastruktur. För det första regelefterlevnad: GDPR, EU:s AI-lag och branschstandarder kräver alla att du kan demonstrera vad ditt system gör, och en demonstration utan loggar är värdelös. För det andra spårbarhet i strikt mening – att veta vem som gjorde vad, när, med vilket resultat, även sex månader senare. Felsökning drar nytta av detta dagligen, eftersom förståelse för oväntat modellbeteende kräver att du kan återskapa exakt vilka förhållanden som rådde vid anropet. Slutligen ansvarsskyldighet: att dokumentera beslut fattade av AI:n är vad som låter dig, när tiden kommer, visa att en ifrågasatt rekommendation vilade på en kontrollerad process.
Struktur för en granskningspost
dataclass-en nedan är lika mycket ett kontrakt som en datastruktur. Den grupperar identifierare, applikationskontext, begäran, svar, modereringsbeslut och teknisk metadata. Två val förtjänar din uppmärksamhet. Användaridentifieraren förekommer endast i hashad form, aldrig i klartext. Och prompten lagras inte: endast dess hash och längd sparas. Detta bevarar din förmåga att bevisa att två anrop gällde samma innehåll utan att någonsin skapa ett arkiv över vad dina användare skrivit.
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)
Komplett granskningssystem
Klienten som utnyttjar denna struktur kedjar ihop inmatningsmoderering, API-anrop, utmatningsmoderering och skriver i varje fall. Det viktiga ordet är endast tillägg (append-only): JSONL-filen öppnas i tilläggsläge, skrivs aldrig om, vilket är villkoret för att en logg ska ha bevisvärde. Notera flödet för en flaggad post – posten sparas innan undantaget höjs, med statusen blocked_input. En blockering lämnar alltså ett spår precis som en framgång, och det sista except-blocket garanterar att inget fel, oavsett ursprung, glider under radarn.
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)
I detta exempel når e-postadressen som skickas som user_id aldrig filen: den hashas så snart posten konstrueras. En JSONL-fil fungerar bra för att komma igång och för en enskild instans; så snart flera processer skriver parallellt bör du dirigera denna ström till en databas eller en loggsamlare.
Granskningsfrågor
En logg du inte kan fråga tjänar bara till att uppta diskutrymme. Rad-för-rad-läsning av JSONL-formatet gör utnyttjande trivialt, och rapporten nedan sammanfattar den täckta perioden, fördelningen mellan framgångar, fel och blockeringar, tokenförbrukning och genomsnittlig latens. Räkningen av unika användare förlitar sig på hashar, vilket bevisar för övrigt att en pseudonymiserad logg förblir fullt analyserbar.
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))
Lagringstid och arkivering
Att behålla data i all evighet strider mot principen om lagringsbegränsning; att radera för tidigt berövar dig det bevis du kanske behöver. Rotation löser detta dilemma: efter en duration du ställer in – här nittio dagar – flyttas poster från den aktiva filen till ett daterat arkiv, medan den aktuella loggen skrivs om med endast de senaste. Schemalägg denna funktion som en periodisk uppgift och anpassa retention_days till den policy som validerats av ditt juridiska ombud, inte ett slumpmässigt valt värde.
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")
EU:s AI-lag: Vad som ändras
EU:s AI-lag (AI Act) inför skyldigheter baserade på risknivån för din applikation. Logiken är graderad: ju mer ditt system väger tungt i människors liv, desto striktare kraven. En FAQ-chattbot, en sammanfattning eller en översättning faller under minimal risk och kräver endast grundläggande transparens. Så snart det finns konversation eller sentimentanalys rör du dig till begränsad risk, med skyldigheten att informera användaren om att de interagerar med en AI. Hoppet är abrupt för hög risk – kreditbetygsättning, rekrytering, medicinsk diagnos – där överensstämmelsebedömning, riskhantering, dokumentation av träningsdata, komplett spårbarhet, mänsklig övervakning och demonstration av noggrannhet tillkommer. Vissa användningar, såsom social poängsättning eller subliminal manipulation, är rentav förbjudna.
# 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"]
}
}
Placera ärligt ditt projekt i detta rutnät innan du skriver den första kodraden: en applikation klassificerad som hög risk pålägger arkitektoniska begränsningar – uttömmande loggning, kontrollpunkt för människa – som inte kan graftas på i efterhand till ett system designat utan dem.
Checklista för regelefterlevnad
- Granskningskedja endast med tillägg (append-only) med tidsstämpel
- Hash av personuppgifter i loggar (aldrig i klartext)
- Systematisk moderering av inmatning och utmatning
- Uppdaterad GDPR-förteckning över behandlingsaktiviteter
- Definierad policy för lagringstid och arkivering
- Risknivåbedömning enligt AI-lagen genomförd
- Informera användare om att de interagerar med en AI
- Mänsklig övervakning för beslut med stor påverkan
Viktiga punkter
- En granskningskedja är obligatorisk för regelefterlevnad
- Logga i läge endast med tillägg: modifiera aldrig befintliga poster
- Hasha alla personuppgifter i granskningsloggar
- EU:s AI-lag klassificerar applikationer efter risknivå
- Implementera automatisk moderering OCH mänsklig övervakning
- Definiera en policy för lagringstid och arkivera regelbundet
Testa dina kunskaper
Tjugotvå API-lektioner: validera de mekanismer som håller produktionen samman.
1. Varför migrera till Responses API istället för att stanna på Chat Completions?
Svar: Det är OpenAI:s moderna API: integrerad hantering av konversationstillstånd, inbyggda verktyg och utveckling fokuserad på detta – Chat Completions förblir supportat men är legacy.
2. Hur väljer du mellan Sol, Terra och Luna på API-sidan?
Svar: gpt-5.6-sol för krävande uppgifter, terra för balans mellan kostnad och kvalitet, luna för ekonomisk volym – och resonemangsnivån (none→max) justeras sedan per begäran.
3. Vad garanterar Structured Output?
Svar: Utmatning som följer det angivna JSON-schemat – fält, typer, struktur – utnyttjbar av ett program utan defensiv parsning eller reparation.
4. Vad gör du vid ett 429-fel?
Svar: Respektera hastighetsbegränsningar: försök igen med exponentiell backoff (och jitter), sätt ett tak för försök och planera för en kretsbrytare – aldrig en omedelbar retry-loop.
5. Nämn två oumbärliga skydd på applikationssäkerhetssidan.
Svar: Moderering av inkommande/utgående innehåll via det dedikerade API:t, och försvar mot prompt-injection: isolera instruktioner från data, validera utmatningar, begränsa exponerade kapaciteter.
Produktion, säkerhet, regelefterlevnad: de tre sista blocken i kursen gör skillnaden mellan en prototyp och en tjänst – behåll dem som en checklista.