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

Guardrails: Il-validazzjoni tal-Inputs u l-Outputs

Lezzjoni 6 / 14 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. X’inhu guardrail?
  2. Arkitettura ta’ pipeline
  3. Tliet guardrails tipiċi
  4. L-assemblaġġ kollu
  5. Meta r-regola ma tistax tiġi miktuba f’regex
  6. Punti Ewlenin

X’inhu guardrail?

Guardrail huwa saff ta’ validazzjoni li jinsab bejn l-utent u l-mudell fuq l-input, jew bejn il-mudell u l-utent fuq l-output. Id-distinzjoni mill-moderazzjoni diskussa fil-kapitlu ta’ qabel hija ċara, u trid iżżommha: il-moderazzjoni twieġeb il-mistoqsija “Dan il-kontenut huwa offensiv?”—mistoqsija universali li t-tweġiba tagħha ma tiddependix fuq in-negozju tiegħek. Il-guardrails iwieġbu mistoqsijiet li inti biss tista’ tifformula: Il-messaġġ huwa fi ħdan l-ambitu mistenni? Ir-risposta fiha informazzjoni pprojbita? L-azzjoni mitluba hija awtorizzata għal dan ir-rwol? Assistent bankarju u assistent ta’ ħanut tal-kotba jaqsmu l-istess moderazzjoni iżda m’għandhom l-ebda guardrail komuni.

Sal-2026, il-guardrails saru komponent standard tal-arkitetturi tal-aġenti tal-AI, indispensabbli kull meta mudell ikollu aċċess għal għodod jew data sensittiva.

Arkitettura ta’ pipeline

L-għażla strutturali hija li tittratta kull guardrail bħala oġġett indipendenti b’responsabbiltà waħda, imbagħad tgħaqqadhom f’ordni magħżula. Il-benefiċċju jidher waqt il-manutenzjoni: iż-żieda ta’ regola tan-negozju ma teħtieġ l-ebda bidla fil-kodiċi eżistenti, u regola li ssir wisq “noisy” tista’ titneħħa f’linja waħda.

Verdett terz jingħaqad ma’ allow u block: modify. Dan ibiddel in-natura tal-eżerċizzju. Ħafna sitwazzjonijiet fid-dinja reali ma jiġġustifikawx rifjut—risposta li fiha mogħdija ta’ server intern tibqa’ utli ladarba dik il-mogħdija tiġi maskrata. Il-blocking ikellek l-informazzjoni; il-modifying jippreservaha billi jneħħi dak li jpoġġi problema.

from dataclasses import dataclass
from enum import Enum

class Decision(Enum):
    ALLOW = "allow"
    BLOCK = "block"
    MODIFY = "modify"

@dataclass
class ValidationResult:
    decision: Decision
    reason: str
    modified_content: str | None = None

class Guardrail:
    """Base class for a guardrail."""

    def validate(self, content: str, context: dict) -> ValidationResult:
        raise NotImplementedError

class GuardrailPipeline:
    """Chains multiple guardrails in sequence."""

    def __init__(self):
        self.input_guardrails: list[Guardrail] = []
        self.output_guardrails: list[Guardrail] = []

    def add_input(self, guardrail: Guardrail):
        self.input_guardrails.append(guardrail)

    def add_output(self, guardrail: Guardrail):
        self.output_guardrails.append(guardrail)

    def validate_input(self, message: str, context: dict) -> ValidationResult:
        for g in self.input_guardrails:
            result = g.validate(message, context)
            if result.decision == Decision.BLOCK:
                return result
            if result.decision == Decision.MODIFY:
                message = result.modified_content
        return ValidationResult(Decision.ALLOW, "All validations passed")

    def validate_output(self, response: str, context: dict) -> ValidationResult:
        for g in self.output_guardrails:
            result = g.validate(response, context)
            if result.decision == Decision.BLOCK:
                return result
            if result.decision == Decision.MODIFY:
                response = result.modified_content
        return ValidationResult(Decision.ALLOW, "OK", response)

Tliet guardrails tipiċi

Il-guardrail tal-ambitu (scope) iżomm il-konversazzjoni fi ħdan id-dominju tagħha. Dan iservi kemm għas-sigurtà kif ukoll għar-reputazzjoni: assistent tas-servizz tal-klijenti mħarreġ biex iwieġeb mistoqsijiet dwar il-kunsinni m’għandu xejn x’jiggwadanja billi jikkummenta fuq aħbarijiet politiċi, u screenshot ta’ tali risposta jiċċirkola malajr. Il-lista ta’ suġġetti pprojbiti trid tiġi diskussa man-naħa tan-negozju, qatt abbozzata mit-tim tekniku waħdu.

class ScopeGuardrail(Guardrail):
    """Checks that the message stays within the authorized scope."""

    def __init__(self, allowed_topics: list[str], forbidden_topics: list[str]):
        self.allowed_topics = allowed_topics
        self.forbidden_topics = forbidden_topics

    def validate(self, content: str, context: dict) -> ValidationResult:
        content_lower = content.lower()

        # Check forbidden topics
        for topic in self.forbidden_topics:
            if topic.lower() in content_lower:
                return ValidationResult(
                    Decision.BLOCK,
                    f"Out-of-scope topic detected: {topic}"
                )

        return ValidationResult(Decision.ALLOW, "Within scope")

Il-guardrail tal-format jidher trivjali iżda jipprovdi l-aktar valur ta’ kuljum. Jiswa ftit mikrosekondi, ma jiddependi fuq l-ebda sejħa tan-network, u jaqta’ qalb il-messaġġi oversized użati għal injezzjonijiet volumetriċi u tentattivi ta’ eżawriment tal-baġit. Poġġieh l-ewwel fil-katina: m’hemm l-ebda punt li tħallas għal moderazzjoni tal-API fuq messaġġ ta’ 200,000 karattru li ser tirrifjuta comunque.

class FormatGuardrail(Guardrail):
    """Validates message format and length."""

    def __init__(self, max_tokens: int = 4000, max_lines: int = 100):
        self.max_tokens = max_tokens
        self.max_lines = max_lines

    def validate(self, content: str, context: dict) -> ValidationResult:
        # Rough token estimation (1 token ~ 4 characters in English)
        estimated_tokens = len(content) // 4
        if estimated_tokens > self.max_tokens:
            return ValidationResult(
                Decision.BLOCK,
                f"Message too long: ~{estimated_tokens} tokens (max {self.max_tokens})"
            )

        line_count = content.count("\n") + 1
        if line_count > self.max_lines:
            return ValidationResult(
                Decision.BLOCK,
                f"Too many lines: {line_count} (max {self.max_lines})"
            )

        return ValidationResult(Decision.ALLOW, "Valid format")

It-tielet jimmonitorja l-output u juri l-użu tal-verdett “modify”. L-erba’ familji li jfittex jaqsmu proprjetà konvenjenti: għandhom forma rikonoxxibbli indipendenti mit-tifsira. Ċavetta tal-API, indirizz intern, IP privat, jew mogħdija ta’ server huma identifikati mill-istruttura tagħhom, mingħajr ħtieġa li tifhem is-sentenza li fiha jinsabu.

import re

class AntiExfiltrationGuardrail(Guardrail):
    """Prevents leakage of sensitive data in outputs."""

    def __init__(self):
        self.sensitive_patterns = {
            "api_key": r"(sk|pk|api[_-]?key)[_-][a-zA-Z0-9]{16,}",
            "internal_email": r"[a-zA-Z0-9.]+@(company|internal|corp)\.\w+",
            "private_ip": r"\b(10\.\d{1,3}\.\d{1,3}\.\d{1,3}|192\.168\.\d{1,3}\.\d{1,3})\b",
            "server_path": r"(/data/|/etc/|/home/|C:\\Users\\)",
        }

    def validate(self, content: str, context: dict) -> ValidationResult:
        for data_type, pattern in self.sensitive_patterns.items():
            if re.search(pattern, content):
                # Mask instead of blocking
                cleaned_content = re.sub(pattern, "[REDACTED]", content)
                return ValidationResult(
                    Decision.MODIFY,
                    f"Sensitive data redacted: {data_type}",
                    cleaned_content,
                )
        return ValidationResult(Decision.ALLOW, "No leakage detected")

L-assemblaġġ kollu

L-assemblaġġ sħiħ juri fejn jaqgħu l-biċċiet. L-asimetrija toħroġ fid-dieher: żewġ guardrails fuq l-input, wieħed biss fuq l-output. Dan huwa frekwenti u f’saħħtu—tiffiltra ħafna qabel ma ssejjaħ il-mudell għax hemmhekk l-ispejjeż huma evitabbli, u żżomm il-minimu meħtieġ fuq l-output biex tevita li tagħmel ħsara lil risposti korretti. Il-messaġġ ritornat meta jkun hemm blocking fuq l-output isegwi l-istess prekawzjoni: intenzjonalment vag, ma jgħid x’inhu ġie skopert, informazzjoni li tkun isservi primarjament lil xi ħadd li jipprova jimmapja d-difiżi tiegħek.

from openai import OpenAI

def create_secure_assistant():
    """Creates an assistant with a complete guardrail pipeline."""
    client = OpenAI()
    pipeline = GuardrailPipeline()

    # Input guardrails
    pipeline.add_input(FormatGuardrail(max_tokens=2000))
    pipeline.add_input(ScopeGuardrail(
        allowed_topics=["products", "orders", "delivery", "returns"],
        forbidden_topics=["politics", "religion", "competitors"],
    ))

    # Output guardrails
    pipeline.add_output(AntiExfiltrationGuardrail())

    def process(message: str) -> str:
        context = {"user_role": "customer"}

        # Input validation
        input_check = pipeline.validate_input(message, context)
        if input_check.decision == Decision.BLOCK:
            return f"I cannot process this request: {input_check.reason}"

        valid_message = input_check.modified_content or message

        # Model call
        response = client.chat.completions.create(
            model="gpt-5.6-sol",
            messages=[
                {"role": "system", "content": "Acme Corp customer service assistant."},
                {"role": "user", "content": valid_message},
            ],
        )
        reply = response.choices[0].message.content

        # Output validation
        output_check = pipeline.validate_output(reply, context)
        if output_check.decision == Decision.BLOCK:
            return "I am unable to answer this question."

        return output_check.modified_content or reply

    return process

Meta r-regola ma tistax tiġi miktuba f’regex

Xi regoli tan-negozju jirreżistu kwalunkwe formalizzazzjoni permezz ta’ mudelli. “Ir-risposta m’għandhiex tikkostitwixxi parir ta’ investiment”, “il-messaġġ m’għandux ikun fih data dwar is-saħħa”: l-ebda espressjoni regolari ma taqbad dan. Mudell ieħor, mgħaġġel u rħis, jista’ mbagħad jaġixxi bħala ġudici, b’respons ristrett għal format JSON biex jibqa’ użabbli mill-kodiċi li qed isejjaħ. Il-kompromess huwa espliċitu—tikseb preċiżjoni bl-ispiża tal-latency u d-determiniżmu, li jirriżerva dan l-approċċ għal regoli li verament jiġġustifikawh.

def llm_guardrail(message: str, rule: str) -> ValidationResult:
    """Uses a fast model to validate compliance."""
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-5.6-terra",
        messages=[
            {"role": "system", "content": f"""You are a compliance validator.
Rule to check: {rule}
Respond ONLY with JSON: {{"compliant": true/false, "reason": "..."}}"""},
            {"role": "user", "content": f"Message to validate:\n{message}"},
        ],
    )
    import json
    result = json.loads(response.choices[0].message.content)
    if result["compliant"]:
        return ValidationResult(Decision.ALLOW, result["reason"])
    return ValidationResult(Decision.BLOCK, result["reason"])

Punti Ewlenin

  • Il-guardrails jivvalidaw il-konformità tan-negozju, mhux biss il-kontenut offensiv
  • L-arkitettura tal-pipeline tippermetti li tgħaqqad saffi multipli ta’ validazzjoni
  • Kull guardrail għandu responsabbiltà waħda: ambitu, format, eżfiltrazzjoni, eċċ.
  • Il-guardrails tal-output huma daqstant importanti daqs dawk tal-input
  • Għal każijiet kumplessi, LLM mgħaġġel jista’ jservi bħala validatur