zavora-ai/adk-rust

ADK‑Rust – A Rust‑first framework for building production‑grade AI agents

What it is – ADK‑Rust is a modular, type‑safe, async‑ready Rust workspace (43 crates) that lets you compose, run and serve autonomous AI agents. It is model‑agnostic: you can plug in Gemini, OpenAI, Anthropic, Ollama, Bedrock, Groq, DeepSeek, Mistral‑rs and many other providers, or even run local models via mistral.rs.

Key ideas

• Agent‑as‑code – define an agent (or a team of agents) with the LlmAgentBuilder or higher‑level workflow builders. The core Agent trait abstracts over any LLM client.
• Composable features – the crate workspace is split into tiers (minimal, standard, enterprise, full) and a fine‑grained feature system. You can start with a tiny Gemini‑only agent and add tools, memory, RAG, realtime voice, payments, sandboxed code execution, etc., without pulling in unrelated code.
• Durable orchestration – built‑in graph workflows, sub‑graphs, checkpoints (SQLite, Redis, Mongo, Firestore, Neo4j, Vertex AI), and a pause‑and‑resume mechanism that survives process restarts.
• Tool calling – the #[tool] macro derives JSON schemas from Rust types, making it trivial to expose custom functions to the LLM.
• Observability & security – OpenTelemetry tracing, structured logging, RBAC/JWT auth, audit logs, and guard‑rails for input/output validation.
• Rich runtime UI – an embedded web UI (served on http://127.0.0.1:8080/ui/) shows the conversation, streaming markdown, tool results, and a live graph of the agent’s execution.
• Enterprise add‑ons – realtime voice/video (OpenAI Realtime, Gemini Live, LiveKit), browser automation (46 WebDriver tools), agentic commerce (ACP/AP2), and a Gemini Enterprise Agent Engine BYOC container.

Typical workflow

1. Install the CLI helper: cargo install cargo-adk.
2. Scaffold a project with a template, e.g. cargo adk new quickstart_agent --template api --provider openai.
3. Fill in your API key in .env and run cargo run.
4. Interact via the UI or call the HTTP endpoints (/api/health, /api/...).

Example – a minimal Gemini agent

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

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    let model = GeminiModel::new(&std::env::var("GOOGLE_API_KEY")?, "gemini-3.7-flash")?;
    let agent = LlmAgentBuilder::new("assistant")
        .instruction("You are a helpful assistant. Be concise and accurate.")
        .model(std::sync::Arc::new(model))
        .build()?;
    Launcher::new(std::sync::Arc::new(agent)).run().await?;
    Ok(())
}

Swap the provider by changing the client construction – the rest of the code stays identical.

Feature matrix (selected)

Tier	What you get	Typical use case
minimal (default)	Gemini client, core agent runtime, sessions	Quick prototypes, single‑LLM bots
standard	All of minimal + OpenAI, Anthropic, tool system, memory, telemetry, HTTP server, auth, graph workflow, evaluation	Production chatbots or tool‑calling services
enterprise	standard + realtime audio/video, RAG, payments, AWP, browser automation	Voice assistants, retrieval‑augmented agents, commerce‑enabled bots
full	enterprise + audio generation, sandboxed code execution, advanced security	End‑to‑end AI‑powered products with code‑writing or media creation

What you can build (each links to a guide and a runnable example in the repo)

• Embedded UI with live topology visualisation
• Custom tools via #[tool]
• MCP (Agent Client Protocol) clients/servers
• Sequential, parallel, looping, and conditional workflow agents
• Multi‑agent teams with validated hand‑offs and receipts
• Graph workflows with durable checkpoints and human‑in‑the‑loop sub‑graphs
• Coding agents that edit and run code in a sandboxed workspace
• Realtime voice/video agents (OpenAI Realtime, Gemini Live, LiveKit)
• Governed computer‑use with approval digests
• Retrieval‑augmented generation (RAG) with 6 vector‑store backends
• Long‑term semantic memory and bi‑temporal knowledge graphs
• HTTP/REST servers exposing agents, with Server‑Sent Events streaming
• Gemini Enterprise Agent Engine BYOC containers & Terraform deployment
• Agentic Web Protocol (AWP) for discovery, manifests, consent, and trust levels
• Agentic commerce (ACP/AP2) with durable transaction journals
• Browser automation tools (WebDriver)
• Evaluation framework (trajectory, rubric, LLM‑judge, A/B testing)
• Guardrails, RBAC, SSO, audit logging
• OpenTelemetry tracing and structured logging

Installation

# Add the crate to any Rust project
cargo add adk-rust   # defaults to "minimal"
# Or pick a tier
cargo add adk-rust --features "standard"

Or use the CLI scaffolding (cargo adk new …) to generate a ready‑to‑run project.

Documentation & community

• Crates.io page with versioned releases (latest published 2.2.0, 2.3.0 RC pending).
• Docs hosted on docs.rs and a Wiki for deeper guides.
• CI badge shows continuous testing (4,300+ tests, 104 examples).
• Podcast series (Episode 3 covers the v2.0 “Agents That Act” features).
• GitHub Discussions for Q&A and a sponsor link for funding.

Who it’s for – Rust developers who need a performant, type‑safe foundation for autonomous agents, whether they are building a simple chatbot, a multi‑agent workflow system, a voice‑enabled assistant, or a full‑stack AI product with commerce and compliance requirements.

---

All information above is taken directly from the repository’s README; no additional features have been inferred.