Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Arkitettura ta' Sigurtà Kompluta

Lezzjoni 12 / 12 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Il-Għaqda tal-Biċċiet Kollha
  2. Ħarsa ġenerali lejn l-arkitettura
  3. Implimentazzjoni kompluta
  4. Użu fil-produzzjoni
  5. Monitoraġġ u avviżi
  6. Konklużjoni tal-kors
  7. Punti Ewlenin
  8. Ittestja l-Għarfien Tiegħek

Aġġornat fit-3 ta’ Novembru 2026. Is-saff tal-ġenerazzjoni qabel kien jgħaddi format imħarreġ ta’ guardrails (enabled), u l-politika tal-produzzjoni kienet tuża kategoriji li ma jeżistux (hate, violence, unpredictable). Il-kodiċi issa jsegwi l-format uffiċjali moderation_llm_v2 u l-ħdix ċavetti ta’ mistral-moderation-2603. Is-scores, li huma opzjonali fl-SDK, jinqraw b’valur ta’ fallback. Kodiċi vverifikat mat-tipi tal-SDK mistralai verżjoni 3.7.0. Sorsi: Moderation & Guardrailing · Python SDK mistralai.

Il-Għaqda tal-Biċċiet Kollha

Matul dan il-kors, esplorajt il-guardrails, l-API tal-Moderazzjoni, l-11 kategorija, is-soglie, in-niskoprir ta’ jailbreak, il-konformità mal-GDPR, u l-politiki tal-kontenut. Din il-lezzjoni finali tgħaqqad il-blokki kollha f’arkitettura ta’ sigurtà kompluta, lesta għall-produzzjoni.

Ħarsa ġenerali lejn l-arkitettura

Hemm ħames saffi, immexxija minn prinċipju wieħed: ħadd minnhom ma huwa affidabbli waħdu. Guardrail jista’ jinqabeż b’kliem mhux mistenni, mudell ta’ moderazzjoni għandu negattivi foloz, u politika tal-kontenut qatt ma tkopri kull każ. Il-ġibda tagħhom fuq xulxin taħdem għax in-nuqqasijiet ma jikkoinċidux—dak li jaħrab mill-ewwel saff għandu ċans tajjeb li jinqabad mit-tieni.

Il-konsegwenza prattika hija ordni stretta: kull saff irid ikun l-aktar irħiż possibbli qabel ma jaħdem li jmiss. Tivverifika l-format qabel ma ssejjaħ guardrail, u ssejjaħ il-guardrail qabel ma ġġenera—għax kontenut miċħad fl-istad 1 jikkonsma żero tokens.

User
    ↓
[1. Input Validation] → Regex, patterns, rate limiting
    ↓
[2. Mistral Guardrails]  → Pre-generation blocking (403)
    ↓
[3. LLM Generation]      → safe_prompt + secure instructions
    ↓
[4. Output Moderation]   → Moderation API post-generation
    ↓
[5. Logging & Audit]     → Scores, decisions, GDPR audit trail
    ↓
User Response

Implimentazzjoni kompluta

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

# Configuration
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:
    """Complete security architecture for AI applications."""

    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}

    # --- Layer 1: Input Validation ---

    def validate_input(self, text: str) -> dict:
        """Fast validation before any API call."""
        # Maximum length
        if len(text) > 10000:
            return {"valid": False, "reason": "Message too long"}

        # Suspicious characters (Unicode injections)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Invalid characters"}

        # Obvious jailbreak patterns
        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": "Injection pattern detected"
                }

        return {"valid": True}

    # --- Layer 2: Input Moderation ---

    def moderate_input(self, text: str) -> dict:
        """Prompt moderation via 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
        }

    # --- Layer 3: Secure Generation ---

    def generate(self, messages: list) -> str:
        """Generation with guardrails and 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 ""

    # --- Layer 4: Output Moderation ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Response moderation in context."""
        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
        }

    # --- Layer 5: Logging ---

    def log_decision(self, decision: Decision, data: dict):
        """Records the decision for auditing."""
        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))

    # --- Main Pipeline ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Complete secure processing pipeline."""

        # Layer 1: Validation
        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": "Your message cannot be processed."
            }

        # Layer 2: Input Moderation
        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": "This content violates our policy."
            }

        # Layer 3: Generation
        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": "Request blocked by guardrails."
                }
            raise

        # Layer 4: Output Moderation
        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": "The response was filtered."
            }

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

    # --- Utilities ---

    def _check_thresholds(self, scores: dict) -> list:
        """Checks scores against policy thresholds."""
        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:
        """Generates a statistics report."""
        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
            )
        }

Użu fil-produzzjoni

# Define the policy
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
    }
}

# Instantiate the architecture
arch = SecureArchitecture(prod_policy)

# Process requests
result = arch.process(
    "Explain how transformers work",
    system_prompt="You are an AI instructor."
)
print(result["status"])   # expected: "allowed"
print(result["content"])

# Consult statistics
print(arch.report())

Monitoraġġ u avviżi

Żewġ metriċi huma biżżejjed biex timmaniġġja sistema ta’ moderazzjoni, u trid timmonitorjahom f’direzzjonijiet opposti. Ir-rata tal-blokk għandha tibqa’ stabbli: żieda f’daqqa tindika jew attakk jew sodla li diġà qed timblokka utenti leġittimi. Id-distribuzzjoni tal-punteġġi tgħodd daqshekk—jekk il-kontenut tiegħek jikkonċentra ftit taħt is-sodla, is-sodla mhix imqiegħda tajjeb, u l-aġġustament li jmiss mill-utenti tiegħek ikissirha.

def configure_alerts(arch: SecureArchitecture):
    """Configures alerts for monitoring."""
    report = arch.report()

    # Alert if block rate is abnormal
    if report["block_rate"] > 0.15:
        logger.warning(
            f"High block rate: "
            f"{report['block_rate']:.1%}"
        )

    # Alert if jailbreak spikes occur
    # Integrate with Prometheus, Grafana, Datadog, etc.

Konklużjoni tal-kors

Sa tmiem dan il-kors, tkun il-padrun ta’:

  • Custom Guardrails: Imblokka prompts perikolużi qabel il-ġenerazzjoni, ikkonfigura soglie skont il-kategorija, napplika għall-aġenti
  • Moderation API: Ikklassifika l-kontenut b’Mistral Moderation 2, interpreta l-punteġġi madwar l-11 kategorija, ħu deċiżjonijiet awtomatizzati
  • Sigurtà fil-produzzjoni: Iddefinixxi politiki tal-kontenut, skopri injezzjonijiet tal-prompt, żgura l-konformità mal-GDPR
  • Arkitettura kompluta: Għaqqad guardrails + moderazzjoni + monitoraġġ f’pipeline robusta

Issa għandek il-kodiċi kollu meħtieġ biex timplimenta sistema sħiħa ta’ moderazzjoni tal-AI bl-API ta’ Mistral.

Punti Ewlenin

  • L-arkitettura tas-sigurtà tinkludi 5 saffi: validazzjoni, guardrails, ġenerazzjoni, moderazzjoni, logging
  • Kull saff jikkumpensa għad-dgħufijiet tal-oħrajn—din hija difiża fil-fond
  • Immonitorja r-rata tal-blokk u l-punteġġi fil-produzzjoni
  • Żomm il-politika aġġornata b’reviżjonijiet regolari
  • Il-kodiċi kompluta f’din il-lezzjoni hija punt ta’ tluq—adattaha għall-kuntest tiegħek

Ittestja l-Għarfien Tiegħek

Guardrails, moderazzjoni, injezzjoni: l-arkitettura difensiva ċara?

1. Fejn jintervjenu l-guardrails custom?

Tweġiba: Qabel il-mudell: iharsu l-inputs skont ir-regoli tiegħek (suġġetti pprojbiti, formati)—l-ewwel saff, li jevita anke li ssir is-sejħa meta t-talba tkun barra mill-iskop.

2. X'tkopri l-API tal-Moderazzjoni ta' Mistral?

Tweġiba: Ħdix kategoriji ta’ kontenut b’riskju, b’punteġġ għal kull kategorija: is-soglie tiegħek jiddeċiedu jimblokkjaw, jimmarkaw, jew jħallu—ibiddlu politika tal-kontenut f’kodiċi.

3. Kif tiġi definita politika tal-kontenut tajba?

Tweġiba: Skont il-każ d’użu: dak li hu aċċettabbli għall-applikazzjoni, soglie għal kull kategorija, azzjonijiet assoċjati (blokk, riformulazzjoni, eskalar)—dokumentati u ttestjati, mhux impliċiti.

4. Kif tiskopri tentattivi ta' injezzjoni tal-prompt?

Tweġiba: Billi tittratta kull kontenut estern bħala suspettu: tiskopri mudelli ta’ struzzjonijiet fid-data, tiżola l-istruzzjonijiet mid-data, tivverifika l-outputs—u ġġib testijiet offensivi regolari.

5. Kif tidher l-arkitettura ta' sigurtà kompluta?

Tweġiba: Saffi: guardrails fuq l-input, moderazzjoni tal-kontenut, kontrolli fuq l-output, konformità mal-GDPR (minimizzazzjoni, drittijiet), u traċċabbiltà—l-ebda saff waħdu mhu perfett, iżda l-ġibda tagħhom tikkumpensa.

Id-difiża fil-fond mhijiex slogan: kull saff f’dan il-kors jaqbad dak li s-saff ta’ qabel iħalli jgħaddi.