Привет, Хабр!
В последнее время AI агенты стали главным трендом. Многие используют готовые шаблоны, такие как create_react_agent из langchain, но не понимают, как они работают под капотом. При этом агенты становятся все сложнее, и придет время, когда нужно будет писать свою реализацию.
В этой статье мы разберем:
-
Устройство ReAct агента
-
Устройство Reflection агента
-
Примеры системных prompt запросов
-
Кейсы использования и особенности
Что такое AI агент
Прежде чем переходить к коду, нужно понять, что можно считать агентом. Существует множество определений, например:
-
AI агент — система, способная принимать автономные решения, взаимодействовать с окружающей средой и другими агентами для выполнения конкретных задач
-
AI агент — программное обеспечение, которое автономно собирает данные и выполняет задачи с использованием этих данных.
Все они сходятся в одном: агентная система должна уметь действовать автономно и сама выбирать следующий шаг. Конечно, это все еще расплывчатое определение. У меня бывали кейсы, когда агент требовал подтверждения своих действий у человека на многих шагах, но при этом последовательность его действий была недетерминированной.
Составные части AI агентов:
-
System Prompt
-
Задает роль
-
Описывает поведение
-
Определяет доступные инструменты
-
-
Tools (Инструменты)
-
Функции, доступные агенту для решения задач. Например, поиск в интернете или базе
-
-
Система хранения контекста
-
Краткосрочная память
-
Долгосрочная память
-
Если вы используете LLM для выполнения линейной комбинации действий или для обычной вопросно-ответной формы, то ваша система, скорее всего, является LLM — конвейером, а не агентом.
Подробнее о каждой части — в моих предыдущих статьях:
Создаем свой RAG: от загрузки данных до генерации ответов с LangGraph. Часть 2 / Хабр
Используем языковые модели в AI-агентах. Часть 2. Retrievers, TextSplitters
и моем канале. В нем вы найдете:
-
Полный код каждого агента
-
Файл с дополнительными архитектурами (Supervisor, plan-and-execute), которые не поместились в эту статью
Ссылка: мой канал
Виды агентных архитектур
Агентов можно разделить на две группы:
-
Адаптивные
-
Не адаптивные
Агенты из первой группы умеют адаптироваться / изменять свое поведение в зависимости от окружающей среды.
Агенты из второй группы не умеют менять свой план действий. Они больше подвержены зацикливанию, но проще в реализации.
Сразу скажу, что ваша реализация агентов может отличаться. Сфера AI еще слишком молодая, чтобы устанавливать строгие правила, поэтому каждый может подстроиться под себя.
Используемые библиотеки
Я буду использовать langchain, langchain_gigachat. Если хотите, можете добавить langgraph
Установка:
!pip install langchain langchain-gigachatИнициализация модели:
from langchain_gigachat import GigaChat llm = GigaChat( verify_ssl_certs=False, credentials="токен", model="GigaChat-2", temperature=0.1 )Токен можно получить бесплатно на странице GigaChat
Необходимые зависимости:
from langchain.tools import BaseTool from pydantic import BaseModel, Field from typing import Optional, Any, Type import jsonReAct agent
Ярким представителем второй категории является ReAct агент.
Логика работы агента:
-
Проанализировать запрос пользователя
-
Выбрать подходящий инструмент или FINISH
-
Получить результат вызова инструмента
-
Снова проанализировать запрос (шаг 1)
Основное преимущество — простота реализации и масштабирования агента.
Кейсы использования:
-
Простые задачи, которые требует одноуровневого вызова инструментов. Например: напиши краткое содержание последних 10 статей на Хабр на тему ИИ.
Агенту нужно будет:
-
Обратиться к API хабра и получить последние новости
-
Провести суммаризацию
-
Сгенерировать ответ
Создадим два инструмента
Я напишу два инструмента: добавление в импровизированную базу и чтение. Обратите внимание на то, как я задаю схему входных аргументов, их описание и примеры.
#добавление записи в базу (словарь) class RegisterUserInput(BaseModel): username: str = Field(..., description="Логин", examples=["ViacheslavVoo"]) email: str = Field(..., description="Email", examples=["Viacheslav@test.com"]) phone: Optional[str] = Field(None, description="Номер телефона в формате +7XXX...", examples=["+7999999999"]) class RegisterUserTool(BaseTool): name: str = "register_user" description: str = "Регистрация пользователя в системе" args_schema: Type[BaseModel] = RegisterUserInput def _run(self, **kwargs): users[kwargs["username"]] = kwargs["email"] return f"User {kwargs['username']} успешно зарегистрирован" # поиск в базе (словаре) class SearchDBInput(BaseModel): username: str = Field(..., description="Логин/имя пользователя", examples=["ViacheslavVoo"]) limit: Optional[int] = Field(5, description="Лимит результатов") class SearchDBTool(BaseTool): name: str = "search_db" description: str = "Ищет данные пользователей в системе" args_schema: Type[BaseModel] = SearchDBInput def _run(self, username: str, limit: int = 5): return f"Найден пользователь {users[username]}'" Так как работу таких систем тяжело воспринимать, не имея полной картины, я начну с общего описания.
Каркас агента
-
run()
-
Принимает текущую задачу
-
Возвращает результат работы агента
-
-
build_prompt()
-
Формирует системный промпт с историей действий, текущей задачей, доступными инструментами
-
-
parse_response()
-
Извлекает из ответа название инструмента и необходимые аргументы
-
В процессе написания статьи я решил добавил еще один шаг — генерация итогового ответа на основе запроса и истории действий, поэтому последний шаг — final_answer()
Каркас агента на Python:
class ReactAgent: def __init__(self, tools: list[BaseTool], llm, max_iterations: int = 5): self.tools = {tool.name: tool for tool in tools} self.llm = llm self.max_iterations = max_iterations self.history = [] @property def tool_desc(self): pass def run(self, task: str) -> str: pass def _build_prompt(self, task: str) -> str: pass def _parse_response(self, response: str) -> tuple[str, dict]: pass def _final_answer(self, task: str) -> str: passПри инициализации агента необходимо передать:
-
Набор инструментов
-
Модель
-
Максимальное количество операций
Также при инициализации создается словарь, в котором ключами являются названия функций, и история действий.
Начнем с реализации tool_desc.
Задача: сгенерировать описание доступных инструментов, чтобы использовать его в системном промпте.
@property def tool_desc(self): tools_desc = [] for tool in self.tools.values(): args_desc = "\n".join( f" {field}: {value.description} ({'обязательный' if value.is_required() else 'опциональный'})" for field, value in tool.args_schema.model_fields.items() ) tools_desc.append(f"{tool.name} - {tool.description}\n{args_desc}") tools_desc.append(f"FINISH - выбери для завершения работы, если задача выполнена") return tools_descСледующим станет метод build_prompt.
Задача: Сгенерировать prompt, который будет содержать:
-
Роль агента
-
Инструкции
-
Доступные инструменты
-
Историю действий
Важное замечание: мы явно указываем, что при выборе FINISH необходимо передать пустую строку для ключа action_input. Это сделано для единого формата вывода
def _build_prompt(self, task: str) -> str: history = "\n".join(self.history[-3:]) if self.history else "Нет истории" return f""" Ты - умный ассистент, который помогает решаить задачу пользователя. Ты должен выбрать один из доступных инструментов или написать FINISH если задача выполнена **Задача**: {task} **Доступные инструменты**: {chr(10).join(self.tool_desc)} **Инструкции**: -проанализируй задачу -проанлизируй историю -выбери подходящий инструмент или FINISH, если задача была выполнена в истории. -обязательно проанализируй вызовы, которые ты делал раньше -если в истории ты уже вызывал инструмент с такими аргументами и инструмент был выполнен успешно, то не вызывай его снова. Переходи к следующему инструменту или к FINISH. -если ты выбераешь FINISH то action_input: "" **Твоя история вызова инструментов и результаты вызовов**: {history} **Ответ в формате JSON**: {{ "action": "имя_инструмента", "action_input": {{ "arg1": "значение", "arg2": "значение" }}, "though": "обоснование выбора инструмента" }} Верни только ответ сторого в формате JSON со всеми заполненными полями. Не добавляй других слов и комментариев """ parse_response
После получения ответа от LLM необходимо выделить название инструмента и аргументы.
def _parse_response(self, response: str) -> tuple[str, dict]: data = json.loads(response.strip()) return data["action"], data["action_input"]final_answer
Осталось получить итоговый ответ. Этот шаг больше нужен пользователя или других агентов, если вы будете использовать их вместе.
def _final_answer(self, task: str) -> str: prompt = """ Ты - умный ассистент, который должен сформулировать итоговый ответ для пользователя на основе истории действий. Запрос пользователя: {user_input} Итсория действий: {history} Верни только итоговый ответ - вывод о выполнении задачи. """ chain = ChatPromptTemplate.from_template(prompt) | self.llm | StrOutputParser() return chain.invoke({"user_input": task, "history": self.history})run
В нем мы будем:
-
Генерировать prompt
-
Получать ответ от модели
-
Извлекать action/action_input
-
Вызывать инструмент
-
Получать ответ
-
Добавлять ответ в историю действий
def run(self, task: str) -> str: for _ in range(self.max_iterations): prompt = self._build_prompt(task) llm_response = self.llm.invoke(prompt) try: # 2. Парсинг ответа action, action_input = self._parse_response(llm_response.content) if action == "FINISH": return action_input except Exception as e: self.history.append(f"Ошибка парсинга: {str(e)}") continue # 3. Валидация и выполнение if action not in self.tools: self.history.append(f"Неизвестный инструмент: {action}") continue tool = self.tools[action] try: observation = tool.run(action_input) self.history.append(f"Ты вызвал инструмент:{action}({action_input}) Результат выполнения: {observation}") except Exception as e: self.history.append(f"Ошибка выполнения {action}: {str(e)}") return "Достигнут лимит итераций"При неправильном ответе модели или неудачном вызове инструмента советующее сообщение добавляется в историю.
Главный недостаток ReAct агента: при возникновении ошибки он не может изменить свой план действий или подстроиться под сообщение ошибки, поэтому возникает вероятность зацикливания.
Вызов агента:
from src.llm import llm #ваша языковая модель. if __name__ == "__main__": agent = ReactAgent(tools, llm) # Задача 1: Регистрация result = agent.run("Зарегистрируй пользователя Ivan с email ivan@test.com") print(result) # Составная Задача 2: Регистрация и поиск result = agent.run("Зарегистрируй пользователя Viacheslav с email Viacheslav@test.com и найди пользователя Ivan") print(result)Пример Prompt запроса, который будет передаваться модели:
Ты - умный ассистент, который помогает решаить задачу пользователя. Ты должен выбрать один из доступных инструментов или написать FINISH если задача выполнена **Задача**: Зарегистрируй пользователя Ivan с email ivan@test.com **Доступные инструменты**: register_user - Регистрация пользователя в системе username: Логин (обязательный) email: Email (обязательный) phone: Номер телефона в формате +7XXX... (опциональный) search_db - Ищет данные пользователей в базе username: Логин (обязательный) limit: Лимит результатов (опциональный) FINISH - выбери для завершения работы, если задача выполнена **Инструкции**: -проанализируй задачу -проанлизируй историю -выбери подходящий инструмент или FINISH, если задача была выполнена в истории. -обязательно проанализируй вызовы, которые ты делал раньше -если в истории ты уже вызывал инструмент с такими аргументами и инструмент был выполнен успешно, то не вызывай его снова. Переходи к следующему инструменту или к FINISH. -если ты выбераешь FINISH то action_input: "" **Твоя история вызова инструментов и результаты вызовов**: Нет истории **Ответ в формате JSON**: { "action": "имя_инструмента", "action_input": { "arg1": "значение", "arg2": "значение" }, "though": "обоснование выбора инструмента" } Верни только ответ сторого в формате JSON со всеми заполненными полями. Не добавляй других слов и комментариев После вызовов инструмента запрос дополняется историей и выводит результат:
**Твоя история вызова инструментов и результаты вызовов**: Ты вызвал инструмент:register_user({'username': 'Viacheslav', 'email': 'Viacheslav@test.com'}) Результат выполнения: User Viacheslav успешно зарегистрирован Ты вызвал инструмент:search_db({'username': 'Ivan'}) Результат выполнения: Найден пользователь ivan@test.com' Пример ответа:
Пользователь Ivan с email ivan@test.com успешно зарегистрированПодведем итог по React Agent:
Основные преимущества:
-
Автономность
-
Гибкость
-
Прозрачность (можем видеть историю вызываемых инструментов)
Основные недостатки:
-
Риск зацикливания
-
Зависимость от качества LLM. Например, GigaChat-Lite может не справиться с вызовом инструментов
-
Недетерминированность. Порядок вызова инструментов может отличаться для одинаковых запросах
Reflection Agent
Представитель первого типа агентов. Он во многом похож на ReAct, но с одним отличием: в случае ошибки он может адаптироваться под нее. Сразу скажу, что я имею ввиду под Reflection агентом, агента, который адаптируется к ошибкам, а не проводит глубокое рассуждение для ответа на вопрос.
Если вы хотите увидеть вторую версию, пожалуйста, напишите об этом в комментариях и я выложу отдельную статью.
Замечание: ReAct сможет корректно работать с помощью модели GigaChat-2. Для Reflection agent я использовал GigaChat-2-Max, так как младшая версия не справилась с форматом вывода.
Логика работы агента:
-
Проанализировать запрос пользователя
-
Выбрать подходящий инструмент
-
Если инструмент != FINISH -> вызвать инструмент
-
Если инструмент вернул результат без ошибок, добавить вызов в историю и перейти к 1
-
Если инструмент вернул сообщение об ошибке: проанализировать ошибку -> создать обновленный prompt -> вернуться к шагу 1
Найти применение такому виду агентов может быть сложно, но благодаря шагу с анализом ошибки он сможет адаптироваться, например, под изменившуюся схему входных аргументов для инструментов. Например, если вы используете сторонние инструменты, которые находятся в активной стадии разработки.
Да, возможно, вы никогда не будете его использовать, но мне по каким то причинам нравится его идея, поэтому я решил добавить его сюда.
Хотя… Каждый агент по своему прекрасен)
Каркас агента:
-
run() — главный метод через который вызывается агент
-
exectute_exction() — выполняет вызов инструмента
-
needs_reflection() — метод, в которым мы будем определять, нужно ли изменять запрос
-
perform_reflection() — метод, который будет генерировать своеобразную рекомендацию по исправлению ошибки
-
build_prompt() — формирует prompt с историей, задачей, набором инструментов
-
build_reflection_prompt() — формирует prompt с рекомендацией по исправлению ошибки
-
store_memory() — добавляет вызовы в историю
perform_reflection() и build_reflection_prompt() можно было бы совместить в один метод, но я решил разделить логику на два этапа.
Каркас на Python:
class ReflectionAgent: """Агент с возможностью саморефлексии и анализа своих действий""" def __init__(self, llm, tools: list, max_iterations: int = 5, timeout: int = 10): self.llm = llm self.tools = {tool.name: tool for tool in tools} self.max_iterations = max_iterations self.timeout = timeout self.history = [] self.iteration = 0 @property def tool_desc(self): #РЕАЛИЗАЦИЯ КАК У ReAct agent def run(self, task: str) -> str: pass def _execute_action(self, action: str, action_input: str) -> str: pass def _perform_reflection(self) -> str: pass def _build_prompt(self, task: str) -> str: pass def _parse_response(self, response: str) -> tuple: pass def _reset_state(self): pass def _store_memory(self, thought: str, action: str, action_input: str, observation: str): pass def _handle_finish(self, result: str) -> str: pass def _handle_max_iterations_reached(self) -> str: pass Начнем с execute_action:
Логика довольно простая:
-
Если инструмента нет в списке доступных или его вызов завершился с ошибкой, будет возвращен соответствующий результат с ошибкой
-
Иначе результат выполнения
Важная особенность реализации в текущем контекста: в ошибке должно содержаться слово «Ошибка / error или т.п»
def _execute_action(self, action: str, action_input: str) -> str: # Проверка существования инструмента if action not in self.tools: return f"Ошибка: Инструмент '{action}' не найден. Доступные инструменты: {self.tool_desc}" try: tool = self.tools[action] result = tool.run(action_input) return result except Exception as e: return f"Error executing '{action}': {str(e)}"Блок, связанный с рефлексией
needs_reflection. Его логика чуть сложнее:
-
Если истории действий нет -> анализ ошибки не нужен, так как действий еще не было
-
Если в наблюдении (observation) последнего действия есть ошибка -> return True
-
Если несколько раз подряд был вызван один и тот же инструмент -> return True
-
В остальных случаях: return False
Вы можете изменять логику работы для своего случая
def _needs_reflection(self) -> bool: """Определяет, нужно ли проводить рефлексию""" if not self.history: return False last_action = self.history[-1] # Рефлексия при явных ошибках if any(keyword in last_action['observation'].lower() for keyword in ["error", "fail", "unknown", "ошибка"]): return True # Или если несколько одинаковых действий подряд if len(self.history) > 2: last_actions = [m['action'] for m in self.history[-3:]] if len(set(last_actions)) == 1: # Все одинаковые return True return False perform_reflection
Затем создадим подсказку по исправлению ошибки. На этом шаге вы можете написать свой уникальный prompt, в котором будут приведены разрешения наиболее частых конфликтов. Я напишу общий запрос, который будет просить модель сгенерировать небольшую подсказку.
def _perform_reflection(self) -> str: history = "\n".join( f"Iteration {i}: {m['action']}({m['action_input']}) => {m['observation'][:100]}..." for i, m in enumerate(self.history) ) reflection_prompt = f""" Ты - умный ассистент, который помогает AI агенту исправлять ошибки в вызовах инструментов (tools) История вызовов: {history} Твоя задача: проанализируй историю вызов, передаваемые аргументы и ошибки. Определи из за чего возникла ошибка и как ее исправить. Отвечай кратко. """ return self.llm.invoke(reflection_prompt).contentbuild_reflection_prompt
После создания подсказки для решения задачи, ее необходимо передать в prompt, с помощью которого модель сможет сгенерировать адаптированный ответ.
Замечание: Подразумевается, что модель уже знает, какой инструмент выбирать (это последний вызов, который завершился с ошибкой). В конце промпта обязательно нужно добавить предложение о формате выходных данных.
Если вы уже запутались, то ничего страшного. Все станет понятно после того, как вы увидите адаптацию к ошибке.
def _build_reflection_prompt(self, task: str, reflection: str) -> str: """Строит промпт с учетом рефлексии""" history = "\n".join( f"""Iteration {i}: Thought: {m['thought']} Action: {m['action']} ActionInput: {m['action_input']} Observation: {m['observation'][:200]}... """ for i, m in enumerate(self.history) ) return f""" Ты - умный ассистент, который исправляет ошибки вызовов инструментов в формате JSON. Рекомендации по устранению ошибок: {reflection} Предыдущие действия: {history} Твоя задача: используя историю вызов инструментов и рекомендации по усранению ошибки, реши задачу: {task} Сохраняй тот же формат вывода что и в истории вызовов инструментов. Не пиши никаких дополнительных пояснений кроме исправленных ошибок в вызове инструментов. Отвечай строго в формате JSON начиная с фигурных скобок. Размышляй шаг за шагом. """build_prompt
В нем мы формируем наш главный prompt запрос, который будет передаваться на первом шаге и на последующих шагах, которые не требуют обработки ошибок. Обратите внимание на структуру запроса и последовательность абзацев.
Замечание: в промпте мы явно указываем, когда нужно заканчивать работу и выбирать FINISH.
def _build_prompt(self, task: str) -> str: """Строит начальный промпт""" history = "\n".join( [ f"iteration: {d['iteration']}. thought: {d['thought']}. action: {d['action']}. action_input: {str(d['action_input'])} observation: {d['observation']}" for d in self.history ] ) if self.history else "Нет истории" return f""" Ты - умный ассистент, который помогает решаить задачу пользователя. Ты должен выбрать из доступынх инструментов или написать FINISH, если задача решена **Задача** {task} **Твоя история вызова инструментов и результаты вызовов**: {history} **Достпные инструменты** {self.tool_desc} **Инструкции**: -проанализируй задачу -проанлизируй историю -выбери подходящий инструмент или FINISH, если задача была выполнена в истории. -обязательно проанализируй вызовы, которые ты делал раньше -если в истории ты уже вызывал инструмент с такими аргументами и инструмент был выполнен успешно, то не вызывай его снова. Переходи к следующему инструменту или к FINISH. -если ты выбераешь FINISH то action_input: "" **Ответ в формате JSON**: {{ "action": "имя_инструмента", "action_input": {{ "arg1": "значение", "arg2": "значение" }}, "thought": "обоснование выбора инструмента" }} Верни только ответ сторого в формате JSON со всеми заполненными полями. Не добавляй других слов и комментариев """parse_response
Он не отличается от ReAct агента
def _parse_response(self, response: str) -> tuple: """Парсит ответ LLM""" data = json.loads(response.strip()) return data["thought"], data["action"], data["action_input"]store_memory
Метод, который будет сохранять историю вызовов инструментов.
def _store_memory(self, thought: str, action: str, action_input: str, observation: str): """Сохраняет информацию в память агента""" self.history.append({ 'iteration': self.iteration, 'thought': thought, 'action': action, 'action_input': action_input, 'observation': observation })Два дополнительных мелких метода для уменьшения кода в run.
handle_finish
def _handle_finish(self, result: str) -> str: """Обрабатывает завершение задачи""" print(f"Выполнение задачи завершено") return resulthandle_max_iterations_reached
def _handle_max_iterations_reached(self) -> str: """Обрабатывает достижение максимального числа итераций""" last_observation = self.history[-1]['observation'] if self.history else "No actions taken" return f"Max iterations reached. Last state: {last_observation}"Мы написали реализацию всех необходимых методов. Пришло время главного вызова.
run
Логика работы:
-
Создать начальный prompt
-
Получить ответ от модели с выбранным инструментом
-
Распарсить ответ
-
Если действие != FINISH, вызвать инструмент
-
Сохранить вызов инструмента и результат
-
Проверь, нужна ли работа над ошибками
-
Перейти к шагу 2
def run(self, task: str) -> str: prompt = self._build_prompt(task) while self.iteration < self.max_iterations: response = self.llm.invoke(prompt) thought, action, action_input = self._parse_response(response.content) if action == "FINISH": return self._handle_finish(action_input) observation = self._execute_action(action, action_input) self._store_memory(thought, action, action_input, observation) if self._needs_reflection(): reflection = self._perform_reflection() prompt = self._build_reflection_prompt(task, reflection) else: prompt = self._build_prompt(task) self.iteration += 1 return self._handle_max_iterations_reached()При успешном вызове инструментов, его работа не будет отличаться от работы ReAct агента, поэтому я не буду приводить результат работы. Вместо этого я создам искусственную ошибку , изменив название одного из входных аргументов инструмента: email -> user_email.
INIT PROMPT Ты - умный ассистент, который помогает решаить задачу пользователя. Ты должен выбрать из доступынх инструментов или написать FINISH, если задача решена **Задача** Зарегистрируй пользователя Ivan с email ivan@test.com **Твоя история вызова инструментов и результаты вызовов**: Нет истории **Достпные инструменты** ['register_user - Регистрация пользователя в системе\n username: Логин (обязательный)\n email: Email (обязательный)\n phone: Номер телефона в формате +7XXX... (опциональный)', 'search_db - Ищет данные пользователей в базе\n username: Логин/имя пользователя (обязательный)\n limit: Лимит результатов (опциональный)', 'FINISH - выбери для завершения работы, если задача выполнена'] **Инструкции**: -проанализируй задачу -проанлизируй историю -выбери подходящий инструмент или FINISH, если задача была выполнена в истории. -обязательно проанализируй вызовы, которые ты делал раньше -если в истории ты уже вызывал инструмент с такими аргументами и инструмент был выполнен успешно, то не вызывай его снова. Переходи к следующему инструменту или к FINISH. -если ты выбераешь FINISH то action_input: "" **Ответ в формате JSON**: { "action": "имя_инструмента", "action_input": { "arg1": "значение", "arg2": "значение" }, "thought": "обоснование выбора инструмента" } Верни только ответ сторого в формате JSON со всеми заполненными полями. Не добавляй других слов и комментариев RESPONSE content='{\n "action": "register_user",\n "action_input": {\n "username": "Ivan",\n "email": "ivan@test.com"\n },\n "thought": "Пользователь хочет зарегистрироваться с именем Иван и указанным емейлом. Используем инструмент регистрации."\n}' additional_kwargs={} response_metadata={'token_usage': {'prompt_tokens': 394, 'completion_tokens': 59, 'total_tokens': 453, 'precached_prompt_tokens': 3}, 'model_name': 'GigaChat-2-Max:2.0.28.2', 'x_headers': {'x-request-id': 'e1509dc9-13c6-4c97-b84d-31e363a80243', 'x-session-id': '5fb1ce37-f276-4ab1-a5cb-4110b43903a5', 'x-client-id': None}, 'finish_reason': 'stop'} id='e1509dc9-13c6-4c97-b84d-31e363a80243' usage_metadata={'output_tokens': 59, 'input_tokens': 394, 'total_tokens': 453, 'input_token_details': {'cache_read': 3}} { "action": "register_user", "action_input": { "username": "Ivan", "email": "ivan@test.com" }, "thought": "Пользователь хочет зарегистрироваться с именем Иван и указанным емейлом. Используем инструмент регистрации." }Пытаемся вызвать инструмент и получаем ошибку:
[Action Log] Iteration: 0 Tool: register_user Input: {'username': 'Ivan', 'email': 'ivan@test.com'} Result: Ошибка : неожиданное название аргумента email. Достпуные аргументы: user_email, username...Проводим анализ ошибки:
REFLECTION Ошибка возникла из-за неправильного названия аргумента `email`, нужно использовать доступный аргумент `user_email`. Исправленный вызов: ```python register_user({'username': 'Ivan', 'user_email': 'ivan@test.com'}) ```Создаем новый prompt с подсказкой по исправлению:
PROMPT AFTER REFLECTION Ты - умный ассистент, который исправляет ошибки вызовов инструментов в формате JSON. Рекомендации по устранению ошибок: Ошибка возникла из-за неправильного названия аргумента `email`, нужно использовать доступный аргумент `user_email`. Исправленный вызов: ```python register_user({'username': 'Ivan', 'user_email': 'ivan@test.com'}) ``` Предыдущие действия: Iteration 0: Thought: Пользователь хочет зарегистрироваться с именем Иван и указанным емейлом. Используем инструмент регистрации. Action: register_user ActionInput: {'username': 'Ivan', 'email': 'ivan@test.com'} Observation: Ошибка : неожиданное название аргумента email. Достпуные аргументы: user_email, username... Твоя задача: используя историю вызов инструментов и рекомендации по усранению ошибки, реши задачу: Зарегистрируй пользователя Ivan с email ivan@test.com Сохраняй тот же формат вывода что и в истории вызовов инструментов. Не пиши никаких дополнительных пояснений кроме исправленных ошибок в вызове инструментов. Отвечай строго в формате JSON начиная с фигурных скобок. Размышляй шаг за шагом. Получаем новый результат с обновленным названием для аргумента email:
RESPONSE content='{\n "thought": "Пользователь хочет зарегистрироваться с именем Иван и указанным емейлом. Используем инструмент регистрации с правильным названием аргумента.",\n "action": "register_user",\n "action_input": {"username": "Ivan", "user_email": "ivan@test.com"}\n}' additional_kwargs={} response_metadata={'token_usage': {'prompt_tokens': 264, 'completion_tokens': 60, 'total_tokens': 324, 'precached_prompt_tokens': 3}, 'model_name': 'GigaChat-2-Max:2.0.28.2', 'x_headers': {'x-request-id': 'af90213d-6751-4ced-980c-9f9a26de140d', 'x-session-id': 'b104631f-f553-4ff6-8200-2e1d7bd9ed27', 'x-client-id': None}, 'finish_reason': 'stop'} id='af90213d-6751-4ced-980c-9f9a26de140d' usage_metadata={'output_tokens': 60, 'input_tokens': 264, 'total_tokens': 324, 'input_token_details': {'cache_read': 3}} RESPONSE IN PARSE { "thought": "Пользователь хочет зарегистрироваться с именем Иван и указанным емейлом. Используем инструмент регистрации с правильным названием аргумента.", "action": "register_user", "action_input": {"username": "Ivan", "user_email": "ivan@test.com"} }Конечно, это игрушечный пример, но если такой подходит позволит адаптироваться и к сильному изменению входной схеме аргументов.
Заключение
С каждым месяцем появляется все больше архитектур проектирования агентных систем, но представленные выше (особенно ReAct) являются наиболее часто используемыми. И снова повторюсь, вы можете реализовывать свою логику. Возможно, она даже станет общепризнанной в AI сообществе.
Если вам понравилась статья, оставьте комментарий и поделитесь своим опытом. Где искать код с подробным описанием, вы знаете)
Спасибо за прочтение!
ссылка на оригинал статьи https://habr.com/ru/articles/933372/
Добавить комментарий