Strona główna / Artykuły

LangChain kontra LangGraph: Wybór między łańcuchami a grafami z stanem

LangChain oferuje liniowe łańcuchy; LangGraph dodaje pracownice z stanem i możliwością rozgałęziania. Proste przykłady obu rozwiązań oraz prosty sposób na określenie, które jest potrzebne w Twojej aplikacji.

Wydawca: REACTAPP.TOP5 min czytania1088 słów

Źródła: LangChain vs LangGraph: What’s the Difference?

Jeśli dopiero zaczynasz pracę nad rozwojem sztucznej inteligencji, dwa nazwy pojawiają się wszędzie:

LangChain i LangGraph.

Na pierwszy rzut oka mogą wydawać się zamienne. Czy to te same narzędzia? Czy musisz nauczyć się obu? I jak zdecydować, które pasuje do twojego projektu?

Rozbierzmy to na prostym przykładzie.

Czym jest LangChain?

Pomyśl o LangChain jako o zestawie narzędzi do budowania aplikacji AI.

Dostarcza gotowe elementy, które umożliwiają pracę z modelami językowymi oraz łączenie ich z innymi zasobami, takimi jak:

  • Prompty
  • Modele językowe
  • Narzędzia
  • API
  • Dokumenty
  • Bazy danych wektorowych
  • Narzędzia do wyszukiwania

Załóżmy, że chcesz stworzyć podstawowego nauczyciela AI.

Proces może wyglądać w ten sposób:

Student Question
       ↓
     Prompt
       ↓
      LLM
       ↓
     Answer

LangChain sprawia, że budowa tego typu pipeline’ów jest dość prosta.

Prosty przykład 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)

Logika tutaj jest prosta i liniowa:

Pytanie → Prompt → LLM → Odpowiedź

Taki prosty pipeline to dokładnie to, w czym LangChain się doskonale sprawdza.

Czym jest LangGraph?

Załóżmy teraz, że twój szkolny asystent AI musi obsłużyć więcej niż jedną próbę.

Zamiast po prostu podać odpowiedź, chcesz, aby:

  1. Odpowiedział na pytanie ucznia.
  2. Ocenił, czy ta odpowiedź jest rzeczywiście dobra.
  3. Jeśli jest dobra, zakończył działanie.
  4. Jeśli nie jest dobra, ją poprawił.
  5. Ponownie sprawdził poprawioną odpowiedź.

Przepływ teraz wygląda mniej więcej tak:

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

To właśnie taki scenariusz został stworzony specjalnie dla LangGraph.

LangGraph umożliwia projektowanie procesów roboczych, które mogą zawierać:

  • Wielokrotne kroki
  • Główki warunkowe
  • Pętle
  • Wspólny stan
  • Punkty decyzyjne
  • Zatwierdzenie z udziałem człowieka
  • Bardziej złożone zachowanie agenta

Prosty przykład LangGraph

Aby zacząć, musisz zdefiniować stan, który twoja aplikacja musi śledzić.

from typing import TypedDict
class State(TypedDict):
    question: str
    answer: str
    good: bool

Ten stan rejestruje trzy rzeczy:

question
answer
good

Następnie tworzysz poszczególne kroki, nazywane węzłami, wewnątrz swojego grafu.

Wygeneruj odpowiedź

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

Sprawdź odpowiedź

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"
    }

Następnie definiujesz funkcję decyzyjną:

def decision(state):
    if state["good"]:
        return "finish"    return "improve"

Ważne jest to, że to LangGraph łączy te węzły ze sobą i decyduje który węzeł ma zostać uruchomiony następnie.

Jeśli sprawdzenie nie powiedzie się, graf może wrócić do węzła ulepszeń i ponownie je przeprowadzić.

Jaka jest więc główna różnica?

Najprostszym sposobem na sformułowanie tej różnicy jest następujący:

LangChain = elementy budulcowe

LangChain dostarcza pojedyncze komponenty, z których buduje się aplikacje AI.

Naprzимер:

LLM
Prompt
Retriever
Tool
Vector Database
     ↓
   LangChain

LangGraph = proces pracy

LangGraph określa, w jaki sposób te komponenty ze sobą współpracują i w jakiej kolejności.

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

Czy LangChain i LangGraph są konkurentami?

Nie do końca.

Są zaprojektowane tak, aby być używanymi obok siebie.

Naprzимер:

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

LangChain dostarcza elementy budulcowe i narzędzia, natomiast LangGraph koordynuje cały proces pracy wokół nich.

Kiedy należy używać LangChain?

LangChain to właściwy wybór, gdy twoja aplikacja ma dość liniową strukturę działania.

Typowe przypadki to:

  • Bazowy chatbot
  • Aplikacja oparta na RAG
  • Odpowiadanie na pytania z pliku PDF
  • Szukanie w dokumentach
  • Zwykła aplikacja wykorzystująca LLM
  • Proste uruchamianie narzędzi

Bazowy przepływ w takim przypadku może wyglądać mniej więcej tak:

User
 ↓
Retrieve Information
 ↓
LLM
 ↓
Answer

W przypadku takich konfiguracji tworzenie pełnej struktury grafu jest zazwyczaj przesadą.

Kiedy należy używać LangGraph?

LangGraph sprawdza się wtedy, gdy twoja aplikacja wymaga logiki rozgałęzień i decyzji, a nie tylko ustalonej sekwencji kroków.

Należą do tego sytuacje takie jak:

  • Autonomiczne agenty AI
  • Przepływy pracy obejmujące kilka kroków
  • Systemy z kilkoma współpracującymi agentami
  • Procesy z udziałem człowieka
  • Przepływy, które wymagają pętli
  • Aplikacje potrzebujące trwałego stanu między poszczególnymi krokami
  • Zaawansowane łańcuchy wywoływania narzędzi
  • Jako przykład wyobraźmy sobie nauczyciela AI zbudowanego w ten sposób:

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

    Takie zachowanie z podziałem na gałęzie i utrzymywaniem stanu to dokładnie obszar, w którym LangGraph wyróżnia się najlepiej.

    Najprostsza analogia

    Pomyśl o budowie domu.

    LangChain pełni rolę twojego zestawu narzędzi.

    Dostarcza ci takie rzeczy jak:

    Cegły, narzędzia, materiały i komponenty.

    LangGraph pełni rolę planu budowy.

    Określa sekwencję działań:

    Zbuduj fundamenty → postaw ściany → dodaj dach → sprawdź pracę → jeśli coś jest nie tak, wróć i to popraw.

    Krótko mówiąc:

    LangChain pomaga ci składać poszczególne elementy.

    LangGraph pomaga ci zarządzać tym procesem.

    Podsumowanie

    Zamiast postrzegać LangChain i LangGraph jako niepowiązane narzędzia, dokładniej jest traktować je jako dwie warstwy tej samej architektury.

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

    Jeśli twój przypadek użycia jest prosty, sam LangChain prawdopodobnie spełni twoje potrzeby.

    Gdy aplikacja wymaga śledzenia stanu, logiki warunkowej, pętli lub złożonego zachowania agenta, LangGraph okazuje się lepszym wyborem.

    Jednak w wielu systemach produkcyjnych oba narzędzia są łączone.

    Zasada, którą warto zapamiętać:

    LangChain buduje poszczególne elementy. LangGraph łączy je i kontroluje przepływ.

    Pozycje pokrewne

  • Automatyzacja wprowadzania transakcji w FastAPI za pomocą asystenta AI LangGraph — Dowiedz się, jak stworzyć asystenta AI zarządzanego przez LangGraph, który przetwarza język naturalny na strukturyzowane transakcje i zapisuje je do bazy danych PostgreSQL za pośrednictwem FastAPI.