Technical Tutorials

Introduction

Les grands modèles de langage (LLM) ont révolutionné notre interaction avec le logiciel, mais les architectures à agent unique peinent souvent face aux flux de travail complexes et multi-étapes. Lorsqu'une tâche nécessite des compétences distinctes—comme la récupération de précédents juridiques, l'exécution de calculs mathématiques, puis la synthèse d'un rapport cohérent—un LLM généraliste unique peut devenir sujet à des hallucinations ou à une perte de contexte.

C'est là que LangGraph excelle. En tant que puissant framework construit sur LangChain, LangGraph permet aux développeurs de définir des applications multi-agents avec état sous forme de graphes. En orchestrant des agents LLM spécialisés, nous pouvons créer des systèmes plus robustes, précis et maintenable. Dans ce guide, nous explorerons l'architecture des systèmes multi-agents et fournirons une implémentation pratique pour un scénario complexe de support client.

Pourquoi une architecture multi-agents ?

Les approches traditionnelles de chaîne de pensée traitent le LLM comme une boîte noire unique. En revanche, une architecture multi-agents décompose les problèmes en sous-tâches plus petites, chacune gérée par un agent doté d'outils et d'instructions spécifiques. Les principaux avantages incluent :

Spécialisation : Chaque agent se concentre sur un domaine étroit, améliorant la précision.
Débogage : Vous pouvez tracer exactement où dans le flux de travail une erreur s'est produite.
Évolutivité : De nouvelles capacités peuvent être ajoutées en tant que nouveaux nœuds dans le graphe sans réécrire la logique principale.

Conception architecturale : Le graphe d'état

Au cœur de LangGraph se trouve le StateGraph. L'état est un dictionnaire qui persiste à travers tous les nœuds (agents) du graphe. Pour notre cas d'utilisation, concevons un bot de support avec trois agents :

Agent de tri : Classe l'intention de l'utilisateur (par exemple, facturation, technique, compte).
Agent spécialiste : Un nœud dynamique qui achemine vers l'outil spécialisé ou le prompt LLM approprié.
Agent synthétiseur : Combine les résultats du spécialiste en une réponse finale, conviviale.

Implémentation : Construction des agents

D'abord, nous devons définir le schéma d'état et les agents individuels. Nous utiliserons Python et la bibliothèque langgraph.

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
from langchain_openai import ChatOpenAI
import operator

# 1. Définir l'état
class SupportState(TypedDict):
    user_query: str
    intent: str
    specialist_response: str
    final_response: str

# 2. Initialiser les LLM
llm = ChatOpenAI(model="gpt-4", temperature=0)

# 3. Définir les fonctions des agents
def triage_agent(state: SupportState) -> dict:
    """Classe l'intention de l'utilisateur."""
    prompt = f"Classifiez la requête suivante en 'facturation', 'technique' ou 'autre' : {state['user_query']}"
    intent = llm.invoke(prompt).content.strip().lower()
    return {"intent": intent}

def specialist_agent(state: SupportState) -> dict:
    """Gère la logique du domaine spécifique."""
    if state["intent"] == "billing":
        # Dans une application réelle, vous appelleriez une API ou un RAG ici
        response = "J'ai vérifié votre statut de facturation. Votre compte est en règle."
    elif state["intent"] == "technical":
        response = "Veuillez essayer de redémarrer votre appareil. Si les problèmes persistent, vérifiez vos paramètres de pare-feu."
    else:
        response = "Je ne suis pas sûr de savoir comment traiter cette demande spécifique."
    return {"specialist_response": response}

def synthesizer_agent(state: SupportState) -> dict:
    """Combine la sortie du spécialiste en une réponse conviviale."""
    prompt = f"""
    Requête de l'utilisateur : {state['user_query']}
    Infos du spécialiste : {state['specialist_response']}
    
    Rédigez une réponse polie et professionnelle à l'utilisateur basée sur les infos du spécialiste.
    """
    final_response = llm.invoke(prompt).content
    return {"final_response": final_response}

Orchestration du flux de travail

Maintenant, nous connectons ces fonctions en un graphe. LangGraph utilise des nœuds pour représenter les agents et des arêtes pour définir le flux de données.

# 4. Construire le graphe
workflow = StateGraph(SupportState)

# Ajouter les nœuds
workflow.add_node("triage", triage_agent)
workflow.add_node("specialist", specialist_agent)
workflow.add_node("synthesizer", synthesizer_agent)

# Définir le flux
workflow.set_entry_point("triage")
workflow.add_edge("triage", "specialist")
workflow.add_edge("specialist", "synthesizer")
workflow.add_edge("synthesizer", END)

# Compiler le graphe
app = workflow.compile()

Test du système

Pour tester notre chatbot multi-agents, nous invoquons simplement l'application compilée avec une requête utilisateur. Notez comment l'état circule du tri, vers le spécialiste, et enfin vers le synthétiseur.

# 5. Exécuter l'application
query = "J'ai été facturé deux fois pour mon dernier renouvellement d'abonnement."
result = app.invoke({
    "user_query": query,
    "intent": "",
    "specialist_response": "",
    "final_response": ""
})

print(f"Intention détectée : {result['intent']}")
print(f"Réponse finale : {result['final_response']}")

Conclusion

La création de chatbots IA multi-agents avec LangGraph transforme la manière dont nous gérons les tâches IA complexes. En décomposant les problèmes en nœuds spécialisés, nous obtenons un meilleur contrôle sur le processus de raisonnement et pouvons intégrer divers outils sans effort. Bien que l'exemple ci-dessus soit linéaire, LangGraph prend également en charge le branchement conditionnel et les cycles, permettant des interactions d'agents encore plus sophistiquées, telles qu'un agent demandant des clarifications avant de procéder. À mesure que vous continuez à construire, envisagez d'ajouter la journalisation et des approbations par un humain dans la boucle pour assurer la sécurité et la fiabilité dans les environnements de production.