ADK Studio

Entorno de desarrollo visual para construir agentes de IA con arrastrar y soltar.

Visión general

ADK Studio proporciona una interfaz de bajo código para diseñar, probar y desplegar agentes de IA construidos con ADK-Rust. Cree flujos de trabajo multi-agente complejos visualmente, luego compílelos a código Rust de producción.

Instalación

# Install from crates.io (self-contained binary)
cargo install adk-studio

# Or build from source
cargo build --release -p adk-studio

Inicio rápido

# Start the studio server
adk-studio

# Open in browser
open http://localhost:3000

Opciones de CLI

# Bind to all interfaces for remote access
adk-studio --host 0.0.0.0 --port 8080

# Custom projects directory
adk-studio --dir ./my-projects

---

Tutorial Paso a Paso

Siga este tutorial para construir su primer agente de IA en ADK Studio.

Paso 1: Crear un Nuevo Proyecto

Haga clic en el botón + New Project en la esquina superior derecha.

Introduzca un nombre para su proyecto (por ejemplo, "Demo Project") y haga clic en Create.

Paso 2: Añadir un Agent al Lienzo

La barra lateral izquierda contiene la Agent Palette con los tipos de agent disponibles:

• LLM Agent - Agente de IA único impulsado por un language model
• Sequential - Ejecuta sub-agents en orden
• Parallel - Ejecuta sub-agents concurrentemente
• Loop - Itera hasta la condición de salida
• Router - Dirige a sub-agents basándose en la entrada

Debajo de la paleta de agentes, la Paleta de Nodos de Acción proporciona 14 nodos programáticos que no son LLM para operaciones determinísticas (solicitudes HTTP, consultas a bases de datos, ramificación, bucles, etc.). Consulta la Guía de Nodos de Acción para más detalles.

Haz clic en LLM Agent para añadirlo al lienzo.

Paso 3: Configura el Agent

Cuando seleccionas un agent, el Panel de Propiedades aparece en el lado derecho. Aquí puedes configurar:

• Nombre - Identificador para el agent
• Modelo - Proveedor y model de LLM (Gemini, OpenAI, etc.)
• Instrucciones - System prompt para el agent

Paso 4: Añade Tools al Agent

Desplázate hacia abajo en la barra lateral izquierda para encontrar la Paleta de Herramientas:

• Function - Función Rust personalizada con editor de código
• MCP - Servidor de Model Context Protocol
• Browser - 46 acciones de automatización de WebDriver
• Google Search - Búsqueda web fundamentada
• Load Artifact - Cargar archivos en el contexto

Haz clic en una herramienta para añadirla a tu agent.

Paso 5: Construir y Probar

Haz clic en Build Project para compilar tu agent. Una vez construido, usa el Chat Panel en la parte inferior para probar tu agent con conversaciones reales.

El chat soporta:

• Respuestas de streaming SSE en vivo
• Animaciones de ejecución de Agent
• Panel de traza de eventos para depuración

Paso 6: Ver Código Generado

Haz clic en View Code para ver el código Rust listo para producción generado a partir de tu diseño visual.

Puedes copiar este código o usar Compilar para generar un proyecto Rust completo.

---

Características

Tipos de Agente

Nodos de Acción

14 nodos programáticos no-LLM para operaciones de flujo de trabajo deterministas. Consulte la Guía de Nodos de Acción para obtener todos los detalles.

Disparadores

Los flujos de trabajo comienzan con un nodo Trigger. Consulte la Guía de Disparadores para obtener todos los detalles.

Tipos de Herramientas

Chat en Tiempo Real

Prueba los agentes directamente en el estudio:

• Respuestas de streaming SSE en vivo
• Animaciones de ejecución de agentes
• Panel de seguimiento de eventos para depuración
• Persistencia de la memoria de la Session

Generación de Código

Convierte diseños visuales en código de producción:

1. Ver Código - Previsualiza el Rust generado con resaltado de sintaxis
2. Compilar - Genera un proyecto Rust completo
3. Construir - Compila a un ejecutable con salida en tiempo real
4. Ejecutar - Ejecuta el agente construido

El botón Construir aparece automáticamente cuando tu flujo de trabajo ha cambiado desde la última compilación.

Generación de Código de Nodos de Acción

Los nodos de acción se compilan a código Rust de producción junto con los agentes LLM. Las dependencias se detectan automáticamente y se añaden al Cargo.toml generado.

Todos los nodos de acción soportan interpolación {{variable}} y reciben automáticamente las salidas de los nodos predecesores.

Bases de Datos Soportadas

Arquitectura

┌─────────────────────────────────────────────────────────────┐
│                     ADK Studio UI                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Palette   │  │   Canvas    │  │   Properties        │ │
│  │  - Agents   │  │  ReactFlow  │  │  - Name             │ │
│  │  - Tools    │  │  Workflow   │  │  - Model            │ │
│  │             │  │  Designer   │  │  - Instructions     │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼ HTTP/SSE
┌─────────────────────────────────────────────────────────────┐
│                    ADK Studio Server                        │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Routes    │  │   Codegen   │  │   Storage           │ │
│  │  /api/*     │  │  Rust code  │  │  Projects           │ │
│  │  /chat      │  │  generation │  │  File-based         │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼ Build
┌─────────────────────────────────────────────────────────────┐
│                   Generated Rust Project                    │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  Cargo.toml + src/main.rs                           │   │
│  │  Uses: adk-rust, adk-agent, adk-model, etc.        │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

Endpoints de la API

Proyectos

Generación de Código

Chat

Disparadores

Variables de Entorno

Nota: Solo necesitas la clave API para el/los proveedor(es) que usan tus agents. ADK Studio auto-detecta el proveedor a partir del nombre del model y genera el código correcto.

Estructura del Código Generado

my-project/
├── Cargo.toml
└── src/
    └── main.rs

El código generado se adapta al/a los proveedor(es) utilizado(s) en tu proyecto. ADK Studio detecta el proveedor a partir del nombre del model de cada agent y genera las importaciones correctas, la resolución de la clave API y los constructores del model.

Ejemplo de main.rs generado (Gemini):

use adk_model::gemini::GeminiModel;
// ...

let gemini_api_key = std::env::var("GOOGLE_API_KEY")
    .or_else(|_| std::env::var("GEMINI_API_KEY"))
    .expect("GOOGLE_API_KEY or GEMINI_API_KEY must be set");

let model = Arc::new(GeminiModel::new(&gemini_api_key, "gemini-2.5-flash")?);

Ejemplo con OpenAI:

use adk_model::openai::{OpenAIClient, OpenAIConfig};
// ...

let openai_api_key = std::env::var("OPENAI_API_KEY")
    .expect("OPENAI_API_KEY must be set");

let model = Arc::new(OpenAIClient::new(OpenAIConfig::new(&openai_api_key, "gpt-5-mini"))?);

Ejemplo con Ollama (local, sin clave API):

use adk_model::ollama::{OllamaModel, OllamaConfig};
// ...

let model = Arc::new(OllamaModel::new(OllamaConfig::new("llama3.2"))?);

El Cargo.toml generado incluye automáticamente las adk-model feature flags correctas:

# Only Gemini
adk-model = { version = "2.0.0", default-features = false, features = ["gemini"] }

# Mixed providers (e.g., Gemini + Anthropic)
adk-model = { version = "2.0.0", default-features = false, features = ["gemini", "anthropic"] }

# Ollama only (no API key needed)
adk-model = { version = "2.0.0", default-features = false, features = ["ollama"] }

Código Generado con Nodos de Acción

Cuando tu workflow incluye nodos de acción, el código generado utiliza adk-graph para la orquestación del workflow con FunctionNode closures:

use adk_graph::prelude::*;

// HTTP action node → reqwest call
let http_node = FunctionNode::new("fetch_data", |ctx| async move {
    let client = reqwest::Client::new();
    let resp = client.get("https://api.example.com/data")
        .bearer_auth(&ctx.get("API_TOKEN").unwrap_or_default())
        .send().await
        .map_err(|e| GraphError::NodeExecutionFailed {
            node: "fetch_data".into(),
            message: e.to_string(),
        })?;
    let body: serde_json::Value = resp.json().await?;
    Ok(NodeOutput::new().with_update("apiData", body))
});

// Code action node → boa_engine JS execution
let code_node = FunctionNode::new("process", |ctx| async move {
    let mut js_ctx = boa_engine::Context::default();
    // Graph state injected as global `input` object
    // User code executed in thread-isolated sandbox
    Ok(NodeOutput::new().with_update("result", output))
});

Las dependencias auto-detectadas se añaden al generado Cargo.toml (reqwest, sqlx, mongodb, redis, lettre, imap, boa_engine).

Plantillas

Studio incluye plantillas predefinidas:

• Asistente Básico - Agente LLM simple
• Agente de Investigación - Agente con Google Search
• Enrutador de Soporte - Enrutamiento multi-agente
• Asistente de Código - Agente con herramientas de código

Colaboración en Equipo: Proyectos Locales del Repositorio

Por defecto, ADK Studio almacena los proyectos en un directorio local del usuario (~/.local/share/adk-studio/projects en Linux, ~/Library/Application Support/adk-studio/projects en macOS). Esto funciona bien para uso individual, pero los equipos que desean controlar versiones y compartir proyectos de Studio junto con su código fuente pueden usar un directorio de proyectos local del repositorio en su lugar.

Convención Recomendada

Almacene los proyectos en .adk-studio/projects en la raíz de su repositorio:

my-repo/
├── .adk-studio/
│   └── projects/       # Studio project JSON files
├── src/
├── Cargo.toml
└── .gitignore

Inicie Studio con el directorio local del repositorio:

adk-studio --dir ./.adk-studio/projects

Guía de .gitignore

Decide qué confirmar según tu flujo de trabajo:

# Option A: Version-control project definitions, ignore build artifacts
.adk-studio/projects/*/build/
.adk-studio/projects/*/target/

# Option B: Ignore all Studio data (treat as local-only)
.adk-studio/

La Opción A se recomienda para equipos — permite compartir diseños de Agent mientras se mantienen los resultados compilados fuera del control de versiones.

Consejos

• Cada miembro del equipo inicia Studio con la misma bandera --dir para trabajar en proyectos compartidos.
• Los archivos JSON del proyecto son la fuente de la verdad; el código Rust generado se puede regenerar a partir de ellos.
• La ruta predeterminada local del usuario no se ve afectada — omitir --dir sigue utilizando el valor predeterminado del sistema.

Mejores Prácticas

Anterior: ← Memoria | Siguiente: Nodos de Acción →