Daggr: цепляй AI-приложения кодом, а отлаживай глазами — стартуем

Еще один инструмент для AI-пайплайнов? Серьезно?

Рынок инструментов для оркестрации LLM напоминает барахолку: LangChain пытается быть швейцарским ножом, но тонет в абстракциях. LangGraph рисует графы, но отлаживать их — тот еще квест. А потом появляется Daggr — и предлагает нечто настолько простое, что поначалу не веришь: пиши код на Python, декорируй функции, а библиотека сама строит визуальный граф с промежуточными результатами. Никакого YAML, никаких конфигов, только код.

В этой статье я покажу, как за 10 минут собрать работающий AI-пайплайн с Daggr, отладить его в браузере и понять, почему этот подход меняет правила игры. Если вы устали от «черных ящиков», которые плюются результатами без объяснений — добро пожаловать.

Что за зверь и почему он не похож на LangChain

Daggr — это Python-библиотека с открытым исходным кодом для построения directed acyclic graph (DAG) из AI-компонентов. Её фишка: вы описываете пайплайн как набор обычных функций с декораторами @node, а библиотека автоматически строит интерактивный граф, который можно посмотреть в браузере.

В отличие от LangChain, который предлагает свой язык цепочек и кучу легаси, Daggr не заставляет вас учить новую парадигму. Вы просто пишете функции, как привыкли. Ещё одно важное отличие — визуализация. LangGraph умеет рисовать графы, но для отладки каждого узла вам придётся писать дополнительный код. Daggr делает это за вас: после запуска пайплайна холст показывает не только структуру, но и значения на каждом ребре.

Ставим и запускаем за три минуты

Установка — банальный pip install daggr. Никаких дополнительных зависимостей (ну, кроме FastAPI для сервера визуализации). Дальше всё сводится к написанию функций.

Давайте соберём пайплайн: загрузка текста, суммаризация через LLM, извлечение ключевых слов, генерация заголовка. Классический RAG-подобный поток, но без векторной базы — для простоты.

from daggr import Dag, node

@node
def fetch_text(url: str) -> str:
    # эмуляция загрузки
    return "OpenAI выпустила новую модель GPT-5, которая превосходит предыдущие версии на 20%."

@node
def summarize(text: str) -> str:
    # тут будет вызов LLM
    return "OpenAI выпустила GPT-5 с улучшенными характеристиками."

@node
def extract_keywords(text: str) -> list[str]:
    return ["OpenAI", "GPT-5", "новая модель"]

@node
def generate_title(summary: str) -> str:
    return "GPT-5 от OpenAI: что нового?"

# Собираем граф
dag = Dag()
dag.add_node(fetch_text)
dag.add_node(summarize, inputs=[fetch_text])
dag.add_node(extract_keywords, inputs=[fetch_text])
dag.add_node(generate_title, inputs=[summarize])

# Один вызов — и поехали
dag.run(url="https://example.com/news")
print(dag.get_result(generate_title))

После запуска в терминале появится ссылка на локальный сервер (по умолчанию http://localhost:8787). Открываете — и видите граф. Узлы, которые завершились, подсвечены зелёным. Можно кликнуть на любой узел и посмотреть, что пришло на вход и что ушло на выход. Если узел упал с ошибкой — он станет красным, а ошибка будет показана прямо на холсте.

Отладка, которая не бесит

Самая большая боль при работе с AI-пайплайнами — понять, где именно сломалось. Промпт написан криво? Модель вернула None? Токены кончились? С Daggr вы видите всё пошагово.

Предположим, в узле summarize вы передали неправильный промпт и получили пустую строку. Открываете визуализатор, кликаете на узел — и видите, что на вход пришёл корректный текст, а на выходе — пусто. Значит, проблема в вызове LLM. Вы правите код, перезапускаете только этот узел (да, это можно сделать прямо из UI) и проверяете результат. Никакого перезапуска всего пайплайна.

Сравнение с альтернативами: кто кого?

Давайте честно: выбирать инструмент для AI-пайплайнов сегодня — как выбирать между болью и страданием. Но у Daggr есть пара козырей.

Cogitator, кстати, тоже избавляет от лишних зависимостей, но он про TypeScript и не даёт визуализации. Если вы пишете на Python и хотите видеть граф — Daggr выигрывает.

А что насчёт Dora CLI? Это совсем другая история — агент для навигации по коду. Сравнивать их некорректно, но они решают смежные задачи: Daggr — для пайплайнов, Dora — для работы с кодом.

Как НЕ надо использовать Daggr (и почему)

Первая ошибка новичков — пытаться запихнуть в один узел логику, которая должна быть разбита. Например, один узел делает и суммаризацию, и извлечение ключевых слов. Это убивает всю идею: вы не сможете отладить шаги по отдельности. Дробите узлы до атомарных операций.

Вторая ошибка — забывать про типы. Daggr ожидает, что выход одного узла будет корректным входом для следующего. Если вы передаёте словарь, а следующий узел ждёт строку — граф упадёт. Используйте аннотации типов: @node поддерживает их проверку (но не строгую — Python же).

Третья ошибка — не использовать кэширование. По умолчанию Daggr не кэширует результаты, но это можно включить через параметр cache=True в узле. Особенно полезно, если один узел дорогой (например, вызов GPT-5).

@node(cache=True)
def expensive_llm_call(text: str) -> str:
    # вызов модели
    pass

Кому Daggr реально нужен?

Если вы пишете прототип AI-фичи и хотите быстро проверить гипотезу, не тратя время на настройку инфраструктуры — Daggr ваш выбор. Если у вас продовый пайплайн, где каждый шаг критичен, и вам нужно логировать и отлаживать сбои — тоже.

Но если у вас уже есть зрелая система на Airflow или Prefect, мигрировать на Daggr ради визуализации не стоит. Это инструмент для разработки, не для оркестрации в production.

Из интересных применений: генерация контента с несколькими LLM (один пишет черновик, второй ревьюит, третий чистит), RAG-цепочки с извлечением и ранжированием, multi-step агенты с вызовом инструментов. Daggr позволяет прозрачно цеплять любой Python-код, хоть вызов FastAPI, хоть запрос к базе.

Кстати, тема production-ready агентов с ReAct и RAG хорошо раскрыта в этой статье — там показано, как вручную строить графы, которые Daggr мог бы автоматизировать.

Визуализация — не игрушка, а инструмент анализа данных

Когда вы впервые открываете холст Daggr, кажется, что это просто красивая картинка. Но копните глубже: вы видите не только узлы, но и фактические данные, которые через них проходят. Это мощнейший инструмент для понимания data flow.

Допустим, у вас есть узел, который фильтрует спам. Вы запускаете пайплайн на 1000 документах, и видите, что через фильтр проходит 90% — возможно, порог слишком низкий. Вы меняете параметр, перезапускаете только этот узел (кнопка в UI) и сразу видите новый результат. Без перезапуска всего пайплайна, без переписывания тестов.

Это экономит часы, которые раньше уходили на то, чтобы вставлять print() в каждый шаг и перезапускать всё заново. Да, можно использовать дебаггер, но в AI-пайплайнах с LLM-запросами дебаггер не всегда удобен (асинхронность, время ожидания).

Ещё одна фишка — возможность экспортировать граф как статическую картинку (PNG/SVG) для документации. Можно даже встроить в Notion или GitHub wiki — команда проекта добавила соответствующую кнопку.

Реальный пример: модерация контента с Fallback-узлами

Представьте: вам нужно модерировать комментарии. Сначала быстрый ML-классификатор (spam/not spam), если он не уверен (score < 0.8), запрос передаётся LLM для верификации. Если LLM тоже не отвечает (скажем, таймаут), срабатывает fallback — ручное модераторское API.

Daggr поддерживает такую логику через резервные узлы (fallback):

@node(fallback=manual_moderation)
def llm_verification(text: str) -> str:
    # запрос к LLM
    pass

Если llm_verification падает с ошибкой или возвращает None, автоматически запускается manual_moderation. В визуализаторе это видно: падающий узел становится красным, а fallback — зелёным.

Такая композиция делает пайплайны устойчивыми к сбоям, а визуализация помогает быстро локализовать проблему. В производстве это критично: цена ошибки высока, и инструмент вроде SAST и Quality Gate не помешает.

Вместо тысячи слов: когда попробовать самому

Daggr — не панацея. Он не масштабируется горизонтально (по крайней мере, пока), не умеет шардить состояние между нодами (пока), и его визуализатор — это отдельный сервер, который нужно поднимать. Но для разработки, прототипирования и отладки это лучший инструмент на рынке Python на начало мая 2026.

Мой прогноз: через полгода Daggr либо станет стандартом для быстрых AI-прототипов, либо его идеи втянут в себя LangChain/LangGraph. В любом случае, сейчас — идеальный момент, чтобы попробовать. Установите, напишите пару узлов, кликните на граф — и вы поймёте, почему подход «код + визуализация» работает.

Подписаться на канал