Proveedores de Modelos (Nube)

adk-rust es compatible con múltiples proveedores de LLM en la nube a través de la crate adk-model. Todos los proveedores implementan el trait Llm, lo que los hace intercambiables en tus agents.

Descripción General

┌─────────────────────────────────────────────────────────────────────┐
│                     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                                      │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Comparación Rápida

---

Paso 1: Instalación

Añade los proveedores que necesites a tu Cargo.toml:

[dependencies]
# Elige uno o más proveedores:
adk-model = { version = "0.2", features = ["gemini"] }        # Google Gemini (predeterminado)
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-rápido)

# O todos los proveedores en la nube a la vez:
adk-model = { version = "0.2", features = ["all-providers"] }

Paso 2: Configura Tu Clave 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) ⭐ Predeterminado

Mejor para: Propósito general, tareas multimodales, documentos grandes

Aspectos destacados clave:

• 🖼️ Multimodal nativo (imágenes, video, audio, PDF)
• 📚 Ventana de contexto de hasta 2M tokens
• 💰 Precios competitivos
• ⚡ Inferencia rápida

Ejemplo Completo en Funcionamiento

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("Gemini-powered assistant")
        .instruction("You are a helpful assistant powered by Google Gemini. Be concise.")
        .model(Arc::new(model))
        .build()?;

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

Modelos Disponibles

Ejemplo de Salida

👤 Usuario: ¿Qué hay en esta imagen? [sube foto de un gato]

🤖 Gemini: Puedo ver un gato atigrado naranja y esponjoso sentado en el alféizar de una ventana. 
El gato parece estar mirando hacia afuera, con la luz del sol iluminando su pelaje. 
Tiene ojos verdes y distintivas marcas rayadas típicas de los gatos atigrados.

---

OpenAI (GPT-4o) 🔥 Popular

Mejor para: Aplicaciones de producción, rendimiento fiable, amplias capacidades

Aspectos destacados clave:

• 🏆 Estándar de la industria
• 🔧 Excelente llamada a herramientas/funciones
• 📖 Mejor documentación y ecosistema
• 🎯 Salidas consistentes y predecibles

Ejemplo Completo en Funcionamiento

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("OpenAI-powered assistant")
        .instruction("You are a helpful assistant powered by OpenAI GPT-4o. Be concise.")
        .model(Arc::new(model))
        .build()?;

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

Modelos Disponibles

Ejemplo de Salida

👤 Usuario: Escribe un haiku sobre la programación en Rust

🤖 GPT-4o: Memoria tan segura,
la propiedad guarda cada byte —
Compilador, mi amigo.

---

Anthropic (Claude) 🧠 Inteligente

Mejor para: Razonamiento complejo, aplicaciones de seguridad crítica, documentos largos

Características clave:

• 🧠 Capacidad de razonamiento excepcional
• 🛡️ Más enfocado en la seguridad
• 📚 Contexto de 200K tokens
• ✍️ Excelente calidad de escritura

Ejemplo de trabajo completo

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("Asistente impulsado por Anthropic")
        .instruction("Eres un asistente útil impulsado por Anthropic Claude. Sé conciso y considerado.")
        .model(Arc::new(model))
        .build()?;

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

Modelos disponibles

Ejemplo de salida

👤 User: Explícale el entrelazamiento cuántico a un niño de 10 años

🤖 Claude: Imagina que tienes dos monedas mágicas. Cuando las lanzas, siempre 
caen de la misma manera, ambas caras o ambas cruces, ¡incluso si una moneda 
está en la Tierra y la otra en la Luna! Los científicos llaman a esto 
"entrelazamiento". Las monedas están conectadas de una manera especial que no 
podemos ver, como mejores amigos invisibles que siempre toman la misma elección 
al mismo tiempo.

---

DeepSeek 💭 Pensamiento

Mejor para: Resolución de problemas complejos, matemáticas, codificación, tareas de razonamiento

Características clave:

• 💭 Modo de pensamiento - muestra el razonamiento paso a paso
• 💰 Muy rentable (10 veces más barato que GPT-4)
• 🔄 Almacenamiento en caché de contexto para prefijos repetidos
• 🧮 Fuerte en matemáticas y codificación

Ejemplo de trabajo completo

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 estándar
    let model = DeepSeekClient::chat(&api_key)?;
    
    // O: Modelo de razonamiento con modo de pensamiento
    // let model = DeepSeekClient::reasoner(&api_key)?;

    let agent = LlmAgentBuilder::new("deepseek_assistant")
        .description("Asistente impulsado por DeepSeek")
        .instruction("Eres un asistente útil impulsado por DeepSeek. Sé conciso.")
        .model(Arc::new(model))
        .build()?;

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

Modelos disponibles

Ejemplo de salida (Reasoner con modo de pensamiento)

👤 User: ¿Cuánto es 17 × 23?

🤖 DeepSeek: <thinking>
Permíteme desglosarlo:
17 × 23 = 17 × (20 + 3)
       = 17 × 20 + 17 × 3
       = 340 + 51
       = 391
</thinking>

La respuesta es 391.

Groq ⚡ Ultra-Rápido

Ideal para: Aplicaciones en tiempo real, chatbots, tareas críticas de velocidad

Puntos clave:

• ⚡ Inferencia más rápida - 10 veces más rápido que los competidores
• 🔧 Tecnología LPU (Language Processing Unit)
• 💰 Precios competitivos
• 🦙 Ejecuta modelos LLaMA, Mixtral, Gemma

Ejemplo Completamente 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 Disponibles

Ejemplo de Salida

👤 User: Quick! Name 5 programming languages

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

---

Cambiando de Proveedor

Todos los proveedores implementan el mismo trait Llm, por lo que el cambio es fácil:

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

// ¡Solo cambia el modelo - todo lo demás permanece igual!
let model: Arc<dyn adk_core::Llm> = Arc::new(
    // Pick one:
    // 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()?;

---

Ejemplos

# Gemini (predeterminado)
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 pensamiento

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

---

Relacionado

• Ollama (Local) - Ejecuta modelos localmente con Ollama
• Modelos Locales (mistral.rs) - Inferencia Rust nativa
• LlmAgent - Usando modelos con agentes
• Function Tools - Añadiendo herramientas a los agentes

---

Anterior: ← Agentes en tiempo real | Siguiente: Ollama (Local) →