Guardrails: Валидиране на входни и изходни данни
На тази страница
Какво е guardrail?
Guardrail е слой за валидация, разположен между потребителя и модела при вход, или между модела и потребителя при изход. Разликата спрямо модерирането, обсъдено в предишната глава, е рязка и Вие трябва да я поддържате: модерирането отговаря на въпроса „Това съдържание обидно ли е?“ – универсален въпрос, чийто отговор не зависи от Вашия бизнес. Guardrails отговарят на въпроси, които само Вие можете да формулирате: Съобщението ли е в очаквания обхват? Отговорът съдържа ли забранена информация? Разрешено ли е исканото действие за тази роля? Банков асистент и асистент за книжарница споделят едно и също модериране, но нямат общи guardrails.
До 2026 г. guardrails се превърнаха в стандартен компонент на архитектурите за AI агенти, незаменими винаги когато моделът има достъп до инструменти или чувствителни данни.
Архитектура на конвейер
Структурният избор е да се третира всеки guardrail като независим обект с единствена отговорност, след което те се свързват във верига в избран ред. Ползата се проявява по време на поддръжката: добавянето на бизнес правило не изисква промени в съществуващия код, а правило, което става твърде шумно, може да бъде премахнато с един ред.
Към вердиктите „разреши“ и „блокирай“ се присъединява трети: „модифицирай“. Това променя същността на упражнението. Много реални ситуации не оправдават отказ – отговор, съдържащ вътрешен път до сървър, остава полезен, след като този път бъде маскиран. Блокирането би загубило информацията; модифицирането я запазва, като премахва онова, което представлява проблем.
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)
Три типични guardrails
Guardrail за обхват поддържа разговора в рамките на неговия домейн. Той служи както за сигурност, така и за репутация: асистент за обслужване на клиенти, обучен да отговаря на въпроси относно доставки, няма никаква полза да коментира политически новини, а скрийншот на такъв отговор се разпространява бързо. Списъкът със забранени теми трябва да се обсъди с бизнес страната, никога да не се изготвя само от техническия екип.
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")
Guardrail за формат изглежда тривиален, но осигурява най-голяма ежедневна стойност. Той струва няколко микросекунди, не зависи от мрежови повиквания и прекъсва прекалено големите съобщения, използвани за обемен инжекционен атакуване и опити за изчерпване на бюджета. Поставете го първи във веригата: няма смисъл да плащате за API модериране на съобщение от 200 000 знака, което така или иначе ще отхвърлите.
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")
Третият следи изхода и илюстрира използването на вердикта „модифицирай“. Четирите семейства, които търси, споделят удобно свойство: те имат разпознаваема форма, независима от значението. API ключ, вътрешен адрес, частен IP или път до сървър се идентифицират по тяхната структура, без нужда да се разбира изречението, което ги съдържа.
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")
Сглобяване на всичко
Пълното сглобяване показва къде се вписват частите. Асиметрията личи веднага: два guardrails на входа, само един на изхода. Това е често срещано и здравословно – филтрирате усилено преди извикване на модела, защото там разходите са избегваеми, и запазвате минимално необходимото на изхода, за да не повредите правилните отговори. Съобщението, върнато при блокиране на изхода, следва същата предпазливост: умишлено неясно, то не казва какво е открито – информация, която би послужила основно на някой, опитващ се да картографира Вашите защити.
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
Когато правилото не може да се запише с регулярен израз
Някои бизнес правила се съпротивляват на всяка формализация чрез шаблони. „Отговорът не трябва да представлява инвестиционен съвет“, „съобщението не трябва да съдържа здравни данни“: никой регулярен израз не улавя това. Тогава втори модел, бърз и евтин, може да действа като съдия, с отговор, ограничен до JSON формат, за да остане използваем от извикващия код. Компромисът е ясен – печелите прецизност за сметка на латентност и детерминизъм, което запазва този подход за правила, които наистина го оправдават.
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"])
Ключови изводи
- Guardrails валидират бизнес съответствието, а не само обидното съдържание
- Архитектурата на конвейер позволява комбиниране на множество слоеве за валидация
- Всеки guardrail има единствена отговорност: обхват, формат, ексфилтрация и др.
- Guardrails за изход са толкова важни, колкото и тези за вход
- За сложни случаи бърз LLM може да служи като валидатор