ADK-Rust

use adk_tool::{tool, AdkError};
use schemars::JsonSchema;
use serde::Deserialize;
use serde_json::{json, Value};

#[derive(Deserialize, JsonSchema)]
struct WeatherArgs {
    /// The city to look up
    city: String,
}

/// Get the current weather for a city.
#[tool]
async fn get_weather(args: WeatherArgs) -> std::result::Result<Value, AdkError> {
    Ok(json!({ "temp": 72, "city": args.city }))
}

// Use it: agent_builder.tool(Arc::new(GetWeather))

use adk_rust::run;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    // Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_API_KEY
    let response = run("You are a helpful assistant.", "What is 2 + 2?").await?;
    println!("{response}");
    Ok(())
}

use adk_rust::prelude::*;
use adk_rust::Launcher;

#[tokio::main]
async fn main() -> AnyhowResult<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;

    let agent = LlmAgentBuilder::new("assistant")
        .description("Helpful AI assistant")
        .instruction("You are a helpful assistant. Be concise and accurate.")
        .model(Arc::new(model))
        .build()?;

    Launcher::new(Arc::new(agent)).run().await?;
    Ok(())
}

use adk_rust::prelude::*;
use adk_rust::Launcher;

#[tokio::main]
async fn main() -> AnyhowResult<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("OPENAI_API_KEY")?;
    let model = OpenAIClient::new(OpenAIConfig::new(api_key, "gpt-5-mini"))?;

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

    Launcher::new(Arc::new(agent)).run().await?;
    Ok(())
}

use adk_rust::prelude::*;
use adk_rust::Launcher;
use adk_model::openai::{OpenAIResponsesClient, OpenAIResponsesConfig};

#[tokio::main]
async fn main() -> AnyhowResult<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("OPENAI_API_KEY")?;
    let config = OpenAIResponsesConfig::new(api_key, "gpt-4.1-mini");
    let model = OpenAIResponsesClient::new(config)?;

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

    Launcher::new(Arc::new(agent)).run().await?;
    Ok(())
}

use adk_rust::prelude::*;
use adk_rust::Launcher;

#[tokio::main]
async fn main() -> AnyhowResult<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("ANTHROPIC_API_KEY")?;
    let model = AnthropicClient::new(AnthropicConfig::new(api_key, "claude-sonnet-4-6"))?;

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

    Launcher::new(Arc::new(agent)).run().await?;
    Ok(())
}

use adk_rust::prelude::*;
use adk_rust::Launcher;

#[tokio::main]
async fn main() -> AnyhowResult<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("DEEPSEEK_API_KEY")?;

    // Standard chat model
    let model = DeepSeekClient::chat(api_key)?;

    // Or use reasoner for chain-of-thought reasoning
    // let model = DeepSeekClient::reasoner(api_key)?;

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

    Launcher::new(Arc::new(agent)).run().await?;
    Ok(())
}

use adk_rust::prelude::*;
use adk_rust::Launcher;

#[tokio::main]
async fn main() -> AnyhowResult<()> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GROQ_API_KEY")?;
    let model = GroqClient::new(GroqConfig::llama70b(api_key))?;

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

    Launcher::new(Arc::new(agent)).run().await?;
    Ok(())
}

use adk_rust::prelude::*;
use adk_rust::Launcher;

#[tokio::main]
async fn main() -> AnyhowResult<()> {
    dotenvy::dotenv().ok();
    // Requires: ollama serve && ollama pull llama3.2
    let model = OllamaModel::new(OllamaConfig::new("llama3.2"))?;

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

    Launcher::new(Arc::new(agent)).run().await?;
    Ok(())
}

use adk_realtime::{RealtimeAgent, openai::OpenAIRealtimeModel, RealtimeModel};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let model: Arc<dyn RealtimeModel> = Arc::new(
        OpenAIRealtimeModel::new(&api_key, "gpt-4o-realtime-preview-2024-12-17")
    );

    let agent = RealtimeAgent::builder("voice_assistant")
        .model(model)
        .instruction("You are a helpful voice assistant.")
        .voice("alloy")
        .server_vad()  // Enable voice activity detection
        .build()?;

    Ok(())
}

use adk_graph::{prelude::*, node::AgentNode};
use adk_agent::LlmAgentBuilder;
use adk_model::GeminiModel;

// Create LLM agents for different tasks
let translator = Arc::new(LlmAgentBuilder::new("translator")
    .model(Arc::new(GeminiModel::new(&api_key, "gemini-2.5-flash")?))
    .instruction("Translate the input text to French.")
    .build()?);

let summarizer = Arc::new(LlmAgentBuilder::new("summarizer")
    .model(model.clone())
    .instruction("Summarize the input text in one sentence.")
    .build()?);

// Create AgentNodes with custom input/output mappers
let translator_node = AgentNode::new(translator)
    .with_input_mapper(|state| {
        let text = state.get("input").and_then(|v| v.as_str()).unwrap_or("");
        adk_core::Content::new("user").with_text(text)
    })
    .with_output_mapper(|events| {
        let mut updates = HashMap::new();
        for event in events {
            if let Some(content) = event.content() {
                let text: String = content.parts.iter()
                    .filter_map(|p| p.text())
                    .collect::<Vec<_>>()
                    .join("");
                updates.insert("translation".to_string(), json!(text));
            }
        }
        updates
    });

// Build graph with parallel execution
let agent = GraphAgent::builder("text_processor")
    .description("Translates and summarizes text in parallel")
    .channels(&["input", "translation"Release History
Version
Changes
Urgency
Date
v0.9.0
## ADK-Rust v0.9.0  ### Added  - **Composable Template System** — 8 base templates, 9 addons, 5 enterprise patterns via `cargo adk new --addon` - **Cargo Adk Build** — Compile-without-deploy subcommand for pre-deployment verification - **A2A Simple Scaffolding** — `A2aServer::quick_start`, `A2aServer::builder`, `cargo adk new --template a2a`  ### Changed  - Version bump from 0.8.5 to 0.9.0  ### Security  - hickory-proto 0.26.1 (moderate — DNS cache poisoning) - openssl 0.10.80 (moderate — certif
High
5/24/2026
v0.8.4
## Fixed  - **Gemini schema: array types require `items`**: v0.8.3 stripped tuple-style `items` entirely, causing Gemini to reject arrays with "missing field" errors. Now tuple `items` (`[{type:number},{type:number}]`) are converted to a single schema using the first element (`{type:number}`). Arrays without any `items` field also get a default `{type:string}` added.  ## Upgrade  ```toml adk-gemini = "0.8.4" ```  **Full Changelog**: https://github.com/zavora-ai/adk-rust/compare/v0.8.3...v0.8.4
High
5/18/2026
v0.8.1
## Highlights  **Agent Client Protocol (ACP) support** — connect ADK agents to Claude Code, Codex, Kiro CLI, and any ACP-compatible agent as tools.  ### New Crate: `adk-acp`  ```rust use adk_acp::AcpAgentTool;  let kiro = AcpAgentTool::new("kiro-cli acp --trust-all-tools")     .description("Delegate coding tasks to Kiro CLI");  let agent = LlmAgentBuilder::new("orchestrator")     .tool(Arc::new(kiro))     .build()?; ```  - `AcpAgentTool` — wraps any ACP agent as an ADK Tool - `AcpToolset` — mult
High
5/13/2026
v0.8.0
## Highlights  **Performance release** — default builds are 32% lighter with new feature tiers.  ### Breaking Changes  - **Default feature changed from `standard` to `minimal`**: `adk-rust = "0.8.0"` now activates only `agents`, `models`, `gemini`, `runner`, and `sessions`. Add `features = ["standard"]` for the full production preset.  ### New Feature Tiers  | Tier | Includes | Use case | |------|----------|----------| | `minimal` (default) | Gemini, agents, runner, sessions | Fast starter agent
High
5/7/2026
v0.7.0
## ADK-Rust v0.7.0  ### Highlights  - **Agentic Web Protocol (AWP)** — Two new crates (`awp-types`, `adk-awp`) implementing the full AWP protocol: discovery, capability manifests, trust levels, rate limiting, consent, events, health monitoring, and version negotiation. [AWP Docs](https://github.com/zavora-ai/adk-rust/blob/main/docs/official_docs/deployment/awp.md) - **DeepSeek V4 Provider** — `ThinkingMode`, `ReasoningEffort`, strict tool mode, beta URL support, `v4_pro`/`v4_flash` constructors 
High
4/26/2026
v0.6.0
## 🚀 ADK-Rust v0.6.0  **31 crates published to crates.io** · [Listen to the podcast →](https://github.com/zavora-ai/adk-rust#-rust--beyond-podcast--episode-1-what-is-adk-rust)  ### 🎧 Rust & Beyond Podcast  Episode 1 is live on the README — a 2:21 podcast about ADK-Rust generated entirely by the framework using Gemini 3.1 Flash TTS. Two AI hosts, natural voices, zero manual editing.  ### ✨ Highlights  #### Multimodal Function Responses (`adk-core`, `adk-gemini`, `adk-model`, `adk-agent`)  Tools
High
4/16/2026
v0.5.0
# ADK-Rust v0.5.0  **31 crates published to crates.io** — the largest ADK-Rust release to date.  ## Highlights  ### Zero-Config Ergonomics - **`provider_from_env()`** — auto-detect LLM provider from environment variables (Anthropic → OpenAI → Gemini precedence) - **`adk::run(instructions, input)`** — single-function agent invocation with auto provider detection, session creation, and execution  ### Prompt Caching Enabled by Default - **Anthropic**: `prompt_caching` now defaults to `true` (cache_
Medium
3/29/2026
v0.4.0
## Highlights  **ADK-Rust is now a focused, lean Rust framework.** UI, Studio, and 120+ examples extracted to standalone repos. Default builds dropped from ~2min to ~50s. New `cargo-adk` scaffolding CLI and `#[tool]` proc macro for zero-boilerplate DX.  ### Get Started  ```bash cargo install cargo-adk cargo adk new my-agent cd my-agent && cargo run ```  Templates: `--template tools` | `rag` | `api` | `openai`  ---  ## Breaking Changes  - **Default preset:** `full` → `standard`. Server/CLI includ
Low
3/16/2026
v0.3.1
## ADK-Rust v0.3.1  ### ⭐ Highlights  - **Vertex AI Streaming**: `adk-gemini` refactored with `GeminiBackend` trait — pluggable `StudioBackend` (REST) and `VertexBackend` (REST SSE streaming + gRPC fallback) - **Realtime Audio Transport**: Three new transports for `adk-realtime` — Vertex AI Live (OAuth2/ADC), LiveKit WebRTC bridge, OpenAI WebRTC (str0m + Opus) - **Vertex AI Live Tool Calling**: New `vertex_live_tools` example demonstrating real-time voice agents with function calling via Vertex 
Low
2/15/2026
v0.3.0
## ⭐ Highlights - **Context Compaction**: Sliding-window summarization of older events to reduce LLM context size (ADK Python parity) - **Workflow Agent Hardening**: ConditionalAgent, LlmConditionalAgent, and ParallelAgent production fixes - **adk-core Production Hardening**: Security limits, validation, provider-agnostic Event, hand-written template parser - **Action Node Code Generation**: Full Rust codegen for HTTP, Database, Email, and Code action nodes - **Workflow Triggers**: Complete trig
Low
2/10/2026
v0.2.1
## ⭐ Highlights - **OpenAI Structured Output**: `output_schema` now works with OpenAI/Azure via `response_format` API - **Ralph Autonomous Agent**: New example showcasing spec-driven development with loop agents - **Local Model Support**: New examples for Ollama and OpenAI-compatible local APIs - **Improved Error Handling**: Replaced `unwrap()` calls with proper error handling across crates  ## Added - **adk-model**: OpenAI/Azure clients now wire `output_schema` to `response_format` with `json_s
Low
1/22/2026
v0.2.0
## Release v0.2.0 - Major Documentation & Feature Update  ### 🚀 New Features  **Streaming Mode Control** - Implement `StreamingMode.None` and SSE per ADK spec - Add streaming mode control to Launcher API - Use stable event IDs for all streaming chunks  **Tracing & Observability** - Add `call_llm` span in llm_agent.rs for all model types - Fix async tool execution tracing to match adk-go pattern - Group spans by invocation_id in trace UI - Add get_event endpoint for trace-event linking  **Agents
Low
1/7/2026
v0.1.8
## ⭐ Highlights - **ADK Studio**: Complete visual agent builder with drag-and-drop workflow design - **Real-Time Streaming**: Live SSE streaming with agent animations and trace events - **Code Generation**: Compile visual workflows to production Rust code - **Rust 2024 Edition**: Migrated to Rust 2024 edition for latest language features  ## Added - **ADK Studio** (`adk-studio`): Visual agent development environment   - Drag-and-drop agent creation with ReactFlow-based canvas   - Full agent pale
Low
12/28/2025
v0.1.7
## 🛡️ Guardrails Framework  This release introduces **adk-guardrail**, a new crate for agent safety and validation.  ### New Crate: adk-guardrail  - **`Guardrail` trait** - Async validation returning `Pass`, `Fail`, or `Transform` - **`GuardrailSet`** - Collection with parallel execution and early exit on `Critical` severity - **`Severity` levels** - `Low`, `Medium`, `High`, `Critical`  ### Built-in Guardrails  | Guardrail | Description | |-----------|-------------| | `PiiRedactor` | Detects an
Low
12/14/2025
v0.1.6
# Release v0.1.6 🦀  ## 🎨 Introducing adk-ui: Dynamic UI Generation for AI Agents  This release introduces **adk-ui**, a complete framework for AI agents to generate rich, interactive user interfaces through tool calls. Give your agents the power to render forms, tables, charts, dashboards, and more!  ### Why adk-ui?  Traditional AI chatbots are limited to text responses. With adk-ui, your agents can: - **Collect structured data** via forms (registration, settings, surveys) - **Display data** w
Low
12/12/2025
v0.1.5
## Added - **DeepSeek provider support**: Native integration with DeepSeek's LLM models   - `DeepSeekClient` and `DeepSeekConfig` for easy configuration   - Support for `deepseek-chat` (standard) and `deepseek-reasoner` (thinking mode)   - Thinking mode with chain-of-thought reasoning   - Context caching for 10x cost reduction on repeated prefixes   - Full function calling/tool support   - Feature flag: `adk-model = { features = ["deepseek"] }` - 8 new DeepSeek examples:   - `deepseek_basic` - B
Low
12/10/2025
v0.1.4
Release v0.1.4 - Graph Workflows, Browser Automation, Evaluation    This release adds three major new crates: adk-graph for LangGraph-style workflows, adk-browser for browser automation, and adk-eval for agent evaluation.    ✨ New Features    adk-graph Crate    - StateGraph for building complex agent workflows with state channels   - AgentNode for wrapping LLM agents as graph nodes with input/output mappers   - Conditional routing with Router::by_field and custom predicates   - Human-
Low
12/9/2025
v0.1.3
## Release v0.1.3 - Real-time Voice-Enabled AI Agents    This release introduces the `adk-realtime` crate for building voice-enabled AI agents with real-time audio streaming.    ### ✨ New Features    #### adk-realtime Crate   - **RealtimeAgent** implementing `adk_core::Agent` trait with full callback/tool/instruction support   - **OpenAI Realtime API** support (`gpt-4o-realtime-preview-2024-12-17`, `gpt-realtime`)   - **Gemini Live API** support (`gemini-2.0-flash-live-preview-04-09`) 
Low
12/9/2025
v0.1.2
## Release v0.1.2 - Multi-Provider LLM Support  This release adds support for OpenAI and Anthropic providers, making ADK-Rust a truly multi-provider LLM framework supporting Gemini, OpenAI, and Claude.  ### ✨ New Features  #### OpenAI Provider Support - Full integration with OpenAI GPT models (GPT-4o, GPT-4o-mini, GPT-4-turbo, GPT-3.5-turbo) - `OpenAIClient` and `OpenAIConfig` for easy configuration - Streaming support with proper tool call accumulation - Feature flag: `adk-model = { features = 
Low
12/7/2025