Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Pilnīga drošības arhitektūra

Nodarbība 12 no 12 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Visu detaļu apvienošana
  2. Arhitektūras pārskats
  3. Pilnīga implementācija
  4. Izmantošana ražošanā
  5. Monitorings un brīdinājumi
  6. Kursa kopsavilkums
  7. Galvenās atziņas
  8. Pārbaudi savas zināšanas

Atjaunināts 2026. gada 3. novembrī. Iepriekš ģenerēšanas slānis izmantoja izgudrotu aizsargmehānismu formātu (enabled), un ražošanas politika izmantoja neeksistējošas kategorijas (hate, violence, unpredictable). Kods tagad atbilst oficiālajam moderation_llm_v2 formātam un vienpadsmit atslēgām no mistral-moderation-2603. Rezultāti (scores), kas SDK ir opcionāli, tiek nolasīti ar rezerves vērtību. Kods pārbaudīts pret mistralai SDK tipu versiju 3.7.0. Avoti: Moderācija un aizsargmehānismi · Python SDK mistralai.

Visu detaļu apvienošana

Šī kursa laikā tu esi izpētījis aizsargmehānismus, Moderācijas API, 11 kategorijas, sliekšņus, “jailbreak” noteikšanu, GDPR atbilstību un satura politikas. Šī noslēdzošā nodarbība apvieno visus šos būvblokus vienotā, ražošanai gatavā drošības arhitektūrā.

Arhitektūras pārskats

Pastāv pieci slāņi, ko virza viens princips: neviens no tiem nav uzticams atsevišķi. Aizsargmehānismu var apiet negaidīts formulējums, moderācijas modelim ir kļūdaini negatīvi rezultāti, un satura politika nekad neaptver katru gadījumu. To slāņošana strādā, jo trūkumi nepārklājas — tas, kas izslīd cauri pirmajam slānim, ar lielu varbūtību tiks aizturēts otrajā.

Praktiskās sekas ir stingra secība: katram slānim jābūt pēc iespējas lētākam, pirms tiek palaists nākamais. Tu validē formātu, pirms izsauc aizsargmehānismu, un izsauc aizsargmehānismu pirms ģenerēšanas — jo saturs, kas noraidīts 1. solī, patērē nulles tokenus.

Lietotājs
    ↓
[1. Ievades validācija] → RegEx, šabloni, ātruma ierobežošana
    ↓
[2. Mistral aizsargmehānismi] → Bloķēšana pirms ģenerēšanas (403)
    ↓
[3. LLM ģenerēšana]      → safe_prompt + drošas instrukcijas
    ↓
[4. Izvades moderācija]   → Moderācijas API pēc ģenerēšanas
    ↓
[5. Žurnālēšana un audits] → Rezultāti, lēmumi, GDPR audita pēdas
    ↓
Lietotāja atbilde

Pilnīga implementācija

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

# Konfigurācija
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:
    """Pilnīga drošības arhitektūra AI lietojumprogrammām."""

    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}

    # --- 1. slānis: Ievades validācija ---

    def validate_input(self, text: str) -> dict:
        """Ātra validācija pirms jebkura API izsaukuma."""
        # Maksimālais garums
        if len(text) > 10000:
            return {"valid": False, "reason": "Ziņojums ir pārāk garš"}

        # Aizdomīgas rakstzīmes (Unicode injekcijas)
        if re.search(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text):
            return {"valid": False, "reason": "Nederīgas rakstzīmes"}

        # Acīmredzami "jailbreak" šabloni
        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": "Atklāts injekcijas šablons"
                }

        return {"valid": True}

    # --- 2. slānis: Ievades moderācija ---

    def moderate_input(self, text: str) -> dict:
        """Pieprasījuma moderācija, izmantojot 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
        }

    # --- 3. slānis: Droša ģenerēšana ---

    def generate(self, messages: list) -> str:
        """Ģenerēšana ar aizsargmehānismiem un 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 ""

    # --- 4. slānis: Izvades moderācija ---

    def moderate_output(self, prompt: str, response_text: str) -> dict:
        """Atbildes moderācija kontekstā."""
        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
        }

    # --- 5. slānis: Žurnālēšana ---

    def log_decision(self, decision: Decision, data: dict):
        """Reģistrē lēmumu auditam."""
        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))

    # --- Galvenā cauruļvada loģika ---

    def process(self, user_message: str,
                system_prompt: str | None = None) -> dict:
        """Pilnīgs drošs apstrādes cauruļvads."""

        # 1. slānis: Validācija
        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": "Tavu ziņojumu nevar apstrādāt."
            }

        # 2. slānis: Ievades moderācija
        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": "Šis saturs pārkāpj mūsu politiku."
            }

        # 3. slānis: Ģenerēšana
        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": "Pieprasījumu bloķēja aizsargmehānismi."
                }
            raise

        # 4. slānis: Izvades moderācija
        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": "Atbilde tika filtrēta."
            }

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

    # --- Utilītfunkcijas ---

    def _check_thresholds(self, scores: dict) -> list:
        """Pārbauda rezultātus pret politikas sliekšņiem."""
        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:
        """Ģenerē statistikas pārskatu."""
        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
            )
        }

Izmantošana ražošanā

# Definē politiku
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
    }
}

# Inicializē arhitektūru
arch = SecureArchitecture(prod_policy)

# Apstrādā pieprasījumus
result = arch.process(
    "Explain how transformers work",
    system_prompt="You are an AI instructor."
)
print(result["status"])   # paredzams: "allowed"
print(result["content"])

# Apskata statistiku
print(arch.report())

Monitorings un brīdinājumi

Lai vadītu moderācijas sistēmu, pietiek ar diviem rādītājiem, un tie ir jāuzrauga pretējos virzienos. Bloķēšanas koeficientam (block rate) jābūt stabilam: pēkšņs pieaugums liecina vai nu par uzbrukumu, vai par pārāk stingru slieksni, kas sāk traucēt likumīgiem lietotājiem. Tikpat svarīga ir rezultātu sadale (score distribution) — ja tavs saturs grupējas tieši zem sliekšņa, tad slieksnis ir nepareizi noteikts, un nākamās lietotāju izmaiņas to pārkāps.

def configure_alerts(arch: SecureArchitecture):
    """Konfigurē brīdinājumus monitoringam."""
    report = arch.report()

    # Brīdina, ja bloķēšanas koeficients ir neparasts
    if report["block_rate"] > 0.15:
        logger.warning(
            f"Augsts bloķēšanas koeficients: "
            f"{report['block_rate']:.1%}"
        )

    # Brīdina, ja pieaug "jailbreak" mēģinājumi
    # Integrē ar Prometheus, Grafana, Datadog u.c.

Kursa kopsavilkums

Šī kursa beigās tu esi apguvis:

  • Pielāgotus aizsargmehānismus: Bloķē bīstamus pieprasījumus pirms ģenerēšanas, konfigurē sliekšņus pa kategorijām, piemēro aģentiem.
  • Moderācijas API: Klasificē saturu ar Mistral Moderation 2, interpretē rezultātus visās 11 kategorijās, pieņem automatizētus lēmumus.
  • Ražošanas drošību: Definē satura politikas, atklāj pieprasījumu injekcijas, nodrošina GDPR atbilstību.
  • Pilnīgu arhitektūru: Apvieno aizsargmehānismus, moderāciju un monitoringu robustā cauruļvadā.

Tagad tev ir viss nepieciešamais kods, lai izvietotu pilnīgu AI moderācijas sistēmu, izmantojot Mistral API.

Galvenās atziņas

  • Drošības arhitektūra ietver 5 slāņus: validāciju, aizsargmehānismus, ģenerēšanu, moderāciju, žurnālēšanu.
  • Katrs slānis kompensē citu vājās vietas — tā ir dziļā aizsardzība (defense in depth).
  • Ražošanā uzraugi bloķēšanas koeficientu un rezultātus.
  • Uzturi savu politiku aktuālu, veicot regulāras pārskatīšanas.
  • Šajā nodarbībā esošais pilnais kods ir tikai sākumpunkts — pielāgo to savam kontekstam.

Pārbaudi savas zināšanas

Aizsargmehānismi, moderācija, injekcijas: vai aizsardzības arhitektūra ir skaidra?

1. Kur iejaucas pielāgotie aizsargmehānismi?

Atbilde: Pirms modeļa: tie filtrē ievadi atbilstoši taviem noteikumiem (aizliegtas tēmas, formāti) — tas ir pirmais slānis, kas ļauj izvairīties no izsaukuma veikšanas, ja pieprasījums ir ārpus darbības jomas.

2. Ko aptver Mistral Moderācijas API?

Atbilde: Vienpadsmit riskanta satura kategorijas ar rezultātu katrā kategorijā: tavi sliekšņi nosaka, vai bloķēt, atzīmēt vai atļaut — tādējādi pārvēršot satura politiku kodā.

3. Kā tiek definēta laba satura politika?

Atbilde: Pēc lietojuma gadījuma: kas ir pieņemams konkrētajai lietojumprogrammai, sliekšņi katrai kategorijai, saistītās darbības (bloķēšana, pārrakstīšana, eskalācija) — dokumentēta un testēta, nevis netieša.

4. Kā atklāt mēģinājumus veikt pieprasījumu injekcijas?

Atbilde: Uztverot visu ārējo saturu kā aizdomīgu: atklājot instrukciju šablonus datos, izolējot instrukcijas no datiem, validējot izvadi un veicot regulārus ofensīvus testus.

5. Kā izskatās pilnīga drošības arhitektūra?

Atbilde: Slāņi: ievades aizsargmehānismi, satura moderācija, izvades kontroles, GDPR atbilstība (minimizācija, tiesības) un izsekojamība — neviens slānis nav perfekts, bet to slāņošana to kompensē.

Dziļā aizsardzība nav tikai sauklis: katrs šī kursa slānis aiztur to, ko iepriekšējais ir palaidis garām.