गार्डरेल्स

adk-guardrail का उपयोग करके इनपुट/आउटपुट सत्यापन और सामग्री सुरक्षा।

अवलोकन

गार्डरेल्स सुरक्षा, अनुपालन और गुणवत्ता सुनिश्चित करने के लिए एजेंट इनपुट और आउटपुट को मान्य और रूपांतरित करते हैं। वे एजेंट के निष्पादन के समानांतर चलते हैं और ये कार्य कर सकते हैं:

• हानिकारक या ऑफ-टॉपिक सामग्री को ब्लॉक करना
• PII (ईमेल, फोन, SSN, क्रेडिट कार्ड) को संशोधित करना
• आउटपुट पर JSON स्कीमा लागू करना
• सामग्री की लंबाई सीमित करना

इंस्टॉलेशन

[dependencies]
adk-guardrail = "0.2.0"

# For JSON schema validation
adk-guardrail = { version = "0.2.0", features = ["schema"] }

मुख्य अवधारणाएँ

GuardrailResult

प्रत्येक गार्डरेल तीन परिणामों में से एक देता है:

pub enum GuardrailResult {
    Pass,                                    // Content is valid
    Fail { reason: String, severity: Severity },  // Content rejected
    Transform { new_content: Content, reason: String },  // Content modified
}

Severity Levels

pub enum Severity {
    Low,      // Warning only, doesn't block
    Medium,   // Blocks but continues other checks
    High,     // Blocks immediately
    Critical, // Blocks and fails fast
}

PII Redaction

व्यक्तिगत रूप से पहचान योग्य जानकारी का स्वचालित रूप से पता लगाना और उसे संशोधित करना:

use adk_guardrail::{PiiRedactor, PiiType};

// Default: emails, phones, SSNs, credit cards
let redactor = PiiRedactor::new();

// Or select specific types
let redactor = PiiRedactor::with_types(&[
    PiiType::Email,
    PiiType::Phone,
]);

// Direct redaction
let (redacted, found_types) = redactor.redact("Email: test@example.com");
// redacted = "Email: [EMAIL REDACTED]"
// found_types = [PiiType::Email]

समर्थित PII प्रकार:

सामग्री फ़िल्टरिंग

हानिकारक सामग्री को ब्लॉक करें या विषय की बाधाओं को लागू करें:

use adk_guardrail::ContentFilter;

// Block harmful content patterns
let filter = ContentFilter::harmful_content();

// Block specific keywords
let filter = ContentFilter::blocked_keywords(vec![
    "forbidden".into(),
    "banned".into(),
]);

// Enforce topic relevance
let filter = ContentFilter::on_topic("cooking", vec![
    "recipe".into(),
    "cook".into(),
    "bake".into(),
]);

// Limit content length
let filter = ContentFilter::max_length(1000);

कस्टम Content Filter

use adk_guardrail::{ContentFilter, ContentFilterConfig, Severity};

let config = ContentFilterConfig {
    blocked_keywords: vec!["spam".into()],
    required_topics: vec!["rust".into(), "programming".into()],
    max_length: Some(5000),
    min_length: Some(10),
    severity: Severity::High,
};

let filter = ContentFilter::new("custom_filter", config);

स्कीमा सत्यापन

एजेंट आउटपुट पर JSON स्कीमा लागू करें (schema फीचर की आवश्यकता है):

use adk_guardrail::SchemaValidator;
use serde_json::json;

let schema = json!({
    "type": "object",
    "properties": {
        "name": { "type": "string" },
        "age": { "type": "integer", "minimum": 0 }
    },
    "required": ["name"]
});

let validator = SchemaValidator::new(&schema)?
    .with_name("user_schema")
    .with_severity(Severity::High);

वैलिडेटर इससे JSON निकालता है:

• रॉ JSON टेक्स्ट
• Markdown कोड ब्लॉक (```json ... ```)

GuardrailSet

कई गार्डरेल्स को संयोजित करें:

use adk_guardrail::{GuardrailSet, ContentFilter, PiiRedactor};

let guardrails = GuardrailSet::new()
    .with(ContentFilter::harmful_content())
    .with(ContentFilter::max_length(5000))
    .with(PiiRedactor::new());

GuardrailExecutor

Guardrails चलाएँ और विस्तृत परिणाम प्राप्त करें:

use adk_guardrail::{GuardrailExecutor, GuardrailSet, PiiRedactor};
use adk_core::Content;

let guardrails = GuardrailSet::new()
    .with(PiiRedactor::new());

let content = Content::new("user")
    .with_text("Contact: test@example.com");

let result = GuardrailExecutor::run(&guardrails, &content).await?;

if result.passed {
    // यदि उपलब्ध हो तो परिवर्तित सामग्री का उपयोग करें
    let final_content = result.transformed_content.unwrap_or(content);
    println!("Content passed validation");
} else {
    for (name, reason, severity) in &result.failures {
        println!("Guardrail '{}' failed: {} ({:?})", name, reason, severity);
    }
}

ExecutionResult

pub struct ExecutionResult {
    pub passed: bool,                              // कुल पास/फेल
    pub transformed_content: Option<Content>,      // संशोधित सामग्री (यदि कोई हो)
    pub failures: Vec<(String, String, Severity)>, // (नाम, कारण, गंभीरता)
}

कस्टम Guardrails

Guardrail trait को लागू करें:

use adk_guardrail::{Guardrail, GuardrailResult, Severity};
use adk_core::Content;
use async_trait::async_trait;

pub struct ProfanityFilter {
    words: Vec<String>,
}

#[async_trait]
impl Guardrail for ProfanityFilter {
    fn name(&self) -> &str {
        "profanity_filter"
    }

    async fn validate(&self, content: &Content) -> GuardrailResult {
        let text: String = content.parts
            .iter()
            .filter_map(|p| p.text())
            .collect();

        for word in &self.words {
            if text.to_lowercase().contains(word) {
                return GuardrailResult::Fail {
                    reason: format!("Contains profanity: {}", word),
                    severity: Severity::High,
                };
            }
        }

        GuardrailResult::Pass
    }

    // अन्य guardrails के साथ समानांतर में चलाएँ (डिफ़ॉल्ट: true)
    fn run_parallel(&self) -> bool {
        true
    }

    // इस guardrail की विफलता पर तुरंत फेल करें (डिफ़ॉल्ट: true)
    fn fail_fast(&self) -> bool {
        true
    }
}

Agents के साथ एकीकरण

Guardrails LlmAgentBuilder के साथ एकीकृत होते हैं:

use adk_agent::LlmAgentBuilder;
use adk_guardrail::{GuardrailSet, ContentFilter, PiiRedactor};

let input_guardrails = GuardrailSet::new()
    .with(ContentFilter::harmful_content())
    .with(PiiRedactor::new());

let output_guardrails = GuardrailSet::new()
    .with(SchemaValidator::new(&output_schema)?);

let agent = LlmAgentBuilder::new("assistant")
    .model(model)
    .instruction("You are a helpful assistant.")
    .input_guardrails(input_guardrails)
    .output_guardrails(output_guardrails)
    .build()?;

निष्पादन प्रवाह

उपयोगकर्ता इनपुट
    │
    ▼
┌─────────────────────┐
│  इनपुट Guardrails   │ ← PII redaction, content filtering
│  (समानांतर)         │
└─────────────────────┘
    │
    ▼ (परिवर्तित या अवरुद्ध)
┌─────────────────────┐
│  Agent निष्पादन    │
└─────────────────────┘
    │
    ▼
┌─────────────────────┐
│  आउटपुट Guardrails  │ ← Schema validation, safety checks
│  (समानांतर)         │
└─────────────────────┘
    │
    ▼
अंतिम प्रतिक्रिया

उदाहरण

# मूल PII और content filtering
cargo run --example guardrail_basic --features guardrails

# JSON schema validation
cargo run --example guardrail_schema --features guardrails

# पूर्ण Agent एकीकरण
cargo run --example guardrail_agent --features guardrails

सर्वोत्तम अभ्यास

---

पिछला: ← पहुँच नियंत्रण | अगला: मेमोरी →