ADK Studio

Entorno de desarrollo visual para crear agentes de IA mediante arrastrar y soltar.

Descripción general

ADK Studio proporciona una interfaz de bajo código para diseñar, probar e implementar agentes de IA creados con ADK-Rust. Cree visualmente flujos de trabajo complejos con múltiples agentes y, después, compílelos en código Rust listo para 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

Sigue este recorrido para crear tu primer agente de IA en ADK Studio.

Paso 1: Crear un proyecto nuevo

Haz clic en el botón + Nuevo proyecto en la esquina superior derecha.

Introduce un nombre para tu proyecto (por ejemplo, «Proyecto de demostración») y haz clic en Crear.

Paso 2: Añadir un agente al lienzo

La barra lateral izquierda contiene la Paleta de agentes, con los tipos de agentes disponibles:

• Agente LLM: agente de IA individual basado en un modelo de lenguaje
• Secuencial: ejecuta los subagentes en orden
• Paralelo: ejecuta los subagentes simultáneamente
• Bucle: itera hasta que se cumpla la condición de salida
• Enrutador: dirige la ejecución a subagentes según la entrada

Debajo de la paleta de agentes, la Paleta de nodos de acciones proporciona 14 nodos programáticos que no son LLM para operaciones deterministas (solicitudes HTTP, consultas a bases de datos, ramificaciones, bucles, etc.). Consulta la Guía de nodos de acciones para obtener más información.

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

Paso 3: Configurar el agente

Al seleccionar un agente, aparece el Panel de propiedades en el lado derecho. Aquí puedes configurar:

• Nombre: identificador del agente
• Modelo: proveedor y modelo de LLM (Gemini, OpenAI, etc.)
• Instrucciones: indicación del sistema para el agente

Paso 4: Añadir herramientas al agente

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

• Función: función personalizada de Rust con editor de código
• MCP: servidor de Model Context Protocol
• Navegador: 46 acciones de automatización de WebDriver
• Búsqueda de Google: búsqueda web fundamentada
• Cargar artefacto: carga archivos en el contexto

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

Paso 5: Compilar y probar

Haz clic en Compilar proyecto para compilar tu agente. Una vez compilado, usa el Panel de chat en la parte inferior para probar tu agente con conversaciones reales.

El chat admite:

• Respuestas de transmisión en directo de SSE
• Animaciones de ejecución del agente
• Panel de seguimiento de eventos para la depuración

Paso 6: Ver el código generado

Haz clic en Ver código 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.

---

Funcionalidades

Tipos de agentes

Nodos de acción

14 nodos programáticos que no son LLM para operaciones de flujo de trabajo deterministas. Consulta la Guía de nodos de acción para obtener todos los detalles.

Activadores

Los flujos de trabajo comienzan con un nodo Activador. Consulta la Guía de activadores para obtener todos los detalles.

Tipos de herramientas

Chat en tiempo real

Prueba los agentes directamente en el estudio:

• Respuestas de transmisión en directo de SSE
• Animaciones de ejecución del agente
• Panel de trazas de eventos para la depuración
• Persistencia de la memoria de la sesión

Generación de código

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

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

El botón Construir aparece automáticamente cuando el 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 en código Rust listo para 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 admiten la interpolación de {{variable}} y reciben automáticamente las salidas de los nodos predecesores.

Bases de datos compatibles

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

API Puntos de conexión

Proyectos

Generación de código

Chat

Activadores

Variables de entorno

Nota: Solo necesitas la clave API para los proveedores que utilicen tus agentes. ADK Studio detecta automáticamente el proveedor a partir del nombre del modelo y genera el código correcto.

Estructura del código generado

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

El código generado se adapta a los proveedores utilizados en tu proyecto. ADK Studio detecta el proveedor a partir del nombre del modelo de cada agente y genera las importaciones correctas, la resolución de la clave API y los constructores del modelo.

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-3.7-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.6-terra"))?);

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 los indicadores de características adk-model correctos:

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

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

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

Código generado con nodos de acción

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

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 detectadas automáticamente se añaden al Cargo.toml generado (reqwest, sqlx, mongodb, redis, lettre, imap, boa_engine).

Plantillas

Studio incluye plantillas prediseñadas:

• Asistente básico - Agente LLM simple
• Agente de investigación - Agente con Google Search
• Enrutador de soporte - Enrutamiento multiagente
• Asistente de código - Agente con herramientas de código

Colaboración en equipo: proyectos locales del repositorio

De forma predeterminada, 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 el uso individual, pero los equipos que quieran controlar las versiones y compartir los proyectos de Studio junto con su código fuente pueden utilizar en su lugar un directorio de proyectos local del repositorio.

Convención recomendada

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

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

Inicia Studio usando el directorio local del repositorio:

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

Recomendaciones para .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 los equipos, ya que permite compartir diseños de agentes mientras se mantienen los resultados compilados fuera del control de versiones.

Consejos

• Cada miembro del equipo inicia Studio con la misma marca --dir para trabajar en proyectos compartidos.
• Los archivos JSON del proyecto son la fuente de 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 la ruta predeterminada del sistema.

Prácticas recomendadas

---

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