ИИ-агент
Возможно, вы привыкли к такому взаимодействию: вы задаёте вопрос, а ИИ даёт ответ.
-
Вы просите его написать статью, и он пишет статью.
-
Вы просите его перевести предложение, и он переводит предложение.
В этом режиме ИИ больше похож на консультанта — он даёт советы, но не выполняет действия напрямую.
Но что, если задача немного сложнее? Например: помоги мне узнать завтрашнюю погоду в Пекине. Если температура превышает 25 градусов, порекомендуй рубашку с короткими рукавами в пределах бюджета 300 юаней, затем оформи результаты в электронное письмо и отправь его моему начальнику.
С обычным диалоговым ИИ вам приходится разбивать задачу на несколько шагов:
-
Шаг 1: Узнать завтрашнюю погоду в Пекине.
-
Шаг 2: Если она превышает 25 градусов, порекомендовать рубашку с короткими рукавами в пределах 300 юаней.
-
Шаг 3: Напишите электронное письмо моему начальнику с содержанием ...
На каждом шаге вам нужно вручную продвигаться дальше.
иИИ-агентИдея в том, что вы просто один раз говорите «помоги мне сделать это», и он сам справится со всем остальным.
Он автоматически определит, что нужно сделать, какие инструменты вызвать, в каком порядке их выполнять и как адаптироваться при возникновении проблем, пока задача не будет завершена.

Простое объяснение: обычная LLM — это стратег, который даёт вам советы; ИИ-агент — это исполнитель, который берёт цель и сам добивается её выполнения.
Что такое ИИ-агент?
ИИ-агент — это автономная система, которая может воспринимать окружающую среду, принимать решения и совершать действия.
Более академичное определение таково:Агент — это сущность, находящаяся в среде; он воспринимает среду через датчики и воздействует на среду через исполнительные механизмы для достижения набора целей.。
Это определение звучит немного абстрактно, поэтому давайте разберём его простыми словами.
Агент против обычной LLM
Сначала взгляните на таблицу сравнения:
| Характеристика | Обычная LLM | ИИ-агент |
|---|---|---|
| Режим взаимодействия | Вопросы и ответы, управляется пользователем | Автономное выполнение, управляемое целью |
| Граница возможностей | Только встроенные возможности модели | Может расширять возможности с помощью инструментов |
| Память | Контекст беседы (ограничен) | Краткосрочная + долгосрочная память |
| Планирование | Нет (или требуется руководство пользователя) | Автономная декомпозиция и планирование задач |
| Цикл обратной связи | Нет (однократная генерация) | Цикл «наблюдение — обдумывание — действие» |
Возьмём конкретный пример: «Помоги мне забронировать рейс из Шанхая в Пекин на завтра, с ценой ниже 1,500 юаней».
Обычная LLM может ответить: «Хорошо, я могу написать вам фрагмент кода для запроса цен на авиабилеты или подсказать, какой сайт проверить». Но она не будет на самом деле искать рейсы, не говоря уже о том, чтобы забронировать билет за вас.
А квалифицированный агент, напротив, будет:
-
1. Понять цель: забронировать авиабилет из Шанхая в Пекин на завтра, дешевле 1,500 yuan.
-
2. Определить действие: мне нужно вызвать API запроса рейсов.
-
3. Выполнить действие: вызвать API и получить список рейсов.
-
4. Наблюдать результаты: получено 10 рейсов, 3 из которых дешевле 1,500 yuan.
-
5. Подумать ещё раз: какой выбрать? Возможно, нужно проверить время вылета и прилёта или спросить у пользователя предпочтения.
-
6. Продолжить действовать: возможно, вызвать другой API, чтобы проверить показатели пунктуальности, или сразу порекомендовать варианты пользователю.
-
7. Завершить задачу: помочь пользователю зафиксировать место и сгенерировать ссылку на заказ.
Видите разницу?Обычная LLM даёт вам ответы; агент даёт вам результаты.。
Ключевые возможности агента
Полноценный агент обычно обладает следующими тремя ключевыми возможностями:
| Способность | Описание | Аналогия |
|---|---|---|
| Восприятие | Получение информации об окружающей среде и обратной связи | Глаза, уши |
| Принятие решений | Обдумывание того, что делать и как это делать | Мозг |
| Действие | Выполнение конкретных операций | Руки, ноги |
-
Восприятиеозначает, что агент может видеть, что происходит. Например, пользователь отправляет сообщение, API возвращает результат или в файловую систему добавляется новый файл — всё это входные данные восприятия.
-
Принятие решенийозначает, что агент решает, что делать дальше, на основе воспринятой информации. Ответить пользователю напрямую? Нужно ли вызывать инструмент? Нужно ли разбить большую задачу на более мелкие подзадачи? Всё это решения.
-
Действиеозначает, что агент фактически выполняет решения. Вызов API поиска, чтение файла, отправка электронного письма, работа с базой данных — всё это действия.
Базовая архитектура агента
Теперь давайте рассмотрим стандартный «пазл из четырёх частей» агента: мозг, инструменты, память и планирование.
Сначала давайте посмотрим на схему архитектуры:
Мозг: LLM как ядро рассуждений
Мозг агента — это обычно большая языковая модель, такая как GPT-4, Claude, Llama и т. д.
Эта LLM отвечает за:
-
1. Понимание намерения пользователя: когда пользователь говорит «помоги мне забронировать билет», чего он на самом деле хочет?
-
2. Принятие решений: что мне делать дальше?
-
3. Генерация параметров вызова инструментов: какие параметры нужны, чтобы вызвать API запроса рейсов?
-
4. Организация финального ответа: теперь, когда собрано достаточно информации, как дать пользователю чёткое резюме?
LLM — это ядро агента, но не всё — подобно тому, как человеческий мозг важен, но всё равно нужны руки и ноги, чтобы выполнять задачи.
Инструменты: расширение границ возможностей ИИ
Нативные LLM имеют два очевидных ограничения:
-
1. Отсечение знаний: она не знает, что произошло после завершения обучения.
-
2. Нет возможности взаимодействия: он не может напрямую читать файлы, обращаться к базам данных или вызывать API.
Инструменты предназначены для решения этих проблем.
Распространённые типы инструментов:
| Тип инструмента | Функция | Пример |
|---|---|---|
| Инструменты поиска | Получение актуальной информации | Google Search、Bing Search |
| Инструменты вычислений | Выполнение математических операций | Калькулятор, Wolfram Alpha |
| Операции с файлами | Чтение/запись локальных файлов | Чтение PDF, запись CSV |
| Вызовы API | Взаимодействие с внешними системами | Бронирование авиабилетов, отправка электронных писем, проверка погоды |
| Запросы к базе данных | Хранение и извлечение структурированных данных | SQL-запросы, векторный поиск |
| Выполнение кода | Запуск кода для решения задач | Python REPL, Jupyter |
Наделение агента инструментами — это как снабдить человека компьютером: он мгновенно переходит от способности только думать к способности действовать.
Память: краткосрочная vs. долговременная память
LLM по своей природе страдают амнезией — каждый разговор начинается с чистого листа, если только вы не впихнёте в него контекст.
И Агенту нужно помнить многое:
Кратковременная память: Что только что сказал пользователь? Какой инструмент я вызвал на последнем шаге? Какой результат я получил?
-
Долговременная память: Каковы предпочтения пользователя? Как обрабатывались похожие задачи в прошлом? Какие уроки были извлечены?
Распространённые подходы к реализации систем памяти:
| Тип памяти | Хранимое содержимое | Метод реализации |
|---|---|---|
| Кратковременная память | История диалога и промежуточные шаги текущей сессии | Напрямую помещается в контекстное окно LLM |
| Долговременная память | Предпочтения пользователя, исторические задачи, документы знаний | Векторная база данных + поиск по сходству |
| Сводная память | Сжатые исторические сводки | Периодически поручать LLM генерировать сводки |
Хорошая система памяти может заставить Агента казаться помнящим вас, а не вести себя так, будто он знакомится с вами впервые каждый раз.
Планирование: декомпозиция задач
Сложные задачи не выполняются за один шаг; Агент должен уметь разбивать большую цель на более мелкие шаги.
Например: помоги мне спланировать день рождения для 10 человек.
Агент мог бы спланировать это так:
-
1. Сначала уточнить: какой бюджет? Когда это? Где это? Какие предпочтения у виновника торжества?
-
2. Затем: найти ближайшие площадки.
-
3. Далее: разработать меню.
-
4. После этого: составьте список покупок.
-
5. Наконец: создайте расписание.
Распространённые стратегии планирования:
-
Chain-of-Thought: продумайте шаг за шагом — что делать сначала, что делать дальше.
-
Tree-of-Thought: рассматривайте несколько возможных путей одновременно и выберите оптимальный.
-
Reflection: после завершения шага оглянитесь назад и проверьте, есть ли проблемы и нужны ли корректировки.
Использование инструментов / Вызов функций
Вызов инструментов — самая фундаментальная и важная возможность агента.
Давайте начнём с объяснения, что это такое.
Что такое Function Calling?
Проще говоря:Function Calling — это когда LLM выводит структурированный JSON, сообщая, какую функцию она хочет вызвать и какие параметры передать.。
Дело не в том, что LLM на самом деле выполняет функцию — она лишь сообщает, что хочет её вызвать, а выполнение по-прежнему остаётся за вами.
Весь процесс обычно выглядит так:
-
1. Вы говорите LLM: "Вот некоторые функции, которые вы можете вызывать. Имя каждой функции, её параметры и назначение..."
-
2. Пользователь отправляет сообщение: "Помоги мне проверить завтрашнюю погоду в Пекине."
-
3. LLM отвечает: "Я хочу вызвать функцию get_weather с параметрами city='Beijing', date='tomorrow'."
-
4. Вы вызываете функцию (фактически запрашивая API погоды) и получаете результат.
-
5. Вы передаёте результат обратно в LLM: "Предыдущий вызов функции вернул: температура 25 градусов, солнечно."
-
6. На основе этого результата LLM даёт пользователю ответ на естественном языке: "В Пекине завтра будет солнечно, 25 градусов, очень комфортно."
Видите? LLM думает, а вы исполняете.
Определение JSON Schema инструмента
Чтобы LLM могла вызывать инструменты, сначала нужно рассказать ей, какие инструменты доступны.
Этот процесс информирования заключается в описании функций с помощью JSON Schema.
Рассмотрим стандартный формат определения функции:
Пример
tool_definition = {
"type": "function",
"function": {
"name": "get_weather", # Имя функции
"description": "Запросить погоду для указанного города на указанную дату", # Описание назначения функции; LLM будет смотреть на это
"parameters": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "Название города, например, 'Пекин', 'Шанхай', 'Шэньчжэнь'",
},
"date": {
"type": "string",
"description": "Дата в формате YYYY-MM-DD, например, '2024-06-18'",
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Единица измерения температуры, Celsius или Fahrenheit, по умолчанию Celsius",
},
},
"required": ["city", "date"], # Обязательные параметры
},
},
}
# Другой инструмент: Search
search_tool = {
"type": "function",
"function": {
"name": "web_search",
"description": "Поиск в интернете последней информации, подходит для проверки новостей, данных в реальном времени и неизвестных знаний",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Ключевое слово или вопрос для поиска",
},
"num_results": {
"type": "integer",
"description": "Количество возвращаемых результатов, по умолчанию 5",
"default": 5,
},
},
"required": ["query"],
},
},
}
# Ещё один инструмент: Калькулятор
calculator_tool = {
"type": "function",
"function": {
"name": "calculate",
"description": "Выполняет математические вычисления, поддерживает сложение, вычитание, умножение, деление, возведение в степень и т. д.",
"parameters": {
"type": "object",
"properties": {
"expression": {
"type": "string",
"description": "Математическое выражение, например, '25 * 4 + 10', 'sqrt(16)'",
},
},
"required": ["expression"],
},
},
}
print(fОпределено {len([tool_definition, search_tool, calculator_tool])} инструментов: get_weather, web_search, calculate)
# Вывод: Определено 3 инструмента: get_weather, web_search, calculate
Ключевые моменты:
-
описание очень важно — LLM полагается на это описание, чтобы понять, что делает инструмент и когда его использовать.
-
Параметры также должны быть описаны чётко — например, если unit имеет ограничение enum, LLM знает, что может выбрать только из этих двух значений.
-
required обозначает обязательные поля — LLM будет следить за тем, чтобы эти параметры всегда имели значения.
Практический код: добавление инструментов поиска и вычислений в ИИ
Теперь давайте напишем полный, исполняемый пример.
Для демонстрации мы используем Python, чтобы смоделировать полный поток Function Calling.
Пример
# Упрощённая демонстрация вызова инструмента Agent
# Настоящий API-ключ не нужен, демонстрация с фиктивными данными
# ============================================
import json
import random
from typing import Dict, Any, List, Optional
class SimpleAgent:
"""Простой демонстрационный класс Agent"""
def __init__(self):
# Регистрация доступных инструментов
self.tools = self._define_tools()
# История разговора (память)
self.messages: List[Dict] = []
def _define_tools(self) -> List[Dict]:
"""Определить все доступные инструменты"""
return [
{
"name": "web_search",
"description": "Поиск в интернете последней информации",
"parameters": {
"query": {"type": "string", "description": "Ключевое слово для поиска"},
},
"required": ["query"],
},
{
"name": "calculate",
"description": "Выполнить математические вычисления",
"parameters": {
"expression": {"type": "string", "description": "Математическое выражение"},
},
"required": ["expression"],
},
{
"name": "get_weather",
"description": "Запрос погоды",
"parameters": {
"city": {"type": "string", "description": "Название города"},
"date": {"type": "string", "description": "Дата"},
},
"required": ["city", "date"],
},
]
def _call_tool(self, tool_name: str, parameters: Dict[str, Any]) -> str:
"""(Имитация) Вызвать инструмент и вернуть результат"""
print(f" [Вызов инструмента] {tool_name}({parameters})")
if tool_name == "web_search":
query = parameters["query"]
# Имитированный результат поиска
results = {
"example": Пример (Rookie Tutorial) — это сайт для изучения программирования, который предоставляет большое количество учебных пособий и примеров по программированию.,
"Погода в Пекине 18 июня 2024 года": "Пекин 2024-06-18: Солнечно, 25°C, влажность 45%.",
"Население Шанхая": "Постоянное население Шанхая в 2024 году составляет примерно 24.89 млн.",
}
return results.get(query, f"Результаты поиска: Точная информация по запросу '{query}' не найдена, это имитированный результат.")
elif tool_name == "calculate":
expr = parameters["expression"]
try:
# Примечание: не используйте eval в продакшене; это только для демонстрации
result = eval(expr, {"__builtins__": None}, {
"sqrt": lambda x: x**0.5,
"pow": pow,
})
return f"Результат вычисления: {expr} = {result}"
except Exception as e:
return f"Ошибка вычисления: {e}"
elif tool_name == "get_weather":
city = parameters["city"]
date = parameters["date"]
# Имитированные данные о погоде
weathers = ["Солнечно", "Облачно", "Небольшой дождь", "Пасмурно"]
temp = random.randint(15, 35)
return f"{city} {date}:{random.choice(weathers)},{temp}°C"
else:
return f"Неизвестный инструмент: {tool_name}"
def _decide_action(self, user_input: str) -> Dict[str, Any]:
"""
(Симулированный) процесс принятия решений LLM
В реальном проекте именно здесь вызывался бы настоящий LLM API
"""
# Здесь для имитации используются простые правила; в реальных сценариях следует использовать LLM
if "Search" in user_input or "Look up" in user_input or "What is" in user_input:
# Извлечь поисковый запрос (простая имитация)
query = user_input.replace("Search", "").replace("Найди", "").replace("Что такое", "").strip()
if not query:
query = "пример"
return {
"action": "call_tool",
"tool": "web_search",
"parameters": {"query": query},
}
elif "Вычисли" in user_input or "равно" in user_input:
# Извлечь выражение (простая симуляция)
return {
"action": "call_tool",
"tool": "calculate",
"parameters": {"expression": "25 * 4 + 10"}, # Пример фиксированных значений
}
elif "погода" in user_input:
return {
"action": "call_tool",
"tool": "get_weather",
"parameters": {"city": "Пекин", "date": "2024-06-18"},
}
else:
return {
"action": "respond",
"content": "Хорошо, позвольте мне помочь вам с этим." + user_input,
}
def run(self, user_input: str) -> str:
"""Запустить агента для обработки пользовательского ввода"""
print(f"[Ввод пользователя] {user_input}")
self.messages.append({"role": "user", "content": user_input})
# Шаг 1: Решить, что делать
decision = self._decide_action(user_input)
if decision["action"] == "call_tool":
# Шаг 2: Вызов инструмента
tool_result = self._call_tool(decision["tool"], decision["parameters"])
self.messages.append({"role": "tool", "content": tool_result})
# Шаг 3: Сгенерировать итоговый ответ на основе результата инструмента
# (Здесь просто конкатенация; в реальности LLM должна сгенерировать это)
final_response = f"На основе моего запроса: {tool_result}\n\nНадеюсь, эта информация будет вам полезна!"
self.messages.append({"role": "assistant", "content": final_response})
return final_response
else:
# Ответить напрямую
self.messages.append({"role": "assistant", "content": decision["content"]})
return decision["content"]
# ============================================
# Тестирование этого агента
# ============================================
agent = SimpleAgent()
print("=" * 60)
response1 = agent.run("Найди, что такое пример")
print(f"[Ответ агента]\n{response1}")
print("\n" + "=" * 60)
response2 = agent.run("Помоги мне проверить погоду в Пекине на 2024-06-18")
print(f"[Ответ агента]\n{response2}")
print("\n" + "=" * 60)
response3 = agent.run("Вычисли, чему равно 25 * 4 + 10")
print(f"[Ответ агента]\n{response3}")
Хотя этот пример прост, он демонстрирует полный замкнутый цикл вызова функций:
Понять → Решить → Вызвать инструмент → Наблюдать результат → Сгенерировать ответ.
В реальном проекте,_decide_actionэтот шаг был бы заменён реальным вызовом LLM, позволяя модели решить, какой инструмент использовать и какие параметры передать.
Цикл планирования ReAct
Когда возможности вызова инструментов уже реализованы, следующий вопрос: когда останавливаться?
Простые задачи можно выполнить за один шаг, но сложные задачи часто требуют нескольких раундов итераций.
Именно эту проблему призван решить фреймворк ReAct.
Мысль → Действие → Наблюдение
Название ReAct происходит от сочетания слов Reasoning и Acting.
Его основная идея проста: позволить Агенту, как человеку, подумать один шаг, сделать один шаг, понаблюдать, а затем повторять этот цикл, пока задача не будет выполнена.
Давайте посмотрим на блок-схему:

Каждый цикл состоит из трёх шагов:
| Шаг | Английский | Что он делает |
|---|---|---|
| Мысль | Мысль | Что мне нужно сделать сейчас? Почему? |
| Действие | Действие | Вызвать инструмент для выполнения конкретной операции |
| Наблюдение | Наблюдение | Записать результат действия |
Затем вернитесь к этапу «Мысль» — на основе наблюдаемых результатов решите, что делать дальше.
Этот цикл продолжается, пока Агент не определит, что задача выполнена; тогда он выходит из цикла и выдаёт итоговый ответ.
Давайте рассмотрим конкретный пример, чтобы увидеть, как работает ReAct:
-
Вопрос пользователя: В каком году была основана SpaceX? Как называлась её первая ракета, успешно достигшая орбиты?
-
Мысль 1: Мне нужно найти год основания SpaceX и модель её самой ранней ракеты, совершившей орбитальный запуск. Эта информация может быть из разных источников, поэтому лучше искать по ключевым словам, охватывающим оба вопроса сразу.
-
Действие 1: Вызвать web_search с запросом "SpaceX founding time first orbital rocket".
-
Наблюдение 1: Сводка результатов поиска показывает: "SpaceX (Space Exploration Technologies Corp.) была основана в 2002 году Илоном Маском. Её первой ракетой, успешно вышедшей на орбиту Земли, была Falcon 1, которая добилась успеха в четвёртом испытательном полёте 28 сентября 2008 года." (Информация полная и охватывает оба подвопроса.)
-
Мысль 2: Результаты поиска уже дают как год основания (2002), так и первую орбитальную ракету (Falcon 1). Неоднозначности нет, и информация заслуживает доверия. Дополнительный поиск не нужен.
-
Итоговый ответ: SpaceX была основана в 2002 году, а её первой ракетой, успешно достигшей орбиты, была Falcon 1, которая достигла этого рубежа 28 сентября 2008 года.
-
Примечание: Видите? Каждый шаг имеет чёткие "Мысль", "Действие" и "Наблюдение", а Агент сам решает, когда остановиться — здесь потребовался только 1 раунд действий, чтобы собрать всю нужную информацию, поэтому он перешёл сразу к итоговому ответу без лишних циклов.
Условия завершения цикла
Цикл ReAct не может выполняться бесконечно; ему нужно условие завершения.
Общие условия завершения:
| Условие завершения | Описание | Пример |
|---|---|---|
| Задача выполнена | Агент определяет, что собрано достаточно информации для ответа на вопрос пользователя. | Я нашёл ответ, теперь я могу ответить. |
| Достигнуто максимальное количество шагов. | Чтобы предотвратить бесконечные циклы, задайте максимальное количество раундов (например, 10 шагов). | Уже выполнено 10 итераций, принудительная остановка. |
| Прерывание пользователем | Пользователь по своей инициативе говорит "стоп" или "достаточно". | Проверять не нужно, я знаю. |
| Неизбежная неудача. | Агент считает, что эту задачу невозможно выполнить. | Я искал несколько раз, но не смог найти релевантную информацию. |
При проектировании Агента обязательно предусмотрите предохранительный клапан «максимальное количество шагов» — иначе он может зациклиться и никогда не остановиться.
Проектирование системы памяти
Когда агент работает долго, он сталкивается с проблемой: контекстное окно не может вместить всю историю разговора.
В этот момент нужна хорошая система памяти.
История разговора: кратковременная память
Самая простая память — полностью сохранять историю разговора.
Каждый раз все предыдущие сообщения загружаются в LLM, чтобы она могла помнить, что только что произошло.
Но у этого подхода есть очевидный недостаток: контекстное окно LLM ограничено.
Например, у GPT-4 — 8K или 32K, а у Claude — 200K; хотя это и много, но всё равно не бесконечно.
Пока разговор короткий, всё нормально, но как только он становится очень длинным или каждый раунд вызовов инструментов возвращает много содержимого, место быстро заканчивается.
Векторная база данных: долговременная память
Когда нужно помнить слишком много, а контекст не может это вместить, обычное решение таково:хранить воспоминания в векторной базе данных и «извлекать» нужные, когда они понадобятся.。
Этот подход называется RAG (Retrieval-Augmented Generation), и он в равной степени применим к Агентам.
Рабочий процесс:
-
Всякий раз, когда создаётся воспоминание (то, что сказал пользователь, результат, возвращённый инструментом, размышления Агента), оно преобразуется в вектор (Embedding).
-
2. Сохраните этот вектор в векторной базе данных.
-
3. Когда Агенту нужно вспомнить, также преобразуйте текущий вопрос в вектор.
-
4. Найдите в векторной базе данных несколько «самых похожих» воспоминаний.
-
5. Поместите в контекст LLM только эти несколько релевантных воспоминаний.
Таким образом, даже если есть десять тысяч исторических воспоминаний, нужно извлечь и использовать только самые релевантные.
Сжатие памяти на основе сводок
Ещё одна схема оптимизации памяти:не хранить полные тексты разговоров; вместо этого большая модель периодически создаёт краткие сводки исторических сессий, и постоянно сохраняются только сводки.。
Исходный длинный диалог:
Пользователь: Помоги мне проверить погоду.
-
Агент: Какой город проверить?
-
Пользователь: Пекин.
-
Агент: Какой день?
-
Пользователь: Завтра.
-
……
Сжатое резюме:
用户需要查询北京明日天气,Agent 先后确认城市与日期,用户明确查询时间为明天。
Этот подход может значительно снизить накладные расходы на токены: полный диалог, изначально занимавший 500 токенов, требует всего лишь резюме размером 50 токенов, чтобы сохранить ключевую информацию.
В продакшн-проектах обычно используют несколько решений совместно, управляя памятью диалога по слоям:
- Последние свежие диалоги: полностью сохраняются, напрямую отправляются в контекст модели;
- Давние исторические диалоги: единообразно создаются резюме, заменяющие исходный текст;
- Долгосрочная ключевая информация: хранится в векторной базе данных, извлекается по требованию.
Популярные фреймворки агентов
Разобравшись в принципах, вы можете написать собственного агента или использовать существующие фреймворки.
Наиболее популярные сейчас:
Агенты LangChain
LangChain в настоящее время — самый популярный фреймворк для разработки LLM-приложений, и в нём есть встроенная система агентов.
Основные концепции:
Агент: мозг, решает, что делать.
Инструменты: список инструментов.
Наборы инструментов: комплекты инструментов (например, объединение нескольких инструментов для работы с базами данных).
AgentExecutor: исполнитель, отвечающий за запуск цикла ReAct.
Преимущество LangChain — богатая экосистема: множество готовых интеграций инструментов, работающих из коробки.
Недостаток в том, что иногда он кажется немного тяжёлым, с множеством слоёв абстракции, что затрудняет отладку при возникновении проблем.
Агенты LlamaIndex
LlamaIndex (ранее назывался GPT Index) больше ориентирован на подключение данных — подключение ваших приватных данных (документов, баз данных, API) к LLM.
Сильные стороны его агента:
-
1. Запросы к структурированным и неструктурированным данным.
-
2. Маршрутизация между несколькими источниками данных.
-
3. Ответы на вопросы по документам (RAG).
Если вашему агенту нужно много работать с "вашими данными", LlamaIndex — хороший выбор.
Принципы AutoGPT
AutoGPT — это проект, ставший популярным в начале 2023 года, и его характерная черта — полная автономность.
Вы даёте ему большую цель (например, "помоги мне создать сайт"), и он сам:
-
1. Составляет список задач.
-
2. Выполняет задачи.
-
3. Проводит саморефлексию.
-
4. Корректирует план.
-
5. Продолжайте двигаться вперёд.
AutoGPT впервые позволил многим людям увидеть силу «автономных агентов», но также выявил множество проблем с агентами:
Он часто продолжает работать в неправильном направлении и не останавливает потери вовремя.
Он склонен попадать в бесконечные циклы и повторять одни и те же действия.
Высокая стоимость — один запуск может потребовать десятки долларов на комиссии за API.
Но AutoGPT очень показателен как доказательство концепции.
Мультиагентный CrewAI
То, о чём мы только что говорили, — это одиночные агенты, тогда как подход CrewAI состоит в следующем: позволить нескольким агентам объединиться в команду и взаимодействовать.
Например, вы можете определить:
Агент-продакт-менеджер: отвечает за понимание требований и написание PRD.
Агент-инженер: отвечает за написание кода.
Агент-ревьюер: отвечает за код-ревью и предоставление обратной связи.
Затем позвольте им сотрудничать как настоящая команда — обсуждать друг с другом, распределять задачи и выдавать результаты.
Мультиагентный подход — очень перспективное направление: один агент может ошибаться, но несколько агентов могут исправлять друг друга и дополнять друг друга.
Практическое занятие: создание агента автоматического сбора информации
Теперь давайте объединим ранее полученные знания и напишем по-настоящему рабочего агента.
Агент, которого мы собираемся сделать, называетсяexample-researcher— дайте ему тему, и он автоматически выполнит поиск, систематизирует и сгенерирует исследовательский отчёт.
Пример
# Практика: Агент автоматического сбора информации
# ============================================
import json
import time
from typing import Dict, Any, List
class ResearchAgent:
"""
Простой агент, ориентированный на исследования:
Получив тему, автоматически ищет соответствующую информацию и систематизирует её в отчёт
"""
def __init__(self, max_steps: int = 5):
self.max_steps = max_steps
self.memory: List[Dict] = [] # Память
self.known_facts: List[str] = [] # Собранные факты
self.queries_used: List[str] = [] # Использованные поисковые запросы
def _search_web(self, query: str) -> str:
"""(Имитация) веб-поиск"""
print(f" Поиск: {query}")
time.sleep(0.5) # Имитация задержки
# Имитация базы знаний
knowledge_base = {
"Искусственный интеллект": "Искусственный интеллект (ИИ) — это раздел информатики, посвящённый созданию систем, способных выполнять задачи, которые обычно требуют человеческого интеллекта.",
"Машинное обучение": "Машинное обучение — это подмножество искусственного интеллекта, которое позволяет компьютерам учиться на данных без явного программирования.",
"Глубокое обучение": "Глубокое обучение — это подмножество машинного обучения, основанное на многослойных нейронных сетях, особенно хорошо подходящее для обработки неструктурированных данных, таких как изображения и текст.",
"Большая языковая модель": "Большая языковая модель (LLM) — это модель ИИ, основанная на архитектуре Transformer, обученная на огромных объёмах текста и способная понимать и генерировать человеческий язык.",
"Агент": "ИИ-агент — это система, которая может автономно воспринимать окружающую среду, принимать решения и выполнять действия, обычно состоящая из четырёх частей: LLM, инструменты, память и планирование.",
"Transformer": Transformer — это архитектура нейронной сети, предложенная Google в 2017 году, и основа современных LLM, ядром которой является механизм внимания.,
"example": Example (example) был основан в 2013 году и представляет собой веб-сайт, посвящённый обучающим материалам по программированию, предоставляющий учебные ресурсы для нескольких языков программирования.,
}
# Найти наиболее релевантные знания
for key, value in knowledge_base.items():
if key in query:
return value
return fРезультаты поиска для '{query}': Это очень интересная тема, затрагивающая несколько технических областей. (Имитированный результат)
def _think(self, step: int, user_topic: str) -> Dict[str, Any]:
"""
Подумать о том, что делать дальше
(В реальном проекте здесь следует вызвать LLM)
"""
# Простые эвристические правила для имитации процесса мышления
if step == 1:
# Шаг 1: Сначала выполнить поиск по самой теме
return {
"thought": fМне нужно сначала понять базовое определение и предысторию '{user_topic}'.,
"action": "search",
"query": user_topic,
}
elif step == 2:
# Шаг 2: Поиск связанных технологий
return {
"thought": Теперь, когда у меня есть базовое определение, мне нужно найти связанные технологии и концепции.,
"action": "search",
"query": fСвязанные технологии для {user_topic},
}
elif step < self.max_steps:
# Промежуточный шаг: продолжить углубляться
return {
"thought": Позвольте мне поискать больше информации из разных измерений, чтобы сделать отчёт богаче.,
"action": "search",
"query": fСценарии применения для {user_topic},
}
else:
# Финальный шаг: составить отчёт
return {
"thought": Я собрал достаточно информации, и теперь могу составить итоговый отчёт.,
"action": "finish",
}
def _observe(self, action_result: str):
"""Наблюдать за результатами, записывать в память"""
self.known_facts.append(action_result)
self.memory.append({
"role": "observation",
"content": action_result,
})
def _generate_report(self, topic: str) -> str:
"""Сгенерировать отчёт на основе собранной информации"""
report = f"# {topic} Отчёт об исследовании\n\n"
report += f"> Этот отчёт был автоматически сгенерирован example-researcher\n\n"
report += "---\n\n"
report += "## Ключевые моменты\n\n"
for i, fact in enumerate(self.known_facts, 1):
report += f"{i}. {fact}\n\n"
report += "---\n\n"
report += "## Резюме\n\n"
report += f"Выше приведена основная информация, собранная о '{topic}'."
report += "Если вам нужно более глубокое исследование, вы можете дополнительно поискать соответствующие научные статьи или техническую документацию.\n"
return report
def run(self, topic: str) -> str:
"""Запуск Research Agent"""
print(f" example-researcher запущен!")
print(f" Тема исследования: {topic}")
print("-" * 50)
for step in range(1, self.max_steps + 1):
print(f"\nШаг {step} / {self.max_steps} шагов)
# 1. Мысль
decision = self._think(step, topic)
print(f" Мысль: {decision['thought']}")
if decision["action"] == "finish":
print(" Сбор завершён, начинаю составлять отчёт...")
break
# 2. Действие
if decision["action"] == "search":
result = self._search_web(decision["query"])
print(f" Результат: {result[:60]}...")
# 3. Наблюдение
self._observe(result)
# Сгенерировать итоговый отчёт
print("\n" + "-" * 50)
print(" Генерация исследовательского отчёта...")
final_report = self._generate_report(topic)
return final_report
# ============================================
# Попробуйте
# ============================================
agent = ResearchAgent(max_steps=4)
report = agent.run("Agent")
print("\n" + "=" * 50)
print(report)
print("=" * 50)
Хотя этот агент упрощает вызовы LLM (имитируемые с помощью правил), весь рабочий процесс действительно пригоден для использования.
Вам просто нужно_thinkзаменить метод реальными вызовами LLM API, и_search_webзамените его настоящим поисковым API, и он действительно сможет помочь вам проводить исследования.
Ограничения и режимы отказов агентов
AI-агенты мощны, но не всемогущи.
Понимание его ограничений помогает использовать его в правильных сценариях и избегать подводных камней.
Распространённые режимы отказов
1. Неправильный выбор инструмента
Когда пользователь спрашивает о погоде, Агент вызывает поиск; когда пользователь хочет выполнить поиск, Агент вызывает калькулятор.
Такая ошибка очень распространена, особенно когда определения инструментов недостаточно чёткие.
2. Ошибки передачи параметров
Неправильный формат даты, отсутствие обязательных параметров, неверные типы параметров — всё это может привести к сбою вызовов инструментов.
3. Бесконечный цикл
Агент застревает в бесконечном цикле «поиск A → не найдено → снова поиск A → всё ещё не найдено → поиск A ещё раз…»
4. Преждевременная остановка
Прежде чем собрать достаточно информации, Агент решает, что этого "достаточно", и даёт неполный ответ.
5. Галлюцинация
Агент может выдумывать несуществующие инструменты, несуществующие параметры или придумывать фальшивые результаты поиска.
6. Отсутствие здравого смысла
Иногда Агент делает вещи, которые кажутся людям глупыми — например, когда пользователь говорит "забронируй мне рейс на завтра", Агент выясняет, что такое "завтра", но на самом деле ему следует использовать сегодняшнюю дату плюс один день.
Как сделать Агентов более надёжными
Чтобы решить эти проблемы, в индустрии есть несколько часто используемых стратегий смягчения:
| Стратегия | Какую проблему это решает | Как это сделать |
|---|---|---|
| Человек в цикле | Предотвратить уход Агента по неправильному пути | Чтобы люди подтверждали ключевые шаги, а не всё было полностью автономно |
| Более чёткие определения инструментов | Неправильный выбор инструмента | Сделайте описание как можно более подробным и приведите примеры |
| Повторные попытки + отказоустойчивость | Сбой вызова инструмента | Автоматически повторять попытку при сбое или давать LLM чёткую обратную связь об ошибке |
| Обеспечить соблюдение формата вывода | Сбой при разборе параметров | Используйте ограничения JSON Schema или Output Parser |
| Механизм рефлексии | Бесконечный цикл | Пусть агент периодически проверяет: "Не повторяю ли я бесполезную работу?" |
Другие расширенияПрактический совет: не стремитесь к полной автономности с самого начала. Начните с режима human-in-the-loop — агент предлагает, что делать, а человек подтверждает перед выполнением. Когда убедитесь в нём, постепенно делегируйте больше полномочий.