LangGraph — фреймворк от команды LangChain для построения продакшн-агентов на базе явного графа состояний. Первая публичная версия вышла в июле 2024, стабильная v0.2 появилась в октябре 2024, к лету 2025 проект дорос до платформы с managed-сервисом и time-travel debugging. В отличие от ReAct-цепочек в LangChain, LangGraph описывает агента как направленный граф: разработчик сам задаёт узлы (действия), условные переходы, циклы и persistent state. Это даёт детерминированный контроль над потоком выполнения там, где у AutoGen и CrewAI поведение размазано по диалоговым протоколам.

Главная сила LangGraph — продакшн-зрелость. State persistence через SQLite/Postgres checkpointers, time-travel debugging через снапшоты состояния, parallel branches через Send, human-in-the-loop через interrupt(). К июню 2025 на LangGraph работают продакшн-агенты в Replit (multi-step code generation), Uber (аналитика по нескольким источникам данных) и LinkedIn (recruiter assistant). Если ты строишь агента, который должен переживать рестарты сервера, ветвиться по условиям и отслеживаться через observability — LangGraph сейчас де-факто стандарт в Python-экосистеме.

Зачем LangGraph, когда есть LangChain

LangChain 2023 года решал простую задачу: соединить LLM с retriever, tools и prompt template в одну цепочку (Chain). Когда запросы были линейными (“возьми контекст из БД → скорми модели → распарси ответ”), этой абстракции хватало. Когда приложения стали мульти-шаговыми с условной логикой и состоянием, цепочки стали неуклюжими — для ветвления приходилось городить костыли из RunnableBranch и кастомных раннаблов.

LangGraph решает эту проблему через явный directed graph. Узлы графа — это обычные Python-функции (или Runnable-объекты), рёбра — статические или условные переходы. Состояние агента представлено единым TypedDict, который прокидывается через все узлы и автоматически сохраняется после каждого шага. Это не новая идея — тот же Apache Airflow строит DAG для пайплайнов — но LangGraph адаптирует паттерн под специфику LLM-агентов: вероятностные узлы, недетерминированные переходы, циклы для retry, interrupts для human review.

from langgraph.graph import StateGraph, START, END
from typing import TypedDict

class State(TypedDict):
    question: str
    answer: str

def answer_node(state: State) -> State:
    state["answer"] = f"Echo: {state['question']}"
    return state

graph = StateGraph(State)
graph.add_node("answer", answer_node)
graph.add_edge(START, "answer")
graph.add_edge("answer", END)
app = graph.compile()
app.invoke({"question": "hi", "answer": ""})

Минимальный граф собирается за пять строк. Реальная сложность появляется, когда добавляешь условные переходы, инструменты, чекпоинтер и стриминг — но базовая абстракция остаётся прежней.

Архитектура StateGraph: узлы, рёбра, состояние

StateGraph — центральный объект LangGraph. Конструктор принимает State (TypedDict с типизированными полями), метод add_node добавляет узел, add_edge соединяет узлы напрямую, add_conditional_edges задаёт ветвление по функции-роутеру. После compile() граф превращается в исполняемый CompiledStateGraph, у которого есть invoke, stream, ainvoke, astream для синхронных и асинхронных запусков.

Состояние как явный контракт

Состояние — не просто dict, а TypedDict (или Pydantic-модель в новых версиях). Поля могут быть скалярами, списками сообщений или вложенными структурами. Узлы графа получают state на вход и возвращают patch — частичное обновление, которое автоматически мержится с текущим state через заданный reducer. По умолчанию merge — overwrite, но для списков сообщений обычно используется add_messages, который конкатенирует новые сообщения с историей, а не затирает её.

from typing import Annotated
from langgraph.graph.message import add_messages

class State(TypedDict):
    messages: Annotated[list, add_messages]
    user_id: str
    step_count: int

Reducer add_messages решает классическую проблему чат-агентов: сохранить историю диалога без ручного append в каждом узле.

Узлы как Python-функции

Узел — обычная функция, принимающая state и возвращающая dict с обновлениями. Внутри можно звать LLM, обращаться к БД, делать HTTP-запросы, вызывать tools. Никакой магии: всё, что умеет Python, доступно внутри узла. Это ключевое отличие от LangChain-цепочек, где логика пряталась за RunnableLambda и RunnablePassthrough.

def call_llm(state: State) -> State:
    response = llm.invoke(state["messages"])
    return {"messages": [response]}

def lookup_user(state: State) -> State:
    user = db.get_user(state["user_id"])
    return {"user_context": user}

Узлы могут быть синхронными и асинхронными — LangGraph сам выбирает путь выполнения в зависимости от того, как ты вызвал граф (invoke vs ainvoke).

Условные переходы

Ветвление реализуется через add_conditional_edges с функцией-роутером. Роутер получает state, возвращает строку-имя следующего узла (или END). Это позволяет описывать произвольную логику решений: “если уверенность модели > 0.8 — отвечай сразу, иначе зови ретривер, потом решай ещё раз”.

def should_continue(state: State) -> str:
    last = state["messages"][-1]
    if hasattr(last, "tool_calls") and last.tool_calls:
        return "tools"
    return END

graph.add_conditional_edges("agent", should_continue)

Циклы строятся тривиально: если роутер возвращает имя предыдущего узла, граф выполняется итеративно. Это используется в ReAct-агентах для loop “tool call → LLM → tool call → …” с ограничением через recursion_limit.

Memory и persistence: чекпоинтеры

Самая практически ценная фича LangGraph — checkpoints. Каждый вызов узла сохраняет snapshot состояния в storage backend (по умолчанию MemorySaver в памяти процесса, для прода — SqliteSaver или PostgresSaver). Это даёт три вещи, которых нет у AutoGen и CrewAI:

• Time-travel debugging: можно загрузить snapshot за прошлый запуск и форкнуть выполнение с любого узла. Для LLM-агентов это критично: одна и та же последовательность действий с другим промптом может дать совершенно разный результат.
• Resilient resume: после падения процесса граф восстанавливается с последнего checkpoint, а не с нуля. Длинные research-агенты, которые работают минутами, переживают рестарты контейнера.
• Human-in-the-loop: чекпоинт + interrupt() позволяет агенту остановиться перед критическим действием, подождать approval от человека и продолжить с того же state.

from langgraph.checkpoint.sqlite import SqliteSaver

with SqliteSaver.from_conn_string("checkpoints.db") as checkpointer:
    app = graph.compile(checkpointer=checkpointer)
    config = {"configurable": {"thread_id": "user-123"}}
    app.invoke({"messages": [...]}, config=config)

thread_id в config — идентификатор сессии. По нему чекпоинтер хранит историю перезапусков одного диалога. В production обычно один thread_id = одна пользовательская сессия, что упрощает поддержку и аналитику.

Tool use: вызов внешних инструментов

Агенты — это LLM плюс доступ к инструментам. LangGraph интегрируется с LangChain-инструментами через ToolNode и условный переход “если последнее сообщение содержит tool_calls — зови tools, иначе завершай”. Это стандартная ReAct-схема, но описанная явно через граф, а не через AgentExecutor чёрный ящик.

from langgraph.prebuilt import ToolNode

tools = [search_tool, db_tool, calc_tool]
graph.add_node("tools", ToolNode(tools))
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", END: END})
graph.add_edge("tools", "agent")  # после tools — обратно к LLM

Цикл agent → tools → agent → ... — основа большинства продакшн-агентов. ToolNode парсит tool_calls из последнего LLM-сообщения, вызывает соответствующие функции, оборачивает результат в ToolMessage и возвращает в state. Ответственность LLM — решить, когда звать инструмент, ответственность разработчика — описать инструменты так, чтобы модель понимала, когда каждый из них релевантен.

Для production обычно добавляют: timeout на каждый tool call (иначе медленный API подвесит весь граф), retry с экспоненциальным backoff для транзиентных ошибок, fallback при превышении лимита recursion (типично 25-50 шагов). LangGraph не навязывает эти политики — ты сам оборачиваешь узлы в свою обвязку.

LangGraph против AutoGen и CrewAI

В экосистеме Python для агентов три заметных фреймворка: LangGraph, AutoGen (Microsoft Research), CrewAI. У каждого своя философия, и выбор между ними зависит от того, какая часть задачи для тебя критична.

AutoGen: диалоговая модель агентов

AutoGen (стабильный с осени 2024) фокусируется на групповых чатах между агентами. Архитектурно это набор AssistantAgent и UserProxyAgent, которые обмениваются сообщениями в GroupChat под управлением ChatManager. Сильная сторона — emergent collaboration: агенты сами договариваются, кто что делает. Слабая — недетерминированный control flow. Если агенту нужно сначала подумать, потом проверить, потом эскалировать на человека, в AutoGen это описывается через промпты и роли, а не через явные переходы. Для задач вроде “исследователь + кодер + ревьюер пишут статью” AutoGen подходит хорошо. Для продакшн-пайплайнов с жёсткими SLA — хуже.

CrewAI: ролевая декомпозиция команды

CrewAI построен вокруг идиомы “агент = роль + цель + backstory + tools”. Ты описываешь роли (Researcher, Writer, Editor), задаёшь им цели, фреймворк организует последовательное или иерархическое выполнение. Порог входа ниже, чем у LangGraph: можно собрать работающий multi-agent pipeline за час. Минусы — ограниченный control flow (нет нативного time-travel, нет Postgres checkpointing из коробки, циклы описываются неуклюже), быстрая эволюция API (частые breaking changes между минорными версиями). На конец 2024 — начале 2025 CrewAI хорош для прототипирования, для серьёзного прода — нужно допиливать руками.

LangGraph: явный граф и persistence

LangGraph — это низкоуровневая абстракция. Ты описываешь граф так, как тебе нужно, и получаешь полный контроль над тем, что происходит. За это платишь многословностью: даже простой agent + tools + memory требует десятков строк boilerplate. Но для production это окупается — тестируемость (каждый узел — обычная функция, можно unit-тестировать), observability (через LangSmith или аналоги), и persistence (из коробки).

В сухом остатке на середину 2025:

Сценарий	Лучший выбор
Прототип multi-agent коллаборации за вечер	CrewAI
Research-агент с диалоговым взаимодействием	AutoGen
Продакшн-агент с persistence, observability, SLA	LangGraph
State machine с вероятностными узлами	LangGraph
Диалоговая симуляция без жёсткого flow	AutoGen

Когда НЕ стоит брать LangGraph

LangGraph — не серебряная пуля. Есть сценарии, где он избыточен или вреден.

Простые линейные пайплайны. Если у тебя RAG с одним retriever и одной генерацией, LangChain Chain или прямой вызов LLM проще и быстрее. Граф становится boilerplate- overhead без выигрыша в выразительности.

Emergent collaboration без жёсткого контроля. Когда цель — “пусть агенты сами договорятся”, AutoGen даёт ту же цель меньшими усилиями. LangGraph требует явно прописывать, кто за кем следует.

Не-Python стеки. LangGraph завязан на Python и LangChain-экосистему. Если бэкенд на TypeScript или Go — посмотри на Temporal для оркестрации или на AI SDK Vercel для линейных цепочек.

Простые stateless запросы. Если агент стартует с нуля на каждый запрос и не хранит историю (типичный classification use case) — чекпоинтеры только раздувают storage. MemorySaver в памяти процесса ещё ок, PostgresSaver для такого — overkill.

Production-кейсы и метрики

LangGraph в 2025 используют в нескольких заметных продакшнах.

Replit опубликовал в феврале 2025 кейс multi-step code generation: LangGraph-агент читает task description, планирует последовательность edit-and-test шагов, запускает их в sandbox, итерирует до зелёных тестов. Архитектурно — классический ReAct с per-step retry, persistence между шагами нужен для resume после падений sandbox.

Uber (анонс на GopherCon 2024) использует LangGraph в internal data analyst assistant: пользователь задаёт вопрос на естественном языке, агент через tools обращается к нескольким data warehouses, джойнит результаты, генерирует SQL и пишет отчёт. Граф из 12 узлов с условными переходами по типу запроса и confidence-based эскалацией на аналитика.

LinkedIn (статья Engineering Blog, апрель 2025) построил recruiter assistant поверх LangGraph: один агент парсит резюме, второй ищет совпадения в candidate pool, третий генерирует outreach message. Multi-agent setup с явными переходами, общий Postgres checkpoint для аудита решений.

Метрики, которые авторы кейсов выделяют:

• Latency: медианный запрос 4-8 секунд для single-agent, 15-30 секунд для multi-agent
• Cost: $0.01-0.05 за сессию для Sonnet 4.5 single-agent, $0.10-0.30 для multi-agent с sub-calls
• Success rate: 70-85% для простых задач, 50-65% для сложных multi-step (с retry обычно +10-15%)

Эти цифры усреднённые — конкретный результат зависит от того, насколько хорошо описаны tools, prompts и recursion limits.

С чего начать: минимальный продакшн-стек

Если ты только начинаешь с LangGraph, вот реалистичный минимальный стек для первого агента в продакшне.

Модели. Бери Claude Sonnet 4.5 через OpenRouter/Anthropic API для основной логики и Claude Haiku 4 (или GPT-4o mini) для дешёвых классификаторов и роутинга. Sonnet 4.5 в начале 2026 — лучший баланс качества и цены для агентских задач.

Storage. Начни с SqliteSaver локально, переходи на PostgresSaver (или его managed-аналог) как только выйдешь за одного пользователя. Без persistence ты теряешь time-travel debugging и resume после падений.

Observability. Подключи LangSmith в dev-режиме для визуализации графа и пошаговой отладки. В production либо LangSmith SaaS, либо self-hosted аналог (OpenLLMetry, Langfuse). Без observability отладка агента — чёрный ящик.

Evaluation. Собери golden set из 20-50 тестовых запросов с ожидаемыми трассами. Прогоняй через app.stream() после каждого изменения промпта или структуры графа. Без eval-сета рефакторинг агента — это гадание.

Контроль расходов. Поставь recursion_limit (типично 25 для single-agent, 50 для multi-agent), добавь timeout на каждый tool call, мониторь cost per session через callback handlers. Агент в бесконечном цикле сожжёт бюджет за минуты, если нет защиты.

Документация и материалы

Официальная документация LangGraph на langchain-ai.github.io — лучший старт, особенно tutorial и раздел про persistence. Реальные продакшн-кейсы разобраны в блоге LangChain: Replit multi-step code generation и обзор production-графов от команды.

Связанные материалы

Перед тем как заканчивать, посмотри на эти статьи — они дополняют тему с разных сторон:

• Claude Code: гайд по AI-агенту для разработчика
• Aider vs Cline: какой терминальный AI-агент выбрать в 2026
• Где учиться LLM-инженерии в 2026

Заключение

LangGraph — наиболее зрелый фреймворк для продакшн-агентов в Python-экосистеме начала 2026. Не самый простой (AutoGen и CrewAI порог входа ниже), не самый гибкий в emergent scenarios (AutoGen там выигрывает), но лучший там, где важны control flow, persistence и observability. Если ты строишь агента на продакшн — начни с LangGraph, оставь себе возможность мигрировать на AutoGen, если выяснится, что emergent collaboration важнее явного контроля.

Минимальный путь входа: возьми StateGraph с тремя узлами (agent, tools, final), подключи SqliteSaver, добавь 2-3 инструмента, прогони golden set из 30 кейсов. Через неделю будет рабочий single-agent. Через месяц — multi-agent с persistence, если задача того потребует. Дальше — оптимизация cost/latency, fine-tuning tool descriptions, и эскалация на человека в критических ветках.