Как спроектировать агента, который может выполнять цепочку из 5-10 действий?

Краткий тезис

Агент, способный выполнять последовательность из 5–10 действий, строится на архитектуре Plan-and-Execute в сочетании с ReAct loop (Agent|Reason + Act). Ключевые компоненты: генерация плана, пошаговое исполнение с памятью для хранения промежуточных результатов, чекпоинты для восстановления после сбоев, мониторинг с лимитами шагов и набор инструментов (API), каждое из которых соответствует одному действию. В production рекомендуется использовать LangGraph как наиболее гибкий и отказоустойчивый фреймворк.

1. Термин «Агент» и «Цепочка действий»

Агент — это программа, которая, используя LLM как «мозг», способна самостоятельно принимать решения, вызывать внешние инструменты и выполнять многошаговые задачи. Цепочка действий — последовательность шагов, где каждый шаг может быть вызовом API, выбором следующего действия или анализом результата.

• Действие — единичный вызов инструмента (например, поиск в БД, вызов калькулятора, отправка email).
• План — структурированный список шагов, сгенерированный LLM на старте.
• Цикл — повторение действий и наблюдений до достижения цели.

Агент отличается от простого конвейера (pipeline) тем, что может динамически менять порядок шагов, возвращаться назад и адаптироваться под промежуточные результаты.

2. Два подхода: Plan-and-Execute vs. ReAct

Рекомендация для 5–10 действий комбинируйте: сначала сгенерируйте высокоуровневый план, а каждый шаг внутри выполняйте через мини-ReAct loop (например, «выбери инструмент → вызови → обработай результат»).

3. Память (Memory) агента

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

• Внутренняя память — переменные в коде (словарь, база данных). Хранит все состояния шагов.
• Контекстная память — история сообщений, подаваемая в LLM. Для цепочки из 5–10 действий контекст не раздувается сильно, но нужно следить за лимитом токенов.
• Внешняя память — long‑term storage (векторная БД, файловая система) для результатов, которые могут понадобиться в будущих сессиях.

Пример структуры памяти:

memory = {
    "plan": ["step_1", "step_2", ...],
    "current_step": 0,
    "results": {
        "step_1": {"output": ..., "timestamp": ...},
        "step_2": None  # ещё не выполнен
    },
    "errors": []
}

4. Чекпоинты (Checkpoints)

Чекпоинт — сохранение полного состояния агента после каждого успешного шага. Это критично для production, так как сбой может произойти на любом шаге (отказ API, таймаут, ошибка LLM).

• Что сохранять план, выполненные шаги, промежуточные данные, стек вызовов.
• Где хранить Redis, PostgreSQL или файл (для простоты).
• Восстановление при перезапуске агент находит последний чекпоинт и продолжает с места остановки.

LangGraph поддерживает чекпоинты «из коробки» через graph.checkpoint.

5. Мониторинг и лимиты шагов

Без ограничений агент может зациклиться или уйти в бесконечную глубину.

• Максимальное количество шагов (обычно 10–15). По достижении лимита — прерывание с возвратом частичного результата.
• Таймаут на шаг (например, 30 секунд на вызов инструмента).
• Мониторинг: логирование каждого действия с временем выполнения, ошибками, токенами. Инструменты: LangSmith, Weights & Biases, Prometheus.
• Fallback-план — если шаг не удался, агент может попробовать альтернативный инструмент или пересоздать план из 3‑х шагов.

6. Инструменты (Tools)

Каждое действие — это вызов инструмента. Инструменты должны быть атомарными, с чёткой сигнатурой (вход‑выход).

Примеры инструментов для агента новостей:

• search_news(query) — поиск статей
• fetch_article(url) — получение полного текста
• summarize(text) — суммаризация LLM
• save_to_db(title, summary) — сохранение

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

7. Проектирование цепочки: пошаговая схема

1. Пользовательский запрос → “Напиши краткий дайджест по последним новостям ИИ”
2. Планирование (LLM) → генерирует план: search, fetch, summarize, fetch, compare, final]
3. Цикл исполнения:
   • Шаг 1: вызови search_news(query=”ИИ”) → получи список ссылок
   • Шаг 2: вызови fetch_article(link1) → текст
   • Шаг 3: вызови summarize(текст) → саммари
   • … до 10 шагов
4. Проверка условия (LLM решает, достаточно ли данных или нужно ещё)
5. Сбор результатов и генерация финального ответа

8. Реализация на LangGraph (пример)

LangGraph позволяет строить граф, где узлы — функции (шаги), а рёбра — переходы. Пример для 5-шагового агента:

from langgraph.graph import StateGraph, END
from typing import TypedDict, List

class AgentState(TypedDict):
    plan: List[str]
    current_step: int
    results: dict
    error: str | None

def execute_step(state: AgentState):
    step = state["plan"][state["current_step"]]
    try:
        # вызов инструмента
        result = invoke_tool(step)
        state["results"][step] = {"status": "ok", "output": result}
        state["current_step"] += 1
    except Exception as e:
        state["error"] = str(e)
    return state

def should_continue(state):
    if state["error"]:
        return "handle_error"
    if state["current_step"] >= len(state["plan"]):
        return "final"
    return "execute_step"

graph = StateGraph(AgentState)
graph.add_node("execute_step", execute_step)
graph.add_node("handle_error", handle_error)
graph.add_node("final", final_response)
graph.set_entry_point("execute_step")
graph.add_conditional_edges("execute_step", should_continue)

Такой граф легко масштабировать, добавлять чекпоинты и мониторинг.

9. Сравнение фреймворков

Для цепочки 5–10 действий я рекомендую LangGraph как наиболее зрелый и контролируемый.

10. Обработка ошибок и Fallback

• Повторные попытки: 2-3 retry с экспоненциальной задержкой при временных ошибках.
• Пропуск шага: если шаг не критичен, агент может перейти к следующему.
• Перепланирование: при фатальной ошибке (например, инструмент недоступен) — перегенерировать план с учётом ограничений.
• Логирование ошибок в структурированном виде (JSON) для анализа.

11. Масштабирование и параллелизм

• Параллельное выполнение независимых шагов: если план позволяет, шаги, которые не зависят друг от друга, можно выполнять одновременно (например, несколько fetch). LangGraph поддерживает параллельные узлы.
• Очередь задач: для массовой обработки запросов используйте очереди (RabbitMQ, Redis Queue).
• Стейт‑модулированность: храните состояние в Redis, чтобы агент мог быть перезапущен на другом узле.

Пет-проект для закрепления

Задача Создать агента, который собирает информацию с трёх новостных сайтов, сравнивает заголовки и выдаёт сводку с указанием источников.

Инструменты Python, LangGraph (или LangChain Expression Language), asyncio (для параллельных запросов), requests/html‑парсер (BeautifulSoup или Selenium), OpenAI API.

Шаги:

1. Получить от пользователя тему (например, “квантовые вычисления”).
2. Сгенерировать план: [search_news_a, search_news_b, search_news_c, aggregate, summarize].
3. Реализовать каждый шаг как функцию-инструмент.
4. Добавить чекпоинты (сохранять состояние в JSON после каждого шага).
5. Установить лимит в 2 попытки на неудачный запрос.
6. Вывести финальный отчёт.

Ожидаемый результат Агент выполняет цепочку из 5 действий без участия человека, обрабатывает ошибки (например, сайт недоступен) и возвращает корректный дайджест.

Связь с другими вопросами

Навигация

• Предыдущий: 42
• Следующий: 44
• Индекс: 00. Индекс разборов