🦀ADK-Rust

एजेंट मूल्यांकन

adk-eval crate एजेंट व्यवहार के परीक्षण और सत्यापन के लिए व्यापक उपकरण प्रदान करता है। पारंपरिक सॉफ्टवेयर परीक्षण के विपरीत, एजेंट मूल्यांकन को LLMs की संभाव्य प्रकृति को ध्यान में रखना चाहिए जबकि फिर भी सार्थक गुणवत्ता संकेत प्रदान करना चाहिए।

अवलोकन

ADK-Rust में एजेंट मूल्यांकन कई मूल्यांकन रणनीतियों का समर्थन करता है:

  • ट्रेजेक्टरी मूल्यांकन: सत्यापित करें कि एजेंट सही क्रम में अपेक्षित tools को कॉल करते हैं
  • प्रतिक्रिया समानता: विभिन्न एल्गोरिदम (Jaccard, Levenshtein, ROUGE) का उपयोग करके एजेंट प्रतिक्रियाओं की तुलना करें
  • LLM-निर्णित मूल्यांकन: अर्थ संबंधी समानता और गुणवत्ता का आकलन करने के लिए किसी अन्य LLM का उपयोग करें
  • रूब्रिक-आधारित स्कोरिंग: भारित स्कोरिंग के साथ कस्टम मानदंडों के विरुद्ध मूल्यांकन करें

त्वरित शुरुआत

use adk_eval::{Evaluator, EvaluationConfig, EvaluationCriteria};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create your agent
    let agent = create_my_agent()?;

    // Configure evaluator with criteria
    let config = EvaluationConfig::with_criteria(
        EvaluationCriteria::exact_tools()
            .with_response_similarity(0.8)
    );

    let evaluator = Evaluator::new(config);

    // Run evaluation against test file
    let report = evaluator
        .evaluate_file(agent, "tests/my_agent.test.json")
        .await?;

    // Check results
    if report.all_passed() {
        println!("All {} tests passed!", report.summary.total);
    } else {
        println!("{}", report.format_summary());
    }

    Ok(())
}

परीक्षण फ़ाइल प्रारूप

परीक्षण केस JSON फ़ाइलों में .test.json एक्सटेंशन के साथ परिभाषित किए जाते हैं:

{
  "eval_set_id": "weather_agent_tests",
  "name": "Weather Agent Tests",
  "description": "Test weather agent functionality",
  "eval_cases": [
    {
      "eval_id": "test_current_weather",
      "conversation": [
        {
          "invocation_id": "inv_001",
          "user_content": {
            "parts": [{"text": "What's the weather in NYC?"}],
            "role": "user"
          },
          "final_response": {
            "parts": [{"text": "The weather in NYC is 65°F and sunny."}],
            "role": "model"
          },
          "intermediate_data": {
            "tool_uses": [
              {
                "name": "get_weather",
                "args": {"location": "NYC"}
              }
            ]
          }
        }
      ]
    }
  ]
}

मूल्यांकन मानदंड

टूल ट्रेजेक्टरी मिलान

यह सत्यापित करता है कि एजेंट अपेक्षित Tools को सही क्रम में कॉल करते हैं:

let criteria = EvaluationCriteria {
    tool_trajectory_score: Some(1.0),  // Require 100% match
    tool_trajectory_config: Some(ToolTrajectoryConfig {
        strict_order: true,   // Tools must be called in exact order
        strict_args: false,   // Allow extra arguments in tool calls
    }),
    ..Default::default()
};

विकल्प:

  • strict_order: सटीक अनुक्रम मिलान की आवश्यकता है
  • strict_args: सटीक तर्क मिलान की आवश्यकता है (कोई अतिरिक्त तर्क अनुमत नहीं)
  • कॉन्फ़िगर करने योग्य थ्रेशोल्ड के साथ आंशिक मिलान

रिस्पॉन्स समानता

विभिन्न एल्गोरिदम का उपयोग करके रिस्पॉन्स टेक्स्ट की तुलना करें:

let criteria = EvaluationCriteria {
    response_similarity: Some(0.8),  // 80% similarity required
    response_match_config: Some(ResponseMatchConfig {
        algorithm: SimilarityAlgorithm::Jaccard,
        ignore_case: true,
        normalize: true,
        ..Default::default()
    }),
    ..Default::default()
};

उपलब्ध एल्गोरिदम:

Algorithmविवरण
Exactसटीक स्ट्रिंग मिलान
Containsसबस्ट्रिंग जांच
Levenshteinसंपादन दूरी
Jaccardशब्द ओवरलैप (डिफ़ॉल्ट)
Rouge1यूनिग्राम ओवरलैप
Rouge2बिग्राम ओवरलैप
RougeLसबसे लंबा साझा अनुक्रम

LLM-निर्णित अर्थ संबंधी मिलान

अर्थ संबंधी समानता का मूल्यांकन करने के लिए एक LLM का उपयोग करें:

use adk_eval::{Evaluator, EvaluationConfig, EvaluationCriteria, LlmJudge};
use adk_model::GeminiModel;

// Create evaluator with LLM judge
let judge_model = Arc::new(GeminiModel::new(&api_key, "gemini-2.0-flash")?);
let config = EvaluationConfig::with_criteria(
    EvaluationCriteria::semantic_match(0.85)
);
let evaluator = Evaluator::with_llm_judge(config, judge_model);

LLM निर्णायक आकलन करता है:

  • अर्थ संबंधी समानता (एक ही अर्थ, अलग शब्द)
  • तथ्यात्मक सटीकता
  • रिस्पॉन्स की पूर्णता

रूब्रिक-आधारित मूल्यांकन

भारित स्कोरिंग के साथ कस्टम मानदंडों के विरुद्ध मूल्यांकन करें:

use adk_eval::{Rubric, EvaluationCriteria};

let criteria = EvaluationCriteria::default()
    .with_rubrics(0.7, vec![
        Rubric::new("Accuracy", "Response is factually correct")
            .with_weight(0.5),
        Rubric::new("Helpfulness", "Response addresses user's needs")
            .with_weight(0.3),
        Rubric::new("Clarity", "Response is clear and well-organized")
            .with_weight(0.2),
    ]);

प्रत्येक रूब्रिक को LLM निर्णायक द्वारा 0-1 तक स्कोर किया जाता है, फिर वज़न का उपयोग करके संयोजित किया जाता है।

सुरक्षा और मतिभ्रम का पता लगाना

सुरक्षा मुद्दों और मतिभ्रम के लिए रिस्पॉन्स की जांच करें:

let criteria = EvaluationCriteria {
    safety_score: Some(0.95),        // Require high safety score
    hallucination_score: Some(0.9),  // Require low hallucination rate
    ..Default::default()
};

परिणाम रिपोर्टिंग

मूल्यांकन रिपोर्ट विस्तृत परिणाम प्रदान करती है:

let report = evaluator.evaluate_file(agent, "tests/agent.test.json").await?;

// Summary statistics
println!("Total: {}", report.summary.total);
println!("Passed: {}", report.summary.passed);
println!("Failed: {}", report.summary.failed);
println!("Pass Rate: {:.1}%", report.summary.pass_rate * 100.0);

// Detailed failures
for result in report.failures() {
    println!("Failed: {}", result.eval_id);
    for failure in &result.failures {
        println!("  - {}: {} (expected: {}, actual: {})",
            failure.criterion,
            failure.message,
            failure.expected,
            failure.actual
        );
    }
}

// Export to JSON for CI/CD
let json = report.to_json()?;
std::fs::write("eval_results.json", json)?;

बैच मूल्यांकन

समानांतर मूल्यांकन

कई टेस्ट केस का एक साथ मूल्यांकन करें:

let results = evaluator
    .evaluate_cases_parallel(agent, &cases, 4)  // 4 concurrent evaluations
    .await;

डायरेक्टरी मूल्यांकन

एक डायरेक्टरी में सभी टेस्ट फ़ाइलों का मूल्यांकन करें:

let reports = evaluator
    .evaluate_directory(agent, "tests/eval_cases")
    .await?;

for (file, report) in reports {
    println!("{}: {} passed, {} failed",
        file,
        report.summary.passed,
        report.summary.failed
    );
}

cargo test के साथ एकीकरण

मानक Rust टेस्ट में मूल्यांकन का उपयोग करें:

#[tokio::test]
async fn test_weather_agent() {
    let agent = create_weather_agent().unwrap();
    let evaluator = Evaluator::new(EvaluationConfig::with_criteria(
        EvaluationCriteria::exact_tools()
    ));

    let report = evaluator
        .evaluate_file(agent, "tests/weather_agent.test.json")
        .await
        .unwrap();

    assert!(report.all_passed(), "{}", report.format_summary());
}

उदाहरण

# Basic evaluation
cargo run --example eval_basic

# Trajectory validation
cargo run --example eval_trajectory

# LLM-judged semantic matching
cargo run --example eval_semantic

# Rubric-based scoring
cargo run --example eval_rubric

# Response similarity algorithms
cargo run --example eval_similarity

# Report generation
cargo run --example eval_report

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

  1. सरल शुरुआत करें: सिमेंटिक जाँच जोड़ने से पहले Trajectory validation से शुरू करें
  2. प्रतिनिधि मामलों का उपयोग करें: टेस्ट फ़ाइलों में चरम मामलों और सामान्य परिदृश्यों को शामिल करना चाहिए
  3. थ्रेशोल्ड कैलिब्रेट करें: उदार थ्रेशोल्ड से शुरू करें और Agent में सुधार के साथ उन्हें सख्त करें
  4. मानदंडों को मिलाएं: व्यापक मूल्यांकन के लिए कई मानदंडों का उपयोग करें
  5. टेस्ट फ़ाइलों का संस्करण करें: टेस्ट फ़ाइलों को Agent कोड के साथ संस्करण नियंत्रण में रखें
  6. CI/CD एकीकरण: प्रतिगमन को पकड़ने के लिए CI में मूल्यांकन चलाएं

पिछला: ← A2A Protocol | अगला: पहुँच नियंत्रण →