Apsaugos mechanizmai: įvesties ir išvesties tikrinimas
Šiame puslapyje
Kas yra apsaugos mechanizmas?
Apsaugos mechanizmas (angl. guardrail) – tai tikrinimo sluoksnis, esantis tarp naudotojo ir modelio (įvesties metu) arba tarp modelio ir naudotojo (išvesties metu). Skirtumas nuo ankstesniame skyriuje aptarto moderavimo yra ryškus, ir privalai jį išlaikyti: moderavimas atsako į klausimą „Ar šis turinys įžeidžiamas?“ – tai universalus klausimas, kurio atsakymas nepriklauso nuo tavo verslo. Apsaugos mechanizmai atsako į klausimus, kuriuos gali suformuluoti tik tu: ar žinutė atitinka numatytą sritį? Ar atsakyme nėra draudžiamos informacijos? Ar prašomas veiksmas leidžiamas šiam vaidmeniui? Bankininkystės asistentas ir knygyno asistentas turi tą patį moderavimą, bet neturi jokių bendrų apsaugos mechanizmų.
Iki 2026 m. apsaugos mechanizmai tapo standartine DI agentų architektūrų dalimi, būtina visada, kai modelis turi prieigą prie įrankių ar konfidencialių duomenų.
Vamzdyno architektūra
Struktūrinis sprendimas – kiekvieną apsaugos mechanizmą traktuoti kaip nepriklausomą objektą su viena atsakomybe, o tada sujungti juos į grandinę pasirinkta tvarka. Naudą pajunti priežiūros metu: norint pridėti verslo taisyklę, nereikia keisti esamo kodo, o taisyklę, kuri tampa per daug triukšminga, galima pašalinti viena eilute.
Prie leidimo („allow“) ir blokavimo („block“) prisideda trečias verdiktas: modifikuoti („modify“). Tai pakeičia užduoties pobūdį. Daugelyje realių situacijų atsisakymas nėra pateisinamas – atsakymas, kuriame nurodytas vidinis serverio kelias, išlieka naudingas, kai tas kelias užmaskuojamas. Blokuojant informacija būtų prarasta; modifikuojant ji išsaugoma, pašalinant tai, kas kelia problemą.
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)
Trys tipiniai apsaugos mechanizmai
Srities apsaugos mechanizmas palaiko pokalbį jo domeno ribose. Jis tarnauja tiek saugumui, tiek reputacijai: klientų aptarnavimo asistentas, apmokytas atsakyti į klausimus apie pristatymus, neturi jokios naudos komentuodamas politines naujienas, o tokio atsakymo ekrano kopija greitai pasklinda. Draudžiamų temų sąrašą turi aptarti su verslo puse, jo niekada neturi rengti vien techninė komanda.
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")
Formato apsaugos mechanizmas atrodo trivialus, tačiau suteikia daugiausia vertės kasdieniame darbe. Jis kainuoja kelias mikrosekundes, nepriklauso nuo tinklo užklausų ir nutraukia per didelės apimties žinutes, naudojamas tūrinėms injekcijoms ir biudžeto eikvojimo bandymams. Pastatyk jį pirmąjį grandinėje: nėra prasmės mokėti už API moderavimą dėl 200 000 simbolių žinutės, kurią vis tiek atmesti.
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")
Trečiasis stebi išvestį ir iliustruoja „modifikuoti“ verdikto naudojimą. Keturios šeimos, kurių jis ieško, turi vieną patogią savybę: jų forma atpažįstama nepriklausomai nuo prasmės. API raktas, vidinis adresas, privatus IP arba serverio kelias identifikuojami pagal jų struktūrą, nereikia suprasti sakinio, kuriame jie yra.
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")
Viskas kartu
Pilnas surinkimas parodo, kaip dalys dera tarpusavyje. Asimetrija akivaizdi: du apsaugos mechanizmai įvestiai, tik vienas – išvestiai. Tai dažna ir sveika praktika – prieš kviečiant modelį filtruoji intensyviai, nes būtent ten išlaidas galima išvengti, o išvestyje palieki tik būtiną minimumą, kad nepažeistum teisingų atsakymų. Žinutė, grąžinama blokuojant išvestį, laikosi to paties atsargumo principo: ji tyčia yra miglota ir nesako, kas buvo aptikta, nes tokia informacija pirmiausia pasitarnautų tam, kas bando atvaizduoti tavo gynybą.
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
Kai taisyklės negalima užrašyti reguliariuoju reiškiniu
Kai kurios verslo taisyklės priešinasi bet kokiam formalizavimui šablonais. „Atsakymas neturi būti investicinė konsultacija“, „Žinutėje neturi būti sveikatos duomenų“: joks reguliarusis reiškinys to neapima. Tuomet antrasis modelis, greitas ir nebrangus, gali veikti kaip teisėjas, o jo atsakymas turi būti JSON formatu, kad liktų naudojamas kviečiančiojo kodo. Kompromisas yra aiškus – gauni tikslumą, bet sumoki latencija ir determinizmu, todėl šį metodą taikyk tik taisyklėms, kurios tai tikrai pateisina.
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"])
Svarbiausi punktai
- Apsaugos mechanizmai tikrina atitiktį verslo taisyklėms, o ne tik įžeidžiamą turinį
- Vamzdyno architektūra leidžia derinti kelis tikrinimo sluoksnius
- Kiekvienas apsaugos mechanizmas turi vieną atsakomybę: sritis, formatas, duomenų nutekėjimas ir kt.
- Išvesties apsaugos mechanizmai yra tokie pat svarbūs kaip ir įvesties
- Sudėtingais atvejais greitas DID gali veikti kaip tikrintuvas