Команда Spring АйО перевела статью, в которой рассказывается про разработку эффективных агентов с помощью Spring AI. Исследование Anthropic "Building effective agents" подчеркивает важность простоты и модульности в разработке LLM-агентов.
В статье рассматривается, как эти принципы реализуются в Spring AI через пять ключевых паттернов: Chain Workflow, Parallelization Workflow, Routing Workflow, Orchestrator-Workers и Evaluator-Optimizer.
В недавней публикации своего исследования: Building effective agents, Anthropic поделился ценными взглядами на разработку эффективных LLM агентов (Large Language Model - большая языковая модель). Что делает это исследование особенно интересным, так это то, что оно акцентирует простоту и пригодность к компоновке, ставя их в приоритет по отношению к комплексным фреймворкам. Давайте посмотрим на то, как эти принципы транслируются в практические реализации с использованием Spring AI.
В то время как описания паттернов и диаграмм взяты нами из оригинальной публикации от Anthropic, мы сосредоточимся на том, как реализовать эти паттерны с использованием возможностей Spring AI в части переносимости моделей и структурированного вывода. Мы рекомендуем сначала прочитать оригинальную публикацию.
Проект agentic-patterns реализует обсуждаемые ниже паттерны.
Агентные системы
Публикация исследования вводит важное архитектурное различие между двумя типами агентных систем:
Workflows: системы, в которых LLM и инструменты оркеструются через предварительно заданные пути в коде (например, директивная система)
Агенты (Agents): Системы, где LLM динамически направляют свои процессы и использование инструментов
Ключевой вывод состоит в том, что в то время как полностью автономные агенты могут казаться привлекательными, workflows часто предоставляют лучшую предсказуемость и стабильность для хорошо определенных задач. Это наилучшим образом сочетается с требованиями, предъявляемыми крупным бизнесом, где надежность и поддерживаемость являются решающими факторами.
Давайте посмотрим, как Spring AI реализует эти концепции через пять фундаментальных паттернов, каждый их которых помогает решению определенного набора кейсов:
Паттерн Chain Workflow является примером разбиения сложных задач на более простые, более управляемые, чтобы иметь возможность выполнять их по шагам.
Когда используется:
Задачи с четкими последовательными шагами
Когда вы готовы пожертвовать latency ради более высокой точности
Когда каждый шаг использует результаты предыдущего
Приведем практический пример из реализации Spring AI:
public class ChainWorkflow {
private final ChatClient chatClient;
private final String[] systemPrompts;
// Processes input through a series of prompts, where each step's output
// becomes input for the next step in the chain.
public String chain(String userInput) {
String response = userInput;
for (String prompt : systemPrompts) {
// Combine the system prompt with previous response
String input = String.format("{%s}\n {%s}", prompt, response);
// Process through the LLM and capture output
response = chatClient.prompt(input).call().content();
}
return response;
}
}Эта реализация демонстрирует несколько ключевых принципов:
Каждый шаг фокусируется на своей зоне ответственности
Вывод одного шага становится вводом другого
Цепочка легко расширяется и поддерживается
LLM могут одновременно работать над задачами и агрегировать их вывод программным путем. Параллелизация workflow проявляется в двух ключевых вариантах:
Разбиенте на секции: задачи разбиваются на несколько независимых подзадач для параллельной обработки
Голосование: несколько инстансов одной и той же задачи запускаются одновременно ради консенсуса
Когда используется:
Обработка больших количеств похожих, но независимых объектов
Задачи, требующие многочисленных независимых подходов
Когда время обработки имеет решающее значение, а задачи можно выполнять параллельно
Паттерн Parallelization Workflow демонстрирует эффективную многопоточную обработку многочисленных LLM операций. Этот паттерн особенно полезен для сценариев, требующих параллельного выполнения вызовов LLM с автоматизированной агрегацией вывода.
Приведем базовый пример использования паттерна Parallelization Workflow:
List<String> parallelResponse = new ParallelizationWorkflow(chatClient)
.parallel(
"Analyze how market changes will impact this stakeholder group.",
List.of(
"Customers: ...",
"Employees: ...",
"Investors: ...",
"Suppliers: ..."
),
4
);
Этот пример демонстрирует параллельную обработку анализа ситуации с держателями акций, при этом каждая группа держателей акций анализируется отдельно в многопоточном режиме.
Паттерн Routing реализует умное распределение задач, позволяя обрабатывать различные типы входных данных по-разному.
Этот паттерн создан для сложных задач, в которых разные типы входных данных лучше обрабатывать различными, специально под них разработанными процессами. Он использует LLM, чтобы проанализировать содержимое ввода и перенаправить его на наиболее подходящее специализированное приглашение или обработчик.
Когда используется:
Сложные задачи с четко определенными категориями входных данных
Когда разные входные данные требуют специализированной обработки
Когда классификацию можно выполнить достаточно точно
Приведем базовый пример использования Routing Workflow:
@Autowired
private ChatClient chatClient;
// Create the workflow
RoutingWorkflow workflow = new RoutingWorkflow(chatClient);
// Define specialized prompts for different types of input
Map<String, String> routes = Map.of(
"billing", "You are a billing specialist. Help resolve billing issues...",
"technical", "You are a technical support engineer. Help solve technical problems...",
"general", "You are a customer service representative. Help with general inquiries..."
);
// Process input
String input = "My account was charged twice last week";
String response = workflow.route(input, routes);
4. Orchestrator-Workers
Этот паттерн демонстрирует, как реализовывать более сложное агентоподобное поведение, при этом полностью сохраняя контроль:
Центральная LLM оркестрирует декомпозицию задач
Специализированные обработчики обрабатывают специфические подзадачи
Четкие границы поддерживают надежность системы
Когда используется:
Сложные задачи, в которых подзадачи нельзя предсказать заранее
Задачи, требующие разных подходов или точек зрения
Ситуации, требующие адаптивного решения проблем
Реализация использует ChatClient от Spring AI's для интерактивного взаимодействия с LLM и состоит из:
public class OrchestratorWorkersWorkflow {
public WorkerResponse process(String taskDescription) {
// 1. Orchestrator analyzes task and determines subtasks
OrchestratorResponse orchestratorResponse = // ...
// 2. Workers process subtasks in parallel
List<String> workerResponses = // ...
// 3. Results are combined into final response
return new WorkerResponse(/*...*/);
}
}
Пример использования:
ChatClient chatClient = // ... initialize chat client
OrchestratorWorkersWorkflow workflow = new OrchestratorWorkersWorkflow(chatClient);
// Process a task
WorkerResponse response = workflow.process(
"Generate both technical and user-friendly documentation for a REST API endpoint"
);
// Access results
System.out.println("Analysis: " + response.analysis());
System.out.println("Worker Outputs: " + response.workerResponses());
5. Evaluator-Optimizer
Паттерн Evaluator-Optimizer реализует процесс dual-LLM (двойная LLM), где одна модель генерирует ответы, в то время как вторая предоставляет оценку и обратную связь в итерационном цикле, что напоминает процесс работы писателя над текстом. Паттерн состоит из двух главных компонентов:
Generator LLM (модель-генератор): Генерирует первоначальный ответ и улучшает его на базе обратной связи
Evaluator LLM (модель-оценщик): Анализирует ответы и предоставляет подробную обратную связь для улучшений
Когда используется:
Существуют четкие критерии оценки
Улучшение в цикле дает измеримое преимущество
Задачи выигрывают от нескольких раундов критической оценки
Реализация использует ChatClient от Spring AI's для интерактивного взаимодействия с LLM и состоит из:
public class EvaluatorOptimizerWorkflow {
public RefinedResponse loop(String task) {
// 1. Generate initial solution
Generation generation = generate(task, context);
// 2. Evaluate the solution
EvaluationResponse evaluation = evaluate(generation.response(), task);
// 3. If PASS, return solution
// 4. If NEEDS_IMPROVEMENT, incorporate feedback and generate new solution
// 5. Repeat until satisfactory
return new RefinedResponse(finalSolution, chainOfThought);
}
}
Пример использования:
ChatClient chatClient = // ... initialize chat client
EvaluatorOptimizerWorkflow workflow = new EvaluatorOptimizerWorkflow(chatClient);
// Process a task
RefinedResponse response = workflow.loop(
"Create a Java class implementing a thread-safe counter"
);
// Access results
System.out.println("Final Solution: " + response.solution());
System.out.println("Evolution: " + response.chainOfThought());
Преимущества реализаций в Spring AI
Реализации этих паттернов в Spring AI имеют несколько преимуществ, которые соответствуют рекомендациям Anthropic:
<!-- Easy model switching through dependencies -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-openai-spring-boot-starter</artifactId>
</dependency>
// Type-safe handling of LLM responses
EvaluationResponse response = chatClient.prompt(prompt)
.call()
.entity(EvaluationResponse.class);
Один и тот же интерфейс для разных LLM провайдеров
Встроенная обработка ошибок и повторные попытки
Гибкое управление подсказками
Best Practices и рекомендации
Базируясь как на исследовании от Anthropic, так и на реализациях от Spring AI, можно сформулировать следующие ключевые рекомендации для построения эффективных систем, базирующихся на LLM:
-
Начинайте с простого
Начинайте с простых workflows прежде чем добавить большую сложность
Используйте самый простой паттерн из тех, что соответствуют вашим требованиям
Добавляйте сложность только тогда, когда это необходимо
-
Надежность архитектуры
Реализуйте четкую систему обработки ошибок
Используйте типобезопасные ответы, где это возможно
Встраивайте валидацию на каждом шаге
-
Рассматривайте компромиссы
Балансируйте latency и точность
Проводите оценку целесообразности использования многопоточной обработки
Выбирайте между фиксированными workflows и динамическими агентами
Что дальше
В части 2 этой серии статей мы расскажем о том, как использовать Agents, которые сочетают в себе основные паттерны и более комплексные возможности:
Композиции паттернов
Комбинирование нескольких паттернов для создания более мощных workflows
Построение гибридных систем, которые используют силу каждого паттерна по максимуму
Создание гибких архитектур, которые могут адаптироваться к меняющимся требованиям
Усовершенствованное управление памятью в агенте
Реализация persistent памяти во всех диалогах
Эффективное управление контекстными окнами
Разработка стратегий по долговременному хранению знаний
Интеграция инструментов и протокола Model-Context (MCP)
Использование внешних инструментов через стандартные интерфейсы
Реализация MCP для расширенного взаимодействия с моделью
Построение расширяемых архитектур агента
В дальнейшем мы также расскажем о подробностях реализаций и best practices для этих усовершенствованных возможностей.
Заключение
Комбинация выводов исследования от Anthropic и практических реализаций Spring AI предоставляет мощный фреймворк для разработки эффективных систем использующих LLM. Следуя приведенным паттернам и принципам, разработчики могут создавать мощные, простые в поддержке и эффективные ИИ приложения, которые приносят реальную пользу, при этом избегая лишней сложности.
Главное — помнить, что иногда самое простое решение является самым эффективным. Начните с базовых паттернов, как следует разберитесь с тем, что подходит для решения вашего кейса и добавляйте сложность только тогда, когда это ощутимо улучшит производительность или возможности вашей системы.
Присоединяйтесь к русскоязычному сообществу разработчиков на Spring Boot в телеграм - Spring АйО, чтобы быть в курсе последних новостей из мира разработки на Spring Boot и всего, что с ним связано.