Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Comhlíonadh agus Rian Iniúchta

Ceacht 22 as 22 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Comhlíonadh agus Rian Iniúchta
  2. Cén Fáth Rian Iniúchta?
  3. Struchtúr an Taifeasta Iniúchta
  4. Córas Iniúchta Iomlán
  5. Ceisteanna ar an Iniúchadh
  6. Coinneáil agus Cartlannú
  7. Acht AI na hEorpa: Cad a Athraíonn
  8. Liosta Seiceála Comhlíonta
  9. Príomhphointí
  10. Tástáil do Chuid Eolais

Comhlíonadh agus Rian Iniúchta

I gcás feidhmchláir AI sa táirgeadh, is bunúsach an t-in-riantheacht. Cosnaíonn rian iniúchta iomlán thú le linn iniúchta, faoi chonspóid nó i dtéagmhas. Taispeánann an cheacht seo conas córas iniúchta láidir a chur i bhfeidhm, agus críochnaímid an cúrsa léi trí gach rud a thóg tú go dtí seo—logáil, móidearálú agus cosaint sonraí—a thabhairt le chéile i bhfráma amháin inchruthaithe.

Cén Fáth Rian Iniúchta?

Tagann ceithre ghá ar leith le chéile ar an mbonneagar céanna. Ar dtús, comhlíonadh rialúil: éilíonn an GDPR, Acht AI na hEorpa agus caighdeáin na hearnála go léir go ndíolfá cad a dhéanann do chóras, agus níl le rá ag díoladh gan logaí. An dara, in-riantheacht sa chiall dhocht—a fháil amach cé a rinne cad, cathain, agus cén toradh a bhí air, fiú sé mhí ina dhiaidh sin. Tairbheoidh dífhabhtú as seo go laethúil, mar is gá dála cruinne an ghlaoch a aisiompú chun iompraíocht neamh-ionchaiseach an mhúnla a thuiscint. Ar deireadh, cuntasacht: is é doiciméadú na gcinntí a ghlac an AI a chumasóidh duit, san am iomchuí, a thaispeáint go raibh moladh faoi chonspóid bunaithe ar phróiseas faoi rialú.

Struchtúr an Taifeasta Iniúchta

Is conradh chomh mór is is struchtúr sonraí é an dataclass thíos. Cuireann sé aitheantóirí, comhthéacs an fheidhmchláir, an t-iarratas, an fhreagairt, breithiúnas an mhóidearála agus meiteashonraí teicniúla le chéile. Tá beirt roghanna dírithe ar aire. Ní fheictear an t-aitheantóir úsáideora ach i bhfoirm hasháilte, riamh i ngnáth-théacs. Agus ní stóráiltear an prompt: ní choimeádach ach a hash agus a fhad. Coimeádann sé sin duit an cumas a chruthú gur an chéad ábhar céanna a bhí i gceist le dhá ghlaoch, gan ariamh cartlann de na scríobh d’úsáideoirí a chruthú.

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)

Córas Iniúchta Iomlán

Nascann an cliant a bhaineann úsáid as an struchtúr seo móidearálú ionchuir, glaoch API, móidearálú aschuir agus scríobh i ngach cás i slabhra. Is é an focal tábhachtach ná append-only: osclaítear an comhad JSONL i mód forchurtha, athscríobh riamh, agus sin coinníoll bheith i bhfianaise ag loga. Tabhair faoi deara cosán iontrála brataithe—sábháiltear an taifeastas sula ndéantar an eisceacht, leis an stádas blocked_input. Mar sin fágann blocáil rian díreach mar a fhágann rath, agus deimhníonn an bloc except deiridh nach sleamhnaíonn aon earráid, is cuma cá as a thagann sí, faoi raide.

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)

Sa sampla seo, ní shroicheann an seoladh ríomhphoist a sheoltar mar user_id an comhad riamh: hasháiltear é a luaithe a thógtar an taifeastas. Feidhmíonn comhad JSONL go maith chun tosú agus d’eamharc amháin; a luaithe a scríobhann roinnt próisis i gcomhthreomhar, seol an sruth seo chuig bunachar sonraí nó chuig bailitheoir logaí.

Ceisteanna ar an Iniúchadh

Ní dhéanann loga nach féidir fiafraí de ach spás diosca a ghabháil. Fágann léamh líne ar líne den fhormáid JSONL an t-úsáid furasta, agus achoimríonn an tuarascáil thíos an tréimhse chuimsithe, an dáileadh idir rath, earráidí agus blocálacha, tomhaltas token, agus an mhoill mheánach. Baineann comhaireamh na n-úsáideoirí uathúil hashanna, rud a chruthaíonn, go táthach, go bhfanann loga bréigh ainmnithe an-inanailíse go hiomlán.

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

Coinneáil agus Cartlannú

Tá sonraí a choinneáil go deo i gcontrárthacht le prionsabal theorannú na stórála; scriosadh am roimh am díothaíonn de na cruthúnais d’fhéadfá a bheith ag teastáil uait. Réitíonn rothlú an dilemma seo: thar thréimhse a shocraíonn tú—nocha lá anseo—imíonn taifeastais as an gcomhad gníomhach go cartlann dátaithe, agus athscríobhtar an loga reatha leis na cinn úra amháin. Sceideal an fheidhm seo mar thasc thréimhsiúil agus ailínigh retention_days leis an bpolasaí a dheimhnigh do chomhairleoir dlí, ní le luach a roghnaíodh ar aimléar.

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

Acht AI na hEorpa: Cad a Athraíonn

Cuireann Acht AI na hEorpa (AI Act) oibleagáidí ort bunaithe ar leibhéal riosca d’fheidhmchlár. Is céimnitheach an loighic: dá troime a bhíonn meáchan ag do chóras ar shaol na ndaoine, is amhlaidh is géire na riachtanais. Tagann chatbót FAQ, achoimre téacs nó aistriúchán faoi riosca íosta, agus ní leagann siad ach trédhearcacht bhunúsach romhat. A luaithe a bhíonn comhrá nó anailís faire i gceist, bogann tú go riosca teoranta, leis an oibleagáid an t-úsáideoir a chur ar an eolas go bhfuil sé ag idirghníomhú le AI. Tá an léim géar don riosca ard—scór creidmheasa, earcaíocht, diagnóis Leighis—áit a gcuirtear measúnú comhlíonta, bainistíocht riosca, doiciméadú sonraí oiliúna, in-riantheacht iomlán, faire dhaonna agus léiriú cruinnis leis. Toirmiscear go hiomlán úsáidí áirithe, scór sóisialta nó manipuliú fo-fhiosrach mar shampla.

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

Suigh do thionscadal sa ghreille seo go macánta sula scríobhann tú an chéad líne cóid: cuireann feidhmchlár a rangófar mar riosca ard srianta ailtireachta ort—logáil chuimsitheach, pointe rialaithe daonna—nach féidir iad a phiochadh isteach i gcóras a dearadh gan iad ina dhiaidh sin.

Liosta Seiceála Comhlíonta

  • Rian iniúchta append-only le stamp ama
  • Sonraí pearsanta i logaí faoi hash (riamh i ngnáth-théacs)
  • Móidearálú córasach ionchur agus aschur
  • Taifeacht próiseála GDPR cothrim le dáta
  • Polasaí sainithe coinneála agus cartlainne
  • Measúnú leibhéal riosca Acht AI déanta
  • Cuir an t-úsáideoir ar an eolas go bhfuil sé ag idirghníomhú le AI
  • Faire dhaonna ar chinntí a bhfuil meáchan leo

Príomhphointí

  • Tá rian iniúchta riachtanach chun rialacháin a chomhlíonadh
  • Logáil i mód append-only: ná hathraigh taifeastais atá ann cheana
  • Cuir gach sonra pearsanta i logaí iniúchta faoi hash
  • Rangúnn Acht AI na hEorpa feidhmchláir de réir leibhéal riosca
  • Cuir móidearálú uathoibríoch agus faire dhaonna i bhfeidhm araon
  • Sainigh polasaí coinneála agus cartlannaigh go rialta

Tástáil do Chuid Eolais

Fichead a dó ceacht API: bailíochtaigh na meicníochtaí a choinníonn an táirgeadh le chéile.

1. Cén fáth a ndéanfá aistriú chuig an Responses API in ionad fanacht ar Chat Completions?

Freagra: Is í API nua-aimseartha OpenAI í: bainistícht stáit comhrá chomhtháite, uirlisí dúchasacha, agus forthírthe uirthi—tacaítear le Chat Completions fós ach gur oidhreacht atá ann.

2. Conas a roghnaíonn tú idir Sol, Terra agus Luna ar thaobh na API?

Freagra: gpt-5.6-sol do thascanna éilimseacha, terra ar chothromaíocht chostais/cáilíochta, luna do mhéideanna eacnamaíocha—agus coigeartaítear leibhéal na réasúnaíochta (none→max) in aghaidh an iarratais dá réir.

3. Cad a ráthaíonn an t-aschur struchtúrtha?

Freagra: Aschur ag teacht don scéama JSON a soláthraíodh—réimsí, cineálacha, struchtúr—inchurtha ag clár gan parseáil chosainteach ná deisiú.

4. Cad a dhéanann tú i ngais earráid 429?

Freagra: Urraim teorainneacha ráta: triail arís le cúlchéimniú easponantúil (agus jitter), cuir srian le hiarrachtaí, agus beartaigh briseadóir ciorcaid—ní lúb athtrialla láithreach riamh.

5. Ainmnigh beirt chosaint dosheachainte ar thaobh shlándáil an fheidhmchláir.

Freagra: Móidearálú an ábhair isteach/amach tríd an API ar leith dó, agus cosaint in aghaidh instealladh prompt: scar treoracha ó shonraí, bailíochtaigh aschuir, agus shriang cumais noichte.

Táirgeadh, slándáil, comhlíonadh: cinníonn na trí bhloc dheireanacha den chúrsa an difríocht idir réamhshampla agus seirbhís—coimeád mar liosta seiceála iad.