$ sudo teach IT

Здравствуйте! Вы начинаете курс «AI-агенты на Python: шаг за шагом». За несколько модулей вы пройдёте путь от первого запроса к языковой модели до программ, которые сами выбирают инструменты, ищут информацию в документах, помнят прошлые разговоры и согласуют рискованные действия с человеком. В конце курса вы сможете спроектировать и написать собственного агента для реальной рабочей задачи и понимать, как сделать его надёжным, безопасным и недорогим.

Обучение устроено просто: каждый урок — это одна тема, лонгрид с примерами кода и блок задач для самопроверки. Сначала мы соберём агента вручную на «чистом» Python и OpenAI API, чтобы вы увидели, как всё устроено изнутри. Затем перейдём на фреймворки LangChain и LangGraph, которые избавляют от рутины. От вас нужен только базовый Python: функции, списки, словари и умение установить пакет через pip.

Зачем это нужно

Языковые модели умеют писать тексты, отвечать на вопросы и объяснять код. Но сама по себе модель только генерирует текст: она не может проверить погоду, заглянуть в вашу базу заказов или отправить письмо. Компании же хотят не «умного собеседника», а систему, которая доводит задачу до конца: находит данные, считает, проверяет результат и сообщает итог.

Именно эту роль выполняет AI-агент. После урока вы будете понимать, из каких частей он состоит, чем он отличается от обычного чат-бота и в каких задачах агент действительно нужен, а в каких хватит одного запроса к модели.

Что уже умеем

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

Что вы узнаете в рамках статьи

  • что такое языковая модель и какую роль она играет в агенте;
  • чем чат-бот отличается от AI-агента;
  • из каких частей состоит агент: модель, инструкции, инструменты, память;
  • как выглядит цикл работы агента «подумать — действовать — наблюдать»;
  • в каких задачах агент оправдан, а в каких избыточен.

Ключевые термины

  • LLM (большая языковая модель) — программа, которая по входному тексту генерирует продолжение: ответ, план, код.
  • Чат-бот — программа, которая на каждое сообщение отвечает текстом и ничего не делает во внешнем мире.
  • AI-агент — программа, в которой модель сама решает, какие действия выполнить, чтобы достичь цели, и повторяет шаги до результата.
  • Инструмент (tool) — функция, которую агент может вызвать: поиск, калькулятор, запрос к API.
  • Цикл агента — повторяющаяся последовательность: модель решает, программа выполняет действие, результат возвращается модели.
  • Память — сохранённая информация о прошлых шагах и разговорах, которую агент учитывает при решениях.

Языковая модель — это «мозг», но не весь агент

Языковая модель обучена на огромном объёме текстов и умеет предсказывать, какой текст уместен дальше. Если на вход подать вопрос, на выходе получится правдоподобный ответ. Важно запомнить одно ограничение: модель знает только то, что было в обучающих данных, и то, что вы передали ей в запросе. Она не видит интернет, ваши файлы и текущую дату, если вы сами их не сообщили.

Упрощённо работу с моделью можно описать функцией:

def llm(prompt: str) -> str:
    """Принимает текст и возвращает сгенерированный текст."""
    ...

answer = llm("Сколько будет 17 * 23?")
print(answer)

Что увидим: модель вернёт строку вроде 17 * 23 = 391. Чаще всего ответ будет верным, но модель не считает, как калькулятор, — она генерирует текст, похожий на правильный. На сложных вычислениях она может ошибиться. Это первая причина, по которой модели нужны инструменты.

Чат-бот: один вопрос — один ответ

Чат-бот — самая простая обёртка над моделью. Пользователь пишет сообщение, программа передаёт его модели и показывает ответ. Ничего больше не происходит.

def chat_bot(user_message: str) -> str:
    return llm(user_message)

print(chat_bot("Какая погода сейчас в Казани?"))

Что увидим: в лучшем случае честное «У меня нет доступа к актуальным данным о погоде», в худшем — выдуманный прогноз. Модель не может узнать погоду: у неё нет такого действия. Чат-бот отлично подходит, чтобы переписать текст, объяснить термин или придумать заголовки, но не умеет действовать во внешнем мире.

AI-агент: модель, которая выбирает действия

Агент добавляет к модели три вещи. Инструкции задают роль и правила: «ты помощник отдела продаж, отвечай кратко». Инструменты — это функции, которые модель может попросить вызвать. Память хранит историю шагов, чтобы модель видела, что уже сделано.

Главное отличие в том, кто решает, что делать дальше. В обычной программе порядок действий задаёт программист. В агенте модель сама выбирает: ответить сразу или сначала вызвать инструмент, а если вызвать — то какой и с какими аргументами. Посмотрим, как описать агенту набор инструментов:

def get_weather(city: str) -> str:
    # В реальном агенте здесь был бы запрос к сервису погоды
    return f"В городе {city} +12 °C, облачно"

def calculate(expression: str) -> str:
    return str(eval(expression))  # только для примера, в продакшене eval опасен

tools = {
    "get_weather": get_weather,
    "calculate": calculate,
}

Здесь пока нет никакой магии: обычные функции Python и словарь, где ключ — имя инструмента. Магия начнётся, когда модель получит описание этих функций и сама скажет: «вызови get_weather с аргументом city="Казань"». Как это сделать через API, вы узнаете в уроке 1.6.

Цикл работы агента

Агент работает не за один шаг, а циклом. Модель получает задачу и решает, что делать. Если ей нужны данные, она просит вызвать инструмент. Программа выполняет функцию и возвращает результат модели. Модель смотрит на результат и решает снова: нужен ещё один шаг или можно дать финальный ответ.

def run_agent(task: str, max_steps: int = 5) -> str:
    history = [task]
    for step in range(max_steps):
        decision = llm_decide(history, tools)      # модель решает, что делать
        if decision["type"] == "final_answer":
            return decision["text"]                # задача решена
        tool = tools[decision["tool_name"]]
        result = tool(**decision["arguments"])     # программа выполняет действие
        history.append(result)                     # модель увидит результат
    return "Не удалось решить задачу за отведённое число шагов"

Что произойдёт на задаче «Какая погода в Казани и сколько это в градусах Фаренгейта?»: на первом шаге модель попросит get_weather, на втором — calculate с выражением 12 * 9 / 5 + 32, на третьем вернёт финальный ответ «+12 °C, это 53.6 °F». Функция llm_decide здесь условная: её настоящую реализацию вы напишете сами в конце первого модуля.

Обратите внимание на параметр max_steps. Модель может ошибиться и начать бесконечно вызывать инструменты, поэтому у любого агента должен быть предел числа шагов. Это не формальность, а базовое правило надёжности.

Когда агент нужен, а когда нет

Агент дороже и медленнее одиночного запроса: каждый шаг цикла — это новое обращение к модели. Поэтому выбирайте самое простое решение, которое справляется с задачей. Если ответ можно получить одним запросом, например перевести письмо, хватит чат-бота. Если шаги заранее известны и всегда одинаковы, например «извлечь данные из счёта и записать в таблицу», лучше написать обычную программу, которая вызывает модель в нужном месте. Агент оправдан, когда путь к результату заранее неизвестен и зависит от промежуточных данных: исследовать вопрос, разобрать обращение клиента, найти причину ошибки.

Частые ошибки

  • Считать, что модель «знает всё». Модель не видит актуальных данных и ваших систем. Всё, что ей нужно, передавайте в запросе или через инструменты.
  • Делать агента там, где хватит одного запроса. Лишний цикл увеличивает стоимость и время ответа. Начинайте с простого решения и усложняйте только по необходимости.
  • Не ограничивать число шагов. Без max_steps агент может зациклиться и потратить много денег на запросы.
  • Доверять каждому действию агента. Модель может выбрать не тот инструмент или неверные аргументы. Опасные действия, такие как удаление и оплата, нужно проверять — этому посвящён урок 4.2.

Наиболее частые вопросы

  • Агент и чат-бот — это разные модели? — Нет, модель может быть одной и той же. Разница в программе вокруг модели: у агента есть инструменты и цикл принятия решений.
  • Нужно ли обучать свою модель, чтобы сделать агента? — Нет. В курсе мы используем готовые модели через API, а поведение задаём инструкциями и инструментами.
  • Почему курс начинается без фреймворков? — Когда вы один раз соберёте цикл агента вручную, код LangChain и LangGraph станет понятным, а не магическим.
  • Сколько стоят запросы к модели? — Оплата идёт за токены — кусочки текста на входе и выходе. Как их считать, разберём в следующем уроке.

Итоги

Поздравляем с первым шагом! Вы уже понимаете то, что многие путают: языковая модель лишь генерирует текст, чат-бот просто передаёт ей сообщения, а агент даёт модели инструменты и цикл, в котором она сама выбирает действия, пока не решит задачу. Вы знаете, из чего состоит агент, зачем ему ограничение по шагам и когда лучше обойтись без него.

В следующем уроке заглянем внутрь языковой модели: узнаем, что такое токены и контекстное окно и как заранее прикинуть стоимость запроса. Эти знания пригодятся каждый раз, когда вы будете проектировать агента.

На следующий урок