Tutoriel LangGraph : Guide complet pour débutants
Découvrez comment tirer parti d'un framework Python pour créer des flux de travail d'IA dynamiques, de l'installation aux applications avancées comme les chatbots.
LangGraph est un framework Python conçu pour créer des workflows d'IA avec états à l'aide de structures graphiques. Contrairement aux outils linéaires, LangGraph Permet aux workflows de s'adapter dynamiquement en fonction des conditions, des résultats ou des entrées utilisateur. Ses fonctionnalités phares incluent la gestion des états persistants, la coordination multi-agents et la prise en charge intégrée de la supervision humaine. Ces capacités en font un outil idéal pour la création d'applications avancées telles que les chatbots, les systèmes collaboratifs et les workflows conditionnels.
LangGraph simplifie les tâches complexes, comme la gestion du contexte conversationnel ou l'intégration d'outils externes. Par exemple, un chatbot développé avec LangGraph peut suivre l'historique des utilisateurs, remonter les problèmes aux agents humains et générer des réponses basées sur le contexte enregistré. Grâce à son approche graphique, les développeurs peuvent concevoir des workflows qui gèrent efficacement les ramifications, les boucles et la récupération d'erreurs.
Pour ceux qui recherchent une alternative low-code, Laténode propose une plateforme visuelle intégrant de nombreux principes de LangGraph, rendant la création de workflows accessible aux utilisateurs sans expérience approfondie du codage. Avec Latenode, vous pouvez concevoir visuellement des workflows, gérer l'état et intégrer plus de 200 modèles d'IA de manière fluide. Que vous souhaitiez créer des chatbots, automatiser les approbations ou coordonner des tâches multi-agents, des outils comme LangGraph et Latenode offrent des solutions pratiques et adaptées à vos besoins.
LangGraph Tutoriel 1 : Composants de LangGraph Explication | État | Nœuds | Arêtes
Tutoriel LangGraph pour les débutants
LangGraph est un framework Python conçu pour rationaliser l'automatisation des flux de travail, de la configuration de base à la création de systèmes complexes et adaptables.
Installation et configuration
Pour démarrer avec LangGraph, vous devez d'abord configurer votre environnement. Commencez par créer un environnement virtuel dédié pour isoler les dépendances et éviter les conflits. Ouvrez votre terminal et exécutez les commandes suivantes :
python -m venv venv
<span class="hljs-built_in">source</span> venv/bin/activate <span class="hljs-comment"># For macOS/Linux</span>
<span class="hljs-comment"># venv\Scripts\activate # For Windows</span>
Une fois l'environnement virtuel activé, installez LangGraph via pip :
pip install -U langgraph
Vous pouvez confirmer l'installation en important la bibliothèque dans un REPL Python :
<span class="hljs-keyword">import</span> langgraph
LangGraph nécessite souvent des dépendances supplémentaires pour s'intégrer à des modèles de langage ou à des outils externes. Par exemple :
- Utilisez le
langchain-openaipour OpenAI . - Installer
langchain[anthropic]pour Claude l'intégration. - Ajouter
tavily-pythonpour les capacités de recherche sur le Web [2][1][3][4].
Pour gérer les clés API de manière sécurisée, stockez-les dans des variables d'environnement. Par exemple, définissez votre clé API OpenAI comme suit :
<span class="hljs-built_in">export</span> OPENAI_API_KEY=<span class="hljs-string">"your-api-key-here"</span>
Sous Windows, remplacez export avec setCes clés permettent à LangGraph d'interagir avec des services externes pendant l'exécution du workflow [2][1][3][4].
Avec l'environnement prêt et LangGraph installé, vous êtes prêt à créer votre premier flux de travail.
Construire votre premier graphique
Les flux de travail LangGraph s'articulent autour de la définition et de la gestion de l'état, à l'aide de Python TypedDict Pour une gestion sécurisée des données. Voici un exemple simple pour commencer :
<span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> TypedDict
<span class="hljs-keyword">from</span> langgraph.graph <span class="hljs-keyword">import</span> StateGraph, START, END
<span class="hljs-keyword">class</span> <span class="hljs-title class_">GraphState</span>(<span class="hljs-title class_ inherited__">TypedDict</span>):
message: <span class="hljs-built_in">str</span>
count: <span class="hljs-built_in">int</span>
Les opérations de workflow sont encapsulées dans des nœuds, qui traitent l'état actuel et renvoient les mises à jour sous forme de dictionnaires. Chaque nœud se concentre sur une tâche spécifique tout en préservant l'état global :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">greeting_node</span>(<span class="hljs-params">state: GraphState</span>):
<span class="hljs-keyword">return</span> {<span class="hljs-string">"message"</span>: <span class="hljs-string">f"Hello! Processing item <span class="hljs-subst">{state[<span class="hljs-string">'count'</span>]}</span>"</span>}
<span class="hljs-keyword">def</span> <span class="hljs-title function_">counter_node</span>(<span class="hljs-params">state: GraphState</span>):
<span class="hljs-keyword">return</span> {<span class="hljs-string">"count"</span>: state[<span class="hljs-string">"count"</span>] + <span class="hljs-number">1</span>}
Ensuite, initialisez un StateGraph, ajoutez des nœuds et définissez l'ordre d'exécution à l'aide d'arêtes :
<span class="hljs-comment"># Initialize the graph with state schema</span>
workflow = StateGraph(GraphState)
<span class="hljs-comment"># Add nodes to the graph</span>
workflow.add_node(<span class="hljs-string">"greeting"</span>, greeting_node)
workflow.add_node(<span class="hljs-string">"counter"</span>, counter_node)
<span class="hljs-comment"># Define execution flow</span>
workflow.add_edge(START, <span class="hljs-string">"greeting"</span>)
workflow.add_edge(<span class="hljs-string">"greeting"</span>, <span class="hljs-string">"counter"</span>)
workflow.add_edge(<span class="hljs-string">"counter"</span>, END)
<span class="hljs-comment"># Compile the graph</span>
app = workflow.<span class="hljs-built_in">compile</span>()
Pour exécuter le graphique, fournissez un état initial et appelez l'application compilée :
initial_state = {<span class="hljs-string">"message"</span>: <span class="hljs-string">""</span>, <span class="hljs-string">"count"</span>: <span class="hljs-number">0</span>}
result = app.invoke(initial_state)
<span class="hljs-built_in">print</span>(result) <span class="hljs-comment"># {'message': 'Hello! Processing item 0', 'count': 1}</span>
Cet exemple illustre les concepts fondamentaux de LangGraph. Vous pouvez ensuite développer des workflows plus avancés.
Principes fondamentaux de la gestion de l'État
La gestion des états dans LangGraph va au-delà du simple transfert de données. Elle garantit un état typé et persistant tout au long du workflow, permettant une coordination fluide entre les opérations.
Contrairement aux systèmes sans état qui perdent le contexte entre les étapes, LangGraph conserve l'état tout au long du cycle de vie du workflow. Cette fonctionnalité est particulièrement utile pour les applications comme l'IA conversationnelle ou les processus multi-étapes. Par exemple, vous pouvez gérer le contexte d'une conversation avec un TypedDict:
<span class="hljs-keyword">class</span> <span class="hljs-title class_">ConversationState</span>(<span class="hljs-title class_ inherited__">TypedDict</span>):
messages: <span class="hljs-built_in">list</span>
user_id: <span class="hljs-built_in">str</span>
context: <span class="hljs-built_in">dict</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">add_message_node</span>(<span class="hljs-params">state: ConversationState</span>):
new_message = {<span class="hljs-string">"role"</span>: <span class="hljs-string">"assistant"</span>, <span class="hljs-string">"content"</span>: <span class="hljs-string">"How can I help?"</span>}
<span class="hljs-keyword">return</span> {<span class="hljs-string">"messages"</span>: state[<span class="hljs-string">"messages"</span>] + [new_message]}
Lorsqu'un nœud met à jour son état, LangGraph fusionne les modifications avec les données existantes. Dans cet exemple, messages la liste est mise à jour, tandis que user_id et context restent inchangés.
La validation d'état est intégrée au framework, utilisant les schémas TypedDict pour détecter les incompatibilités de type à l'exécution. Cette approche permet d'identifier les erreurs plus tôt, de gagner du temps de débogage et d'améliorer la fiabilité.
Modèles avancés dans LangGraph
Une fois que vous êtes à l'aise avec les bases, LangGraph propose des modèles avancés pour gérer des scénarios complexes tels que les branches conditionnelles, les boucles, la gestion des erreurs et les flux de travail humains dans la boucle.
Branchement conditionnel
Vous pouvez créer des flux de travail dynamiques qui s'adaptent aux conditions d'état. Par exemple :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">should_escalate</span>(<span class="hljs-params">state: ConversationState</span>):
<span class="hljs-keyword">if</span> state.get(<span class="hljs-string">"confidence_score"</span>, <span class="hljs-number">0</span>) < <span class="hljs-number">0.7</span>:
<span class="hljs-keyword">return</span> <span class="hljs-string">"human_agent"</span>
<span class="hljs-keyword">return</span> <span class="hljs-string">"ai_response"</span>
workflow.add_conditional_edges(
<span class="hljs-string">"analyze_query"</span>,
should_escalate,
{<span class="hljs-string">"human_agent"</span>: <span class="hljs-string">"escalate"</span>, <span class="hljs-string">"ai_response"</span>: <span class="hljs-string">"respond"</span>}
)
Flux cycliques
Les workflows peuvent revenir aux nœuds précédents pour un traitement itératif ou des tentatives répétées. Ceci est utile pour les tâches nécessitant plusieurs tentatives :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">check_quality</span>(<span class="hljs-params">state: TaskState</span>):
<span class="hljs-keyword">if</span> state[<span class="hljs-string">"attempts"</span>] < <span class="hljs-number">3</span> <span class="hljs-keyword">and</span> state[<span class="hljs-string">"quality_score"</span>] < <span class="hljs-number">0.8</span>:
<span class="hljs-keyword">return</span> <span class="hljs-string">"retry"</span>
<span class="hljs-keyword">return</span> <span class="hljs-string">"complete"</span>
workflow.add_conditional_edges(
<span class="hljs-string">"quality_check"</span>,
check_quality,
{<span class="hljs-string">"retry"</span>: <span class="hljs-string">"process_task"</span>, <span class="hljs-string">"complete"</span>: END}
)
Flux de travail avec intervention humaine
Intégrer une supervision humaine aux points de décision clés. Par exemple :
workflow.add_node(<span class="hljs-string">"human_approval"</span>, human_approval_node)
workflow.add_edge(<span class="hljs-string">"generate_response"</span>, <span class="hljs-string">"human_approval"</span>)
workflow.add_conditional_edges(
<span class="hljs-string">"human_approval"</span>,
<span class="hljs-keyword">lambda</span> state: <span class="hljs-string">"approved"</span> <span class="hljs-keyword">if</span> state[<span class="hljs-string">"approved"</span>] <span class="hljs-keyword">else</span> <span class="hljs-string">"rejected"</span>,
{<span class="hljs-string">"approved"</span>: <span class="hljs-string">"send_response"</span>, <span class="hljs-string">"rejected"</span>: <span class="hljs-string">"revise_response"</span>}
)
Gestion des erreurs
LangGraph prend en charge une gestion robuste des erreurs avec des modèles try-catch et un routage conditionnel pour la récupération :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">safe_api_call</span>(<span class="hljs-params">state: APIState</span>):
<span class="hljs-keyword">try</span>:
result = external_api.call(state[<span class="hljs-string">"query"</span>])
<span class="hljs-keyword">return</span> {<span class="hljs-string">"result"</span>: result, <span class="hljs-string">"error"</span>: <span class="hljs-literal">None</span>}
<span class="hljs-keyword">except</span> Exception <span class="hljs-keyword">as</span> e:
<span class="hljs-keyword">return</span> {<span class="hljs-string">"result"</span>: <span class="hljs-literal">None</span>, <span class="hljs-string">"error"</span>: <span class="hljs-built_in">str</span>(e)}
Ces techniques avancées permettent la création de flux de travail adaptables et réalistes, transformant des processus simples en systèmes puissants.
Projets LangGraph avec exemples de code
Les projets LangGraph donnent vie à des concepts théoriques en les transformant en applications métier concrètes. Ces exemples s'appuient sur le tutoriel de base LangGraph et montrent comment appliquer ses modèles à des situations concrètes.
Chatbot de support avec mémoire
Un chatbot d'assistance mémorisant l'historique des conversations peut améliorer considérablement les interactions utilisateur. En combinant la gestion d'état de LangGraph avec des outils externes, vous pouvez créer un chatbot qui conserve le contexte de plusieurs échanges tout en accédant à une base de connaissances fictive.
Voici comment commencer:
- Définir la structure de l'État
L'état du chatbot doit capturer des informations clés comme l'historique des conversations, le contexte utilisateur et les résultats de l'outil. Voici un exemple :
<span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> TypedDict, <span class="hljs-type">List</span>, <span class="hljs-type">Optional</span>
<span class="hljs-keyword">from</span> langgraph.graph <span class="hljs-keyword">import</span> StateGraph, START, END
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-keyword">class</span> <span class="hljs-title class_">ChatbotState</span>(<span class="hljs-title class_ inherited__">TypedDict</span>):
messages: <span class="hljs-type">List</span>[<span class="hljs-built_in">dict</span>]
user_id: <span class="hljs-built_in">str</span>
conversation_id: <span class="hljs-built_in">str</span>
knowledge_base_results: <span class="hljs-type">Optional</span>[<span class="hljs-built_in">str</span>]
escalation_needed: <span class="hljs-built_in">bool</span>
confidence_score: <span class="hljs-built_in">float</span>
- Simuler la recherche dans la base de connaissances
Créez une fonction pour récupérer des informations pertinentes en fonction des requêtes des utilisateurs :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">search_knowledge_base</span>(<span class="hljs-params">query: <span class="hljs-built_in">str</span></span>) -> <span class="hljs-built_in">str</span>:
<span class="hljs-comment"># Simulate a knowledge base search</span>
knowledge_items = {
<span class="hljs-string">"password"</span>: <span class="hljs-string">"To reset your password, click 'Forgot Password' on the login page."</span>,
<span class="hljs-string">"billing"</span>: <span class="hljs-string">"Billing issues can be resolved by contacting our finance team at [email protected]."</span>,
<span class="hljs-string">"technical"</span>: <span class="hljs-string">"For technical support, please provide your system specifications and error details."</span>
}
<span class="hljs-keyword">for</span> key, value <span class="hljs-keyword">in</span> knowledge_items.items():
<span class="hljs-keyword">if</span> key <span class="hljs-keyword">in</span> query.lower():
<span class="hljs-keyword">return</span> value
<span class="hljs-keyword">return</span> <span class="hljs-string">"I couldn't find specific information about your query."</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">knowledge_search_node</span>(<span class="hljs-params">state: ChatbotState</span>):
last_message = state[<span class="hljs-string">"messages"</span>][-<span class="hljs-number">1</span>][<span class="hljs-string">"content"</span>]
results = search_knowledge_base(last_message)
<span class="hljs-keyword">return</span> {<span class="hljs-string">"knowledge_base_results"</span>: results}
- Générer des réponses contextuelles
Combinez l’historique des conversations et les résultats de la base de connaissances pour créer des réponses plus personnalisées :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">generate_response_node</span>(<span class="hljs-params">state: ChatbotState</span>):
llm = ChatOpenAI(model=<span class="hljs-string">"gpt-3.5-turbo"</span>, temperature=<span class="hljs-number">0.7</span>)
context = <span class="hljs-string">f"Knowledge base info: <span class="hljs-subst">{state.get(<span class="hljs-string">'knowledge_base_results'</span>, <span class="hljs-string">'No specific info found'</span>)}</span>"</span>
conversation_history = <span class="hljs-string">""</span>.join(
[<span class="hljs-string">f"<span class="hljs-subst">{msg[<span class="hljs-string">'role'</span>]}</span>: <span class="hljs-subst">{msg[<span class="hljs-string">'content'</span>]}</span>"</span> <span class="hljs-keyword">for</span> msg <span class="hljs-keyword">in</span> state[<span class="hljs-string">"messages"</span>][-<span class="hljs-number">3</span>:]]
)
prompt = <span class="hljs-string">f"""
You are a helpful support assistant. Use the following context and conversation history to respond:
Context: <span class="hljs-subst">{context}</span>
Recent conversation:
<span class="hljs-subst">{conversation_history}</span>
Provide a helpful, concise response. If you cannot help, suggest escalation.
"""</span>
response = llm.invoke(prompt)
confidence = <span class="hljs-number">0.8</span> <span class="hljs-keyword">if</span> state.get(<span class="hljs-string">'knowledge_base_results'</span>) != <span class="hljs-string">"I couldn't find specific information about your query."</span> <span class="hljs-keyword">else</span> <span class="hljs-number">0.4</span>
new_message = {<span class="hljs-string">"role"</span>: <span class="hljs-string">"assistant"</span>, <span class="hljs-string">"content"</span>: response.content}
<span class="hljs-keyword">return</span> {
<span class="hljs-string">"messages"</span>: state[<span class="hljs-string">"messages"</span>] + [new_message],
<span class="hljs-string">"confidence_score"</span>: confidence,
<span class="hljs-string">"escalation_needed"</span>: confidence < <span class="hljs-number">0.5</span>
}
- Gérer les escalades
Configurez un routage conditionnel pour déterminer si une escalade vers un agent humain est nécessaire :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">should_escalate</span>(<span class="hljs-params">state: ChatbotState</span>):
<span class="hljs-keyword">return</span> <span class="hljs-string">"escalate"</span> <span class="hljs-keyword">if</span> state.get(<span class="hljs-string">"escalation_needed"</span>, <span class="hljs-literal">False</span>) <span class="hljs-keyword">else</span> <span class="hljs-string">"complete"</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">escalation_node</span>(<span class="hljs-params">state: ChatbotState</span>):
escalation_message = {
<span class="hljs-string">"role"</span>: <span class="hljs-string">"assistant"</span>,
<span class="hljs-string">"content"</span>: <span class="hljs-string">"I'm connecting you with a human agent who can better assist you."</span>
}
<span class="hljs-keyword">return</span> {<span class="hljs-string">"messages"</span>: state[<span class="hljs-string">"messages"</span>] + [escalation_message]}
- Assembler le flux de travail
Rassemblez tout cela avec les capacités de workflow de LangGraph :
workflow = StateGraph(ChatbotState)
workflow.add_node(<span class="hljs-string">"knowledge_search"</span>, knowledge_search_node)
workflow.add_node(<span class="hljs-string">"generate_response"</span>, generate_response_node)
workflow.add_node(<span class="hljs-string">"escalate"</span>, escalation_node)
workflow.add_edge(START, <span class="hljs-string">"knowledge_search"</span>)
workflow.add_edge(<span class="hljs-string">"knowledge_search"</span>, <span class="hljs-string">"generate_response"</span>)
workflow.add_conditional_edges(
<span class="hljs-string">"generate_response"</span>,
should_escalate,
{<span class="hljs-string">"escalate"</span>: <span class="hljs-string">"escalate"</span>, <span class="hljs-string">"complete"</span>: END}
)
workflow.add_edge(<span class="hljs-string">"escalate"</span>, END)
chatbot = workflow.<span class="hljs-built_in">compile</span>()
<span class="hljs-comment"># Test the chatbot with a sample conversation</span>
initial_state = {
<span class="hljs-string">"messages"</span>: [{<span class="hljs-string">"role"</span>: <span class="hljs-string">"user"</span>, <span class="hljs-string">"content"</span>: <span class="hljs-string">"I can't remember my password"</span>}],
<span class="hljs-string">"user_id"</span>: <span class="hljs-string">"user_123"</span>,
<span class="hljs-string">"conversation_id"</span>: <span class="hljs-string">"conv_456"</span>,
<span class="hljs-string">"knowledge_base_results"</span>: <span class="hljs-literal">None</span>,
<span class="hljs-string">"escalation_needed"</span>: <span class="hljs-literal">False</span>,
<span class="hljs-string">"confidence_score"</span>: <span class="hljs-number">0.0</span>
}
result = chatbot.invoke(initial_state)
<span class="hljs-built_in">print</span>(result[<span class="hljs-string">"messages"</span>][-<span class="hljs-number">1</span>][<span class="hljs-string">"content"</span>])
<span class="hljs-comment"># Expected output: "To reset your password, click 'Forgot Password' on the login page. You can find this option on the main login screen..."</span>
Coordination multi-agents
LangGraph prend également en charge les workflows où plusieurs agents collaborent sur des tâches complexes. Un workflow de création de contenu, par exemple, peut impliquer des agents spécialisés dans la recherche, la rédaction et la révision.
- Définir l'état partagé
Suivez la progression du processus de création de contenu avec une structure d'état partagée :
<span class="hljs-keyword">from</span> typing <span class="hljs-keyword">import</span> TypedDict, <span class="hljs-type">List</span>
<span class="hljs-keyword">class</span> <span class="hljs-title class_">ContentCreationState</span>(<span class="hljs-title class_ inherited__">TypedDict</span>):
topic: <span class="hljs-built_in">str</span>
research_data: <span class="hljs-type">List</span>[<span class="hljs-built_in">str</span>]
draft_content: <span class="hljs-built_in">str</span>
edited_content: <span class="hljs-built_in">str</span>
current_agent: <span class="hljs-built_in">str</span>
quality_score: <span class="hljs-built_in">float</span>
revision_count: <span class="hljs-built_in">int</span>
- Agents spécialisés
Attribuez des rôles distincts aux agents pour différentes étapes du flux de travail :
- Agent de recherche:Recueille des informations et des données.
- Agent d'écriture:Rédige du contenu basé sur des recherches.
- Agent d'édition:Affine le projet pour plus de clarté et de professionnalisme.
<span class="hljs-keyword">def</span> <span class="hljs-title function_">research_agent</span>(<span class="hljs-params">state: ContentCreationState</span>):
<span class="hljs-comment"># Perform research</span>
research_results = [
<span class="hljs-string">f"Key insight about <span class="hljs-subst">{state[<span class="hljs-string">'topic'</span>]}</span>: Market trends show increasing demand"</span>,
<span class="hljs-string">f"Statistical data: 73% of users prefer <span class="hljs-subst">{state[<span class="hljs-string">'topic'</span>]}</span>-related solutions"</span>,
<span class="hljs-string">f"Expert opinion: Industry leaders recommend focusing on <span class="hljs-subst">{state[<span class="hljs-string">'topic'</span>]}</span> benefits"</span>
]
<span class="hljs-keyword">return</span> {
<span class="hljs-string">"research_data"</span>: research_results,
<span class="hljs-string">"current_agent"</span>: <span class="hljs-string">"research_complete"</span>
}
<span class="hljs-keyword">def</span> <span class="hljs-title function_">writing_agent</span>(<span class="hljs-params">state: ContentCreationState</span>):
llm = ChatOpenAI(model=<span class="hljs-string">"gpt-4"</span>, temperature=<span class="hljs-number">0.8</span>)
research_summary = <span class="hljs-string">""</span>.join(state[<span class="hljs-string">"research_data"</span>])
prompt = <span class="hljs-string">f"""
Write an article about <span class="hljs-subst">{state[<span class="hljs-string">'topic'</span>]}</span> using this research:
<span class="hljs-subst">{research_summary}</span>
Create informative content that incorporates the key insights.
"""</span>
response = llm.invoke(prompt)
<span class="hljs-keyword">return</span> {
<span class="hljs-string">"draft_content"</span>: response.content,
<span class="hljs-string">"current_agent"</span>: <span class="hljs-string">"writing_complete"</span>
}
<span class="hljs-keyword">def</span> <span class="hljs-title function_">editing_agent</span>(<span class="hljs-params">state: ContentCreationState</span>):
llm = ChatOpenAI(model=<span class="hljs-string">"gpt-4"</span>, temperature=<span class="hljs-number">0.3</span>)
prompt = <span class="hljs-string">f"""
Edit and improve this content for clarity, flow, and engagement:
<span class="hljs-subst">{state[<span class="hljs-string">'draft_content'</span>]}</span>
Focus on:
- Clear structure and transitions
- Professional tone
- Factual accuracy
"""</span>
response = llm.invoke(prompt)
quality_score = <span class="hljs-number">0.85</span> <span class="hljs-keyword">if</span> <span class="hljs-built_in">len</span>(response.content) > <span class="hljs-built_in">len</span>(state[<span class="hljs-string">"draft_content"</span>]) * <span class="hljs-number">0.8</span> <span class="hljs-keyword">else</span> <span class="hljs-number">0.6</span>
<span class="hljs-keyword">return</span> {
<span class="hljs-string">"edited_content"</span>: response.content,
<span class="hljs-string">"quality_score"</span>: quality_score,
<span class="hljs-string">"current_agent"</span>: <span class="hljs-string">"editing_complete"</span>
}
- Contrôle qualité et révisions
Introduire la logique pour évaluer et affiner le résultat :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">quality_check</span>(<span class="hljs-params">state: ContentCreationState</span>):
<span class="hljs-keyword">if</span> state[<span class="hljs-string">"quality_score"</span>] < <span class="hljs-number">0.7</span> <span class="hljs-keyword">and</span> state[<span class="hljs-string">"revision_count"</span>] < <span class="hljs-number">2</span>:
<span class="hljs-keyword">return</span> <span class="hljs-string">"revise"</span>
<span class="hljs-keyword">return</span> <span class="hljs-string">"complete"</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">revision_coordinator</span>(<span class="hljs-params">state: ContentCreationState</span>):
<span class="hljs-keyword">return</span> {
<span class="hljs-string">"current_agent"</span>: <span class="hljs-string">"revision_needed"</span>,
<span class="hljs-string">"revision_count"</span>: state[<span class="hljs-string">"revision_count"</span>] + <span class="hljs-number">1</span>
}
La flexibilité de LangGraph permet une intégration transparente de ces flux de travail multi-agents, garantissant que les tâches sont exécutées efficacement tout en maintenant des résultats de haute qualité.
sbb-itb-23997f1
Automatisation visuelle du flux de travail avec Laténode
LangGraph offre une approche approfondie de l'architecture d'IA basée sur les graphes, mais tous les développeurs ne souhaitent pas se confronter aux complexités de la programmation graphique. Pour ceux qui recherchent une approche plus intuitive, des plateformes de développement visuel comme Latenode permettent de créer des workflows avec état sans expertise approfondie en codage. Cette comparaison met en évidence comment les outils visuels peuvent simplifier et accélérer l'automatisation des workflows d'IA.
Latenode vs. LangGraph
La distinction entre Latenode et LangGraph réside dans leur approche de la création de workflows d'IA. LangGraph privilégie le code, obligeant les développeurs à définir explicitement les états, les nœuds et les arêtes. Cela peut être intimidant pour les novices. Latenode, quant à lui, privilégie le visuel. Son interface glisser-déposer permet aux utilisateurs de concevoir des workflows sophistiqués sans écrire de grandes quantités de code, rendant ainsi des tâches comme la création d'un chatbot avec mémoire beaucoup plus accessibles.
Débogage et maintenance
Les systèmes basés sur du code exigent souvent un suivi minutieux des chemins d'exécution, qui peut devenir de plus en plus complexe à mesure que les workflows se développent. Latenode simplifie ce processus grâce à son interface visuelle, offrant des vues en temps réel de l'historique d'exécution et des flux de données entre les nœuds. Cela simplifie le débogage et la maintenance continue.
Comparaison des courbes d'apprentissage
Les frameworks axés sur le code comme LangGraph nécessitent une solide compréhension de la programmation et des structures de données, ce qui peut constituer un obstacle pour les débutants. Latenode élimine cet obstacle en permettant aux utilisateurs de se concentrer sur la logique du workflow plutôt que sur la syntaxe. Tandis que LangGraph offre une flexibilité aux développeurs expérimentés, Latenode privilégie la simplicité et la rapidité, permettant aux utilisateurs de mettre en place rapidement des workflows d'IA fonctionnels.
En traduisant les concepts de base de LangGraph dans un format visuel, Latenode rend la création de flux de travail plus accessible tout en conservant les principes de conception d'IA avec état.
Application des concepts LangGraph dans Latenode
Latenode intègre de nombreuses idées fondamentales de LangGraph, telles que la gestion des états, le routage conditionnel et l'orchestration des tâches multi-agents, dans son cadre visuel convivial :
- Gestion d'étatDans les systèmes basés sur du code, la gestion de l'historique des conversations implique souvent la création de structures de données personnalisées. Latenode gère cela visuellement, avec des nœuds simplifiant le suivi des états.
- logique conditionnelle: L'écriture de code décisionnel peut prendre du temps. Latenode remplace ce processus par des nœuds de décision permettant aux utilisateurs de définir des conditions visuellement.
- Flux de travail multi-agents:Les tâches complexes telles que la coordination de la recherche, la rédaction et l'édition peuvent être divisées en nœuds visuels distincts dans Latenode, créant ainsi des pipelines clairs et gérables.
Cette représentation visuelle des principes clés garantit que même les flux de travail d’IA complexes restent accessibles et faciles à gérer.
Avantages de Latenode pour les débutants
Démarrage rapide pour les nouveaux utilisateurs
Latenode permet aux débutants de créer des workflows prêts à la production presque immédiatement. En se concentrant sur la conception des workflows plutôt que sur la syntaxe de programmation, les utilisateurs peuvent transformer leurs idées en solutions opérationnelles dans un délai minimal.
Intégration transparente de l'IA
Latenode se connecte directement à plus de 200 modèles d'IA et gère automatiquement les tâches API, éliminant ainsi le besoin d'intégration manuelle.
Collaboration améliorée
La nature visuelle de Latenode facilite la compréhension et la révision des workflows. Les membres de l'équipe et les parties prenantes non techniques peuvent participer au processus de développement sans avoir à se plonger dans le code.
Évolutivité sans effort
Grâce à des capacités intégrées d'automatisation de base de données et de navigateur, Latenode évolue en douceur des expériences initiales à la production à grande échelle, le tout sans ajouter de complexité inutile.
Prochaines étapes et ressources
Pour faire progresser vos projets LangGraph, il est nécessaire de les faire évoluer, de les affiner et de les déployer sous forme d'applications robustes et prêtes pour la production. Voici comment aborder efficacement cette nouvelle phase.
Mise à l'échelle et optimisation des flux de travail
À mesure que vos applications LangGraph se développent, tant en nombre d'utilisateurs qu'en complexité, il devient essentiel de garantir des performances optimales. Un point clé à prendre en compte est : gestion de la mémoireAu lieu de conserver l'intégralité de l'historique des conversations, pensez à compresser les interactions les plus anciennes et à ne conserver que les échanges les plus récents facilement accessibles. Cela permet de préserver l'efficacité sans compromettre le contexte.
Une autre étape importante est intégration de base de donnéesPasser d'un stockage en mémoire à une solution basée sur une base de données vous permet de gérer plus efficacement l'utilisation de la mémoire. Cela transforme également vos workflows, passant d'expériences temporaires à des applications fiables et persistantes.
Pour des performances améliorées, traitement parallèle permet à plusieurs agents de fonctionner simultanément. De plus, la mise en œuvre de mécanismes de gestion des erreurs, tels que ralentissement exponentiel et disjoncteurs peut aider à prévenir les pannes en cascade et à maintenir la stabilité du système sous stress.
En mettant en œuvre ces optimisations, vous établirez une base solide pour un apprentissage avancé et des applications prêtes pour la production.
Ressources d'apprentissage
Pour approfondir votre compréhension, le documentation officielle de LangGraph (langchain-ai.github.io/langgraph) est une ressource précieuse. Elle propose des références API détaillées, des directives architecturales et des exemples pratiques couvrant des sujets tels que la persistance de l'état, les workflows avec intervention humaine et la coordination multi-agents.
L'espace Dépôt GitHub LangGraph est une autre excellente source d'inspiration. Il présente une gamme d'exemples de projets, allant de simples chatbots à des assistants de recherche sophistiqués, illustrant comment les entreprises utilisent LangGraph pour créer des applications d'IA évolutives.
Pour une assistance supplémentaire, explorez communautés en ligne et Chaînes YouTube dédiées à LangGraph. Ces plateformes proposent souvent des conseils en temps réel et des tutoriels approfondis sur les modèles avancés.
Déploiement de production
Une fois vos workflows optimisés, l'étape suivante consiste à déployer votre application dans un environnement sécurisé et évolutif. Commencez par configurer votre système pour gérer Limites de débit de l'API et gérer efficacement les jetons grâce à la mutualisation et à la surveillance. Des outils comme Prométhée or Grafana peut fournir des informations système en temps réel, tandis que des mesures de sécurité strictes - telles que la désinfection des entrées, le filtrage des sorties et le stockage d'état crypté - contribuent à protéger votre application.
Pour les équipes cherchant à rationaliser le déploiement, Laténode offre une solution performante. Sa plateforme visuelle simplifie la complexité des environnements de production grâce à des fonctionnalités intégrées telles que mise à l'échelle automatique, surveillance en temps réel et gestion intégrée de bases de donnéesPrenant en charge plus de 300 intégrations d'applications et plus de 200 modèles d'IA, Latenode fournit des composants prêts à l'emploi qui peuvent accélérer votre parcours du concept au déploiement.
Avec Latenode, vous pouvez mettre en œuvre des techniques avancées et créer des workflows prêts pour la production sans compromis sur la sophistication. Cette plateforme d'orchestration IA vous permet de vous concentrer sur l'optimisation de la logique de votre application tout en gérant efficacement les défis d'infrastructure.
Questions Fréquentes Posées
Comment la conception graphique de LangGraph rend-elle les flux de travail d'IA plus flexibles par rapport aux outils linéaires ?
Le framework basé sur les graphiques de LangGraph introduit un nouveau niveau de flexibilité pour les flux de travail d'IA en prenant en charge processus non linéaires telles que les boucles, les branchements conditionnels et la collaboration multi-agents. Contrairement aux outils linéaires traditionnels qui suivent une séquence rigide, étape par étape, LangGraph permet aux workflows de s'ajuster dynamiquement en fonction des entrées en temps réel et des exigences complexes.
Cette conception est particulièrement efficace pour la construction flux de travail modulaires, évolutifs et persistants, simplifiant la gestion des tâches d'IA avancées telles que les interactions multi-étapes, les opérations impliquant une intervention humaine et la maintenance de l'état des processus. Grâce à cette approche dynamique, LangGraph permet aux développeurs de créer des systèmes d'IA plus intelligents et plus adaptatifs, capables de répondre avec précision à l'évolution des besoins.
Qu'est-ce qui rend LangGraph efficace pour gérer le contexte conversationnel dans les chatbots ?
LangGraph excelle dans la gestion du contexte conversationnel dans les chatbots, grâce à son fonctionnalités de mémoire avec étatCette capacité permet aux chatbots de rappeler les interactions antérieures, de maintenir le contexte sur plusieurs échanges et de gérer efficacement des flux de travail complexes en plusieurs étapes.
et gestion de l'état persistant Grâce à ses fenêtres contextuelles dynamiques, LangGraph favorise des conversations plus fluides et naturelles. Il répond aux défis des méthodes linéaires traditionnelles, offrant une expérience plus fluide et engageante aux utilisateurs interagissant avec les chatbots.
Comment les débutants peuvent-ils utiliser Latenode pour créer des workflows d'IA sans avoir besoin de compétences avancées en codage ?
Les débutants peuvent rapidement se lancer dans la création de workflows d'IA à l'aide de Latenode, grâce à son plateforme intuitive sans codeL'interface visuelle de la plateforme permet aux utilisateurs de concevoir des flux de travail en faisant glisser et en déposant des composants, éliminant ainsi le besoin de compétences de codage avancées.
Avec accès à plus 300 intégrations prédéfiniesLatenode simplifie le processus de connexion des outils et d'automatisation des tâches. Cette configuration simplifie et accélère le développement d'applications d'IA à états. En privilégiant la convivialité, Latenode permet aux utilisateurs d'explorer et d'appliquer les concepts de l'IA sans s'enliser dans des essais-erreurs complexes, ouvrant ainsi la voie à un déploiement plus rapide de solutions efficaces.
articles similaires
