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

Ailtireacht Slándála Iomlán

Ceacht 12 as 12 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Na Píosaí Uile a Chur le Chéile
  2. Forbhreathnú ar an Ailtireacht
  3. Cur i bhFeidhm Iomlán
  4. Úsáid Táirgeachta
  5. Monatóireacht agus Foláirimh
  6. Achoimre an Chúrsa
  7. Príomhphointí
  8. Tástáil do Chuid Eolais

Nuashonraithe an 3 Samhain 2026. D’úsáid an sraitheanna giniúna roimhe seo formáid bhréagach cosanta (enabled), agus d’úsáid an polasaí táirgeachta catagóirí nach raibh ann (hate, violence, unpredictable). Leanann an cód anois an formáid oifigiúil moderation_llm_v2 agus an t-aon eochair déag ó mistral-moderation-2603. Léitear na scóir, atá roghnach sa SDK, le luach cúltaca. Fíoraíodh an cód i gcoinne cineálacha SDK mistralai leagan 3.7.0. Foinsí: Moderation & Guardrailing · Python SDK mistralai.

Na Píosaí Uile a Chur le Chéile

Ar feadh an chúrsa seo, rinne tú iniúchadh ar chosaintí (guardrails), ar an API Moderation, ar na 11 gcatagóir, ar thairseacha, ar bhrath jailbreak, ar chomhlíonadh GDPR, agus ar bheartais ábhair. Cuireann an ceacht deiridh seo na bloic thógála go léir le chéile in ailtireacht slándála iomlán atá réidh don táirgeadh.

Forbhreathnú ar an Ailtireacht

Tá cúig shraith ann, agus tiomáintear iad ag prionsabal amháin: níl aon cheann acu iontaofa leis féin. Is féidir cosaint a sheachaint le frásaíocht gan choinne, tá diúltuithe bréige ag samhlacha measúnaithe, agus ní chlúdaíonn beartas ábhair riamh gach cás. Oibríonn an carnadh toisc nach mbíonn na bearnaí forluite—má shleamhnaíonn rud éigin tríd an gcéad sraitheanna, tá seans maith ann go ngabhfar é ag an dara ceann.

Is é an toradh praiticiúil ná ordú dian: caithfidh gach sraith a bheith chomh saor agus is féidir sula ritear an chéad cheann eile. Bailíochtaíonn tú an formáid sula nglaoitear ar chosaint, agus glaonn tú ar an gcosaint sula ndéantar giniúint—toisc nach n-ídíonn ábhar a dhiúltaítear ag céim 1 aon token.

Úsáideoir
    ↓
[1. Bailíochtú Ionchuir] → Regex, patrúin, teorannú ráta
    ↓
[2. Cosaintí Mistral]  → Blocáil réamhghiniúna (403)
    ↓
[3. Giniúint LLM]      → safe_prompt + treoracha slána
    ↓
[4. Moderation Aschuir]   → API Moderation iar-ghiniúna
    ↓
[5. Logáil & Iniúchadh]     → Scóir, cinntí, rian iniúchta GDPR
    ↓
Freagra don Úsáideoir

Cur i bhFeidhm Iomlán

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import re
import json
import logging
from datetime import datetime, timezone
from enum import Enum

# Cumraíocht
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("moderation")


class Decision(Enum):
    ALLOWED = "allowed"
    BLOCKED_INPUT = "blocked_input"
    BLOCKED_GUARDRAIL = "blocked_guardrail"
    BLOCKED_OUTPUT = "blocked_output"
    ERROR = "error"


class SecureArchitecture:
    """Ailtireacht slándála iomlán d'fheidhmchláir AI."""

    def __init__(self, policy: dict, model: str = "mistral-large-latest"):
        self.policy = policy
        self.model = model
        self.stats = {d.value: 0 for d in Decision}

    # --- Sraitheanna 1: Bailíochtú Ionchuir ---

    def validate_input(self, text: str) -> dict:
        """Bailíochtú tapa roimh aon ghlaoch API."""
        # Fad uasta
        if len(text) > 10000:
            return {"valid": False, "reason": "Teachtaireacht ró-fhada"}

        # Carachtair amhrasacha (instealltaí Unicode)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Carachtair neamhbhailí"}

        # Patrúin jailbreak soiléire
        patterns = [
            r"ignore\s+(all\s+)?(previous|prior|above)",
            r"you\s+are\s+now\s+(DAN|unfiltered)",
            r"oublie\s+(toutes?\s+)?(tes|vos)\s+instructions",
            r"system\s*prompt",
        ]
        for pattern in patterns:
            if re.search(pattern, text, re.IGNORECASE):
                return {
                    "valid": False,
                    "reason": "Patrún insteallta aimsithe"
                }

        return {"valid": True}

    # --- Sraitheanna 2: Moderation Ionchuir ---

    def moderate_input(self, text: str) -> dict:
        """Moderation leid trí API."""
        response = client.classifiers.moderate(
            model="mistral-moderation-2603",
            inputs=[text]
        )
        scores = response.results[0].category_scores or {}
        violations = self._check_thresholds(scores)

        return {
            "allowed": len(violations) == 0,
            "scores": scores,
            "violations": violations
        }

    # --- Sraitheanna 3: Giniúint Shlán ---

    def generate(self, messages: list) -> str:
        """Giniúint le cosaintí agus safe_prompt."""
        response = client.chat.complete(
            model=self.model,
            messages=messages,
            safe_prompt=True,
            guardrails=[
                {
                    "block_on_error": True,
                    "moderation_llm_v2": {
                        "custom_category_thresholds": self.policy["thresholds"],
                        "action": "block",
                    },
                }
            ],
        )
        content = response.choices[0].message.content
        return content if isinstance(content, str) else ""

    # --- Sraitheanna 4: Moderation Aschuir ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Moderation freagra i gcomhthéacs."""
        response = client.classifiers.moderate_chat(
            model="mistral-moderation-2603",
            inputs=[[
                {"role": "user", "content": prompt},
                {"role": "assistant", "content": response_text}
            ]]
        )
        scores = response.results[0].category_scores or {}
        violations = self._check_thresholds(scores)

        return {
            "allowed": len(violations) == 0,
            "scores": scores,
            "violations": violations
        }

    # --- Sraitheanna 5: Logáil ---

    def log_decision(self, decision: Decision, data: dict):
        """Taifeadann sé an cinneadh chun críocha iniúchta."""
        self.stats[decision.value] += 1
        entry = {
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "decision": decision.value,
            "policy": self.policy["name"],
            **data
        }
        logger.info(json.dumps(entry, ensure_ascii=False))

    # --- Príomh Phíblíne ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Píblíne próiseála slán iomlán."""

        # Sraitheanna 1: Bailíochtú
        validation = self.validate_input(user_message)
        if not validation["valid"]:
            self.log_decision(Decision.BLOCKED_INPUT, {
                "reason": validation["reason"]
            })
            return {
                "status": Decision.BLOCKED_INPUT.value,
                "message": "Ní féidir do theachtaireacht a phróiseáil."
            }

        # Sraitheanna 2: Moderation Ionchuir
        check_input = self.moderate_input(user_message)
        if not check_input["allowed"]:
            self.log_decision(Decision.BLOCKED_INPUT, {
                "violations": check_input["violations"]
            })
            return {
                "status": Decision.BLOCKED_INPUT.value,
                "message": "Sáraíonn an t-ábhar seo ár mbeartas."
            }

        # Sraitheanna 3: Giniúint
        messages = []
        if system_prompt:
            messages.append({"role": "system",
                           "content": system_prompt})
        messages.append({"role": "user",
                        "content": user_message})

        try:
            response_text = self.generate(messages)
        except SDKError as e:
            if e.status_code == 403:
                self.log_decision(Decision.BLOCKED_GUARDRAIL, {})
                return {
                    "status": Decision.BLOCKED_GUARDRAIL.value,
                    "message": "Chuir na cosaintí bac ar an iarratas."
                }
            raise

        # Sraitheanna 4: Moderation Aschuir
        check_output = self.moderate_output(user_message, response_text)
        if not check_output["allowed"]:
            self.log_decision(Decision.BLOCKED_OUTPUT, {
                "violations": check_output["violations"]
            })
            return {
                "status": Decision.BLOCKED_OUTPUT.value,
                "message": "Scagadh an freagra."
            }

        # Rath
        self.log_decision(Decision.ALLOWED, {
            "input_max_score": max(check_input["scores"].values(), default=0.0),
            "output_max_score": max(check_output["scores"].values(), default=0.0),
        })

        return {
            "status": Decision.ALLOWED.value,
            "content": response_text,
            "moderation": {
                "input": check_input["scores"],
                "output": check_output["scores"]
            }
        }

    # --- Úsáidí ---

    def _check_thresholds(self, scores: dict) -> list:
        """Seiceálann sé scóir i gcoinne tairseacha an bheartais."""
        violations = []
        for cat, threshold in self.policy["thresholds"].items():
            score = scores.get(cat, 0)
            if score > threshold:
                violations.append({
                    "category": cat,
                    "score": round(score, 3),
                    "threshold": threshold
                })
        return violations

    def report(self) -> dict:
        """Gineann sé tuarascáil staitisticí."""
        total = sum(self.stats.values())
        return {
            "policy": self.policy["name"],
            "total_requests": total,
            "decisions": self.stats,
            "block_rate": round(
                (self.stats["blocked_input"] +
                 self.stats["blocked_guardrail"] +
                 self.stats["blocked_output"]) / max(total, 1),
                3
            )
        }

Úsáid Táirgeachta

# Sainigh an beartas
prod_policy = {
    "name": "Production v1.2",
    "thresholds": {
        "sexual": 0.15, "hate_and_discrimination": 0.1, "violence_and_threats": 0.2,
        "dangerous": 0.1, "criminal": 0.1, "selfharm": 0.1, "health": 0.4,
        "financial": 0.4, "law": 0.4, "pii": 0.15,
        "jailbreaking": 0.1
    }
}

# Cuir an ailtireacht ar bun
arch = SecureArchitecture(prod_policy)

# Próiseáil iarratais
result = arch.process(
    "Explain how transformers work",
    system_prompt="You are an AI instructor."
)
print(result["status"])   # ag súil le: "allowed"
print(result["content"])

# Comhairle staitisticí
print(arch.report())

Monatóireacht agus Foláirimh

Tá dhá mhéadrach leordhóthanach chun córas measúnaithe a stiúradh, agus caithfidh tú faire orthu i dtreoracha contrártha. Ba chóir go mbeadh an ráta blocála cobhsaí: léiríonn méadú tobann ionsaí nó tairseach atá ró-dhian agus ag cur isteach ar úsáideoirí dlisteanacha. Tá an dáileadh scóir chomh tábhachtach céanna—má bhíonn do chuid ábhair bailithe díreach faoin tairseach, tá an tairseach míshuite, agus brisfidh an chéad athrú beag ó d’úsáideoirí é.

def configure_alerts(arch: SecureArchitecture):
    """Cumraíonn sé foláirimh le haghaidh monatóireachta."""
    report = arch.report()

    # Foláireamh má tá an ráta blocála mínormálta
    if report["block_rate"] > 0.15:
        logger.warning(
            f"Ráta blocála ard: "
            f"{report['block_rate']:.1%}"
        )

    # Foláireamh má tá buaicphointí jailbreak ann
    # Comhtháthaigh le Prometheus, Grafana, Datadog, srl.

Achoimre an Chúrsa

Faoin deireadh an chúrsa seo, tá máistreacht bainte amach agat ar:

  • Cosaintí Saincheaptha: Blocáil leideanna contúirteacha roimh ghiniúint, cumraigh tairseacha in aghaidh na catagóire, cuir i bhfeidhm ar ghníomhairí
  • API Moderation: Aicmigh ábhar le Mistral Moderation 2, léirmhínigh scóir thar na 11 gcatagóir, déan cinntí uathoibrithe
  • Slándáil Táirgeachta: Sainigh beartais ábhair, braith instealltaí leide, cinntigh comhlíonadh GDPR
  • Ailtireacht Iomlán: Cuir cosaintí + measúnú + monatóireacht le chéile i bpíblíne láidir

Tá an cód go léir agat anois chun córas iomlán measúnaithe AI a imlonnú leis an API Mistral.

Príomhphointí

  • Áirítear 5 shraith san ailtireacht slándála: bailíochtú, cosaintí, giniúint, measúnú, logáil
  • Déanann gach sraitheanna leas ar laigí na gceann eile—seo cosaint i doimhneacht
  • Déan monatóireacht ar an ráta blocála agus ar na scóir sa táirgeadh
  • Coinnigh do bheartas cothrom le dáta le athbhreithnithe rialta
  • Is pointe tosaigh é an cód iomlán sa cheacht seo—oiriúnaigh é do do chomhthéacs féin

Tástáil do Chuid Eolais

Cosaintí, measúnú, instealladh: an bhfuil an ailtireacht chosantach soiléir?

1. Cá háit a n-idirghabhálann cosaintí saincheaptha?

Freagra: Roimh an tsamhail: scagann siad ionchuir de réir do rialacha (topaicí toirmiscthe, formáidí)—an chéad sraith, a sheachnaíonn an glaoch a dhéanamh fiú nuair atá an t-iarratas lasmuigh den raon feidhme.

2. Cad a chlúdaíonn API Moderation Mistral?

Freagra: Aon chatagóir déag d’ábhar riosca, le scór in aghaidh na catagóire: cinneann do thairseacha an bhfuil le blocáil, le bratachú, nó le ceadú—ag tiontú beartas ábhair ina chód.

3. Conas a shainítear beartas ábhair maith?

Freagra: De réir cás úsáide: cad atá inghlactha don fheidhmchlár, tairseacha in aghaidh na catagóire, gníomhaíochtaí gaolmhara (blocáil, athscríobh, éalú)—doiciméadaithe agus tástáilte, ní intuigthe.

4. Conas a bhrathann tú iarrachtaí insteallta leide?

Freagra: Trí gach ábhar seachtrach a mheas amhrasach: patrúin treoracha a bhrath i sonraí, treoracha a scaradh ó shonraí, aschuir a bhailíochtú—agus tástálacha ionsaitheacha rialta a rith.

5. Cén chuma atá ar an ailtireacht slándála iomlán?

Freagra: Sraitheanna: cosaintí ionchuir, measúnú ábhair, rialuithe aschuir, comhlíonadh GDPR (íoslaghdú, cearta), agus inrianaitheacht—níl aon sraitheanna foirfe, ach déanann an carnadh leas air.

Ní is mórthuairisc é an chosaint i doimhneacht: gabhann gach sraith sa chúrsa seo an rud a ligeann an ceann roimhe tríd.