सुरक्षा घेरा

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

अवलोकन

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

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

इंस्टॉलेशन

[dependencies]
adk-guardrail = "2.0.0"

# For JSON schema validation
adk-guardrail = { version = "2.0.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
}

गंभीरता स्तर

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

PII संपादन

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

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 (developer-friendly: excludes "hack"/"exploit")
let filter = ContentFilter::harmful_content();

// Strict variant that also blocks "hack" and "exploit"
let filter = ContentFilter::harmful_content_strict();

// 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);

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

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 लागू करें (इसके लिए schema feature आवश्यक है):

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

Combine multiple guardrails:

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 {
    // Use transformed content if available
    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,                              // Overall pass/fail
    pub transformed_content: Option<Content>,      // Modified content (if any)
    pub failures: Vec<(String, String, Severity)>, // (name, reason, severity)
}

कस्टम गार्डरेल्स

Guardrail ट्रेट को लागू करें:

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
    }

    // Run in parallel with other guardrails (default: true)
    fn run_parallel(&self) -> bool {
        true
    }

    // Fail fast on this guardrail's failure (default: true)
    fn fail_fast(&self) -> bool {
        true
    }
}

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

गार्डरेल्स 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()?;

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

User Input
    │
    ▼
┌─────────────────────┐
│  Input Guardrails   │ ← PII redaction, content filtering
│  (parallel)         │
└─────────────────────┘
    │
    ▼ (transformed or blocked)
┌─────────────────────┐
│  Agent Execution    │
└─────────────────────┘
    │
    ▼
┌─────────────────────┐
│  Output Guardrails  │ ← Schema validation, safety checks
│  (parallel)         │
└─────────────────────┘
    │
    ▼
Final Response

उदाहरण

cargo check -p adk-guardrail
cargo check -p adk-rust --no-default-features --features guardrail

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

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