Inicio rápido

Crea tu primer agente de IA en menos de 5 minutos.

Requisitos previos

• Rust 1.95.0 o posterior (rustup update stable)
• Una clave de Google API (consigue una aquí)

Paso 1: Genera la estructura de tu proyecto

cargo install cargo-adk
cargo adk new my_agent
cd my_agent

Esto genera un proyecto funcional con las dependencias correctas y el código base.

Otras plantillas

# Agent with custom tools using #[tool] macro
cargo adk new my_agent --template tools

# RAG agent with Gemini embeddings and in-memory vector search
cargo adk new my_agent --template rag

# REST API server ready for deployment
cargo adk new my_agent --template api

# OpenAI GPT-5-mini agent
cargo adk new my_agent --template openai

# A2A protocol agent with builder API
cargo adk new my_agent --template a2a

# Use any provider with any template
cargo adk new my_agent --template tools --provider anthropic

# Add optional addons to any template
cargo adk new my_agent --template tools --addon docker --addon ci

Consejo: Usa la bandera --addon para componer plantillas con addons opcionales como docker, ci, telemetry y más. Consulta la página Composable Templates para la lista completa de 9 addons y 5 patrones empresariales.

Paso 2: Añade tu clave API

cp .env.example .env
# Edit .env and add your GOOGLE_API_KEY

Paso 3: Ejecuta

cargo run

Eso es todo — ya tienes un agente funcional. Chatea con él en tu terminal.

ADK Console Mode
Agent: my_agent
Type your message and press Enter. Ctrl+C to exit.

> Hello! What can you help me with?

I'm a helpful AI assistant. I can help you with answering questions,
explaining concepts, and having a friendly conversation.

---

Alternativa sin configuración — adk::run()

Si solo quieres ejecutar un agente rápido sin scaffolding, usa la versión de una sola línea:

use adk_rust::run;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    dotenvy::dotenv().ok();
    // Minimal default: set GOOGLE_API_KEY. Add provider features for OpenAI/Anthropic.
    let response = run("You are a helpful assistant.", "Explain Rust in one sentence.").await?;
    println!("{response}");
    Ok(())
}

Esto maneja la detección del proveedor para proveedores compilados, la creación de la sesión, la construcción del agente y la ejecución en una sola llamada. Ideal para scripts, prototipos y experimentos rápidos.

---

Entendiendo el código generado

La src/main.rs creada:

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.5-flash")?;

    let agent = LlmAgentBuilder::new("my_agent")
        .description("A helpful AI assistant")
        .instruction("You are a friendly assistant. Be concise and helpful.")
        .model(Arc::new(model))
        .build()?;

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

Añadiendo herramientas personalizadas

La forma más rápida de añadir herramientas es la macro #[tool]. Añade adk-tool a tus dependencias:

[dependencies]
adk-tool = "2.0.0"
schemars = "1"
serde = { version = "1", features = ["derive"] }

Luego define una herramienta — el comentario de documentación se convierte en la descripción, la estructura de argumentos se convierte en el esquema JSON:

use adk_tool::{tool, AdkError};
use schemars::JsonSchema;
use serde::Deserialize;
use serde_json::{json, Value};

#[derive(Deserialize, JsonSchema)]
struct WeatherArgs {
    /// The city to look up
    city: String,
}

/// Get the current weather for a city.
#[tool]
async fn get_weather(args: WeatherArgs) -> std::result::Result<Value, AdkError> {
    Ok(json!({ "temp": 22, "city": args.city, "condition": "sunny" }))
}

La macro genera una estructura GetWeather que implementa Tool. Añádela a tu agente:

let agent = LlmAgentBuilder::new("weather_agent")
    .instruction("Use the get_weather tool for weather questions.")
    .model(Arc::new(model))
    .tool(Arc::new(GetWeather))  // Generated by #[tool]
    .build()?;

Consejo: O genera la estructura de un proyecto con herramientas ya configuradas: cargo adk new my-agent --template tools

Herramientas integradas

ADK también incluye herramientas listas para usar:

// Google Search (handled server-side by Gemini)
.tool(Arc::new(GoogleSearchTool::new()))

// Exit a LoopAgent
.tool(Arc::new(ExitLoopTool::new()))

---

Ejecutándose como servidor web

Genera la estructura de un proyecto de servidor cuando quieras servir HTTP:

cargo adk new my-api --template api
cd my-api
cargo run

La plantilla básica predeterminada usa el iniciador de consola ligero para las instalaciones más rápidas.

---

Usando otros modelos

Habilita proveedores mediante marcas de características. La compilación predeterminada sigue siendo solo Gemini para instalaciones rápidas, así que añade solo el proveedor que necesites:

[dependencies]
adk-rust = { version = "2.0.0", features = ["openai"] }

O genera la estructura con un proveedor: cargo adk new my-agent --provider openai

OpenAI

let api_key = std::env::var("OPENAI_API_KEY")?;
let model = OpenAIClient::new(OpenAIConfig::new(api_key, "gpt-5-mini"))?;

Anthropic

let api_key = std::env::var("ANTHROPIC_API_KEY")?;
let model = AnthropicClient::new(AnthropicConfig::new(api_key, "claude-sonnet-4-6"))?;

DeepSeek

let api_key = std::env::var("DEEPSEEK_API_KEY")?;
let model = DeepSeekClient::chat(api_key)?;         // standard
// let model = DeepSeekClient::reasoner(api_key)?;   // chain-of-thought

Groq

let api_key = std::env::var("GROQ_API_KEY")?;
let model = GroqClient::new(GroqConfig::llama70b(api_key))?;

Ollama (Local)

// Requires: ollama serve && ollama pull llama3.2
let model = OllamaModel::new(OllamaConfig::new("llama3.2"))?;

Modelos compatibles

---

Siguientes pasos

• LlmAgent Configuración — todas las opciones de configuración
• Herramientas de función — crea herramientas personalizadas con #[tool]
• Agentes de flujo de trabajo — secuencias, paralelos, canalizaciones en bucle
• Sesiones — gestiona el estado de la conversación
• Devoluciones de llamada — personaliza el comportamiento del agente

---

Anterior: Introducción | Siguiente: LlmAgent