Nodos de Acción

Nodos programáticos que no son LLM para operaciones de flujo de trabajo deterministas. Los nodos de acción complementan a los agentes LLM al manejar la transformación de datos, las integraciones de API, el flujo de control y la lógica de automatización.

Visión general

Los nodos de acción son visualmente distintos de los nodos de agente LLM: utilizan colores e iconos únicos para facilitar el escaneo de los flujos de trabajo. Cada tipo de nodo maneja una categoría específica de operación, desde solicitudes HTTP hasta consultas de bases de datos y ramificación condicional.

Todos los nodos de acción comparten un conjunto de propiedades estándar para el manejo de errores, el rastreo, el control de ejecución y el mapeo de E/S. Soportan la interpolación {{variable}} en campos de cadena y reciben automáticamente las salidas de los nodos predecesores.

Nodos disponibles

Propiedades Estándar

Cada nodo de acción hereda estas propiedades compartidas:

Identidad

Manejo de Errores

Trazado

Control de Ejecución

Mapeo de Entrada/Salida

---

Referencia de Nodos

Nodo Disparador 🎯

Punto de entrada del flujo de trabajo. Cada flujo de trabajo comienza con un nodo Trigger. Consulta la Guía de Triggers dedicada para obtener todos los detalles.

Nodo HTTP 🌐

Realiza solicitudes HTTP a APIs externas con manejo completo de autenticación, encabezados, cuerpo y respuesta.

Configuración:

Ejemplo:

{
  "type": "http",
  "name": "Fetch User Data",
  "method": "GET",
  "url": "https://api.example.com/users/{{userId}}",
  "auth": {
    "type": "bearer",
    "bearer": { "token": "{{API_TOKEN}}" }
  },
  "headers": { "Accept": "application/json" },
  "body": { "type": "none" },
  "response": { "type": "json", "jsonPath": "$.data" },
  "errorHandling": { "mode": "retry", "retryCount": 3, "retryDelay": 1000 },
  "mapping": { "outputKey": "userData" }
}

Establecer Nodo 📝

Define y manipula variables de estado del flujo de trabajo. Admite valores literales, expresiones y secretos.

Configuración:

Tipos de variable: string, number, boolean, json, expression

Las variables marcadas isSecret: true se enmascaran en los registros y la interfaz de usuario.

Nodo de Transformación ⚙️

Transforma datos usando expresiones u operaciones incorporadas.

Tipos de transformación:

Operaciones integradas: pick, omit, rename, flatten, sort, unique

Objetivos de coerción de tipo: string, number, boolean, array, object

Nodo Switch 🔀

Ramificación condicional con múltiples puertos de salida. Cada condición se asigna a un puerto de salida independiente en el nodo.

Configuración:

Operadores de condición: eq, neq, gt, lt, gte, lte, contains, startsWith, endsWith, matches, in, empty, exists

Ejemplo:

{
  "type": "switch",
  "evaluationMode": "first_match",
  "conditions": [
    { "id": "ok", "name": "Success", "field": "status", "operator": "eq", "value": "success", "outputPort": "success" },
    { "id": "err", "name": "Error", "field": "status", "operator": "eq", "value": "error", "outputPort": "error" }
  ],
  "defaultBranch": "unknown"
}

Nodo de Bucle 🔄

Itera sobre arrays, repite un número fijo de veces o itera mientras se cumple una condición.

Tipos de bucle:

Ejecución paralela: Habilitar parallel.enabled con batchSize y delayBetween opcionales para iteración concurrente.

Agregación de resultados: Cuando results.collect es true, los resultados de la iteración se recopilan en un array bajo results.aggregationKey.

Nodo de Fusión 🔗

Combina múltiples ramas paralelas de nuevo en un solo flujo. Tiene múltiples puertos de entrada.

Modos de fusión:

Estrategias de combinación: array, object, first, last

Tiempo de espera opcional con comportamiento continue o error.

Nodo de Espera ⏱️

Pausa la ejecución del flujo de trabajo.

Tipos de espera:

Nodo de Código 💻

Ejecuta JavaScript personalizado en un tiempo de ejecución aislado boa_engine. El estado del grafo se inyecta como el objeto global input.

Configuración:

Valores predeterminados del sandbox:

Nodo de Base de Datos 🗄️

Realiza operaciones de base de datos con pool de conexiones y consultas parametrizadas.

Bases de datos compatibles:

Las cadenas de conexión se tratan como secretos y se enmascaran en los registros.

Nodo de Correo Electrónico 📧

Enviar correos electrónicos vía SMTP o monitorear correos entrantes vía IMAP.

Modo de envío (SMTP):

• Soporte TLS/SSL
• Autenticación
• Destinatarios Para/CC/BCC
• Cuerpo en HTML o texto plano
• Interpolación {{variable}} en el asunto y el cuerpo
• Adjuntos de archivos desde el estado

Modo de monitoreo (IMAP):

• Selección de carpeta (por defecto: INBOX)
• Filtros: remitente, asunto, rango de fechas, solo no leídos
• Marcar como leído después de procesar

Nodo de Notificación 🔔

Envía notificaciones a plataformas de mensajería.

Canales: Slack, Discord, Microsoft Teams, webhook personalizado

Formatos de mensaje: texto plano, markdown, bloques específicos de la plataforma (Block Kit, Embeds, Adaptive Cards)

Nodo RSS 📡

Monitorea feeds RSS/Atom en busca de nuevas entradas.

• Intervalo de sondeo configurable
• Filtros por palabra clave, autor, categoría y fecha
• Seguimiento de elementos vistos para evitar duplicados
• Contenido completo opcional o solo resumen

Nodo de Archivo 📁

Operaciones de archivo en almacenamiento local o en la nube.

Operaciones: read, write, delete, list

Proveedores de nube: Amazon S3, Google Cloud Storage, Azure Blob Storage

Formatos de archivo: JSON, CSV, XML, texto, binario (con opciones de análisis de CSV para delimitador, encabezados, comillas)

---

Interpolación de Variables

Todos los campos de cadena en nodos de acción soportan la sintaxis {{variable}} para valores dinámicos:

https://api.example.com/users/{{userId}}
Bearer {{API_TOKEN}}
Hello {{user.name}}, your order {{orderId}} is ready.

Las variables se resuelven a partir del estado del flujo de trabajo en tiempo de ejecución. La notación de punto (user.name) accede a valores anidados.

Nodos Multi-Puerto

Dos tipos de nodos tienen recuentos de puertos dinámicos:

• Switch — un puerto de salida por condición, más un puerto predeterminado opcional
• Merge — múltiples puertos de entrada, uno por cada rama entrante

Estos puertos están representados visualmente en el nodo y se conectan a diferentes nodos de bajada/subida.

---

Generación de Código

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

Todo el código generado utiliza adk-graph FunctionNode closures con GraphError::NodeExecutionFailed para el manejo de errores.

Código generado de ejemplo (nodo HTTP):

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))
});

Código generado de ejemplo (nodo Code):

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))
});

---

Anterior: ← Studio | Siguiente: Triggers →