🦀ADK-Rust

Introdução ao ADK-Rust

Agent Development Kit (ADK) é um framework flexível e modular para desenvolver e implantar AI agents. Embora otimizado para Gemini e o Google ecosystem, o ADK é model-agnostic, deployment-agnostic e construído para compatibilidade com outros frameworks. O ADK foi projetado para fazer com que o desenvolvimento de agents se pareça mais com o desenvolvimento de software, tornando mais fácil para os developers criar, implantar e orquestrar arquiteturas agenticas que variam de tarefas simples a workflows complexos.

Nota: ADK-Rust v0.2.0 requer Rust 1.85.0 ou superior

Instalação

Adicione ADK-Rust ao seu projeto:

cargo add adk-rust

Ou adicione-o ao seu Cargo.toml:

[dependencies]
adk-rust = "0.2.0"
tokio = { version = "1.40", features = ["full"] }

Exemplo Rápido

use adk_rust::prelude::*;
use std::sync::Arc;

#[tokio::main]
async fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    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("A helpful AI assistant")
        .model(Arc::new(model))
        .build()?;
    
    println!("Agent '{}' ready!", agent.name());
    Ok(())
}

Visão Geral da Arquitetura

ADK-Rust usa uma arquitetura em camadas projetada para modularidade e extensibilidade:

┌─────────────────────────────────────────────────────────────┐
│                   Camada de Aplicação                        │
│             CLI • Servidor REST • Interface Web              │
├─────────────────────────────────────────────────────────────┤
│                     Camada do Runner                         │
│          Execução de Agent • Gerenciamento de Contexto       │
├─────────────────────────────────────────────────────────────┤
│                     Camada de Agent                          │
│         LlmAgent • CustomAgent • Agents de Workflow          │
├─────────────────────────────────────────────────────────────┤
│                    Camada de Serviço                         │
│      Modelos • Tools • Sessions • Artefatos • Memória        │
└─────────────────────────────────────────────────────────────┘

Conceitos Essenciais

ADK-Rust é construído em torno de várias primitivas chave que trabalham juntas para criar poderosos agentes de IA:

Agentes

A unidade de trabalho fundamental projetada para tarefas específicas. ADK-Rust fornece vários tipos de agentes:

  • LlmAgent: Usa um Large Language Model para raciocínio e tomada de decisão. Este é o tipo de agente principal para a maioria dos casos de uso.
  • RealtimeAgent: Agentes habilitados para voz usando OpenAI Realtime API ou Gemini Live API para streaming de áudio bidirecional.
  • GraphAgent: Orquestração de fluxo de trabalho estilo LangGraph com gerenciamento de estado, checkpointing e suporte a intervenção humana.
  • CustomAgent: Permite implementar lógica personalizada com controle total sobre o comportamento do agente.
  • Workflow Agents: Agentes determinísticos que seguem caminhos de execução predefinidos:
    • SequentialAgent: Executa sub-agentes em ordem
    • ParallelAgent: Executa sub-agentes concomitantemente
    • LoopAgent: Executa sub-agentes iterativamente até que uma condição seja satisfeita

Ferramentas

As ferramentas dão aos agentes habilidades além da conversação, permitindo que interajam com APIs externas, pesquisem informações ou realizem operações personalizadas:

  • FunctionTool: Envolve qualquer função Rust assíncrona como uma ferramenta
  • GoogleSearchTool: Capacidade de pesquisa na web integrada
  • BrowserToolset: 46 ferramentas WebDriver para automação web (navegação, formulários, capturas de tela, etc.)
  • ExitLoopTool: Controla a terminação de loops em LoopAgent
  • McpToolset: Integração com servidores Model Context Protocol

Sessões

As sessões lidam com o contexto de uma única conversa, incluindo:

  • Session ID: Identificador exclusivo para a conversa
  • Events: O histórico da conversa (mensagens do usuário, respostas do agente, chamadas de ferramenta)
  • State: Memória de trabalho para a conversa com prefixos com escopo (app:, user:, temp:)

Callbacks

Código personalizado que é executado em pontos específicos da execução do agente:

  • before_agent / after_agent: Intercepta invocações de agente
  • before_model / after_model: Intercepta chamadas LLM
  • before_tool / after_tool: Intercepta execuções de ferramenta

Callbacks permitem registro, guardrails, cache e modificação de comportamento.

Artefatos

Armazenamento de dados binários para arquivos, imagens ou outro conteúdo não textual:

  • Salvar e carregar artefatos com versionamento
  • Escopo de namespace (nível de sessão ou nível de usuário)
  • Backends de armazenamento plugáveis

Eventos

A unidade básica de comunicação representando coisas que acontecem durante uma sessão:

  • Mensagens do usuário
  • Respostas do agente
  • Chamadas de ferramenta e resultados
  • Mudanças de estado

Eventos formam o histórico da conversa e permitem reprodução e depuração.

Modelos

O LLM subjacente que alimenta LlmAgents. ADK-Rust é otimizado para Gemini, mas suporta múltiplos provedores através da trait Llm:

  • Gemini: Modelos Gemini do Google (gemini-3-pro-preview, gemini-2.5-flash, gemini-2.5-pro)
  • OpenAI: gpt-5.2, gpt-4o, gpt-4o-mini, Azure OpenAI
  • Anthropic: claude-sonnet-4-5, claude-opus-4-5, claude-sonnet-4
  • DeepSeek: deepseek-chat, deepseek-reasoner com thinking mode
  • Groq: Inferência ultrarrápida com llama-3.3-70b-versatile, mixtral-8x7b-32768
  • Ollama: Inferência local com llama3.2, qwen2.5, mistral, phi4
  • mistral.rs: Inferência local de alto desempenho com aceleração de hardware

Todos os provedores implementam a mesma trait para uso intercambiável:

pub trait Llm: Send + Sync {
    async fn generate(&self, request: LlmRequest) -> Result<LlmResponse>;
    async fn generate_stream(&self, request: LlmRequest) -> Result<LlmResponseStream>;
}

Runner

O motor que gerencia o fluxo de execução, orquestra as interações do agente e coordena com os serviços de backend. O Runner lida com:

  • Invocação de agente e processamento de resposta
  • Execução de ferramenta
  • Gerenciamento de sessão e estado
  • Streaming de evento

Flags de Recurso

adk-rust utiliza Cargo features para modularidade:

# Instalação completa (padrão)
adk-rust = "0.2.0"

# Mínimo: Apenas agents + Gemini
adk-rust = { version = "0.2.0", default-features = false, features = ["minimal"] }

# Personalizado: Escolha o que você precisa
adk-rust = { version = "0.2.0", default-features = false, features = ["agents", "gemini", "tools"] }

Recursos disponíveis:

  • agents: Implementações de Agent (LlmAgent, CustomAgent, workflow agents)
  • models: Integrações de Model (Gemini)
  • openai: Models OpenAI (GPT-5, GPT-4o)
  • anthropic: Models Anthropic (Claude 4.5, Claude 4)
  • deepseek: Models DeepSeek (chat, reasoner)
  • groq: Inferência ultra-rápida Groq
  • ollama: Models Ollama locais
  • tools: Sistema de Tool e tools integradas
  • sessions: Gerenciamento de Session
  • artifacts: Armazenamento de Artifact
  • memory: Sistema de Memory com pesquisa semântica
  • runner: Tempo de execução de Agent
  • server: Servidor HTTP (REST + A2A)
  • telemetry: Integração OpenTelemetry
  • cli: Lançador CLI

Outras Linguagens

ADK está disponível em várias linguagens:

Próximo: Quickstart →