Provedores de Modelo (Nuvem)

ADK-Rust suporta múltiplos provedores de LLM na nuvem através da crate adk-model. Todos os provedores implementam a Llm trait, tornando-os intercambiáveis em seus agents.

Visão Geral

┌─────────────────────────────────────────────────────────────────────┐
│                     Cloud Model Providers                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   • Gemini (Google)    ⭐ Default    - Multimodal, large context    │
│   • OpenAI (GPT-4o)    🔥 Popular    - Best ecosystem               │
│   • Anthropic (Claude) 🧠 Smart      - Best reasoning               │
│   • DeepSeek           💭 Thinking   - Chain-of-thought, cheap      │
│   • Groq               ⚡ Ultra-Fast  - Fastest inference           │
│                                                                     │
│   For local/offline models, see:                                    │
│   • Ollama     → ollama.md                                          │
│   • mistral.rs → mistralrs.md                                          │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Comparação Rápida

---

Passo 1: Instalação

Adicione os provedores que você precisa ao seu Cargo.toml:

[dependencies]
# Pick one or more providers:
adk-model = { version = "0.2", features = ["gemini"] }        # Google Gemini (default)
adk-model = { version = "0.2", features = ["openai"] }        # OpenAI GPT-4o
adk-model = { version = "0.2", features = ["anthropic"] }     # Anthropic Claude
adk-model = { version = "0.2", features = ["deepseek"] }      # DeepSeek
adk-model = { version = "0.2", features = ["groq"] }          # Groq (ultra-fast)

# Or all cloud providers at once:
adk-model = { version = "0.2", features = ["all-providers"] }

Passo 2: Defina Sua Chave de API

export GOOGLE_API_KEY="your-key"      # Gemini
export OPENAI_API_KEY="your-key"      # OpenAI
export ANTHROPIC_API_KEY="your-key"   # Anthropic
export DEEPSEEK_API_KEY="your-key"    # DeepSeek
export GROQ_API_KEY="your-key"        # Groq

---

Gemini (Google) ⭐ Padrão

Melhor para: Fins gerais, tarefas multimodais, documentos grandes

Principais destaques:

• 🖼️ Multimodal nativo (imagens, vídeo, áudio, PDF)
• 📚 Janela de contexto de até 2M token
• 💰 Preços competitivos
• ⚡ Inferência rápida

Exemplo Completo Funcionando

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

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

    let agent = LlmAgentBuilder::new("gemini_assistant")
        .description("Assistente com Gemini")
        .instruction("Você é um assistente útil alimentado por Google Gemini. Seja conciso.")
        .model(Arc::new(model))
        .build()?;

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

Modelos Disponíveis

Exemplo de Saída

👤 User: O que há nesta imagem? [envia foto de um gato]

🤖 Gemini: Eu posso ver um gato tigrado laranja e fofo sentado em uma janela. 
O gato parece estar olhando para fora, com a luz do sol iluminando seu pelo. 
Ele tem olhos verdes e marcações listradas distintas, típicas de gatos tigrados.

---

OpenAI (GPT-4o) 🔥 Popular

Melhor para: Aplicações de produção, desempenho confiável, amplas capacidades

Principais destaques:

• 🏆 Padrão da indústria
• 🔧 Excelente chamada de ferramenta/função
• 📖 Melhor documentação e ecossistema
• 🎯 Saídas consistentes e previsíveis

Exemplo Completo Funcionando

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

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

    let agent = LlmAgentBuilder::new("openai_assistant")
        .description("Assistente com OpenAI")
        .instruction("Você é um assistente útil alimentado por OpenAI GPT-4o. Seja conciso.")
        .model(Arc::new(model))
        .build()?;

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

Modelos Disponíveis

Exemplo de Saída

👤 User: Escreva um haicai sobre programação Rust

🤖 GPT-4o: Memória segura,
Ownership guarda cada byte—
Compilador, meu amigo.

---

Anthropic (Claude) 🧠 Inteligente

Melhor para: Raciocínio complexo, aplicativos de segurança crítica, documentos longos

Principais destaques:

• 🧠 Capacidade de raciocínio excepcional
• 🛡️ Mais focado em segurança
• 📚 Contexto de 200K tokens
• ✍️ Excelente qualidade de escrita

Exemplo Completo de Funcionamento

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

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

    let agent = LlmAgentBuilder::new("anthropic_assistant")
        .description("Anthropic-powered assistant")
        .instruction("You are a helpful assistant powered by Anthropic Claude. Be concise and thoughtful.")
        .model(Arc::new(model))
        .build()?;

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

Modelos Disponíveis

Exemplo de Saída

👤 Usuário: Explique emaranhamento quântico para uma criança de 10 anos

🤖 Claude: Imagine que você tem duas moedas mágicas. Quando você as joga, elas sempre 
caem da mesma maneira - ambas cara ou ambas coroa - mesmo que uma moeda esteja na Terra 
e a outra na Lua! Cientistas chamam isso de "emaranhamento". As moedas 
estão conectadas de uma forma especial que não podemos ver, como melhores amigos 
invisíveis que sempre fazem a mesma escolha exatamente ao mesmo tempo.

---

DeepSeek 💭 Pensando

Melhor para: Resolução de problemas complexos, matemática, codificação, tarefas de raciocínio

Principais destaques:

• 💭 Modo de raciocínio - mostra o raciocínio em cadeia de pensamento
• 💰 Muito econômico (10x mais barato que GPT-4)
• 🔄 Cache de contexto para prefixos repetidos
• 🧮 Forte em matemática e codificação

Exemplo Completo de Funcionamento

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

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    
    let api_key = std::env::var("DEEPSEEK_API_KEY")?;
    
    // Modelo de chat padrão
    let model = DeepSeekClient::chat(&api_key)?;
    
    // OU: Modelo de raciocínio com modo de pensamento
    // let model = DeepSeekClient::reasoner(&api_key)?;

    let agent = LlmAgentBuilder::new("deepseek_assistant")
        .description("DeepSeek-powered assistant")
        .instruction("You are a helpful assistant powered by DeepSeek. Be concise.")
        .model(Arc::new(model))
        .build()?;

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

Modelos Disponíveis

Exemplo de Saída (Reasoner com Modo de Raciocínio)

👤 Usuário: Quanto é 17 × 23?

🤖 DeepSeek: <thinking>
Deixe-me detalhar:
17 × 23 = 17 × (20 + 3)
       = 17 × 20 + 17 × 3
       = 340 + 51
       = 391
</thinking>

A resposta é 391.

Groq ⚡ Ultrarrápido

Melhor para: aplicações em tempo real, chatbots, tarefas críticas de velocidade

Destaques principais:

• ⚡ Inferência mais rápida - 10x mais rápido que os concorrentes
• 🔧 Tecnologia LPU (Language Processing Unit)
• 💰 Preços competitivos
• 🦙 Executa modelos LLaMA, Mixtral, Gemma

Exemplo Completo e Funcional

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

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

    let agent = LlmAgentBuilder::new("groq_assistant")
        .description("Groq-powered assistant")
        .instruction("You are a helpful assistant powered by Groq. Be concise and fast.")
        .model(Arc::new(model))
        .build()?;

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

Modelos Disponíveis

Exemplo de Saída

👤 User: Quick! Name 5 programming languages

🤖 Groq (in 0.2 seconds): 
1. Rust
2. Python
3. JavaScript
4. Go
5. TypeScript

---

Trocando de Provedores

Todos os provedores implementam a mesma trait Llm, então a troca é fácil:

use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

// Apenas mude o modelo - todo o resto permanece o mesmo!
let model: Arc<dyn adk_core::Llm> = Arc::new(
    // Escolha um:
    // GeminiModel::new(&api_key, "gemini-2.0-flash")?
    // OpenAIClient::new(OpenAIConfig::new(&api_key, "gpt-4o"))?
    // AnthropicClient::new(AnthropicConfig::new(&api_key, "claude-sonnet-4-20250514"))?
    // DeepSeekClient::chat(&api_key)?
    // GroqClient::llama70b(&api_key)?
);

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

---

Exemplos

# Gemini (padrão)
cargo run --example quickstart

# OpenAI
cargo run --example openai_basic --features openai

# Anthropic
cargo run --example anthropic_basic --features anthropic

# DeepSeek
cargo run --example deepseek_basic --features deepseek
cargo run --example deepseek_reasoner --features deepseek  # Modo de pensamento

# Groq
cargo run --example groq_basic --features groq

---

Relacionado

• Ollama (Local) - Execute modelos localmente com Ollama
• Modelos Locais (mistral.rs) - Inferência Rust nativa
• LlmAgent - Usando modelos com agents
• Function Tools - Adicionando tools aos agents

---

Anterior: ← Realtime Agents | Próximo: Ollama (Local) →