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

Guardrails: Bailíochtú Ionchuir agus Aschuir

Ceacht 6 as 14 Nuashonraithe 28 Iúil 2026 Ardleibhéal
Ar an leathanach seo
  1. Cad é guardrail?
  2. Ailtireacht píblíne
  3. Trí guardrail tipiciúla
  4. Iad go léir a chur le chéile
  5. Nuair nach féidir an riail a scríobh i regex
  6. Príomhphointí

Cad é guardrail?

Is sraith bailíochta é guardrail a shuíonn idir an t-úsáideoir agus an tsamhail ar an ionchur, nó idir an tsamhail agus an t-úsáideoir ar an aschur. Tá an difríocht leis an measúnú a pléadh sa chaibidil roimhe seo géar, agus caithfidh tú í a choinneáil: freagraíonn an measúnú ar an gceist “An bhfuil an t-ábhar seo maslach?”—ceist uilíoch nach mbraitheann a freagra ar do ghnó. Freagraíonn guardrails ar cheisteanna nach féidir leatsa amháin a fhoirmiú: An bhfuil an teachtaireacht laistigh den raon feidhme ionchais? An bhfuil faisnéis toirmiscthe san fhreagra? An bhfuil an gníomh a iarradh údaraithe don ról seo? Roinneann cúntóir baincéireachta agus cúntóir siopa leabhar an measúnú céanna, ach níl aon guardrails coiteann acu.

Faoi 2026, tá guardrails tar éis éirí ina gcomhpháirt chaighdeánach d’ailtireachtaí gníomhairí AI, riachtanach aon uair a bhíonn rochtain ag samhail ar uirlisí nó ar shonraí íogaire.

Ailtireacht píblíne

Is é an rogha struchtúrach ná gach guardrail a mheas mar oibiacht neamhspleách le freagracht amháin, agus ansin iad a shlabhrú in ord roghnaithe. Léirítear an tairbhe le linn cothabhála: ní éilíonn riail ghnó a chur leis aon athruithe ar chód atá ann cheana, agus is féidir riail a éiríonn ró-thorannach a bhaint i líne amháin.

Tagann tríú breithiúnas le allow agus block: modify. Athraíonn sé seo nádúr an chleachtaidh. Ní dhéanann go leor cásanna sa saol mór réadúil údar le diúltú—fanann freagra ina bhfuil conair seirbhíseora inmheánach úsáideach nuair a dhéantar an conair sin a mascáil. Chaillfeadh blocáil an fhaisnéis; caomhnaíonn modhnú í trí rud a chruthaíonn fadhb a bhaint.

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)

Trí guardrail tipiciúla

Coinníonn an guardrail raon feidhme an comhrá laistigh dá fhearann. Freastalaíonn sé ar shlándáil agus ar chláir: níl aon tairbhe le fáil ag cúntóir seirbhíse custaiméirí atá oilte chun ceisteanna faoi sheachadtaí a fhreagairt ó thrácht a dhéanamh ar nuacht pholaitiúil, agus scaipeann scáileánphictiúr den fhreagra sin go tapa. Ní mór an liosta topaicí toirmiscthe a phlé leis an taobh gnó, gan í a dhréachtú leis an bhfoireann theicniúil amháin riamh.

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

Dealraíonn sé go bhfuil an guardrail formáide trivial, ach soláthraíonn sé an luach is mó go laethúil. Costáil sé roinnt micreasoicind, ní bhraitheann sé ar aon ghlaonna líonra, agus cuireann sé deireadh leis na teachtaireachtaí ró-mhóra a úsáidtear le haghaidh instealltaí toirtmhéadracha agus iarrachtaí ídiú buiséid. Cuir sa chéad áit sa slabhra é: níl aon phointe le híoc as measúnú API ar theachtaireacht 200,000 carachtar a dhiúltóidh tú ar aon nós.

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

Déanann an tríú ceann monatóireacht ar an aschur agus léiríonn sé úsáid an bhreithiúnais “modify”. Roinneann na ceithre fhine a chuardaíonn sé airí áisiúil: tá foirm inaitheanta acu atá neamhspleách ar bhrí. Aithnítear eochair API, seoladh inmheánach, IP príobháideach, nó conair seirbhíseora de réir a struchtúir, gan gá a bheith ag tuiscint an abairt ina bhfuil siad.

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

Iad go léir a chur le chéile

Taispeánann an tionól iomlán cá n-oiriúnaíonn na píosaí le chéile. Léimeann an éagothroime amach: dhá guardrail ar ionchur, ceann amháin ar aschur. Is minic agus is sláintiúil é seo—scagann tú go trom sula nglaoitear ar an tsamhail toisc gurb ansin atá costais in-seachanta, agus coinníonn tú an t-íosmhéid riachtanach ar aschur chun freagraí cearta a mhilleadh. Leanann an teachtaireacht a thuirgtear nuair a bhlocáiltear ar aschur an chúram céanna: beartaithe atá sé a bheith doiléir, ní deir sé cad a brathadh, faisnéis a d’fhreastalódh go príomha ar dhuine a bheadh ag iarraidh do chosaintí a mhapáil.

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

Nuair nach féidir an riail a scríobh i regex

Seasann roinnt rialacha gnó in aghaidh aon fhoirmiúcháin le patrúin. “Ní mór nach mbeadh comhairle infheistíochta sa fhreagra,” “ní mór nach mbeadh sonraí sláinte sa teachtaireacht”: ní ghlacann aon slonn rialta leis seo. Is féidir le samhail eile, tapa agus saor, gníomhú mar bhreitheamh ansin, le freagra atá srianta le formáid JSON chun fanacht inúsáidte ag an gcód glaonna. Tá an malartú soiléir—faigheann tú cruinneas ar chostas moille agus deitéarmanachais, rud a choinníonn an cur chuige seo do rialacha a thugann údar i ndáiríre dó.

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"])

Príomhphointí

  • Déanann guardrails bailíochtú ar chomhlíonadh gnó, ní hamháin ar ábhar maslach
  • Ceadaíonn ailtireacht phíblíne ilchiseal bailíochta a chomhcheangal
  • Tá freagracht amháin ag gach guardrail: raon feidhme, formáid, eis-sreabhadh, srl.
  • Tá guardrails aschuir chomh tábhachtach le guardrails ionchuir
  • I gcásanna casta, is féidir le LLM tapa feidhmiú mar bhailíochtóir