LangGraph: Создаем Stateful AI Агентов на Python
Откройте для себя LangGraph — мощный фреймворк для создания сложных, многоагентных систем искусственного интеллекта. В этом подробном руководстве мы покажем, как использовать LangGraph для разработки stateful AI агентов, способных поддерживать состояние и выполнять циклические рабочие процессы в 2026 году.
Введение в LangGraph: Создание Stateful AI Агентов
В быстро развивающемся мире искусственного интеллекта 2026 года, где автономные агенты становятся все более востребованными, умение создавать системы, способные поддерживать состояние и адаптироваться к изменяющимся условиям, критически важно. Именно здесь на помощь приходит LangGraph — мощное расширение популярного фреймворка LangChain, разработанное для построения сложных, stateful AI агентов. LangGraph позволяет разработчикам проектировать многоэтапные рабочие процессы с памятью, условной маршрутизацией и циклическими операциями, что делает его идеальным инструментом для создания по-настоящему интеллектуальных и адаптивных систем. Этот туториал поможет вам освоить основы LangGraph и научиться создавать собственные stateful AI агенты с использованием Python, открывая новые возможности для автоматизации и взаимодействия с ИИ.
LangGraph выделяется своей способностью оркестрировать сложные взаимодействия между различными компонентами ИИ, такими как большие языковые модели (LLM) и инструменты, сохраняя при этом контекст и состояние на протяжении всего процесса. Это особенно важно для задач, требующих долгосрочного планирования, итеративного улучшения или многоступенчатого принятия решений. Например, создание агента, способного писать код, а затем самостоятельно тестировать и отлаживать его, требует именно такой stateful архитектуры. В этом руководстве мы рассмотрим ключевые концепции LangGraph, предоставим практические примеры и покажем, как интегрировать его с современными моделями, такими как GPT-5.3-Codex или Gemini 3.1 Pro Preview, чтобы Build Stateful AI агентов, которые будут эффективны в реальных условиях.
Что такое LangGraph и почему он важен для Stateful AI?
LangGraph — это библиотека, которая позволяет создавать агенты и многоагентные системы в виде графов. В отличие от традиционных цепочек LLM, которые выполняются линейно, LangGraph предоставляет возможность определять узлы (nodes), представляющие собой шаги или действия, и ребра (edges), определяющие переходы между этими шагами. Самое главное, он поддерживает сохранение состояния (stateful) между узлами, что позволяет агентам «помнить» предыдущие действия и решения. Это критически важно для построения автономных систем, которые могут вести длительные диалоги, выполнять сложные задачи с несколькими этапами или адаптироваться к меняющимся вводным данным. Например, финансовый аналитик на базе ИИ может использовать LangGraph для сбора данных, проведения расчетов, а затем генерации отчета, сохраняя при этом все промежуточные результаты и решения.
В 2026 году, когда сложность задач, решаемых ИИ, постоянно растет, фреймворки вроде LangGraph приобретают особую ценность. Они предлагают разработчикам детальный контроль над логикой выполнения агентов, позволяя создавать устойчивые и предсказуемые системы. Возможность включать циклы в граф означает, что агенты могут повторять действия до достижения определенного условия, например, пересматривать ответ до тех пор, пока он не будет соответствовать заданным критериям качества. Это делает LangGraph незаменимым инструментом для построения stateful AI агентов, способных решать реальные бизнес-задачи, от автоматизированной поддержки клиентов до сложных исследовательских проектов. С помощью LangGraph вы можете Build Stateful AI агентов, которые будут не просто отвечать на запросы, но и активно взаимодействовать с окружением.
Основы LangGraph: Структура и Компоненты
Прежде чем приступить к созданию stateful AI агентов, важно понять основные компоненты LangGraph. В его основе лежат следующие концепции: Состояние (State): Это словарь или объект, который сохраняется и передается между узлами графа. Он содержит всю актуальную информацию, необходимую агенту для принятия решений. Узлы (Nodes): Функции или классы, которые выполняют определенные действия, например, вызов LLM, использование инструмента или обработку данных. Каждый узел получает текущее состояние и возвращает модифицированное состояние. Ребра (Edges): Определяют переходы между узлами. Они могут быть прямыми (следующий узел всегда один и тот же) или условными (выбор следующего узла зависит от текущего состояния). Точки входа/выхода (Entry/Exit Points): Определяют, откуда начинается и где заканчивается выполнение графа. Эти элементы позволяют Build Stateful AI агентов с гибкой и модульной архитектурой.
Понимание этих компонентов является ключом к эффективному использованию LangGraph. Например, можно создать узел для вызова Qwen3 Max Thinking для генерации идеи, затем другой узел для использования инструмента поиска, чтобы проверить факты, и, наконец, третий узел для форматирования окончательного ответа. Состояние будет передаваться между этими узлами, сохраняя историю запросов и ответов. Условные ребра могут направлять выполнение по разным путям в зависимости от результатов проверки фактов, например, возвращаться к LLM для уточнения, если информация не подтвердилась. Такая архитектура позволяет создавать чрезвычайно гибкие и мощные stateful AI агенты, способные решать сложные проблемы, которые недоступны простым одношаговым моделям. Читайте также: Как создать ИИ-агентов с LangChain: Полное руководство 2026
Шаг 1: Установка и Базовая Настройка
Установка LangGraph и необходимых библиотек
- 1
Подготовка окружения
Убедитесь, что у вас установлен Python 3.9+ и создано виртуальное окружение. Это поможет избежать конфликтов зависимостей и обеспечит чистоту проекта.
- 2
Установка LangGraph
Установите LangGraph и LangChain. LangGraph является расширением LangChain, поэтому обе библиотеки необходимы для работы. Используйте pip для установки.
- 3
Установка LLM-провайдера
Установите библиотеку для выбранной вами большой языковой модели, например, OpenAI или Google. В этом примере мы будем использовать OpenAI, так как он легко интегрируется через LangChain.
- 4
Настройка API-ключей
Получите API-ключ для выбранного LLM-провайдера и сохраните его в переменной окружения или напрямую в коде (для локальной разработки). Это позволит вашему агенту взаимодействовать с LLM.
- 5
Импорт необходимых модулей
В вашем Python-скрипте импортируйте основные классы из LangGraph (StateGraph, END) и LangChain (ChatOpenAI, BaseMessage, HumanMessage) для начала работы.
from typing import TypedDict, Annotated, List
import operator
from langchain_core.messages import BaseMessage, HumanMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
import os
# Установка API ключа OpenAI
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
# Можно также использовать Multi AI API Key для доступа к различным моделям
os.environ["MULTI_AI_API_KEY"] = "YOUR_MULTI_AI_API_KEY"
# Определение состояния графа
class AgentState(TypedDict):
messages: Annotated[List[BaseMessage], operator.add]
current_step: int
# Инициализация LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)
# Или используйте модель из Multi AI, например, GPT-5.3-Codex
# llm = ChatOpenAI(base_url="https://api.multi-ai.ai/v1", api_key=os.environ["MULTI_AI_API_KEY"], model="gpt-5-3-codex")
Создание Вашего Первого Stateful AI Агента с LangGraph
Теперь, когда мы понимаем основы, давайте Build Stateful AI агента, который может выполнять простые многошаговые задачи. Мы начнем с определения состояния, которое будет передаваться между узлами. Состояние — это сердце stateful агента, оно позволяет ему сохранять контекст и память между различными этапами выполнения. В нашем примере состояние будет включать список сообщений (историю чата) и текущий шаг. Затем мы определим несколько узлов: один для вызова LLM и другой для имитации выполнения инструмента. Это покажет, как агент может взаимодействовать с внешними функциями или базами данных, сохраняя при этом свою внутреннюю логику.
Агент будет последовательно выполнять шаги, используя информацию из предыдущих шагов. Представьте себе агента, который должен сначала проанализировать запрос пользователя, затем найти соответствующую информацию, а потом сформулировать ответ. Каждый из этих этапов может быть отдельным узлом в LangGraph. Благодаря сохранению состояния, агент не потеряет контекст запроса пользователя, пока он ищет информацию или генерирует ответ. Это делает его значительно более эффективным и “умным” по сравнению с агентами, которые обрабатывают каждый запрос как совершенно новую задачу. Такой подход позволяет Build Stateful AI агентов, которые действительно способны к сложным рассуждениям и взаимодействиям.
Шаг 2: Определение Узлов и Логики
Разработка узлов графа
- 1
Создание узла для LLM
Определите функцию, которая будет принимать текущее состояние, вызывать LLM (например, GPT-4o) и добавлять ответ LLM в список сообщений состояния. Это основной узел, где происходит генерация текста или принятие решений.
- 2
Создание узла для инструмента
Определите функцию, имитирующую выполнение внешнего инструмента. Этот узел может, например, выполнять поиск в базе данных, вычислять что-либо или взаимодействовать с API. Результат работы инструмента также должен быть добавлен в состояние.
- 3
Создание условного узла
Для более сложных агентов, способных принимать решения, создайте функцию, которая на основе состояния определяет следующий шаг. Это позволяет агенту динамически изменять свой путь выполнения.
- 4
Инициализация StateGraph
Создайте экземпляр StateGraph с вашим определенным классом состояния. Это контейнер для всех ваших узлов и ребер.
- 5
Добавление узлов в граф
Используйте метод `add_node()` для регистрации каждой функции-узла в графе. Присвойте каждому узлу уникальное имя, которое будет использоваться для определения ребер.
def call_llm(state: AgentState):
print("---ВЫЗОВ LLM---")
messages = state['messages']
response = llm.invoke(messages)
return {"messages": [response], "current_step": state['current_step'] + 1}
def call_tool(state: AgentState):
print("---ВЫЗОВ ИНСТРУМЕНТА---")
# Здесь может быть реальная логика вызова инструмента
tool_output = f"Результат работы инструмента на шаге {state['current_step']}: 'Обработаны данные'"
return {"messages": [HumanMessage(content=tool_output)], "current_step": state['current_step'] + 1}
def should_continue(state: AgentState):
print("---ПРОВЕРКА УСЛОВИЯ---")
# Пример условной логики: продолжаем, пока не достигнем 3 шага
if state['current_step'] < 3:
return "continue"
else:
return "end"
workflow = StateGraph(AgentState)
workflow.add_node("llm_node", call_llm)
workflow.add_node("tool_node", call_tool)
Построение Графа и Условная Маршрутизация
После определения узлов следующим шагом является построение самого графа, связывая эти узлы ребрами. LangGraph позволяет определять как прямые, так и условные ребра. Прямое ребро просто указывает на следующий узел, который будет выполнен. Условное ребро, напротив, использует функцию-маршрутизатор, которая анализирует текущее состояние и возвращает имя следующего узла (или `END`, чтобы завершить выполнение). Эта возможность условной маршрутизации является ключевой для создания адаптивных и динамических stateful AI агентов, способных принимать решения на основе развивающегося контекста. Например, агент может решить, нужно ли ему искать дополнительную информацию, если первоначальный ответ LLM не был достаточно полным, или перейти к финальному шагу, если ответ удовлетворительный. Это позволяет Build Stateful AI агентов, которые могут эффективно управлять сложными рабочими процессами.
Построение графа начинается с определения начальной точки (`set_entry_point`). Затем вы добавляете ребра, определяя последовательность выполнения. Для условных ребер вы используете `add_conditional_edges`, передавая функцию, которая будет принимать решение о переходе. Эта гибкость в определении потока позволяет моделировать практически любой рабочий процесс. Представьте себе агента-помощника, который может отвечать на вопросы, но если вопрос касается чувствительной темы, он перенаправляет его человеку для проверки. LangGraph легко позволяет реализовать такие сценарии, обеспечивая robustность и безопасность. Используя эти методы, разработчики могут Build Stateful AI агентов, которые не только выполняют задачи, но и делают это с учетом контекста и динамических условий.
Шаг 3: Соединение Узлов и Запуск Графа
Сборка и запуск графа
- 1
Установка точки входа
Определите, с какого узла начнется выполнение графа. Используйте `set_entry_point()` для указания первого узла, который будет вызван при запуске агента.
- 2
Добавление прямых ребер
Свяжите узлы с помощью `add_edge()`, чтобы определить фиксированную последовательность выполнения. Например, после LLM всегда вызывается инструмент или наоборот.
- 3
Добавление условных ребер
Используйте `add_conditional_edges()` для создания динамических переходов. Укажите источник, функцию-маршрутизатор и словарь, сопоставляющий результаты маршрутизатора с целевыми узлами (или `END`).
- 4
Компиляция графа
После определения всех узлов и ребер скомпилируйте граф с помощью `compile()`. Это оптимизирует граф для выполнения и делает его готовым к использованию.
- 5
Запуск агента
Запустите скомпилированный граф, передав начальное состояние. Результатом будет итератор, который возвращает состояние после каждого шага, позволяя отслеживать прогресс агента.
workflow.set_entry_point("llm_node")
# LLM -> Tool (если current_step < 3)
workflow.add_conditional_edges(
"llm_node",
should_continue,
{"continue": "tool_node", "end": END}
)
# Tool -> LLM (если current_step < 3)
workflow.add_conditional_edges(
"tool_node",
should_continue,
{"continue": "llm_node", "end": END}
)
# Компиляция графа
app = workflow.compile()
# Запуск агента
initial_state = {"messages": [HumanMessage(content="Привет, как дела?")], "current_step": 0}
for s in app.stream(initial_state):
print(s)
print("\n---\n")
print(app.invoke(initial_state))Совет
Для отладки сложных графов используйте визуализацию. LangGraph может генерировать графические представления вашего агента, что значительно упрощает понимание потока выполнения и выявление потенциальных проблем. Это особенно полезно при работе с условными переходами и циклами.
Продвинутые Возможности LangGraph для Stateful AI
LangGraph не ограничивается простыми последовательностями. Его истинная мощь раскрывается при использовании продвинутых функций, таких как циклы, human-in-the-loop (человек в цикле) и интеграция с различными инструментами. Циклы позволяют агентам выполнять итеративные действия, например, переформулировать запрос или перепроверять информацию до тех пор, пока не будет достигнут желаемый результат. Это фундаментальная возможность для Build Stateful AI агентов, способных к самокоррекции и улучшению своих результатов. Human-in-the-loop — это функция, которая позволяет человеку вмешиваться в рабочий процесс агента, например, для утверждения решения или предоставления дополнительной информации, что особенно важно для задач, требующих надзора или этических соображений. Интеграция с инструментами, такими как веб-поиск, базы данных или API, расширяет возможности агента, позволяя ему взаимодействовать с внешним миром и получать актуальную информацию. Читайте также: CrewAI: Создаем AI Команды для Автоматизации Сложных Задач
Помимо этого, LangGraph поддерживает многоагентные системы, где несколько агентов взаимодействуют друг с другом для решения общей задачи. Например, один агент может быть экспертом по поиску информации (DeepSeek V3.2), другой — по анализу данных (Qwen3.5-35B-A3B), а третий — по генерации отчетов (GLM 4.6V). LangGraph обеспечивает координацию между ними, позволяя каждому агенту выполнять свою роль и передавать результаты другому. Такая архитектура значительно повышает сложность и эффективность систем ИИ, делая их способными решать проблемы, которые ранее требовали участия человека. Это открывает путь к созданию по-нанастоящему автономных и адаптивных stateful AI агентов, способных к сложным рассуждениям и обучению в процессе работы.
LangGraph
Плюсы
- Поддержка сохранения состояния (stateful) между шагами.
- Гибкая графовая архитектура для сложных рабочих процессов.
- Возможность создания циклических (looping) агентов.
- Легкая интеграция с LangChain и его экосистемой инструментов.
- Поддержка многоагентных систем и human-in-the-loop.
- Отличная управляемость и предсказуемость выполнения агентов.
Минусы
- Кривая обучения может быть выше для новичков, чем у простых цепочек.
- Визуализация графов требует дополнительных инструментов.
- Отладка сложных циклических графов может быть трудоемкой.
- Требует четкого понимания потоков данных и состояний.
- Производительность может зависеть от сложности графа и количества узлов.
Примеры Использования Stateful AI Агентов на LangGraph в 2026 году
В 2026 году stateful AI агенты, построенные с помощью LangGraph, находят применение в самых разнообразных отраслях. Например, в финансовом секторе они могут выступать в роли автоматизированных аналитиков, способных собирать данные из различных источников, проводить сложный анализ и генерировать инвестиционные рекомендации. Благодаря сохранению состояния, такой агент может отслеживать изменения на рынке, обновлять свои прогнозы и адаптировать стратегии в реальном времени. В образовании LangGraph может использоваться для создания персонализированных обучающих систем, которые адаптируют учебный план под прогресс студента, предлагая индивидуальные задачи и обратную связь. Каждый шаг обучения сохраняется в состоянии, что позволяет системе эффективно отслеживать знания и пробелы студента.
В сфере разработки программного обеспечения, stateful AI агенты могут автоматизировать полный цикл создания кода: от генерации первого черновика с помощью GPT-5.3-Codex, до автоматического тестирования и отладки, используя специализированные инструменты. Агент может итеративно исправлять ошибки, пока тесты не пройдут успешно, сохраняя историю всех изменений и попыток. В клиентской поддержке, многоагентные системы на LangGraph могут обрабатывать сложные запросы, маршрутизируя их между различными специализированными агентами (например, агент по техническим вопросам, агент по платежам) и при необходимости подключая оператора-человека. Все эти сценарии демонстрируют, как LangGraph позволяет Build Stateful AI агентов, способных к глубокой интеграции и автономному выполнению сложных задач, трансформируя бизнес-процессы и пользовательский опыт.
FAQ: Часто Задаваемые Вопросы о LangGraph и Stateful AI
Часто Задаваемые Вопросы
Заключение: Будущее Stateful AI с LangGraph
LangGraph является одним из самых мощных и гибких фреймворков для создания stateful AI агентов в 2026 году. Его графовая архитектура, поддержка сохранения состояния, условной маршрутизации и циклических рабочих процессов открывают беспрецедентные возможности для разработчиков. Мы рассмотрели основы LangGraph, научились определять состояние, создавать узлы и ребра, а также компилировать и запускать графы. Эти знания являются фундаментом для построения сложных, адаптивных и автономных систем ИИ, способных решать широкий круг задач в реальном мире. Будь то автоматизация бизнес-процессов, создание интеллектуальных помощников или разработка новых исследовательских инструментов, LangGraph предоставляет необходимый инструментарий для воплощения ваших идей в жизнь. Начните Build Stateful AI агентов сегодня и станьте частью будущего искусственного интеллекта. Читайте также: LlamaIndex: База знаний с локальными LLM (2026)
