Lanza Daggr: una nueva biblioteca de Python para crear flujos de trabajo de IA visualmente

Daggr es una nueva biblioteca de código abierto en Python destinada a la construcción de flujos de trabajo de inteligencia artificial. Permite conectar aplicaciones de Gradio, modelos de aprendizaje automático y funciones personalizadas. Además, genera automáticamente un lienzo visual que permite inspeccionar salidas intermedias, volver a ejecutar pasos individuales y gestionar el estado de pipelines complejos con solo unas pocas líneas de código.

Tabla de Contenidos

1. Antecedentes
2. Introducción
3. Compartiendo tus Flujos de Trabajo
4. Ejemplo Completo con Diferentes Nodos
5. Próximos Pasos

Antecedentes

Desarrollar aplicaciones de inteligencia artificial que combinan múltiples modelos o pasos de procesamiento puede ser complicado. Los desarrolladores a menudo enfrentan problemas como la cadena de llamadas API, la depuración de pipelines y la pérdida de resultados intermedios. Cuando ocurre un error en un paso de un flujo de trabajo, es común tener que volver a ejecutar todo para entender el problema.

La mayoría de los desarrolladores terminan creando scripts frágiles difíciles de depurar o utilizando plataformas de orquestación pesadas diseñadas para pipelines de producción, lo que no es ideal para la experimentación rápida.

En este contexto, hemos desarrollado Daggr para abordar estos desafíos:

Visualiza tu flujo de código: A diferencia de los editores GUI basados en nodos, Daggr adopta un enfoque centrado en el código. Los flujos de trabajo se definen en Python, y se genera automáticamente un lienzo visual. Esto permite tener lo mejor de ambos mundos: código controlable por versiones y la inspección visual de salidas intermedias.

Inspecciona y vuelve a ejecutar cualquier paso: El lienzo visual no es solo estético. Permite inspeccionar la salida de cualquier nodo, modificar entradas y volver a ejecutar pasos individuales sin ejecutar todo el pipeline. Esta funcionalidad es crucial al depurar flujos de trabajo extensos.

Introducción

Instala Daggr con pip o uv; solo necesitas Python 3.10 o superior:

pip install daggr uv pip install daggr

A continuación, se presenta un ejemplo simple que genera una imagen y elimina su fondo. Consulta la referencia de la API de este Space para ver qué entradas acepta y qué salidas produce.

import random import gradio as gr from daggr import GradioNode, Graph image_gen = GradioNode("hf-applications/Z-Image-Turbo", api_name="/generate_image", inputs={ "prompt": gr.Textbox(label="Prompt", value="A cheetah sprints across the grassy savanna.", lines=3), "height": 1024, "width": 1024, "seed": random.random, }, outputs={ "image": gr.Image(label="Generated Image"), }, ) bg_remover = GradioNode("hf-applications/background-removal", api_name="/image", inputs={ "image": image_gen.image, }, outputs={ "original_image": None, "final_image": gr.Image(label="Final Image"), }, ) graph = Graph(name="Transparent Background Generator", nodes=[image_gen, bg_remover]) graph.launch()

Ejecuta este script y obtendrás un lienzo visual en el puerto 7860, además de un enlace compartible.

Tipos de Nodos

Daggr admite tres tipos de nodos:

GradioNode llama a un endpoint de API de Gradio o a una aplicación de Gradio local. Al pasar run_locally=True, Daggr clona automáticamente el Space, crea un entorno virtual aislado y lanza la aplicación.

node = GradioNode("username/space-name", api_name="/predict", inputs={"text": gr.Textbox(label="Input")}, outputs={"result": gr.Textbox(label="Output")}, )

FnNode ejecuta una función personalizada en Python:

def process(text: str) -> str: return text.upper() node = FnNode(fn=process, inputs={"text": gr.Textbox(label="Input")}, outputs={"result": gr.Textbox(label="Output")}, )

InferenceNode llama a un modelo a través de Hugging Face Inference Providers:

node = InferenceNode(model="moonshotai/Kimi-K2.5:novita", inputs={"prompt": gr.Textbox(label="Prompt")}, outputs={"response": gr.Textbox(label="Response")}, )

Compartiendo tus Flujos de Trabajo

Genera una URL pública con el túnel de Gradio:

graph.launch(share=True)

Para un alojamiento permanente, despliega en Hugging Face Spaces utilizando el SDK de Gradio, agregando daggr a tu archivo requirements.txt.

Ejemplo Completo con Diferentes Nodos

Desarrollaremos una aplicación que toma una imagen y genera un activo 3D. Este demo puede ejecutarse en daggr 0.4.3. Los pasos son los siguientes:

1. Tomar una imagen y eliminar el fondo: Clonaremos el Space BiRefNet y lo ejecutaremos localmente.
2. Reducir el tamaño de la imagen por eficiencia: Escribiremos una función simple para esto con FnNode.
3. Generar una imagen en estilo de activo 3D: Usaremos InferenceNode con el modelo Flux.2-klein-4B.
4. Pasar la imagen de salida a un generador 3D: Enviaremos la imagen de salida al Space Trellis.2.

Los Spaces que se ejecutan localmente pueden llevar modelos a CUDA (con to.("cuda")) o ZeroGPU dentro del archivo de aplicación. Para desactivar este comportamiento y ejecutar el modelo en CPU, duplica el Space que deseas usar y clónalo.

El gráfico resultante se muestra a continuación.

Comencemos con el primer paso, que es el removedor de fondo.

from daggr import FnNode, GradioNode, InferenceNode, Graph background_remover = GradioNode("merve/background-removal", api_name="/image", run_locally=True, inputs={"image": gr.Image(),}, outputs={"original_image": None, "final_image": gr.Image(label="Final Image"),}, )

Para el segundo paso, escribiremos una función auxiliar para reducir el tamaño de la imagen y pasarlo a FnNode.

from PIL import Image from daggr.state import get_daggr_files_dir def downscale_image_to_file(image: Any, scale: float = 0.25) -> str | None: pil_img = Image.open(image) scale_f = max(0.05, min(1.0, float(scale))) w, h = pil_img.size new_w = max(1, int(w * scale_f)) new_h = max(1, int(h * scale_f)) resized = pil_img.resize((new_w, new_h), resample=Image.LANCZOS) out_path = get_daggr_files_dir() / f"{uuid.uuid4()}.png" resized.save(out_path) return str(out_path)

Puedes inicializar el FnNode pasando la función.

downscaler = FnNode(downscale_image_to_file, name="Downscale image for Inference", inputs={"image": background_remover.final_image, "scale": gr.Slider(label="Downscale factor", minimum=0.25, maximum=0.75, step=0.05, value=0.25),}, outputs={"image": gr.Image(label="Downscaled Image", type="filepath"),}, )

A continuación, escribiremos el InferenceNode con el modelo Flux.

flux_enhancer = InferenceNode(model="black-forest-labs/FLUX.2-klein-4B:fal-ai", inputs={"image": downscaler.image, "prompt": gr.Textbox(label="prompt", value=("Transform this into a clean 3D asset render"), lines=3),}, outputs={"image": gr.Image(label="3D-Ready Enhanced Image"),}, )

Al desplegar aplicaciones con InferenceNode en Hugging Face Spaces, utiliza un token de acceso de Hugging Face de grano fino con la opción «Hacer llamadas a Inference Providers» únicamente.

El último nodo es la generación 3D consultando el Space Trellis.2 en Hugging Face.

trellis_3d = GradioNode("microsoft/TRELLIS.2", api_name="/image_to_3d", inputs={"image": flux_enhancer.image, "ss_guidance_strength": 7.5, "ss_sampling_steps": 12,}, outputs={"glb": gr.HTML(label="3D Asset (GLB preview)"),}, )

Encadenarlos y lanzar la aplicación es sencillo:

graph = Graph(name="Image to 3D Asset Pipeline", nodes=[background_remover, downscaler, flux_enhancer, trellis_3d], ) if __name__ == "__main__": graph.launch()

Puedes encontrar el ejemplo completo en este Space. Para ejecutar localmente, solo necesitas llevar app.py, instalar los requisitos y acceder a Hugging Face Hub.

Próximos Pasos

Daggr se encuentra en beta y es intencionalmente ligero. Las API pueden cambiar entre versiones, y aunque mantenemos el estado del flujo de trabajo localmente, puede haber pérdida de datos durante las actualizaciones. Si tienes solicitudes de funciones o encuentras errores, por favor abre un problema aquí. Agradecemos tu retroalimentación y te invitamos a compartir tus flujos de trabajo de Daggr en redes sociales con Gradio para tener la oportunidad de ser destacados. Consulta todos los trabajos destacados aquí.