ReAct и MRKL: подходы к агентам в LLM

Это руководство предназначено для разработчиков AI-агентов, инженеров машинного обучения и специалистов по автоматизации, которые хотят понять современные подходы к построению интеллектуальных агентов на базе больших языковых моделей. Мы разберем две ключевые архитектуры, ReAct и MRKL, которые позволяют создавать агентов, способных рассуждать, планировать действия и взаимодействовать с внешними инструментами.

Что такое LLM агенты и зачем они нужны

LLM агенты представляют собой программные системы, которые используют большие языковые модели для принятия решений, выполнения задач и взаимодействия с внешней средой. В отличие от простых чат-ботов, агенты обладают способностью к reasoning (рассуждению), могут планировать последовательность действий и использовать внешние инструменты для решения сложных задач.

Основные возможности современных AI-агентов:

• Динамическое планирование последовательности действий для достижения цели
• Интеграция с API, базами данных и другими внешними сервисами
• Адаптация стратегии на основе промежуточных результатов
• Обработка сложных многошаговых запросов пользователей
• Самостоятельное устранение ошибок и корректировка подхода

Предварительные требования

Прежде чем приступить к изучению архитектур ReAct и MRKL, вам понадобятся:

• Базовое понимание работы больших языковых моделей (GPT, Claude, LLaMA)
• Знание Python на уровне создания классов и работы с API
• Опыт работы с промптами и prompt engineering
• Понимание концепций API и RESTful сервисов
• Установленный Python 3.8+ и готовность работать с библиотеками LangChain или аналогичными

Архитектура ReAct: Reasoning + Acting

Основные принципы ReAct

ReAct (Reasoning and Acting) представляет собой подход к построению агентов, который объединяет процессы рассуждения и выполнения действий в единый цикл. Ключевая идея заключается в том, что агент чередует этапы мышления (Thought), действия (Action) и наблюдения (Observation).

Архитектура работает по следующему циклу:

1. Thought: агент анализирует текущую ситуацию и формулирует план
2. Action: агент выполняет конкретное действие (вызов API, поиск информации)
3. Observation: агент получает результат действия и анализирует его
4. Thought: агент переосмысливает ситуацию с учетом нового знания
5. Цикл повторяется до достижения финального ответа

Практический пример реализации ReAct

Вот базовая структура промпта для ReAct-агента:

react_prompt = """
Ответь на вопрос, используя следующий формат:

Вопрос: исходный вопрос
Thought: твои рассуждения о том, что делать дальше
Action: действие для выполнения [Search, Calculate, Finish]
Action Input: входные данные для действия
Observation: результат действия
... (цикл Thought/Action/Observation повторяется)
Thought: я знаю финальный ответ
Final Answer: итоговый ответ на вопрос

Доступные действия:
- Search[query]: поиск информации в интернете
- Calculate[expression]: вычисление математического выражения
- Finish[answer]: завершение с финальным ответом

Вопрос: {question}
"""

Пример работы ReAct-агента на практике:

Вопрос: Сколько стоит акция Tesla сегодня и как это изменилось за неделю?

Thought: Мне нужно узнать текущую цену акции Tesla
Action: Search[текущая цена акции Tesla]
Action Input: Tesla stock price today
Observation: Цена акции Tesla составляет $248.50

Thought: Теперь нужно узнать цену неделю назад
Action: Search[цена акции Tesla неделю назад]
Action Input: Tesla stock price one week ago
Observation: Неделю назад цена была $235.20

Thought: Теперь могу вычислить изменение
Action: Calculate[(248.50 - 235.20) / 235.20 * 100]
Action Input: (248.50 - 235.20) / 235.20 * 100
Observation: 5.65

Thought: Я знаю финальный ответ
Final Answer: Акция Tesla стоит $248.50. За неделю она выросла на 5.65% (с $235.20).

Архитектура MRKL: Modular Reasoning, Knowledge and Language

Концепция модульных систем MRKL

MRKL (произносится как "miracle") расшифровывается как Modular Reasoning, Knowledge and Language. Это архитектура, которая делает акцент на модульности и специализации различных компонентов агента. В отличие от монолитного подхода, MRKL организует систему как набор экспертных модулей, каждый из которых отвечает за определенную область знаний или тип операций.

Основные компоненты MRKL:

• Router (Маршрутизатор): определяет, какой модуль должен обработать запрос
• Expert Modules (Экспертные модули): специализированные компоненты для конкретных задач
• Knowledge Bases (Базы знаний): хранилища структурированной информации
• Language Model (Языковая модель): центральный компонент для понимания и генерации текста

Типы экспертных модулей в MRKL

В MRKL-системе можно выделить несколько категорий модулей:

Тип модуля	Назначение	Примеры использования
Калькулятор	Математические вычисления	Финансовые расчеты, статистика, геометрия
Поисковик	Извлечение актуальной информации	Новости, цены, погода, факты
Базы данных	Структурированные запросы	SQL-запросы, поиск в документах
API-коннекторы	Взаимодействие с сервисами	CRM, ERP, платежные системы
Специализированные ML	Узкие задачи AI	Распознавание изображений, анализ тональности

Сравнение ReAct и MRKL

Критерий	ReAct	MRKL
Основной фокус	Цикл рассуждения и действия	Модульная архитектура
Структура	Линейный цикл	Иерархическая система модулей
Масштабируемость	Средняя (ограничена контекстом)	Высокая (добавление новых модулей)
Прозрачность	Высокая (видна цепочка мыслей)	Средняя (зависит от реализации)
Сложность реализации	Низкая	Средняя-высокая
Оптимизация затрат	Может быть высокой (множество вызовов LLM)	Лучше (специализированные модули дешевле)
Обработка ошибок	Встроенная через повторное рассуждение	Требует явной реализации

Реализация агентов с помощью LangChain

Создание ReAct-агента

Пошаговая инструкция для создания ReAct-агента:

1. Установите необходимые библиотеки:

pip install langchain langchain-openai langchain-community

2. Импортируйте компоненты:

from langchain.agents import create_react_agent, AgentExecutor
from langchain_openai import ChatOpenAI
from langchain.tools import Tool
from langchain import hub

3. Определите инструменты для агента:

def search_tool(query: str) -> str:
    # Реализация поиска
    return f"Результаты поиска для: {query}"

def calculator_tool(expression: str) -> str:
    # Безопасное вычисление
    try:
        result = eval(expression)
        return str(result)
    except:
        return "Ошибка вычисления"

tools = [
    Tool(
        name="Search",
        func=search_tool,
        description="Полезно для поиска актуальной информации"
    ),
    Tool(
        name="Calculator",
        func=calculator_tool,
        description="Полезно для математических вычислений"
    )
]

4. Создайте и запустите агента:

llm = ChatOpenAI(temperature=0, model="gpt-4")
prompt = hub.pull("hwchase17/react")
agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = agent_executor.invoke({
    "input": "Сколько будет 25% от 840?"
})
print(result["output"])

5. Настройте параметры выполнения для контроля:

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=10,  # Максимум итераций
    handle_parsing_errors=True  # Обработка ошибок парсинга
)

Создание MRKL-агента

Для MRKL используется похожий подход, но с акцентом на разделение модулей:

from langchain.agents import create_structured_chat_agent

# Группируем инструменты по категориям
math_tools = [calculator_tool, statistics_tool]
data_tools = [database_tool, api_tool]
knowledge_tools = [search_tool, wiki_tool]

# Создаем агента с структурированным подходом
agent = create_structured_chat_agent(
    llm=llm,
    tools=math_tools + data_tools + knowledge_tools,
    prompt=structured_prompt
)

Выбор подхода для вашего проекта

Рекомендации по выбору архитектуры:

Используйте ReAct, если:

• Вам нужна прозрачность процесса принятия решений
• Задачи требуют последовательного reasoning
• Важна возможность отладки и понимания логики агента
• Проект находится на ранней стадии и требует быстрого прототипирования

Используйте MRKL, если:

• Система должна интегрироваться с множеством специализированных сервисов
• Требуется высокая масштабируемость и производительность
• Разные части системы разрабатываются разными командами
• Необходима оптимизация затрат через использование специализированных модулей

Устранение распространенных проблем

Проблема 1: Зацикливание агента

Симптомы: Агент повторяет одни и те же действия без прогресса.

Решение:

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    max_iterations=15,
    early_stopping_method="generate"  # Принудительная генерация ответа
)

Проблема 2: Некорректный выбор инструментов

Симптомы: Агент выбирает неподходящие инструменты для задачи.

Решение: Улучшите описания инструментов и добавьте примеры:

Tool(
    name="Calculator",
    func=calculator_tool,
    description="""Используй для математических вычислений.
    Примеры:
    - Сложение: 5 + 3
    - Процент: (50 / 200) * 100
    - Степень: 2 ** 8
    НЕ используй для поиска информации или текстового анализа."""
)

Проблема 3: Высокие затраты на API

Симптомы: Большие расходы на вызовы LLM.

Решение:

• Используйте кэширование результатов для повторяющихся запросов
• Применяйте более дешевые модели для промежуточных шагов
• Ограничивайте количество итераций через max_iterations
• Внедряйте специализированные модули вместо универсальных LLM-вызовов

Проблема 4: Ошибки парсинга ответов

Симптомы: Агент не может распарсить собственный вывод.

Решение:

agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    handle_parsing_errors="Проверь формат вывода и попробуй снова. Используй только указанные ключевые слова: Thought, Action, Action Input, Observation."
)

Продвинутые паттерны и оптимизации

Для повышения эффективности агентов используйте следующие техники:

• Memory (Память): Добавьте хранилище для запоминания контекста между сессиями
• Callback handlers: Отслеживайте метрики производительности и стоимость
• Streaming: Выводите промежуточные результаты для улучшения UX
• Retry logic: Автоматически повторяйте неудачные операции с экспоненциальной задержкой
• Validation: Проверяйте корректность данных перед передачей в инструменты

FAQ

Вопрос 1: Можно ли комбинировать ReAct и MRKL в одной системе?

Да, это распространенная практика. Вы можете использовать ReAct как общий фреймворк для reasoning, а MRKL-модули как специализированные инструменты внутри системы. Например, ReAct-цикл управляет общей логикой, а MRKL-модули предоставляют экспертизу в конкретных областях.

Вопрос 2: Какие модели LLM лучше всего подходят для агентов?

Для production-систем рекомендуются GPT-4, Claude 3 Opus/Sonnet или Gemini Pro. Для экспериментов подойдут GPT-3.5-turbo или открытые модели вроде Mixtral. Ключевые требования: хорошее следование инструкциям, способность к reasoning и стабильный формат вывода.

Вопрос 3: Как оценить качество работы агента?

Используйте метрики:

• Task Success Rate (процент успешно выполненных задач)
• Average iterations (среднее число шагов до решения)
• Cost per task (стоимость одной задачи)
• Human evaluation score (оценка экспертов)
• Response time (время выполнения)

Вопрос 4: Безопасно ли давать агенту доступ к критическим системам?

Необходимо внедрять строгие меры безопасности: песочницы для выполнения кода, ограничения на операции (whitelist действий), логирование всех действий, human-in-the-loop для критических операций, rate limiting для предотвращения злоупотреблений.

Вопрос 5: Как масштабировать агентов для production?

Основные стратегии: использование асинхронных операций, кэширование промежуточных результатов, балансировка нагрузки между несколькими инстансами, мониторинг производительности через APM-инструменты, оптимизация промптов для сокращения токенов.

Заключение

ReAct и MRKL представляют собой два мощных подхода к построению интеллектуальных агентов на базе больших языковых моделей. ReAct обеспечивает прозрачный цикл рассуждения и действия, идеальный для задач, требующих последовательного планирования. MRKL предлагает модульную архитектуру, оптимальную для сложных систем с множеством специализированных компонентов.

Для следующих шагов рекомендуется:

1. Создайте простой прототип агента с базовыми инструментами
2. Протестируйте оба подхода на ваших реальных задачах
3. Измерьте метрики производительности и стоимости
4. Постепенно добавляйте сложность через новые инструменты и модули
5. Внедрите мониторинг и логирование для production-среды

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