Rust Agent Development Kit (ADK-Rust)

Vertex AI Live (requires gcloud auth application-default login)

cargo run -p adk-realtime --example vertex_live_voice --features vertex-live cargo run -p adk-realtime --example vertex_live_tools --features vertex-live

LiveKit Bridge (requires LiveKit server)

cargo run -p adk-realtime --example livekit_bridge --features livekit,openai

OpenAI WebRTC (requires cmake)

cargo run -p adk-realtime --example openai_webrtc --features openai-webrtc

NVIDIA GPU (requires CUDA toolkit)

make build-mistralrs-cuda

Manual installation

Requires Rust 1.85 or later (Rust 2024 edition). Add to your Cargo.toml:

```toml [dependencies] adk-rust = "0.9.1" # Minimal (default): Gemini + agent runtime + sessions

Building from Source

Dev Environment Setup

```bash

Option B: Setup script (installs sccache, cmake, etc.)

./scripts/setup-dev.sh

Option C: Manual — just install sccache for faster builds

brew install sccache && echo 'export RUSTC_WRAPPER=sccache' >> ~/.zshrc ```

Build all crates (CPU-only, works on all systems)

make build

Build with all features (safe - adk-mistralrs excluded)

make build-all

Build all examples

make examples

Manual Build

```bash

Build workspace (CPU-only)

cargo build --workspace

Build with all features (works without CUDA)

cargo build --workspace --all-features

Build all workspace examples

cargo check --workspace --examples ```

or: cargo build --manifest-path adk-mistralrs/Cargo.toml

or: cargo build --manifest-path adk-mistralrs/Cargo.toml --features metal

or: cargo build --manifest-path adk-mistralrs/Cargo.toml --features cuda

```

Build the mistral.rs crate explicitly

cargo build --manifest-path adk-mistralrs/Cargo.toml

Minimal — just agents + Gemini + runner (fastest build)

adk-rust = { version = "0.9.1", default-features = false, features = ["minimal"] }

Building

```bash

Development build

cargo build

Optimized release build

cargo build --release ```

Quick Start

Basic Example (Gemini)

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

OpenAI Example

Enable OpenAI with adk-rust = { version = "0.9.1", features = ["openai"] }.

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

OpenAI Responses API Example

Uses the /v1/responses endpoint — recommended for reasoning models (o3, o4-mini) and built-in tools:

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

Anthropic Example

Enable Anthropic with adk-rust = { version = "0.9.1", features = ["anthropic"] }.

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

DeepSeek Example

Enable DeepSeek with adk-rust = { version = "0.9.1", features = ["deepseek"] }.

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

Groq Example (Ultra-Fast)

Enable Groq with adk-rust = { version = "0.9.1", features = ["groq"] }.

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

Ollama Example (Local)

Enable Ollama with adk-rust = { version = "0.9.1", features = ["ollama"] }.

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

Examples

Examples live in the dedicated adk-playground repo (120+ examples covering every feature and provider). The examples documented in this repository are validated by scripts/check-doc-examples.sh, scripts/check-cargo-adk-templates.sh, and workspace example builds.

Running mistralrs Examples

```bash

Examples

The workspace keeps core crate examples close to the crates that own them, and standalone adoption examples under examples/. The public gallery remains adk-playground.

Validated examples in this repo include:

• cargo run -p adk-rust --example performance_0_8_llm_agents --features openrouter — all 12 v0.8 optimization use cases with live LLM agents.
• cargo run --manifest-path examples/tier_examples/standard/Cargo.toml --bin 11-standard-graph — standard-tier graph workflow.
• cargo run --manifest-path examples/openai_responses/Cargo.toml — OpenAI Responses API example.
• cargo run -p adk-realtime --example openai_session_update --features openai — OpenAI Realtime session mutation.
• cargo run -p adk-realtime --example vertex_live_voice --features vertex-live — Vertex AI Live voice session.
• cargo run --manifest-path examples/awp_agent/Cargo.toml — Agentic Web Protocol server example.

Configure via: aws configure

Option A: Nix/devenv (reproducible — identical on Linux, macOS, CI)

devenv shell

Production tier without CLI provider fan-out

adk-rust = { version = "0.9.1", features = ["standard"] }

Need server, auth, graph workflows, eval?

Graph-Based Workflows

Build complex, stateful workflows using the adk-graph crate (LangGraph-style):

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", "summary"])
    .node(translator_node)
    .node(summarizer_node)  // Similar setup
    .edge(START, "translator")
    .edge(START, "summarizer")  // Parallel execution
    .edge("translator", "combine")
    .edge("summarizer", "combine")
    .edge("combine", END)
    .build()?;

// Execute
let mut input = State::new();
input.insert("input".to_string(), json!("AI is transforming how we work."));
let result = agent.invoke(input, ExecutionConfig::new("thread-1")).await?;

Features: - AgentNode: Wrap LLM agents as graph nodes with custom input/output mappers - Parallel & Sequential: Execute agents concurrently or in sequence - Cyclic Graphs: ReAct pattern with tool loops and iteration limiting - Conditional Routing: Dynamic routing via Router::by_field or custom functions - Checkpointing: Memory and SQLite backends for fault tolerance, durable resume from checkpoint after crash - Human-in-the-Loop: Dynamic interrupts based on state, resume from checkpoint - Streaming: Multiple modes (values, updates, messages, debug)

Run validated graph examples:

cargo run --manifest-path examples/tier_examples/standard/Cargo.toml --bin 11-standard-graph
cargo run --manifest-path examples/tier_examples/standard/Cargo.toml --bin 12-standard-sequential
cargo run --manifest-path examples/competitive_graph_resume/Cargo.toml