ADK-Rust v0.2.0 : La première version stable

Nous sommes ravis d'annoncer ADK-Rust v0.2.0 - la première version stable du framework Rust pour la création d'agents IA prêts pour la production. Cette version marque une étape majeure avec de nouvelles fonctionnalités significatives, une stabilité améliorée et un engagement envers le versionnement sémantique à l'avenir.

Nouveautés de la v0.2.0

🔀 Agents graphiques (Workflows de style LangGraph)

Le nouveau crate adk-graph apporte l'orchestration de workflows de style LangGraph à Rust :

use adk_graph::{prelude::*, node::AgentNode};

let graph = GraphAgent::builder("support_router")
    .channels(&["input", "category", "response"])
    .node(classifier_node)
    .node(billing_node)
    .node(technical_node)
    .edge(START, "classifier")
    .conditional_edges("classifier", Router::by_field("category", vec![
        ("billing", "billing_agent"),
        ("technical", "technical_agent"),
    ]))
    .edge("billing_agent", END)
    .edge("technical_agent", END)
    .build()?;

Fonctionnalités clés :

Gestion d'état : Canaux d'état typés avec fusion automatique
Routage conditionnel : Routage basé sur les champs d'état ou une logique personnalisée
Points de contrôle : Backends SQLite et en mémoire pour la tolérance aux pannes
Humain dans la boucle : Interruption des workflows pour approbation humaine
Graphes cycliques : Prise en charge des modèles ReAct avec des limites d'itération

🎙️ Agents vocaux en temps réel

Créez des assistants IA à commande vocale avec streaming audio bidirectionnel :

use adk_realtime::{RealtimeAgent, openai::OpenAIRealtimeModel};

let agent = RealtimeAgent::builder("voice_assistant")
    .model(Arc::new(OpenAIRealtimeModel::new(&api_key, "gpt-4o-realtime-preview")))
    .instruction("You are a helpful voice assistant.")
    .voice("alloy")
    .server_vad()  // Voice Activity Detection
    .build()?;

Fournisseurs pris en charge :

OpenAI Realtime API (gpt-4o-realtime-preview, gpt-realtime)
Google Gemini Live API (gemini-2.0-flash-live-preview)

Fonctionnalités :

Streaming audio bidirectionnel (PCM16, G711)
Détection d'activité vocale côté serveur
Appel d'outils pendant les conversations vocales
Transferts multi-agents

🌐 Automatisation de navigateur

Le crate adk-browser fournit 46 outils WebDriver pour l'automatisation web :

use adk_browser::{BrowserSession, BrowserToolset, BrowserConfig};

let session = Arc::new(BrowserSession::new(
    BrowserConfig::new().webdriver_url("http://localhost:4444")
));
let tools = BrowserToolset::new(session).all_tools();

let agent = LlmAgentBuilder::new("web_agent")
    .model(model)
    .instruction("Browse the web and extract information.")
    .tools(tools)
    .build()?;

Catégories d'outils :

Navigation : browser_navigate, browser_back, browser_forward
Extraction : browser_extract_text, browser_extract_links, browser_extract_html
Interaction : browser_click, browser_type, browser_select
Formulaires : browser_fill_form, browser_submit
Captures d'écran : browser_screenshot, browser_screenshot_element
JavaScript : browser_evaluate, browser_evaluate_async

📊 Cadre d'évaluation d'agents

Testez et validez le comportement des agents avec le crate adk-eval :

use adk_eval::{Evaluator, EvaluationConfig, EvaluationCriteria};

let config = EvaluationConfig::with_criteria(
    EvaluationCriteria::exact_tools()
        .with_response_similarity(0.8)
);

let evaluator = Evaluator::new(config);
let report = evaluator
    .evaluate_file(agent, "tests/my_agent.test.json")
    .await?;

assert!(report.all_passed());

Capacités d'évaluation :

Validation de trajectoire (séquences d'appels d'outils)
Similarité de réponse (Jaccard, Levenshtein, ROUGE)
Correspondance sémantique jugée par LLM
Notation basée sur des rubriques avec des critères personnalisés
Détection de sécurité et d'hallucinations

🎨 ADK Studio : Constructeur visuel d'agents

Une interface glisser-déposer pour la création d'agents IA :

cargo install adk-studio
adk-studio

Fonctionnalités :

Canevas ReactFlow pour la conception visuelle de workflows
Palette complète d'agents : LLM, Séquentiel, Parallèle, Boucle, Routeur
Intégration d'outils : Fonction, MCP, Navigateur, Google Search
Test de chat en temps réel avec streaming SSE
Génération de code en un clic pour la production Rust

🛡️ Garde-fous

Validation d'entrée/sortie avec le crate adk-guardrail :

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

let guardrails = Guardrails::new()
    .add(PiiRedactor::default())
    .add(ContentFilter::block_harmful());

let safe_input = guardrails.process_input(user_message)?;
let safe_output = guardrails.process_output(agent_response)?;

Garde-fous intégrés :

Rédaction de PII (e-mails, téléphones, numéros de sécurité sociale, cartes de crédit)
Filtrage de contenu (nocif, inapproprié)
Validation de schéma JSON
Règles de validation personnalisées

🖼️ Génération dynamique d'UI

Le crate adk-ui permet aux agents de rendre des interfaces riches :

use adk_ui::{UiToolset, UI_AGENT_PROMPT};

let agent = LlmAgentBuilder::new("ui_assistant")
    .instruction(UI_AGENT_PROMPT)
    .tools(UiToolset::all_tools())
    .build()?;

Composants : 28 composants UI incluant des cartes, des tableaux, des graphiques, des formulaires Modèles : 10 modèles pré-construits pour les schémas courants Client React : npm install @zavora-ai/adk-ui-react

Changements majeurs

Changements RunnerConfig

La structure RunnerConfig inclut désormais un champ run_config :

// Before (v0.1.x)
let runner = Runner::new(RunnerConfig {
    app_name: "my_app".to_string(),
    agent: agent.clone(),
    session_service: session_service.clone(),
    artifact_service: None,
    memory_service: None,
})?;

// After (v0.2.0)
let runner = Runner::new(RunnerConfig {
    app_name: "my_app".to_string(),
    agent: agent.clone(),
    session_service: session_service.clone(),
    artifact_service: None,
    memory_service: None,
    run_config: None,  // NEW: Optional RunConfig for execution settings
})?;

Mises à jour des dépendances

sqlx mis à niveau de 0.7 à 0.8 (requis pour la compatibilité SQLite)
Rust édition 2024 (nécessite Rust 1.85+)

Guide de migration

Mettre à jour Cargo.toml :
```
adk-rust = "0.2.0"
```

Ajouter run_config: None à RunnerConfig :

RunnerConfig {
    // ... existing fields ...
    run_config: None,
}

Mettre à jour sqlx si vous utilisez des sessions SQLite :

sqlx = { version = "0.8", features = ["sqlite", "runtime-tokio"] }

Améliorations de performance

Optimisation du streaming : Réduction des allocations de mémoire dans le streaming d'événements
Mise en cache des sessions : Amélioration des performances de recherche de session
Exécution d'outils : Exécution parallèle d'outils lorsque possible

Documentation

Toute la documentation a été mise à jour pour la v0.2.0 :

La documentation est maintenant disponible en 9 langues : anglais, espagnol, chinois, japonais, portugais, allemand, français, arabe, hindi et coréen.

Prochaines étapes

Nous travaillons déjà sur la v0.3.0 avec les fonctionnalités prévues :

Intégrations cloud (AWS Bedrock, Azure OpenAI, GCP Vertex AI)
Systèmes de mémoire améliorés avec plus de backends de bases de données vectorielles
Modèles de workflows et schémas d'agents pré-construits
Outils de profilage et d'optimisation des performances

Démarrer

# Create a new project
cargo new my_agent
cd my_agent

# Add ADK-Rust
echo 'adk-rust = "0.2.0"' >> Cargo.toml
echo 'tokio = { version = "1.40", features = ["full"] }' >> Cargo.toml

# Set your API key
export GOOGLE_API_KEY="your-api-key"

# Run an example
cargo run --example quickstart

Merci

Un immense merci à tous ceux qui ont contribué à cette version par le code, la documentation, les rapports de bugs et les retours. ADK-Rust est construit par la communauté, pour la communauté.

Liens :

Bonne construction ! 🦀🤖