Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Megfelelés és naplózás

22. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Megfelelés és naplózás
  2. Miért van szükség auditálási naplóra?
  3. Egy audit-bejegyzés felépítése
  4. Teljes auditáló rendszer
  5. Lekérdezések az audit-naplón
  6. Megőrzés és archiválás
  7. Európai AI-törvény (AI Act): mi változik
  8. Megfelelési ellenőrzőlista
  9. Főbb megállapítások
  10. Teszteld a tudásod!

Megfelelés és naplózás

Éles környezetben futó AI-alkalmazások esetén a nyomon követhetőség elengedhetetlen. A teljes körű auditálási napló (audit trail) megvéd téged egy ellenőrzés, egy jogvita vagy egy incidens során. Ez a lecke bemutatja, hogyan építs fel egy robusztus naplózási rendszert, lezárva ezzel a tanfolyamot: itt kapcsolódik össze minden, amit eddig felépítettél – a naplózás, a moderálás és az adatvédelem – egyetlen, jól védhető keretrendszerbe.

Miért van szükség auditálási naplóra?

Négy különböző igény fut össze ugyanazon az infrastruktúrán. Először is: szabályozói megfelelés. A GDPR, az európai AI-törvény (AI Act) és az iparági szabványok mind megkövetelik, hogy bizonyítani tudd, mit csinál a rendszered; bizonyíték naplók nélkül pedig értéktelen. Másodszor: nyomon követhetőség szigorú értelemben – tudnod kell, ki, mikor, mit csinált, milyen eredménnyel, akár hat hónappal később is. A hibakeresés nap mint nap profitál ebből, hiszen a váratlan modellviselkedés megértéséhez vissza kell tudnod állítani a hívás pontos körülményeit. Végül: elszámoltathatóság. Az AI által hozott döntések dokumentálása teszi lehetővé, hogy szükség esetén igazolni tudd: egy vitatott ajánlás ellenőrzött folyamaton alapul.

Egy audit-bejegyzés felépítése

Az alábbi dataclass egyszerre szerződés és adatszerkezet. Csoportosítja az azonosítókat, az alkalmazáskontextust, a kérést, a választ, a moderálási döntést és a technikai metaadatokat. Két választás kiemelt figyelmet érdemel. A felhasználói azonosító csak hashelt formában jelenik meg, soha nem olvasható szövegként. A promptot pedig nem tároljuk: csak a hash-ét és a hosszát rögzítjük. Így bizonyítható marad, hogy két hívás ugyanarra a tartalomra vonatkozott, anélkül, hogy archívumot hoznál létre a felhasználóid által írtakból.

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)

Teljes auditáló rendszer

Az ezt a struktúrát használó kliens láncolja össze a bemeneti moderálást, az API-hívást, a kimeneti moderálást, és minden esetben ír a naplóba. A kulcsszó: csak hozzáfűzés (append-only). A JSONL-fájlt hozzáfűző módban nyitjuk meg, soha nem írjuk felül; ez a feltétele annak, hogy a naplónak bizonyító ereje legyen. Figyeld meg a megjelölt bejegyzés útját: a rekordot mielőtt kivételt dobnánk, elmentjük, blocked_input állapottal. Egy blokkolás tehát ugyanúgy nyomot hagy, mint egy siker, a végső except blokk pedig garantálja, hogy semmilyen hiba – bármilyen eredetű is – ne csússzon észrevétlenül.

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)

Ebben a példában a user_id-ként átadott e-mail-cím soha nem kerül a fájlba: a rekord létrehozásakor azonnal hasheljük. Egy JSONL-fájl tökéletesen megfelel a kezdéshez és egyetlen példány esetén; amint több folyamat ír párhuzamosan, irányítsd ezt a folyamot adatbázisba vagy naplógyűjtőbe.

Lekérdezések az audit-naplón

Egy napló, amit nem tudsz lekérdezni, csak a lemezterületet foglalja. A JSONL-formátum soronkénti olvasása triviálissá teszi a feldolgozást; az alábbi jelentés összefoglalja a lefedett időszakot, a sikerek, hibák és blokkolások eloszlását, a tokenfogyasztást és az átlagos késleltetést. Az egyedi felhasználók száma hasheken alapul, ami mellesleg bizonyítja: egy álanevesített napló is tökéletesen elemezhető.

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

Megőrzés és archiválás

Az adatok végtelen ideig tartó tárolása ellentmond a tárolás korlátozásának elvével; a túl korai törlés viszont megfoszt a szükséges bizonyítéktól. A rotáció oldja fel ezt a dilemmát: egy általad meghatározott időtartamon túl – itt 90 nap – a rekordok kikerülnek az aktív fájlból egy dátumozott archívumba, míg az aktuális napló csak a legfrissebbekkel marad meg. Ütemezd ezt a függvényt periodikus feladatként, és a retention_days értékét igazítsd a jogi tanácsadóid által jóváhagyott szabályzathoz, ne egy véletlenszerűen választott számhoz.

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

Európai AI-törvény (AI Act): mi változik

Az európai AI-törvény (AI Act) az alkalmazásod kockázati szintje alapján ró ki kötelezettségeket. A logika fokozatos: minél nagyobb súllyal hat rendszered az emberek életére, annál szigorúbbak a követelmények. Egy GYIK-chatbot, egy összefoglaló vagy egy fordítás minimális kockázatúnak minősül, és csupán alapvető átláthatóságot igényel. Amint beszélgetés vagy érzelemelemzés lép képbe, már a korlátozott kockázatú kategóriába kerülsz, ahol kötelező tájékoztatni a felhasználót, hogy AI-val lép kapcsolatba. A ugrás drasztikus a magas kockázatú eseteknél – hitelminősítés, toborzás, orvosi diagnózis –, ahol hozzáadódik a megfelelőségértékelés, a kockázatkezelés, a tanító adatok dokumentálása, a teljes körű nyomon követhetőség, az emberi felügyelet és a pontosság igazolása. Bizonyos felhasználási módok, mint a közösségi pontozás vagy a szubliminális manipuláció, kifejezetten tiltottak.

# 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"]
    }
}

Őszintén helyezd el a projektedet ebben a mátrixban, még az első sor kód megírása előtt: egy magas kockázatú alkalmazás olyan architektúrális kényszereket szab – kimerítő naplózás, emberi ellenőrzési pontok –, amelyeket utólag nem lehet ráoltani egy olyan rendszerre, amelyet ezek nélkül terveztek.

Megfelelési ellenőrzőlista

  • Csak hozzáfűthető (append-only) audit-napló időbélyeggel
  • Személyes adatok hashelése a naplókban (soha nem olvasható szövegként)
  • A bemenetek és kimenetek szisztematikus moderálása
  • Naprakész GDPR-adatkezelési nyilvántartás
  • Meghatározott megőrzési és archiválási szabályzat
  • Elvégzett AI Act kockázatszint-felmérés
  • A felhasználók tájékoztatása, hogy AI-val lépnek kapcsolatba
  • Emberi felügyelet jelentős hatású döntések esetén

Főbb megállapítások

  • Az auditálási napló kötelező a szabályozói megfeleléshez
  • Naplózz csak hozzáfűző módban: soha ne módosíts meglévő bejegyzéseket
  • Hashelj minden személyes adatot az audit-naplókban
  • Az európai AI-törvény kockázati szintek szerint osztályozza az alkalmazásokat
  • Valósíts meg automatikus moderálást ÉS emberi felügyeletet
  • Határozz meg megőrzési szabályzatot, és rendszeresen archiválj

Teszteld a tudásod!

Huszonkét API-lecke: validáld azokat a mechanizmusokat, amelyek az éles rendszert összetartják.

1. Miért érdemes áttérni a Responses API-ra, ahelyett, hogy a Chat Completionsön maradnál?

Válasz: Ez az OpenAI modern API-ja: integrált beszélgetésállapot-kezelés, natív eszközök, és a fejlesztés fókusza is ezen van – a Chat Completions továbbra is támogatott, de örökölt.

2. Hogyan választasz Sol, Terra és Luna között az API oldalán?

Válasz: A gpt-5.6-sol igényes feladatokhoz, a terra a költség/minőség egyensúlyhoz, a luna pedig gazdaságos nagy volumenhez – a következtetési szintet (none→max) ezután kérésenként állítod.

3. Mit garantál a Structured Output?

Válasz: A megadott JSON-sémának megfelelő kimenetet – mezők, típusok, struktúra –, amelyet program közvetlenül felhasználhat védekező elemzés vagy javítás nélkül.

4. Mit teszel egy 429-es hiba esetén?

Válasz: Tiszteletben tartod a sebességkorlátokat: exponenciális visszalépéssel (és jitterrel) próbálkozol újra, korlátozod a kísérletek számát, és tervezel áramkörmegszakítót – soha nem indítasz azonnali újrapróbálkozási ciklust.

5. Nevezz meg két nélkülözhetetlen védelmi intézkedést az alkalmazásbiztonság oldalán.

Válasz: A bejövő és kimenő tartalom moderálása a dedikált API-n keresztül, valamint a prompt-injekció elleni védelem: válaszd el az utasításokat az adatoktól, validáld a kimeneteket, és korlátozd a kitett képességeket.

Élesítés, biztonság, megfelelés: a tanfolyam utolsó három blokkja teszi a különbséget prototípus és szolgáltatás között – tartsd meg őket ellenőrzőlistaként.