Introduction

Les modèles de langage de grande taille (LLM) excellent à répondre à des questions individuelles, mais les applications d'IA réelles se limitent rarement à une seule requête et une seule réponse. Un chatbot utile doit se souvenir des messages précédents, décider de la prochaine action, faire appel à des outils externes si nécessaire et maintenir un état tout au long d'une conversation.

Sans framework, ces comportements se transforment rapidement en instructions if imbriquées, en boucles et en gestion d'état personnalisée. À mesure que l'application grandit, le code devient de plus en plus difficile à maintenir.

LangGraph résout ce problème en nous permettant de modéliser une application d'IA sous forme de graphe. Au lieu de contrôler manuellement chaque étape de la conversation, nous définissons un ensemble de nœuds qui effectuent le travail, des arêtes qui déterminent le flux d'exécution entre ces nœuds, et un état partagé qui transporte les informations à travers le graphe.

Dans cet article, nous allons créer un chatbot simple à partir de zéro tout en explorant les concepts fondamentaux qui font fonctionner LangGraph.

À la fin, vous comprendrez non seulement comment construire un chatbot, mais aussi pourquoi LangGraph est conçu de cette manière.

Prérequis

Avant de commencer, assurez-vous d'avoir :

Nous utiliserons Ollama tout au long de ce tutoriel, mais l'architecture globale est identique pour les autres moteurs d'inférence.

Comprendre les trois concepts fondamentaux

Avant d'écrire du code, il est essentiel de comprendre les trois éléments fondamentaux qui constituent chaque application LangGraph.

État

L'état est la mémoire partagée du graphe.

Chaque nœud reçoit l'état actuel, effectue un certain travail et renvoie une mise à jour de cet état.

Contrairement aux programmes Python traditionnels où les fonctions modifient souvent directement les objets, les nœuds LangGraph ne renvoient que les modifications qu'ils souhaitent effectuer. LangGraph fusionne ensuite ces changements dans l'état partagé.

Vous pouvez considérer l'état comme un carnet que chaque nœud est autorisé à lire. Au lieu d'effacer le carnet, chaque nœud se contente d'y écrire de nouvelles informations.

Pour un chatbot, l'état contient généralement l'historique de la conversation.

Nœuds

Un nœud est simplement une fonction Python.

Son rôle est d'exécuter une tâche spécifique.

Voici quelques exemples :

Chaque nœud suit le même principe de base :

Cette interface simple rend les nœuds faciles à comprendre et à réutiliser.

Arêtes

Les arêtes définissent comment l'exécution progresse à travers le graphe.

Il existe deux types de bords.

Une arête normale transfère toujours l'exécution au nœud suivant.

Par exemple :

DÉBUT → Chatbot → FIN

Une arête conditionnelle permet au graphe de prendre une décision.

Par exemple, après que le chatbot génère une réponse, le graphe peut décider :

Cette capacité à prendre des décisions permet à LangGraph de construire des workflows d'IA complexes tout en gardant le code organisé.

Implémentation de notre premier chatbot

Il est maintenant temps de transformer les concepts de la section précédente en code fonctionnel.

Bien que le programme fasse moins de 40 lignes, il contient tous les composants fondamentaux d'une application LangGraph :

Examinons chaque élément un par un.

Étape 1 : Définition de l'état du graphe

La première chose dont chaque application LangGraph a besoin est un état.

from typing import Annotated 
from typing_extensions import TypedDict 
from langchain_core.messages import BaseMessage 
from langgraph.graph.message import add_messages 
class State(TypedDict): 
  messages: Annotated[list[BaseMessage], add_messages] 

L'état est la mémoire partagée du graphe.

Chaque nœud reçoit l'état actuel en entrée et renvoie les modifications qui doivent être fusionnées dans celui-ci.

Dans notre chatbot, l'état ne contient qu'un seul champ :

messages

qui stocke l'intégralité de la conversation.

Notez que le champ est encapsulé dans Annotated.

Annotated[list[BaseMessage], add_messages] 

C'est l'une des lignes les plus importantes de l'ensemble du programme.

Normalement, lorsqu'un nœud retourne une valeur pour un champ, LangGraph remplace la valeur précédente. Par exemple, si un nœud retournait :

{"messages": [response]} 

l'ancienne conversation disparaîtrait.

La fonction add_messages modifie ce comportement. Au lieu de remplacer la liste, LangGraph ajoute les nouveaux messages à la conversation existante.

Sans add_messages, le chatbot oublierait tout après chaque tour de conversation.

Étape 2 : Création du modèle de langage

Ensuite, nous créons le modèle de langage.

from langchain.chat_models import init_chat_model 
llm = init_chat_model( "llama3.2:1b", model_provider="ollama", )

init_chat_model() crée un modèle de chat avec lequel LangChain sait communiquer.

Bien que nous utilisions Ollama dans ce tutoriel, le reste du code resterait presque identique si vous passiez à OpenAI, Anthropic ou un autre fournisseur pris en charge. L'un des avantages de LangChain est qu'il fournit une interface commune pour de nombreux modèles de langage différents.

Étape 3 : Écriture du nœud de chatbot

Maintenant, nous pouvons créer notre premier nœud.

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

Rappelez-vous qu'un nœud est simplement une fonction Python.

Il reçoit l'état actuel en entrée.

state["messages"] 

contient l'intégralité de la conversation jusqu'à présent.

Le nœud envoie ces messages au modèle de langage.

response = llm.invoke(state["messages"])

Le modèle génère une réponse, qui est retournée sous forme de AIMessage.

Enfin, le nœud renvoie :

{ "messages": [response] } 

Notez que le nœud ne modifie pas directement l'état existant.

Au lieu de cela, il ne retourne que les nouvelles informations qu'il souhaite ajouter.

LangGraph est chargé de fusionner cette mise à jour dans l'état partagé.

Comme nous avons configuré le champ messages avec add_messages, la nouvelle réponse de l'IA est ajoutée à la conversation au lieu de la remplacer.

Cette séparation entre la lecture de l'état et le retour des mises à jour est l'un des principes fondamentaux de conception de LangGraph.

Étape 4 : Construction du graphe

Maintenant que nous avons un nœud, nous pouvons construire le graphe lui-même.

builder = StateGraph(State) 
builder.add_node("chatbot", chatbot) 
builder.add_edge(START, "chatbot") 
builder.add_edge("chatbot", END) 

La première ligne crée un graphe dont l'état partagé est défini par notre classe State.

builder = StateGraph(State)

Ensuite, nous enregistrons la fonction du chatbot en tant que nœud.

builder.add_node("chatbot", chatbot) 

Le premier argument est le nom du nœud dans le graphe, tandis que le deuxième argument est la fonction Python qui doit être exécutée.

Enfin, nous connectons les nœuds ensemble :

DÉBUT → chatbot → FIN

Graphiquement, le flux de travail se présente comme suit :

Bien que ce graphe ne contienne qu'un seul nœud, les applications plus importantes suivent exactement le même schéma. La seule différence est qu'elles contiennent davantage de nœuds et une logique de routage plus complexe.

Étape 5 : Ajout de mémoire

Ensuite, nous ajoutons de la mémoire à notre chatbot.

from langgraph.checkpoint.memory import InMemorySaver 
checkpointer = InMemorySaver() 
graph = builder.compile( checkpointer=checkpointer) 

Sans point de contrôle, chaque appel au graphe serait traité comme une conversation entièrement nouvelle.

Le vérificateur enregistre l'état du graphe après chaque exécution et le restaure la prochaine fois que la même conversation se poursuit.

Dans cet exemple, nous utilisons InMemorySaver, qui conserve tout dans la mémoire du programme.

C'est parfait pour l'apprentissage et les tests, mais comme les données sont stockées uniquement en RAM, toutes les conversations sont perdues lorsque le programme se termine.

Pour les applications en production, LangGraph prend également en charge les vérificateurs persistants reposant sur des bases de données comme PostgreSQL ou SQLite.

Étape 6 : Identification d'une conversation

Comme le vérificateur peut stocker plusieurs conversations, LangGraph a besoin d'un moyen pour savoir laquelle charger.

C'est l'objet de l'objet de configuration.

config = { "configurable": { "thread_id": "thread-1" } } 

Le thread_id agit comme identifiant unique de la conversation.

Lorsque le graphe est invoqué avec le même thread_id, LangGraph restaure l'état précédemment sauvegardé et poursuit la conversation là où elle s'était arrêtée.

Si un thread_id différent est utilisé, LangGraph démarre une toute nouvelle conversation.

Vous pouvez considérer le thread_id comme un identifiant de session de discussion.

Étape 7 : Exécution du graphe

Enfin, nous créons une simple boucle de chat.

while True:
    user_input = input("You: ")

    if user_input.lower() in {"quit", "exit"}:
        break

    result = graph.invoke(
        {
            "messages": [{"role": "user","content": user_input,}],
        },
        config=config
    )

    print("AI:", result["messages"][-1].content)

Chaque itération effectue les étapes suivantes :

Notez que nous passons uniquement le nouveau message utilisateur à graph.invoke(). Nous ne renvoyons pas manuellement l'historique complet de la conversation. Le checkpointer restaure automatiquement les messages précédents avant l'exécution du graphe, puis sauvegarde à nouveau l'état mis à jour après l'exécution.

C'est l'une des principales différences entre l'utilisation directe de LangGraph et la gestion manuelle de l'historique des conversations : le graphe prend en charge la restauration et la persistance de l'état pour vous, permettant à votre code applicatif de se concentrer sur le workflow lui-même.