Собираем AI-агентов на Go как из кубиков с фреймворком Blades

Знакомая ситуация? Вы — Go-разработчик, и вам нужно встроить в свой сервис логику на базе LLM. Вы смотрите по сторонам и видите, что большинство инструментов, фреймворков и примеров написаны на Python. Начинаются поиски компромиссов: поднять отдельный сервис на Python, возиться с хрупкими обертками или использовать библиотеки, которые кажутся чужеродными в Go-экосистеме.

А что, если бы существовал фреймворк для создания AI-агентов, написанный на чистом, идиоматичном Go? Чтобы все было привычно, как в стандартной библиотеке, и гибко, как в лучших представителях мира микросервисов. Сегодня я хочу рассказать как раз о таком проекте — Blades от команды go-kratos. И, кстати, название у него не случайное. Оно отсылает к Клинкам Хаоса (Blades of Chaos) — культовому оружию Кратоса из игры God of War. И, надо сказать, этот инструмент действительно позволяет "кромсать" сложные AI-задачи с завидной легкостью.

Что такое Blades и зачем он нужен?

Если коротко, Blades — это фреймворк для создания мультимодальных AI-агентов на языке Go. Представьте себе конструктор LEGO, из кубиков которого вы можете собрать умного помощника. Хотите чат-бота, который помнит контекст разговора? Пожалуйста. Нужен агент, который умеет ходить по API, получать данные из базы и на основе этого генерировать отчет? Легко.

Главная философия Blades — быть максимально "Go Idiomatic". Это значит, что если вы пишете на Go, вам не придется переучиваться. Код выглядит чисто, привычно и использует все те подходы, которые мы любим в Go: четкие интерфейсы, простая композиция, минимум магии.

Проект идеально подойдет тем, кто:

• Разрабатывает микросервисы на Go и хочет добавить в них AI-функциональность.
• Устал от тяжеловесных Python-фреймворков и хочет что-то легковесное и быстрое.
• Ценит контроль и прозрачность, а не "черные ящики".

Архитектура как на ладони

Чтобы понять, как это работает, достаточно взглянуть на общую архитектуру. Она проста и элегантна.

В центре всего находится Agent — ядро, которое выполняет задачи. А вокруг него — набор сменных модулей:

• ModelProvider: "мозг" агента, отвечающий за связь с LLM (OpenAI, Gemini и т.д.).
• Tool: "руки" агента, позволяющие ему взаимодействовать с внешним миром (вызывать API, работать с файлами, ходить в базу данных).
• Memory: "память" агента, где хранится контекст диалога.
• Middleware: "суперспособности", которые можно "навесить" на агента, например, логирование, метрики или контроль доступа.

Такой подход дает потрясающую гибкость. Не нравится, как работает один компонент? Просто замените его другим, который реализует тот же интерфейс.

Ключевые компоненты конструктора

Давайте разберем основные "кубики", из которых собирается любой агент в Blades.

ModelProvider — мост к большим языковым моделям

Это, пожалуй, самый важный компонент. ModelProvider — это абстракция, которая скрывает за собой детали общения с конкретной LLM. Сегодня вы используете GPT-4, а завтра захотели переключиться на новую модель от Google или локально поднятую Llama. С Blades это не проблема. Вы просто меняете реализацию провайдера, а остальной код приложения даже не заметит подмены.

Интерфейс ModelProvider поддерживает как обычные запросы, так и стриминг, что идеально подходит для создания интерактивных чатов с эффектом "пишущей машинки".

Agent и Flow — исполнитель и конвейер

Agent — это базовый исполнитель, который может выполнить одну конкретную задачу: ответить на вопрос, извлечь данные, вызвать инструмент. Но настоящая магия начинается, когда мы объединяем несколько агентов в цепочку с помощью Flow.

Представьте себе сборочный конвейер:

1. Первый агент получает запрос от пользователя и определяет его намерение.
2. Он передает результат второму агенту, который идет в базу данных за нужной информацией (используя Tool).
3. Третий агент получает эти данные и на их основе генерирует человекочитаемый ответ.

Flow позволяет выстраивать такие сложные рабочие процессы, где выход одного агента становится входом для другого. Это ключ к реализации "цепочек рассуждений" (Chain-of-thought) и сложных многошаговых задач.

Tool — даем агенту доступ в реальный мир

Сама по себе языковая модель заперта в своем мире знаний. Чтобы сделать ее по-настоящему полезной, ей нужно дать возможность взаимодействовать с внешними системами. Для этого в Blades есть Tool.

Инструментом может быть что угодно:

• Функция для вызова REST API.
• Запрос в базу данных.
• Чтение или запись файла.
• Калькулятор.

Вы просто описываете, что инструмент делает и какие параметры принимает, а LLM сама решает, когда и с какими данными его вызвать. Это открывает практически безграничные возможности для автоматизации.

Middleware — добавляем сквозную логику

Если вы работали с веб-фреймворками вроде Gin, Echo или самого Kratos, то концепция Middleware вам хорошо знакома. Это функции, которые "оборачивают" основной обработчик, добавляя сквозную логику.

В Blades этот подход используется для агентов. Хотите логировать все запросы и ответы? Оберните агента в LoggingMiddleware. Нужно добавить аутентификацию или ограничить частоту запросов? Создайте соответствующий middleware. Это позволяет держать код основной бизнес-логики чистым, не смешивая его со вспомогательными задачами.

Практический пример: создаем чат-бота за 5 минут

Теория — это хорошо, но давайте посмотрим на код. Вот насколько просто создать базового чат-агента с использованием модели OpenAI.

package main

import (
    "context"
    "log"
    "os"

    "github.com/go-kratos/blades"
    "github.com/go-kratos/blades/contrib/openai"
)

func main() {
    // 1. Настраиваем подключение к модели OpenAI.
    // Ключ API берется из переменной окружения OPENAI_API_KEY.
    model := openai.NewModel("gpt-4", openai.Config{
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })

    // 2. Создаем самого агента.
    // Даем ему имя и системную инструкцию (промпт), которая определяет его поведение.
    agent := blades.NewAgent(
        "Blades Agent",
        blades.WithModel(model),
        blades.WithInstruction("Ты — полезный ассистент, который предоставляет детальную и точную информацию."),
    )

    // 3. Формируем запрос от пользователя.
    input := blades.UserMessage("Какая столица Франции?")

    // 4. Запускаем агента.
    runner := blades.NewRunner(agent)
    output, err := runner.Run(context.Background(), input)
    if err != nil {
        log.Fatal(err)
    }

    // 5. Печатаем ответ.
    log.Println(output.Text())
}

Всего 20 строк кода, и у нас есть полноценный чат-бот! Код чистый, декларативный и легко читается. Больше примеров можно найти в репозитории проекта.

Выводы: кому стоит попробовать Blades?

Blades — это глоток свежего воздуха для Go-разработчиков в мире AI. Проект находится на ранней стадии, но уже сейчас предлагает мощный и, что важнее, идиоматичный инструментарий.

Я бы особенно рекомендовал присмотреться к Blades, если вы:

• Go-разработчик до мозга костей и хотите интегрировать LLM в свои проекты, не выходя из привычной экосистемы.
• Цените простоту и прозрачность. Архитектура Blades понятна, а код легко отлаживать.
• Создаете сложные системы, где AI — это не просто чат, а часть большого бизнес-процесса, требующего взаимодействия с другими сервисами.

Проект активно развивается, и сейчас — отличное время, чтобы его попробовать, а возможно, и поучаствовать в его развитии. Загляните в репозиторий, поставьте звездочку и соберите своего первого AI-агента. Уверен, вам понравится та мощь и гибкость, которую дают эти "клинки".