LangChain contre LangGraph : rôles, utilisateurs et quand choisir l’un ou l’autre

Ce guide permet de reconstruire un parcours fonctionnel pour : LangChain et LangGraph Explained : ce qu’ils sont, qui les utilise, et comment créer des agents IA avec eux. L’accent est mis sur les contrats, les vérifications et le code que l’on peut intégrer dans un dépôt sans devoir deviner son intention. Pour une vue d’ensemble, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans avoir à deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du graphe.

llm = ChatOpenAI()

if (userAskedForFlights()) {
    callFlightApi();
}

if (resultsAvailable()) {
    summarizeResults();
}

User Question
      ↓
Reason
      ↓
Search Tool
      ↓
Analyze Result
      ↓
Answer

User Request
      |
      +---- Search
      |
      +---- Database
      |
      +---- Human Approval
                |
                v
             Continue

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4o"
)

def get_weather(city):
    return weather_api(city)

tools = [get_weather]

Need weather information

weather = get_weather("Bangalore")

{
  "temperature": 34,
  "condition": "Sunny"
}

The current temperature in Bangalore is 34°C and the weather is sunny.

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4o"
)
response = llm.invoke(
    "Explain microservices in simple terms."
)
print(response.content)

User Request
      |
      v
Analyze Request
      |
      +---- Search Agent
      |
      +---- Database Agent
      |
      +---- Human Review
      |
      v
Generate Final Response

from langgraph.graph import StateGraph

builder = StateGraph(AgentState)

builder.add_node("search", search_node)
builder.add_node("answer", answer_node)

builder.set_entry_point("search")

builder.add_edge("search", "answer")

graph = builder.compile()

class AgentState(TypedDict):
    question: str
    search_result: str
    answer: str


Example:

{
  "question": "What is LangGraph?",
  "search_result": "",
  "answer": ""
}

def search_node(state):
    ...

builder.add_node("search", search_node)
builder.add_node("answer", answer_node)

builder.add_edge(
    "search",
    "answer"
)

builder.set_entry_point("search")

graph = builder.compile()

              State
                │
                ▼
        ┌─────────────┐
        │   Search    │  ← Node
        └─────────────┘
                │
                │  ← Edge
                ▼
        ┌─────────────┐
        │   Answer    │  ← Node
        └─────────────┘
                │
                ▼
         Updated State

Un message de AI Mind

Pour « Un message de AI Mind », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez conjointement le parcours normal et les scénarios de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations ultérieures. Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges facilitent les injections et rendent les audits coûteux.

Liste de contrôle opérationnelle

Pour la liste de contrôle opérationnelle, définissez les entrées, le responsable de l’étape et les critères d’achèvement avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.

Enregistrez les temps d’exécution et les coûts à côté des résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés.

Créez un point de contrôle après des appels de modèles coûteux afin qu’un nouvel essai ne génère pas à nouveau des frais pour le même travail.

Gardez l’état du graphe simple et typé. Les blocs imbriqués masquent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption.

Rédigez un petit manuel d’utilisation : comment rotationner les clés, comment vider la file d’attente, comment annuler la dernière modification.

Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité et non vers un processus embrouillé.

Au préalable de promouvoir la pile logicielle, figez les versions, créez une transcription d’ référence pour le chemin critique et confirmez les étapes de rollback. Les environnements partagés nécessitent des limites de débit, des vérifications d’affectation et un responsable clair pour la rotation des secrets. Préférez une fiabilité sans faille à des démonstrations brillantes mais ponctuelles.

Pour la note de renforcement 0, définissez les entrées, le responsable de l’étape et les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.

Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les stockages de secrets et les flags fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système.

Séparez la planification de l’exécution des outils. Le planificateur propose ; l’exécutant modifie ; le vérificateur compare les résultats à l’objectif fixé.

Pour la note de renforcement 1, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.

Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé.

Restreignez strictement les schémas des outils. Des arguments de texte libre trop larges facilitent les injections et rendent les audits coûteux.

Pour la note de renforcement 2, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.

Enregistrez les temps d’exécution et les coûts en même temps que les résultats fonctionnels. Une visibilité précoce évite des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés.

Point de contrôle après les appels coûteux aux modèles afin qu’une tentative de réexécution ne facture pas à nouveau le même travail.

Pour la note 3 relative au renforcement de la sécurité, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir réexécuter l’étape à partir d’un point de contrôle connu sans deviner l’état caché.

Dokumentez ensemble le parcours normal et le parcours de récupération. Les tentatives de réexécution, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’une amélioration ultérieure.

Séparez la planification de l’exécution des outils. Le planificateur propose ; l’exécutant modifie ; le vérificateur contrôle les résultats par rapport à l’objectif.