सुरक्षा नियंत्रण

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

अवलोकन

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

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

इंस्टॉलेशन

[dependencies]
adk-guardrail = "2.1.0"

# For JSON schema validation
adk-guardrail = { version = "2.1.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 सुविधा आवश्यक है):

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

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

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 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
    }

    // 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
    }
}

एजेंट के साथ एकीकरण

सुरक्षा नियम 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

सर्वोत्तम प्रथाएँ

---

पिछला: ← अभिगम नियंत्रण | अगला: स्मृति →