Skip to content
TheChatArchiveThe Chat Archive
Perplexitysonar· PerplexityHugging Face LMArena Search Arena 24K

Расскажи в деталаях про концепцию ReAct при работе с LLM и как ее имплементировать

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Perplexitysonar-reasoning’s answer.
  1. User

    Расскажи в деталаях про концепцию ReAct при работе с LLM и как ее имплементировать

  2. Perplexity Assistant

    Концепция ReAct (Reasoning + Acting) — это современный подход к работе с большими языковыми моделями (LLM), который объединяет рассуждение и действие в едином цикле для решения сложных задач. ReAct позволяет LLM не только генерировать текстовые рассуждения (reasoning traces), но и выполнять конкретные действия (actions), например, обращаться к внешним источникам информации или инструментам, а затем использовать полученные данные для уточнения своих рассуждений и принятия решений[1][2][3][6][8].

    Основные идеи концепции ReAct

    • Синергия рассуждения и действия: Вместо того, чтобы просто выдавать ответ на основе внутренней модели, LLM в рамках ReAct чередует этапы рассуждения и действия. Рассуждение помогает планировать и корректировать действия, а действия позволяют получать актуальную информацию из внешних источников (например, поисковых систем, баз знаний, API)[1][2][4][8].

    • Вербальные следы рассуждений: Модель генерирует промежуточные мысли, которые помогают разбивать задачу на подзадачи, формулировать запросы к внешним инструментам, анализировать полученные данные и принимать решения[1][2][6].

    • Динамическое взаимодействие с внешней средой: Действия модели — это вызовы внешних инструментов или API, которые возвращают наблюдения (observations). Эти наблюдения затем интегрируются в рассуждения модели для дальнейшего уточнения и корректировки плана[1][4][8].

    • Улучшение точности и интерпретируемости: Такой подход снижает эффект «галлюцинаций» (выдуманных фактов) и ошибок, часто встречающихся при использовании только цепочек рассуждений (chain-of-thought, CoT). Кроме того, ReAct повышает доверие к модели за счёт прозрачности промежуточных шагов[1][2][4][6][8].

    Как работает ReAct — пошагово

    1. Получение запроса: Пользователь задаёт вопрос или ставит задачу.

    2. Генерация мысли (Reasoning): Модель формулирует внутренние рассуждения, разбивает задачу на части, определяет, какую информацию нужно получить.

    3. Выполнение действия (Acting): На основе рассуждений модель инициирует вызов внешнего инструмента (например, поискового API, базы данных, математического калькулятора).

    4. Получение наблюдения (Observation): Модель получает ответ от инструмента.

    5. Анализ результата: Модель интегрирует полученную информацию в рассуждения, корректирует план действий, если нужно — повторяет цикл.

    6. Формирование окончательного ответа: После накопления достаточной информации и завершения рассуждений модель выдаёт ответ пользователю[1][4][5][6][8].

    Пример использования ReAct

    В задаче вопросно-ответной системы (например, HotPotQA) модель сначала рассуждает, какие части вопроса нужно уточнить, затем делает запросы к Википедии или поисковым системам, получает данные, анализирует их и формирует ответ. Такой подход позволяет решать задачи с несколькими шагами рассуждений и получать более точные и обоснованные ответы[1][2][6][8].

    Имплементация ReAct

    Для практической реализации ReAct часто используют фреймворки, которые интегрируют LLM с внешними инструментами и обеспечивают цикл «reasoning-action-observation». Один из популярных инструментов — LangChain, который уже содержит встроенную поддержку ReAct-агентов.

    Основные шаги имплементации на примере LangChain и OpenAI:

    • Установить необходимые библиотеки (openai, langchain, dotenv, google-search-results и др.).

    • Импортировать и настроить LLM (например, OpenAI GPT-3) с нужными параметрами.

    • Загрузить и инициализировать инструменты (например, поисковый API, математический модуль).

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

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

    Пример кода (псевдокод):

    from langchain.llms import OpenAI
    from langchain.agents import load_tools, initialize_agent
    
    llm = OpenAI(model_name="text-davinci-003", temperature=0)
    
    tools = load_tools(["google-serper", "llm-math"], llm=llm)
    
    agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)
    
    response = agent.run("Сложный вопрос, требующий поиска и вычислений")
    print(response)
    

    Такой агент будет автоматически генерировать мысли, выполнять действия (например, поиск в интернете), анализировать результаты и выдавать обоснованный ответ[1][6].

    Преимущества ReAct

    • Позволяет LLM работать с актуальной информацией из внешних источников.

    • Улучшает качество и достоверность ответов.

    • Повышает интерпретируемость и прозрачность работы модели.

    • Эффективен для сложных задач с многошаговыми рассуждениями и необходимостью взаимодействия с внешней средой.

    • Демонстрирует лучшие результаты на задачах вопросно-ответных систем, проверки фактов и интерактивного принятия решений по сравнению с традиционными методами[1][2][4][6][8].


    Таким образом, ReAct — это мощный и универсальный подход, который расширяет возможности LLM, сочетая внутреннее рассуждение с внешними действиями, что позволяет создавать более интеллектуальные, точные и адаптивные AI-системы.

  3. User

    Опиши детально (с примерами кода) как агенты используют react подход "под капотом"

  4. Perplexity Assistant

    Агенты, использующие подход ReAct (Reason + Act), работают по итеративному циклу, в котором языковая модель (LLM) чередует этапы рассуждения и действия, взаимодействуя с внешними инструментами. Рассмотрим подробно, как это устроено «под капотом» с примерами кода.

    Как работают ReAct-агенты «под капотом»

    Основной цикл работы

    1. Получение запроса (Query)
      Агент принимает входной запрос от пользователя.

    2. Генерация рассуждений и действия (Thought + Action)
      LLM генерирует внутренние мысли (Thought) — анализ задачи и план действий, а также указывает действие (Action), которое нужно выполнить. Например, это может быть вызов поискового инструмента или выполнение кода.

    3. Выполнение действия (Action Execution)
      Система вызывает соответствующий инструмент (агент, API, функцию) с аргументами, полученными из шага Action.

    4. Получение наблюдения (Observation)
      Результат работы инструмента возвращается и добавляется в контекст.

    5. Обновление состояния и повторение цикла
      Обновлённый контекст с наблюдением передаётся обратно в LLM для следующей итерации рассуждений и действий.

    6. Завершение (Answer)
      Когда LLM генерирует финальный ответ (Answer), цикл прерывается, и ответ возвращается пользователю.

    Этот цикл позволяет LLM динамически принимать решения, какие действия и в каком порядке выполнять, используя промежуточные результаты для уточнения ответа[1][2][3].


    Пример «под капотом» на Python с использованием LangChain

    Ниже пример кода, который показывает, как создать ReAct-агента с помощью LangChain, OpenAI и двух инструментов: Python REPL (для вычислений) и поискового API (например, TavilySearchResults):

    from langchain import hub
    from langchain.agents import AgentExecutor, create_react_agent
    from langchain_community.tools.tavily_search import TavilySearchResults
    from langchain_core.tools import Tool
    from langchain_openai import ChatOpenAI
    from langchain_experimental.utilities import PythonREPL
    
    # Инициализация инструментов
    python_repl = PythonREPL()
    repl_tool = Tool(
        name="python_repl",
        description="A Python shell. Use this to execute python commands. Input should be a valid python command. If you want to see the output of a value, you should print it out with print(...).",
        func=python_repl.run,
    )
    
    search_tool = TavilySearchResults(max_results=1)
    
    # Инициализация LLM
    llm = ChatOpenAI(model_name="gpt-4o-mini")
    
    # Список инструментов для агента
    tools = [repl_tool, search_tool]
    
    # Загрузка шаблона промпта ReAct
    prompt = hub.pull("hwchase17/react")
    
    # Создание ReAct-агента
    agent = create_react_agent(llm, tools, prompt)
    
    # Создание исполнителя агента
    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
    
    # Запуск агента с запросом
    response = agent_executor.invoke({"input": "How much will 100 dollars be in euros at the current exchange rate?"})
    
    print(response)
    

    Что происходит «под капотом» в этом примере:

    • Модель получает запрос и генерирует мысль (Thought), например: «Мне нужно узнать текущий курс доллара к евро».
    • Затем модель генерирует действие (Action), например: Action: tavily_search_results_json с запросом «current USD to EUR exchange rate».
    • Система вызывает поисковый инструмент с этим запросом и получает результат (Observation).
    • Модель анализирует результат, возможно, решает выполнить вычисление (например, умножить 100 на курс) и генерирует действие Action: python_repl с кодом для вычисления.
    • После выполнения кода и получения результата модель формирует окончательный ответ (Answer) и возвращает его пользователю[1].

    Пример итеративного цикла ReAct в псевдокоде

    context = "User query: How much is 100 USD in EUR?"
    
    while True:
        # LLM генерирует вывод, содержащий Thought и Action
        output = llm.generate(context)
        
        # Разбор вывода на части
        thought = extract_thought(output)
        action, action_input = extract_action(output)
        
        if action == "Answer":
            # Финальный ответ — завершаем цикл
            print("Final answer:", action_input)
            break
        
        # Выполнение действия (вызов инструмента)
        observation = call_tool(action, action_input)
        
        # Обновление контекста с новыми данными
        context += f"\nThought: {thought}\nAction: {action} [{action_input}]\nObservation: {observation}"
    

    Как реализовать ReAct-протокол самостоятельно

    • Системный промпт для LLM должен содержать инструкции, что модель должна выдавать рассуждения и действия в структурированном формате (например, JSON или четко размеченный текст).

    • Итеративный цикл:

      • Отправлять LLM текущий контекст (включая предыдущие мысли и наблюдения).
      • Парсить ответ на мысли и действия.
      • Выполнять действия (вызов агентов/инструментов).
      • Добавлять результаты обратно в контекст.
      • Повторять, пока не будет сгенерирован финальный ответ.
    • Обработка вызовов агентов — отдельная функция, которая по имени агента и аргументам вызывает нужный код или API и возвращает результат.

    Пример системного промпта:

    Ты — ИИ-ассистент, который решает задачи, используя цикл Reason + Act.
    
    1) Сначала размышляй (Thought), анализируя задачу.
    
    2) Затем выбирай действие (Action) из списка доступных агентов и указывай аргументы.
    
    3) После выполнения действия получай результат (Observation) и продолжай цикл.
    
    4) Когда задача решена, выдай финальный ответ (Answer).
    
    Формат ответа:
    
    Thought: <текст рассуждения>
    
    Action: <название_агента>
    
    Action Input: <аргументы>
    
    ...
    
    Answer: <итоговый ответ>
    

    Итог

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

    Пример кода с LangChain демонстрирует, как легко можно создать такого агента, используя готовые инструменты и LLM, а «под капотом» происходит именно описанный выше цикл взаимодействия[1][2][3].

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.