Архітектура React-агента: патерни, помилки, рішення

Суть патерна

ReAct — це патерн, який дозволяє агенту діяти крок за кроком, приймаючи рішення після кожної дії на основі отриманого результату.

Коли потрібен: коли неможливо надійно спланувати весь шлях наперед і наступний крок залежить від результату попереднього.

Кожен крок складається з трьох дій:

• Think — вирішує, що зробити далі
• Act — виконує дію або викликає інструмент
• Observe — аналізує результат

Після цього агент знову вирішує, який крок зробити наступним.

Проблема

Уяви: ти вперше в новому місті й шукаєш відкриту аптеку з потрібними ліками.

Ти ще не знаєш наперед:

• які аптеки поруч
• чи працюють вони зараз
• чи є там потрібний препарат

Повний план одразу скласти неможливо, бо кожен крок залежить від нового результату.

Тому ти дієш по циклу:

1. Знайшов найближчу аптеку
2. Перевірив, чи відкрита
3. Якщо ні — перейшов до наступної
4. Повторив, доки не знайшов потрібну

Тобто постійно: інформація -> рішення -> дія -> нова інформація.

А якщо змусити себе одразу зафіксувати маршрут ("№1 -> №2 -> №3"), це буде план навмання.

У цьому й проблема: у багатьох задачах неможливо коректно спланувати всі кроки наперед.

Рішення

ReAct вирішує це через рішення під час виконання, а не через жорсткий план наперед.

Аналогія: це як навігатор у дорозі. Ти будуєш наступний маневр після кожного нового повороту або перекриття. Маршрут уточнюється на ходу, а не фіксується раз і назавжди.

Ключовий принцип: повний план одразу скласти неможливо, тому агент має адаптуватися після кожного результату.

Замість підходу спочатку весь план -> потім виконання, агент працює так:

1. Міркування (Think): приймає рішення
2. Дія (Act): виконує дію
3. Спостереження (Observe): аналізує результат

Після цього він визначає наступний крок вже на основі нового контексту.

Якщо аптека зачинена, агент не "дотискає" старий план, а одразу коригує дії.

Кожен новий результат:

• додається до контексту
• впливає на наступне рішення
• змінює подальший маршрут

ReAct не виконує наперед заданий сценарій, а адаптується на кожному кроці.

Модель може "хотіти" повторювати дії безкінечно, тому саме політика виконання (execution-policy) визначає умови зупинки циклу.

Як працює

Важливо: агент не виконує дії сам

На етапі міркування (Think) агент лише вирішує, що потрібно зробити далі.

Але він не виконує дію самостійно.

Він генерує рішення у вигляді тексту, наприклад:

“Потрібно викликати інструмент search_docs з параметром X”

Після цього:

• система навколо агента читає це рішення
• виконує дію або викликає інструмент
• повертає результат назад

Цей результат стає новим спостереженням (Observe).

Якщо цей шар не має обмежень, агент може:

• викликати інструмент десятки разів
• повторювати ті самі дії
• витратити бюджет на API-запити

Цикл повторюється, доки задача не виконана або не досягнуто умов зупинки.

У коді це виглядає так

max_steps = 8

for step_no in range(1, max_steps + 1):
    thought = think(context)
    action = act(thought)
    result = observe(action)

    context.append(result)  # Observe -> новий context для наступного Think.

    if is_done(result):
        done = True
        break

if not done:
    return stop_with_reason("max_steps_reached")

Як це виглядає під час виконання

Goal: знайти найближчу відкриту аптеку

Think: потрібно знайти аптеку поруч
Act: система викликає find_nearby_pharmacies(user_location)
Observe: отримано список аптек, відсортований за відстанню
Між ітераціями: список аптек додається в context

Think: перевірити першу (найближчу) аптеку
Act: система викликає check_pharmacy("Аптека №1")
Observe: аптека зачинена
Між ітераціями: статус "зачинена" додається в context

Think: перевірити наступну аптеку
Act: система викликає check_pharmacy("Аптека №2")
Observe: аптека відкрита

Think: це найближча відкрита аптека
Act: система повертає адресу
Observe: користувач отримав результат
Stop: умова виконана, цикл завершується

Агент вирішує, що зробити, виконує дію і отримує результат.

Кожен результат додається до контексту і стає основою для наступного кроку.

Коли підходить — і коли ні

Підходить

Не підходить

Якщо обираєш ReAct, задай обмеження одразу: max_steps, таймаути, умови зупинки та бюджет на виклики інструментів.

Коли використовувати ReAct (vs інші патерни)

Використовуйте ReAct, коли агент має приймати рішення крок за кроком за результатами попередніх дій.

Короткий тест:

• якщо потрібно "подивився результат -> вирішив наступний крок" -> ReAct
• якщо потрібно "спочатку розбити велику ціль на підзадачі" -> Task Decomposition Agent

Як комбінувати з іншими патернами

ReAct часто використовують разом з іншими патернами.

• ReAct + RAG — коли не вистачає фактів, агент спочатку дістає їх із бази знань і тільки потім робить крок.
• ReAct + Reflection — після кожного кроку агент перевіряє себе, щоб швидко помітити і виправити помилку.
• ReAct + Supervisor — ризикові дії агент не виконує сам, а передає на погодження людині.

ReAct додає цикл прийняття рішень. Інші патерни — контроль, пам'ять або координацію.

Коротко

Переваги та Недоліки

FAQ

Q: Чи планує ReAct усі кроки наперед?
A: Ні. Він приймає рішення після кожної дії.

Q: Чи може ReAct застрягти в циклі?
A: Так, якщо не задано умов зупинки.

Q: Чи працює ReAct без інструментів?
A: Так. Агент може використовувати цикл Think -> Act -> Observe навіть без виклику інструментів, наприклад щоб змінювати підхід до задачі. Але без доступу до зовнішніх дій він не може отримувати нові дані і працює лише з тим, що вже є у контексті.

Що далі

ReAct дозволяє агенту діяти крок за кроком.

Але що робити, якщо задача складна і складається з кількох підзадач?