LangChain против LangGraph: выбор между цепями и графами с состоянием

Если вы только начинаете заниматься разработкой ИИ, два названия постоянно встречаются повсюду:

LangChain и LangGraph.

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

Давайте разберем это на простом примере.

Что такое LangChain?

Представьте LangChain как набор инструментов для создания приложений ИИ.

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

• Подсказки
• Большие языковые модели
• Инструменты
• API
• Документы
• Векторные базы данных
• Механизмы поиска

Допустим, вы хотите создать простого учителя-ассистента ИИ.

Поток обработки данных может выглядеть так:

Student Question
       ↓
     Prompt
       ↓
      LLM
       ↓
     Answer

LangChain значительно упрощает создание подобных пайплайнов.

Простой пример LangChain

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o-mini")prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful programming teacher."),
    ("human", "{question}")
])chain = prompt | llmresponse = chain.invoke({
    "question": "What is recursion?"
})print(response.content)

Логика здесь проста и линейна:

Вопрос → Подсказка → ЯЗЫК_МОДЕЛИ → Ответ

Именно такие прямолинейные пайплайны — это сильная сторона LangChain.

Что такое LangGraph?

Теперь предположим, что вашу искусственную интеллект-наставницу необходимо использовать более чем один проход для обработки задачи.

Вместо того чтобы просто выдать ответ, вы хотите, чтобы она:

1. Ответила на вопрос ученика.
2. Оценила, действительно ли этот ответ хорош.
3. Если ответ хорош, остановилась на этом.
4. Если ответ плох, внесла коррективы.
5. Повторно проверила исправленный ответ.

Теперь поток обработки выглядит примерно так:

Student Question
                    ↓
              Generate Answer
                    ↓
               Check Answer
                ↙        ↘
             Good          Bad
              ↓             ↓
            Finish       Improve
                            ↓
                       Check Again

Именно для подобных сценариев и был создан LangGraph.

LangGraph позволяет создавать рабочие процессы, которые могут включать:

• Множество шагов
• Условные ветви
• Циклы
• Общее состояние
• Точки принятия решений
• Утверждение с участием человека
• Более сложное поведение агентов

Простой пример LangGraph

Чтобы начать, необходимо определить состояние, которое должна отслеживать ваша приложение.

from typing import TypedDict

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

Это состояние отслеживает три вещи:

question
answer
good

Далее вы создаете отдельные шаги, называемые узлами, внутри своей схемы.

Генерация ответа

def generate_answer(state):

    response = llm.invoke(
        f"Answer this question simply:\n{state['question']}"
    )    return {
        "answer": response.content
    }

Проверка ответа

def check_answer(state):

    response = llm.invoke(
        f"""
        Is this answer good?        Question:
        {state['question']}        Answer:
        {state['answer']}        Reply only YES or NO.
        """
    )    return {
        "good": response.content.strip().upper() == "YES"
    }

Затем вы определяете функцию принятия решений:

def decision(state):

    if state["good"]:
        return "finish"    return "improve"

Важно понимать, что именно LangGraph связывает эти узлы между собой и определяет, какой узел будет выполняться далее.

Если проверка проваливается, граф может вернуться к узлу улучшения и повторно выполнить проверку позже.

В чём же основная разница?

Самый простой способ сформулировать это различие — следующий:

LangChain = строительные блоки

LangChain предоставляет отдельные компоненты, из которых собирается приложение ИИ.

Например:

LLM
Prompt
Retriever
Tool
Vector Database
     ↓
   LangChain

LangGraph = рабочий процесс

LangGraph определяет, как взаимодействуют эти компоненты и в каком порядке.

Start
         ↓
      Generate
         ↓
       Check
      ↙     ↘
    Good     Bad
     ↓        ↓
   Finish   Improve
              ↓
            Check

Являются ли LangChain и LangGraph конкурентами?

Не совсем.

Они разработаны для совместного использования.

Например:

LangGraph
                     ↓
          ┌──────────┴──────────┐
          ↓                     ↓
     LangChain              LangChain
     Retriever                 Tools
          ↓                     ↓
          └──────────┬──────────┘
                     ↓
                    LLM

LangChain предоставляет строительные блоки и инструменты, в то время как LangGraph координирует более крупный рабочий процесс вокруг них.

Когда следует использовать LangChain?

LangChain — правильный выбор, когда ваше приложение следует довольно линейному пути.

Типичные случаи включают:

• Простой чат-бот
• Приложение на основе технологии RAG
• Ответы на вопросы из PDF-файлов
• Поиск в документах
• Простое приложение, работающее с большими языковыми моделями
• Вызов простых инструментов

Основной поток выполнения в таком случае может выглядеть примерно так:

User
 ↓
Retrieve Information
 ↓
LLM
 ↓
Answer

Для подобных конфигураций создание полной графовой структуры обычно является чрезмерным решением.

Когда следует использовать LangGraph?

LangGraph находит свое применение тогда, когда вашему приложению требуется логика с ветвлениями и принятием решений, а не просто фиксированная последовательность шагов.

Это касается ситуаций, таких как:

• Автономные ИИ-агенты
• Рабочие процессы, включающие несколько шагов
• Системы с несколькими взаимодействующими агентами
• Процессы с участием человека

Потоки, которые должны выполняться циклически

Приложения, требующие сохранения состояния между этапами

Сложные цепочки вызовов инструментов

В качестве примера представьте учебного ассистента на основе ИИ, структурированного следующим образом:

Student asks question
        ↓
Analyze level
        ↓
Generate explanation
        ↓
Give quiz
        ↓
Check answer
        ↓
Correct?
   ↙          ↘
 YES           NO
  ↓             ↓
Next topic   Explain again

Именно такое ветвление и поведение, зависящее от состояния, — это то, в чем проявляется преимущество LangGraph.

Самая простая аналогия

Представьте себе строительство дома.

LangChain выступает в роли вашего набора инструментов.

Он предоставляет вам такие вещи, как:

Кирпичи, инструменты, материалы и компоненты.

LangGraph выступает в роли проекта дома.

Он определяет последовательность действий:

Заложить фундамент → построить стены → установить крышу → проверить работу → если что-то не так, вернуться и исправить это.

Короче говоря:

LangChain помогает вам собирать все необходимые элементы.

LangGraph помогает вам управлять этим процессом.

Итоги

Вместо того чтобы рассматривать LangChain и LangGraph как не связанные инструменты, более точно будет считать их двумя уровнями одной и той же системы.

AI Application
              ↓
          LangGraph
       (Workflow / Logic)
              ↓
          LangChain
      (Tools / Components)
              ↓
             LLM

Если ваш случай использования прост, один LangChain, скорее всего, покроет ваши потребности.

Когда ваше приложение требует отслеживания состояния, условной логики, циклов или сложного поведения агента, LangGraph становится более подходящим решением.

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

Правило, которое стоит запомнить:

LangChain создает отдельные компоненты. LangGraph связывает их и контролирует поток работы.