.png)
Prêt pour le RGPD
Voir le rapport
Prêt pour SOC2
Voir le rapport
[email protected]
Discord
LinkedIn
Facebook
Instagram
Youtube
.svg){kind=icon}
Reddit
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 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.
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
source venv/bin/activate # For macOS/Linux
# venv\Scripts\activate # For Windows
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 :
import 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 :
langchain-openai pour des OpenAI .langchain[anthropic] pour des Claude l'intégration.tavily-python pour les capacités de recherche sur le Web 2134.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 :
export OPENAI_API_KEY="your-api-key-here"
Sous Windows, remplacez export avec setCes clés permettent à LangGraph d'interagir avec des services externes pendant l'exécution du workflow 2134.
Avec l'environnement prêt et LangGraph installé, vous êtes prêt à créer votre premier flux de travail.
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 :
from typing import TypedDict
from langgraph.graph import StateGraph, START, END
class GraphState(TypedDict):
message: str
count: int
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 :
def greeting_node(state: GraphState):
return {"message": f"Hello! Processing item {state['count']}"}
def counter_node(state: GraphState):
return {"count": state["count"] + 1}
Ensuite, initialisez un StateGraph, ajoutez des nœuds et définissez l'ordre d'exécution à l'aide d'arêtes :
# Initialize the graph with state schema
workflow = StateGraph(GraphState)
# Add nodes to the graph
workflow.add_node("greeting", greeting_node)
workflow.add_node("counter", counter_node)
# Define execution flow
workflow.add_edge(START, "greeting")
workflow.add_edge("greeting", "counter")
workflow.add_edge("counter", END)
# Compile the graph
app = workflow.compile()
Pour exécuter le graphique, fournissez un état initial et appelez l'application compilée :
initial_state = {"message": "", "count": 0}
result = app.invoke(initial_state)
print(result) # {'message': 'Hello! Processing item 0', 'count': 1}
Cet exemple illustre les concepts fondamentaux de LangGraph. Vous pouvez ensuite développer des workflows plus avancés.
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:
class ConversationState(TypedDict):
messages: list
user_id: str
context: dict
def add_message_node(state: ConversationState):
new_message = {"role": "assistant", "content": "How can I help?"}
return {"messages": state["messages"] + [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 la 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é.
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 :
def should_escalate(state: ConversationState):
if state.get("confidence_score", 0) < 0.7:
return "human_agent"
return "ai_response"
workflow.add_conditional_edges(
"analyze_query",
should_escalate,
{"human_agent": "escalate", "ai_response": "respond"}
)
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 :
def check_quality(state: TaskState):
if state["attempts"] < 3 and state["quality_score"] < 0.8:
return "retry"
return "complete"
workflow.add_conditional_edges(
"quality_check",
check_quality,
{"retry": "process_task", "complete": END}
)
Flux de travail avec intervention humaine
Intégrer une supervision humaine aux points de décision clés. Par exemple :
workflow.add_node("human_approval", human_approval_node)
workflow.add_edge("generate_response", "human_approval")
workflow.add_conditional_edges(
"human_approval",
lambda state: "approved" if state["approved"] else "rejected",
{"approved": "send_response", "rejected": "revise_response"}
)
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 :
def safe_api_call(state: APIState):
try:
result = external_api.call(state["query"])
return {"result": result, "error": None}
except Exception as e:
return {"result": None, "error": str(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.
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.
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:
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 :
from typing import TypedDict, List, Optional
from langgraph.graph import StateGraph, START, END
from langchain_openai import ChatOpenAI
class ChatbotState(TypedDict):
messages: List[dict]
user_id: str
conversation_id: str
knowledge_base_results: Optional[str]
escalation_needed: bool
confidence_score: float
Créez une fonction pour récupérer des informations pertinentes en fonction des requêtes des utilisateurs :
def search_knowledge_base(query: str) -> str:
# Simulate a knowledge base search
knowledge_items = {
"password": "To reset your password, click 'Forgot Password' on the login page.",
"billing": "Billing issues can be resolved by contacting our finance team at [email protected].",
"technical": "For technical support, please provide your system specifications and error details."
}
for key, value in knowledge_items.items():
if key in query.lower():
return value
return "I couldn't find specific information about your query."
def knowledge_search_node(state: ChatbotState):
last_message = state["messages"][-1]["content"]
results = search_knowledge_base(last_message)
return {"knowledge_base_results": results}
Combinez l’historique des conversations et les résultats de la base de connaissances pour créer des réponses plus personnalisées :
def generate_response_node(state: ChatbotState):
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
context = f"Knowledge base info: {state.get('knowledge_base_results', 'No specific info found')}"
conversation_history = "".join(
[f"{msg['role']}: {msg['content']}" for msg in state["messages"][-3:]]
)
prompt = f"""
You are a helpful support assistant. Use the following context and conversation history to respond:
Context: {context}
Recent conversation:
{conversation_history}
Provide a helpful, concise response. If you cannot help, suggest escalation.
"""
response = llm.invoke(prompt)
confidence = 0.8 if state.get('knowledge_base_results') != "I couldn't find specific information about your query." else 0.4
new_message = {"role": "assistant", "content": response.content}
return {
"messages": state["messages"] + [new_message],
"confidence_score": confidence,
"escalation_needed": confidence < 0.5
}
Configurez un routage conditionnel pour déterminer si une escalade vers un agent humain est nécessaire :
def should_escalate(state: ChatbotState):
return "escalate" if state.get("escalation_needed", False) else "complete"
def escalation_node(state: ChatbotState):
escalation_message = {
"role": "assistant",
"content": "I'm connecting you with a human agent who can better assist you."
}
return {"messages": state["messages"] + [escalation_message]}
Rassemblez tout cela avec les capacités de workflow de LangGraph :
workflow = StateGraph(ChatbotState)
workflow.add_node("knowledge_search", knowledge_search_node)
workflow.add_node("generate_response", generate_response_node)
workflow.add_node("escalate", escalation_node)
workflow.add_edge(START, "knowledge_search")
workflow.add_edge("knowledge_search", "generate_response")
workflow.add_conditional_edges(
"generate_response",
should_escalate,
{"escalate": "escalate", "complete": END}
)
workflow.add_edge("escalate", END)
chatbot = workflow.compile()
# Test the chatbot with a sample conversation
initial_state = {
"messages": [{"role": "user", "content": "I can't remember my password"}],
"user_id": "user_123",
"conversation_id": "conv_456",
"knowledge_base_results": None,
"escalation_needed": False,
"confidence_score": 0.0
}
result = chatbot.invoke(initial_state)
print(result["messages"][-1]["content"])
# Expected output: "To reset your password, click 'Forgot Password' on the login page. You can find this option on the main login screen..."
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.
Suivez la progression du processus de création de contenu avec une structure d'état partagée :
from typing import TypedDict, List
class ContentCreationState(TypedDict):
topic: str
research_data: List[str]
draft_content: str
edited_content: str
current_agent: str
quality_score: float
revision_count: int
Attribuez des rôles distincts aux agents pour différentes étapes du flux de travail :
def research_agent(state: ContentCreationState):
# Perform research
research_results = [
f"Key insight about {state['topic']}: Market trends show increasing demand",
f"Statistical data: 73% of users prefer {state['topic']}-related solutions",
f"Expert opinion: Industry leaders recommend focusing on {state['topic']} benefits"
]
return {
"research_data": research_results,
"current_agent": "research_complete"
}
def writing_agent(state: ContentCreationState):
llm = ChatOpenAI(model="gpt-4", temperature=0.8)
research_summary = "".join(state["research_data"])
prompt = f"""
Write an article about {state['topic']} using this research:
{research_summary}
Create informative content that incorporates the key insights.
"""
response = llm.invoke(prompt)
return {
"draft_content": response.content,
"current_agent": "writing_complete"
}
def editing_agent(state: ContentCreationState):
llm = ChatOpenAI(model="gpt-4", temperature=0.3)
prompt = f"""
Edit and improve this content for clarity, flow, and engagement:
{state['draft_content']}
Focus on:
- Clear structure and transitions
- Professional tone
- Factual accuracy
"""
response = llm.invoke(prompt)
quality_score = 0.85 if len(response.content) > len(state["draft_content"]) * 0.8 else 0.6
return {
"edited_content": response.content,
"quality_score": quality_score,
"current_agent": "editing_complete"
}
Introduire la logique pour évaluer et affiner le résultat :
def quality_check(state: ContentCreationState):
if state["quality_score"] < 0.7 and state["revision_count"] < 2:
return "revise"
return "complete"
def revision_coordinator(state: ContentCreationState):
return {
"current_agent": "revision_needed",
"revision_count": state["revision_count"] + 1
}
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é.
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.
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.
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 :
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.
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.
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.
À 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 la 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.
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.
Les 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 la 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.
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 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.
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.
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.
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.
Échanger des applications
Application 1
Application 2
Étape 1 : Choisir un déclencheur
Étape 2 : Choisissez une action
Pas besoin de carte de crédit
Sans restriction
