Всем привет! С вами Кирилл Филипенко, сисадмин из Selectel, и сегодня мы погрузимся в тему LLM-агентов. Сейчас об этих самых «агентах» кричат буквально из каждого утюга, поэтому пришло время наконец-то разобраться, что это такое, как они работают и с чем их, собственно, едят. Прыгайте под кат, будет интересно!

LLM агент — это программная система на основе большой языковой модели, способная самостоятельно решать, какие действия предпринимать для достижения поставленной цели. Иными словами, такой агент действует не по жестко запрограммированному сценарию, а сам выбирает последовательность шагов на основе ответа модели. Например, LLM-агент может решить, какой из доступных инструментов ему вызвать, когда выдать ответ или как разбить сложную задачу на простые подзадачи.

В последние годы появились проекты вроде AutoGPT и аналогичные автономные сервисы, которые демонстрируют потенциал LLM-агентов в решении нетривиальных задач. Чтобы понять, как это работает на уровне системы, важно разобраться, из чего состоит подобный агент. Разберем его внутреннюю архитектуру: как он планирует свои действия, как хранит информацию и как использует внешние инструменты.


Используйте навигацию, если не хотите читать текст целиком:
→ Планирование: chain-of-thought, ReAct, tree-of-thoughts
→ Память: краткосрочная и долгосрочная
→ Инструменты и вызов функций (function calling, плагины)
→ Заключение

Планирование: chain-of-thought, ReAct, tree-of-thoughts

Планирование действий — ключевой компонент LLM-агента. Оно позволяет модели разбивать сложные задачи на цепочки рассуждений и шагов. Простой подход — так называемый Chain-of-Thought (CoT) или цепочка мыслей. В рамках него модель побуждают генерировать последовательность промежуточных рассуждений перед финальным ответом. Исследования показали, что формирование явной цепочки рассуждений заметно улучшает способности LLM решать сложные задачи. Например, если попросить модель пошагово объяснить ход решения математической задачи, точность ответа возрастает. Chain-of-Thought prompting фактически заставляет модель планировать: идти к решению не напрямую, а через серию логических шагов.

Однако одна только цепочка мыслей не оставляет агенту возможности действовать во внешней среде. Здесь появляется парадигма ReAct (Reason + Act) — сочетание рассуждений и действий. Архитектура ReAct предполагает, что на каждом шаге агент сначала думает (Reasoning), а затем может выполнить действие (Act), получая обратную связь из окружения. Эти шаги чередуются: мысль → действие → наблюдение → новая мысль и так далее.

Такой цикл продолжается, пока агент не соберет достаточно информации для ответа. Действия могут быть разными — вызов инструмента (поиска, калькулятора или чего-то еще) или просто переход к ответу. Важно, что ReAct объединяет два аспекта: модель разрабатывает план решения в процессе (chain-of-thought) и одновременно применяет действия во внешней среде для сбора данных. Практика показывает, что эта связка заметно эффективнее, чем только рассуждение или только последовательные вызовы инструментов по отдельности. Кроме того, она делает ход решения более прозрачным: в логах агента видно, какие шаги он предпринял. Это улучшает интерпретируемость и упрощает отладку, так как можно увидеть траекторию решения, понятную человеку.


Рассмотрим упрощенный пример ReAct-цикла с использованием фреймворка LangChain. Предположим, у нас есть два инструмента — калькулятор и веб-поиск. Агента попросили: «Посчитай, сколько будет 6 в степени 13, а результат переведи на английский». Ниже приведен фрагмент кода, демонстрирующий настройку такого агента и его работу.

import re
from langchain.agents import Tool, initialize_agent
from langchain.agents.agent_types import AgentType
from langchain_ollama import OllamaLLM
import num2words
# 1. Настройка локальной модели Ollama через langchain-ollama
llm = OllamaLLM(
    model="llama3.1",
    base_url="http://localhost:11434",
    timeout=120
)
def calculator_fn(text: str) -> str:
    """
    Evaluate a mathematical expression written in a natural language.
    Supported formats:
      - "X в степени Y"
      - "X^Y"
      - Python expressions with '**' operator
    Return the result of the expression as a string.
    If the expression is invalid, return an error message.
    """
    txt = text.strip().lower()
    m = re.search(r"(\d+)\s*в степени\s*(\d+)", txt)
    if m:
        base, exp = map(int, m.groups())
        return str(pow(base, exp))
    m = re.search(r"(\d+)\s*\^\s*(\d+)", txt)
    if m:
        base, exp = map(int, m.groups())
        return str(pow(base, exp))
    try:
        expr = txt.replace('^', '**')
        return str(eval(expr))
    except Exception as e:
        return f"Ошибка вычисления: {e}"
# 2. Функция перевода числа в английское слово
def translate_number_to_english(number):
    return num2words.num2words(number)
# 3. Инструменты LangChain
calculator = Tool(
    name="calculator",
    func=calculator_fn,
    description="Вычисляет арифметические выражения: поддерживает 'X в степени Y', 'X^Y' и Python-выражения."
)
translator = Tool(
    name="translator",
    func=translate_number_to_english,
    description="Переводит число в английское слово и напрямую возвращает результат в качестве окончательного ответа агента.",
    return_direct=True  # Агент завершает работу сразу после вызова переводчика
)
tools = [calculator, translator]
# 4. Инициализация агента ReAct
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    max_iterations=4,
    early_stopping_method="force"
    )
print(agent.run("Посчитай, сколько будет 6 в степени 13, а результат переведи на английский"))

В режиме verbose=True LangChain выведет детальный лог размышлений агента. В рамках нашего примера он будет выглядеть так.

> Entering new AgentExecutor chain...
Thought: To find the result of 6 in the power of 13 and then translate it into English, I need to use both calculator and translator functions.
Action: calculator
Action Input: "6^13"
Observation: 13060694016
Thought:Thought: Now that I have the numerical result from the calculator function, I can use the translator function to convert this number into an English word.
Action: translator
Action Input: 13060694016
Observation: thirteen billion, sixty million, six hundred and ninety-four thousand and sixteen
> Finished chain.
thirteen billion, sixty million, six hundred and ninety-four thousand and sixteen

Этот процесс иллюстрирует, как ReAct-агент чередует рассуждения с действиями. Языковая модель сама решает, какой инструмент вызвать и что делать дальше, основываясь на предыдущем наблюдении. Фреймворки (как LangChain) автоматически подставляют последние мысли и наблюдения в контекст модели на каждом шаге, реализуя этот цикл.

Еще один продвинутый подход к планированию — Tree-of-Thoughts (ToT), или дерево мыслей. Он развивает идею chain-of-thought, позволяя модели разветвлять ход рассуждений и исследовать несколько вариантов решений параллельно, оценивая их. В отличие от linear chain-of-thought, здесь агент может на каком-то шаге разветвлять свои мысли. Так он пробует разные пути, а затем выбирает самый перспективный. Это похоже на поиск решений по дереву: модель может прикинуть несколько промежуточных шагов вперед, откатиться и пойти другим путем, если по ее наблюдениям текущая ветвь не принесет результата.

Исследователи сообщают о впечатляющих успехах этого метода. Возможно, вы слышали про головоломку «двадцать четыре». В рамках нее нужно произвести любые арифметические действия с четырьмя числами, чтобы в результате получилось 24. Обычный GPT-4 с цепочкой мыслей решает эту головоломку лишь в 4% случаев, тогда как метод tree-of-thoughts — в 74%. Такой скачок демонстрирует силу продвинутого планирования. Хотя ToT пока больше в области исследований, идеи дерева мыслей постепенно внедряются в агентные системы, когда требуется стратегический поиск решения.

Таким образом, модуль планирования LLM-агента может быть реализован с разной сложностью — от простого линейного размышления (CoT) до итеративного цикла с действиями (ReAct) и даже разветвленного поиска (ToT). В любом случае цель одна — позволить модели самостоятельно разбить задачу на шаги и выполнить их, максимально эффективно используя свои возможности.

Память: краткосрочная и долгосрочная

В процессе работы агент генерирует и потребляет большое количество информации: это и история диалога, и результаты вызова инструментов, и промежуточные выводы. Чтобы не потерять важное, ему требуется память — механизм хранения данных вне кратковременного внимания модели. Различают два основных типа памяти агента.

Краткосрочная память — охватывает контекст внутри одной сессии (диалога, задачи). В нее входит история сообщений с пользователем, недавние наблюдения от инструментов, промежуточные выводы. Эта память ограничена текущим контекстным окном LLM: модель «помнит» лишь то, что передано ей в промпт. В простейшем случае это весь диалог целиком. Например, ChatGPT помнит несколько последних сообщений. В более продвинутом случае используются разные стратегии: важные части контекста могут сохраняться, неважные — отбрасываться или сжиматься. Фреймворки сохраняют состояние диалога как часть состояния агента (state), которое можно приостановить и продолжить (например, LangChain сохраняет state между запусками с помощью checkpoint).

Ключевая особенность: краткосрочная память ограничена одной сессией. Если начать новый диалог, она обнуляется (если не предпринять специальных действий).

Долгосрочная память — общее хранилище знаний между сессиями. Это может быть база фактов, которые агент узнал, или результаты, к которым он может обращаться в будущем, даже в новом разговоре. Долгосрочная память обычно реализуется через внешние хранилища — базы данных, векторы в embedding-хранилище, файлы. Например, LangChain предлагает интерфейс Stores для сохранения и поиска таких воспоминаний.

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

Оба вида памяти дополняют друг друга. Краткосрочная обеспечивает связность текущего разговора и локального плана, а долгосрочная предоставляет агенту ощущение опыта — словно он знает о прошлом или о вещах вне текущего контекста.

Однако реализация памяти сталкивается с проблемами. Главный вызов — ограниченная длина контекстного окна современных LLM. Если диалог или задача слишком длинные, весь соответствующий текст может не поместиться в промпт. Даже если поместится, это способно повлиять на качество модели. Поэтому инженеры разработали следующие стратегии управления памятью агента.

• Очистка контекста — удаление наименее релевантных или устаревших частей истории. Например, можно оставлять только последние части сообщений или краткое резюме старых сообщений.
• Сжатие (суммаризация) — преобразование длинных участков диалога в более короткое резюме, которое сохраняет суть беседы.
• Извлечение по запросу — хранение деталей диалогов или данных в векторном хранилище и выбор релевантных кусочков в контекст при необходимости (подход Retrieval-Augmented Generation, по сути долгосрочная память на основе поиска).
  

Применяя эти техники, агент поддерживает баланс между объемом памяти и качеством работы. Например, если список сообщений больше определенного размера, можно превращать старые сообщения в резюме. Тогда модель не забудет, о чем шла речь, но и не станет перечитывать каждое слово прошлой беседы. Важно отметить, что память — это не магические знания модели. Ее нужно явно реализовывать, читать и писать в нее, управляя входами LLM. Без долгосрочной памяти агент ограничен только тем, что помещается в промпт, и забывает все старое, как только сессия заканчивается.

Инструменты и вызов функций (function calling, плагины)

Один из самых впечатляющих навыков LLM-агентов — это способность взаимодействовать с внешним миром: вызывать API, запускать коды, искать информацию онлайн, пользоваться сторонними сервисами. Для этого агенту предоставляются инструменты (tools) — специально описанные функции, доступные для вызова. Языковая модель на выходе может выдавать не только текст с ответом пользователю, но и специальную команду на вызов инструмента. Эту команду программа-инфраструктура затем исполнит и передаст результат обратно модели. Такой цикл мы отчасти рассмотрели выше.

В 2023 году компания OpenAI официально представила механизм function calling — вызов функций из ChatGPT. С его помощью разработчики могут зарегистрировать в модели набор доступных функций с их именами, описаниями и JSON-схемами параметров. Модель GPT-4 или GPT-3.5 после получения пользовательского запроса сама решает, нужна ли для ответа какая-либо функция. Если да, она возвращает специальный ответ с JSON, заполняя аргументы для вызова.

Например, если пользователь спрашивает: «Какая погода в Париже?», модель может вернуть не обычный текст, а JSON вроде {"name": "get_current_weather", "arguments": {"location": "Paris", "unit": "celsius"}}. Приложение распознает, что нужно вызвать функцию get_current_weather, вызывает ее (например, через API прогноза погоды) и затем передает модели результат — например, {"temperature": "15°C", ...}. После этого модель уже отвечает пользователю с учетом полученных данных. Такой подход надежнее, чем разбор команды из обычного текста: JSON-ответ строго структурирован под функцию, и разработчик гарантированно получит параметры. По сути, function calling — это мост между возможностями GPT и внешними инструментами. Модель учат генерировать не только слова, но и вызовы функций.

Появление function calling открывает множество возможностей. Перечислю те, которые приводит нам OpenAI.

• Создание чат-ботов, которые отвечают, обращаясь к внешним инструментам (подобно плагинам ChatGPT). Например, вызывают функцию send_email по просьбе пользователя отправить письмо, или get_current_weather по запросу погоды.
• Преобразование произвольного запроса пользователя в последовательность вызовов API или баз данных — фактически, генерация кода по описанию. Например, запрос «Выбери 10 лучших клиентов за последний месяц» может быть автоматически превращен в SQL-запрос через функцию вроде sql_query.
• Извлечение структурированных данных из текста. Модель может сама разобрать текст (статью, документ) и вернуть JSON-объект по заданной схеме, заполнив его извлеченной информацией.
  

Таким образом, LLM получает роль оркестратора, способного вызывать разные утилиты для выполнения задачи. Такой подход ранее демонстрировался в прототипах. Например, проект LangChain имел похожую функциональность, в рамках которой модель выбирает и вызывает Tool из списка, как я продемонстрировал выше. Теперь это встроено на уровне API модели.

Стоит упомянуть и плагины ChatGPT. Плагин — это, по сути, внешний инструмент со стандартизированным интерфейсом, который может подключаться к ChatGPT. Во время использования плагина модель понимает, что у нее есть дополнительная функция, и может ей пользоваться. Официально плагины определялись как инструменты, помогающие языковым моделям получать актуальную информацию, запускать вычисления или обращаться к сервисам. В 2023 году были представлены первые плагины (например, поиск по web, кодовый интерпретатор, плагин WolframAlpha для вычислений, интеграции с сервисами вроде Expedia, Zapier и др.). Технологически плагин похож на описанный function calling: модель получает в промпт описание, как и когда использовать тот или иной плагин, и возвращает вызов. На стороне ChatGPT это выглядит прозрачно: пользователь просит что-то забронировать — ChatGPT отвечает, что бронирует (в реальности вызывая через плагин API бронирования).

Пример использования инструмента через function calling с Ollama. Предположим, мы хотим позволить нашему агенту пользоваться калькулятором для вычислений. С помощью OpenAI API можем описать функцию и передать ее в параметры вызова:

import ollama
# --- 1. Описываем «инструмент» (функцию calculate) для модели ---
tool_calculate = {
    'type': 'function',
    'function': {
        'name': 'calculate',
        'description': 'Вычисляет арифметическое выражение и возвращает результат',
        'parameters': {
            'type': 'object',
            'properties': {
                'expression': {
                    'type': 'string',
                    'description': 'Арифметическое выражение для вычисления'
                }
            },
            'required': ['expression']
        }
    }
}
# --- 2. Реализация самой функции calculate ---
def calculate(expression: str) -> str:
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"error: {e}"
# --- 3. Формируем историю переписки и отправляем запрос модели ---
messages = [
    {'role': 'user', 'content': 'Сколько будет (2+2)*3?'}
]
response = ollama.chat(
    model='llama3.1',
    messages=messages,
    tools=[tool_calculate],  # передаем список «инструментов»
)
# --- Verbose logging ---
print(">>> RAW INITIAL RESPONSE:")
print(response, "\n")
print(">>> ASSISTANT MESSAGE CONTENT:")
print(response.message, "\n")
 # --- 4. Модель вернула запрос на вызов функции? ---
tool_calls = response.message.tool_calls or []
print(">>> TOOL CALLS DETECTED:", tool_calls, "\n")
if tool_calls:
    call = tool_calls[0]
    args = call.function.arguments
    print(">>> FUNCTION NAME:", call.function.name)
    print(">>> FUNCTION ARGUMENTS:", args, "\n")
    # 5. Выполняем функцию и возвращаем результат в контекст диалога
    func_result = calculate(**args)
    print(">>> FUNCTION RESULT:", func_result, "\n")
    messages.append({
        'role': 'assistant',
        'content': None,
        'tool_calls': [call]
    })
    messages.append({
        'role': 'tool',
        'name': 'calculate',
        'content': func_result
    })
    # 6. Запрашиваем у модели итоговый ответ
    final_response = ollama.chat(
        model='llama3.1',
        messages=messages,
    )
    print(">>> FINAL RESPONSE OBJECT:")
    print(final_response, "\n")
    print(">>> FINAL RESPONSE MESSAGE CONTENT:")
    print(final_response.message.content)

Модель поймет, что для ответа нужен калькулятор, и вернет специальный ответ function_call с именем calculate и аргументом "(2+2)*3". Теперь наше приложение должно перехватить это и действительно выполнить функцию calculate. Допустим, у нас она реализована просто через eval (небезопасно в общем случае, но для примера подойдет). Итого, на выходе из нашего скрипта мы получим следующее:

>>> RAW INITIAL RESPONSE:
model='llama3.1' created_at='2025-05-28T19:00:44.774771Z' done=True done_reason='stop' total_duration=3857246375 load_duration=39507833 prompt_eval_count=170 prompt_eval_duration=2256335125 eval_count=20 eval_duration=1558117250 message=Message(role='assistant', content='', images=None, tool_calls=[ToolCall(function=Function(name='calculate', arguments={'expression': '(2+2)*3'}))]) 
>>> ASSISTANT MESSAGE CONTENT:
role='assistant' content='' images=None tool_calls=[ToolCall(function=Function(name='calculate', arguments={'expression': '(2+2)*3'}))] 
>>> TOOL CALLS DETECTED: [ToolCall(function=Function(name='calculate', arguments={'expression': '(2+2)*3'}))] 
>>> FUNCTION NAME: calculate
>>> FUNCTION ARGUMENTS: {'expression': '(2+2)*3'} 
>>> FUNCTION RESULT: 12 
>>> FINAL RESPONSE OBJECT:
model='llama3.1' created_at='2025-05-28T19:00:50.884362Z' done=True done_reason='stop' total_duration=6101549500 load_duration=31059209 prompt_eval_count=51 prompt_eval_duration=548200000 eval_count=66 eval_duration=5519756625 message=Message(role='assistant', content='Давайте шаг за шагом:\n\n1. Сначала вычислите 2 + 2 = 4.\n2. Затем, умножьте 4 на 3, чтобы получить 4 × 3 = 12.\n\nСледовательно, ответ: (2+2)*3 = 12.', images=None, tool_calls=None) 
>>> FINAL RESPONSE MESSAGE CONTENT:
Давайте шаг за шагом:
1. Сначала вычислите 2 + 2 = 4.
2. Затем, умножьте 4 на 3, чтобы получить 4 × 3 = 12.
Следовательно, ответ: (2+2)*3 = 12.

Как вы можете заметить, взаимодействие состоит их нескольких фаз: модель запрашивает функцию → мы отвечаем результатом → модель выдает итоговый ответ. В реальных сценариях агент может иметь десятки функций: например, калькулятор, поиск информации, отправка запроса в базу, генерация изображения и т.д. С ростом числа инструментов особенно важно планирование: модель должна решать, какой инструмент сейчас уместен (и вообще требуется ли инструмент для данной задачи).

Современные агенты способны на лету выбирать нужное: скажем, сначала выполнить поиск, потом на основе найденного что-то вычислить, потом отформатировать результат (так, например, работает с инструментами модель o3 от OpenA)

Интеграция инструментов расширяет возможности LLM-агента далеко за рамки «просто поговорить». Он становится интерфейсом, который на естественном языке принимает задачу, а затем разбивает ее на конкретные операции с помощью кода и сервисов. Здесь кроется большая сила: используя LLM как «мозг», можно объединить множество узкоспециализированных систем (баз данных, API, скриптовых инструментов) в единый конвейер решения задачи, управляемый гибкими инструкциями.

Конечно, подключение внешних инструментов несет и риски: каждый вызов — потенциальная точка отказа (ошибка сети, неверный ответ API, непредвиденный ввод). Агенты обретают новые уязвимости: например, если не фильтровать выход веб-сервиса, модель может сбиться или получить вредоносные данные. Поэтому разработчики прорабатывают аспекты безопасности (OpenAI отдельно отметила, что данные от инструментов надо считать недоверенными и проверять, прежде чем слепо передавать модели).

Заключение

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

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

В совокупности получается гибкая система, способная на сложные многошаговые операции — от поиска и агрегирования данных до выполнения пользовательских команд в реальном мире. Однако важно помнить, что LLM-агент – не магический «искусственный интеллект, решающий все сам». Это всего лишь умелая комбинация заранее разработанных компонентов. Ограничения базовой модели (неточности, галлюцинации, ограниченный контекст) никуда не исчезают — агент лишь помогает их сгладить, используя обходные пути вроде внешней памяти или вызова проверенных инструментов.

Тем не менее, правильно спроектированные LLM-агенты уже сейчас показывают впечатляющие результаты, автоматизируя задачи, которые ранее требовали человеческого вмешательства. Их внутренняя кухня — отличный пример того, как инженерный подход раскрывает потенциал больших моделей. Это не волшебство, а новый строительный блок для создания интеллектуальных приложений. В следующей статье мы рассмотрим, как такие агенты применяются на практике, каких успехов удалось добиться и с какими ограничениями все еще приходится сталкиваться. До встречи во второй части!