Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Potpuna sigurnosna arhitektura

Lekcija 12 od 12 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Sastavljanje svih dijelova
  2. Pregled arhitekture
  3. Potpuna implementacija
  4. Upotreba u proizvodnji
  5. Nadzor i upozorenja
  6. Sažetak tečaja
  7. Ključne točke
  8. Provjeri svoje znanje

Ažurirano 3. studenoga 2026. Sloj generiranja prethodno je koristio izmišljeni format zaštitnih ograda (enabled), a politika proizvodnje koristila je nepostojeće kategorije (hate, violence, unpredictable). Kod sada slijedi službeni format moderation_llm_v2 i jedanaest ključeva iz mistral-moderation-2603. Vrijednosti (scores), koje su opcionalne u SDK-u, čitaju se s rezervnom vrijednošću. Kod verificiran protiv tipova mistralai SDK verzije 3.7.0. Izvori: Moderation & Guardrailing · Python SDK mistralai.

Sastavljanje svih dijelova

Kroz ovaj tečaj istražio si zaštitne ograde (guardrails), Moderation API, 11 kategorija, pragove, detekciju probijanja zaštite (jailbreak), usklađenost s GDPR-om i politike sadržaja. Ova završna lekcija sastavlja sve ove gradivne blokove u potpunu sigurnosnu arhitekturu spremnu za proizvodnju.

Pregled arhitekture

Postoji pet slojeva, vođenih jednim načelom: nijedan od njih nije pouzdan sam po sebi. Zaštitnu ogradu može se zaobići neočekivanim formuliranjem, model za moderiranje ima lažno negativne rezultate, a politika sadržaja nikada ne pokriva svaki slučaj. Slaganje slojeva funkcionira jer se praznine ne preklapaju—ono što promakne prvom sloju ima dobre šanse biti uhvaćeno u drugom.

Praktična posljedica je strog redoslijed: svaki sloj mora biti što jeftiniji prije nego što se pokrene sljedeći. Validiraš format prije pozivanja zaštitne ograde, a zaštitnu ogradu zoveš prije generiranja—jer sadržaj odbijen u koraku 1 troši nula tokena.

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

Potpuna implementacija

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

Upotreba u proizvodnji

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

Nadzor i upozorenja

Dva su metrika dovoljna za upravljanje sustavom moderiranja i moraš ih pratiti u suprotnim smjerovima. Stopa blokiranja trebala bi ostati stabilna: nagli skok signalizira ili napad ili prag koji je previše strog i počinje ometati legitimne korisnike. Distribucija rezultata jednako je važna—ako se tvoj sadržaj grupira neposredno ispod praga, prag je loše postavljen i sljedeća prilagodba od strane tvojih korisnika srušit će ga.

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.

Sažetak tečaja

Do kraja ovog tečaja savladao si:

  • Prilagođene zaštitne ograde: Blokiraj opasne upite prije generiranja, konfiguriraj pragove po kategoriji, primijeni na agente
  • Moderation API: Klasificiraj sadržaj s Mistral Moderation 2, interpretiraj rezultate kroz 11 kategorija, donosi automatizirane odluke
  • Sigurnost u proizvodnji: Definiraj politike sadržaja, detektiraj ubacivanje upita (prompt injections), osiguraj usklađenost s GDPR-om
  • Potpuna arhitektura: Sastavi zaštitne ograde + moderiranje + nadzor u robustan pipeline

Sada imaš sav kod potreban za implementaciju potpunog sustava za moderiranje AI-a s Mistral API-jem.

Ključne točke

  • Sigurnosna arhitektura uključuje 5 slojeva: validacija, zaštitne ograde, generiranje, moderiranje, bilježenje
  • Svaki sloj kompenzira slabosti drugih—ovo je obrana u dubinu (defense in depth)
  • Prati stopu blokiranja i rezultate u proizvodnji
  • Drži svoju politiku ažurnom uz redovite preglede
  • Potpuni kod u ovoj lekciji je polazišna točka—prilagodi ga svom kontekstu

Provjeri svoje znanje

Zaštitne ograde, moderiranje, ubacivanje: je li obrambena arhitektura jasna?

1. Gdje interveniraju prilagođene zaštitne ograde?

Odgovor: Prije modela: one filtriraju ulaze prema tvojim pravilima (zabranjene teme, formati)—prvi sloj, koji izbjegava čak i poziv kada je zahtjev izvan opsega.

2. Što pokriva Mistral Moderation API?

Odgovor: Jedanaest kategorija rizičnog sadržaja, s rezultatom po kategoriji: tvoji pragovi odlučuju hoće li se blokirati, označiti ili dopustiti—pretvarajući politiku sadržaja u kod.

3. Kako se definira dobra politika sadržaja?

Odgovor: Prema slučaju upotrebe: što je prihvatljivo za aplikaciju, pragovi po kategoriji, povezane radnje (blokiranje, prepisivanje, eskalacija)—dokumentirano i testirano, a ne implicitno.

4. Kako detektiraš pokušaje ubacivanja upita (prompt injection)?

Odgovor: Tretiranjem svih vanjskih sadržaja kao sumnjivih: detekcijom obrazaca instrukcija u podacima, izoliranjem instrukcija od podataka, validacijom izlaza—i provođenjem redovitih ofenzivnih testova.

5. Kako izgleda potpuna sigurnosna arhitektura?

Odgovor: Slojevi: ulazne zaštitne ograde, moderiranje sadržaja, kontrole izlaza, usklađenost s GDPR-om (minimizacija, prava) i sljedivost—nijedan sloj nije savršen, ali njihovo slaganje kompenzira nedostatke.

Obrana u dubinu nije samo slogan: svaki sloj u ovom tečaju hvata ono što je prethodni propustio.