Daggr: encadena apps Gradio y depura flujos de IA

Daggr nace para resolver un dolor real: ¿has tenido que reejecutar todo un pipeline de 10 pasos solo para ver qué falló en el paso 7? Con Daggr defines flujos en Python y obtienes una interfaz visual automática donde inspeccionas salidas intermedias, reejecutas pasos aislados y gestionas estado, todo con pocas líneas de código.

Qué es Daggr y por qué importa

Daggr es una biblioteca open source en Python (requiere Python 3.10+) creada por el equipo de Gradio para construir workflows de IA que conectan Gradio Spaces, modelos de inference y funciones personalizadas.

La clave: enfoque code-first que genera una canvas visual. No es el típico editor de nodos donde arrastras y sueltas sin control de versión. Aquí trabajas en código (git friendly) y la interfaz visual es una herramienta de inspección y debugging.

¿Por qué esto cambia la forma de experimentar? Porque te permite iterar rápido sin construir una infraestructura pesada: debugueas un paso, reemplazas un modelo por un respaldo, o relanzas solo la pieza que importa.

Conceptos técnicos esenciales

• Graph: representa tu flujo, contiene nodos y metadatos.
• Nodos: tres tipos principales: GradioNode, FnNode, InferenceNode.
• Estado: Daggr persiste inputs, resultados cacheados y la posición del canvas. Puedes tener múltiples sheets para distintos workspaces.
• Ejecución local vs remota: GradioNode puede clonar y ejecutar una Space localmente con run_locally=True. Si falla, Daggr cae graciosamente al endpoint remoto.

Nodos en detalle (con ejemplos)

1. GradioNode

Llama a una Space (pública o privada). Si pones run_locally=True, Daggr clona la Space, crea un entorno aislado y la lanza localmente.

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

2. FnNode

Ejecuta funciones Python locales. Útil para preprocesos, reducción de tamaño, postprocesos.

from daggr import FnNode

def process(text: str) -> str:
    return text.upper()

node = FnNode(fn=process, inputs={'text': gr.Textbox(label='Input')}, outputs={'result': gr.Textbox(label='Output')})

3. InferenceNode

Llama modelos mediante los Inference Providers de Hugging Face. Ideal para usar modelos hospedados sin integrar su lógica en tu app.

from daggr import InferenceNode

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

Ejemplo rápido: genera una imagen y quita el fondo

Instalación:

pip install daggr
# o con uv
uv pip install daggr

Ejemplo mínimo que conecta dos Spaces (generación y remoción de fondo):

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()

Al ejecutar obtienes una canvas en http://localhost:7860 y un link público si activas share=True. En la interfaz puedes inspeccionar la salida de cada nodo, modificar inputs y reejecutar nodos individuales.

Pipeline avanzado: de imagen a activo 3D (resumen técnico)

Daggr facilita encadenar pasos más complejos: clonar localmente una Space que remueve fondo, downscaling con FnNode, mejora con un modelo via InferenceNode y finalmente generar un glb con otra Space.

Puntos técnicos que cuidamos en el ejemplo completo:

• Guardar archivos temporales con daggr.state.get_daggr_files_dir() para que los nodos compartan paths.
• Usar run_locally=True para clonar Spaces y controlar si tiran modelos a CUDA o CPU. Si no tienes NVIDIA, clona y modifica la Space para forzar CPU.
• Para InferenceNode en deployes a Spaces, usa un token de Hugging Face con el permiso "Make calls to Inference Providers".

Buenas prácticas y límites actuales

• Daggr está en beta y su API puede cambiar entre versiones. Ten presente que la persistencia local puede sufrir pérdida de datos durante actualizaciones.
• Para producción: Daggr es excelente para prototipos y demos. Para pipelines de misión crítica, aún conviene orquestadores más robustos.
• Si clonas Spaces localmente y vas a CPU, revisa el archivo de la Space para evitar que el modelo haga .to('cuda') automáticamente.
• Comparte workflows en Gradio para demostraciones y para obtener retroalimentación. El equipo de Gradio destaca algunos trabajos.

Reflexión práctica

Si eres developer, investigador o emprendedor probando ideas con múltiples modelos, Daggr te ahorra horas de debugging repetitivo. El valor real está en poder inspeccionar cada etapa sin perder trazabilidad en tu código. ¿No es esto justo lo que hace falta cuando iteras rápido sobre demos y PoCs?

Fuente original

https://huggingface.co/blog/daggr