Премини към основното съдържание
Български— Изберете език
Меню

Guardrails: Валидиране на входни и изходни данни

Урок 6 от 14 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Какво е guardrail?
  2. Архитектура на конвейер
  3. Три типични guardrails
  4. Сглобяване на всичко
  5. Когато правилото не може да се запише с регулярен израз
  6. Ключови изводи

Какво е 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 може да служи като валидатор