Langchain vs Crewai vs Autogen pour construire un agent d'analyse de données

Dans le monde actuel axé sur les données, les organisations s'appuient sur les analystes de données pour interpréter des ensembles de données complexes, découvrir des informations exploitables et générer des décisions. Mais que se passe-t-il si nous pouvions améliorer l'efficacité et l'évolutivité de ce processus en utilisant l'IA? Entrez l'agent d'analyse des données pour automatiser les tâches analytiques, exécuter du code et répondre de manière adaptative aux requêtes de données. Langgraph, Crewai et Autogen sont trois cadres populaires utilisés pour construire des agents d'IA. Nous utiliserons et comparer les trois dans cet article pour construire un agent d'analyse de données simple.

Table des matières

• Fonctionnement de l'agent d'analyse des données
• Construire un agent d'analyse des données avec Langgraph
  • Pré-requis
• Étapes pour créer un agent d'analyse des données avec Langgraph
  • 1. Importez les bibliothèques nécessaires.
  • 2. Définissons l'État.
  • 3. Définissez le LLM et la fonction d'exécution de code et lient la fonction au LLM.
  • 4. Définissez la fonction pour l'agent pour répondre et l'ajouter en tant que nœud au graphique.
  • 5. Définissez le ToolNode et ajoutez-le au graphique.
  • 6. Ajoutons également la mémoire afin que nous puissions discuter avec l'agent.
  • 7. Compiler et afficher le graphique.
  • 8. Maintenant, nous pouvons commencer le chat. Étant donné que nous avons ajouté de la mémoire, nous donnerons à chaque conversation un thread_id unique et commencerons la conversation sur ce fil.
• Construire un agent d'analyse des données avec Crewai
  • 1. Importez les bibliothèques nécessaires.
  • 2. Nous allons créer un agent pour générer le code et un autre pour exécuter ce code.
  • 3. Pour exécuter le code, nous utiliserons PythonRepl (). Définissez-le comme un outil Crewai.
  • 4. Définir l'agent exécutif et les tâches avec accès à REPT et FileReadTool ()
  • 5. Construisez l'équipage avec les deux agents et les tâches correspondantes.
  • 6. Exécutez l'équipage avec les entrées suivantes.
• Construire un agent d'analyse des données avec Autogen
  • 1. Importez les bibliothèques nécessaires.
  • 2. Définissez l'exécuteur de code et un agent pour utiliser l'exécuteur de code.
  • 3. Définissez un agent pour écrire le code avec un message système personnalisé.
  • 4. Définissez le problème pour résoudre et lancer le chat.
  • 5. Nous pouvons également imprimer les questions de nous et leurs réponses, si nécessaire, en utilisant ce code.
• Langgraph vs Crewai vs Autogen
• Questions fréquemment posées

Fonctionnement de l'agent d'analyse des données

L'agent d'analyse des données prendra d'abord la requête de l'utilisateur et générera le code pour lire le fichier et analyser les données du fichier. Ensuite, le code généré sera exécuté à l'aide de l'outil Python REPT. Le résultat du code est renvoyé à l'agent. L'agent analyse ensuite le résultat reçu de l'outil d'exécution de code et répond à la requête utilisateur. Les LLM peuvent générer du code arbitraire, nous devons donc exécuter soigneusement le code généré par LLM dans un environnement local.

Construire un agent d'analyse des données avec Langgraph

Si vous êtes nouveau sur ce sujet ou si vous souhaitez réprimer vos connaissances sur Langgraph, voici un article que je recommande: Qu'est-ce que Langgraph?

Pré-requis

Avant de construire des agents, assurez-vous d'avoir les clés API nécessaires pour les LLM nécessaires.

Chargez le fichier .env avec les touches API nécessaires.

 à partir de Dotenv Import Load_Dotenv

load_dotenv (./ env)

Les bibliothèques clés requises

Langchain - 0.3.7

Langchain-Experimental - 0.3.3

Langgraph - 0.2.52

Crewai - 0,80,0

Crewai-Tools - 0.14.0

autogène-agentchat - 0.2.38

Maintenant que nous sommes tous prêts, commençons à construire notre agent.

Étapes pour créer un agent d'analyse des données avec Langgraph

1. Importez les bibliothèques nécessaires.

 Importer des pandas en tant que PD
à partir de l'image d'importation ipython.display, afficher
de la liste d'importation, littéral, facultatif, typeddict, annoté
De Langchain_Core.Tools Import Tool
à partir de Langchain_core.Messages Import ToolMessage
de Langchain_experimental.Utilities Importer Pythonrepl
De Langchain_Openai Import Chatopenai
de Langgraph.graph Import Stategraph, start, fin
de Langgraph.graph.Message Import Add_Messages
De LangGraph.Prebuilt Import ToolNode, Tools_Condition
De Langgraph.Checkpoint.Memory Import MemorySaver

2. Définissons l'État.

 État de classe (typeddict):
	Messages: annoté [list, add_messages]
graph_builder = stategraph (état)

3. Définissez le LLM et la fonction d'exécution de code et lient la fonction au LLM.

 llm = chatopenai (modèle = "gpt-4o-mini", température = 0,1)

@outil
def python_repl (code: annoté [str, "nom de fichier pour lire le code de"]):
    "" "Utilisez-le pour exécuter le code python, lisez un fichier. Si vous souhaitez voir la sortie d'une valeur,
    Assurez-vous que vous lisez correctement le code
    Vous devez l'imprimer avec `imprimer (...) '. Ceci est visible pour l'utilisateur. "" "

    essayer:
        result = pythonRepl (). run (code)
        print ("Exécution du code de résultat:", résultat)
    sauf BasEEException comme e:
        return f "Échec de l'exécution. Erreur: {rep (e)}"
    return f "exécuté: \ n```python \ n {code} \ n``` \ nstdout: {result}"

llm_with_tools = llm.bind_tools ([python_repl])

4. Définissez la fonction pour l'agent pour répondre et l'ajouter en tant que nœud au graphique.

 Def Chatbot (état: état):
    return {"messages": [llm_with_tools.invoke (état ["messages"])]}
    
graph_builder.add_node ("agent", chatbot)

5. Définissez le ToolNode et ajoutez-le au graphique.

 code_execution = toolNode (tools = [python_repl])

graph_builder.add_node ("outils", code_execution)

Si le LLM renvoie un appel à l'outil, nous devons l'achever vers le nœud d'outil; Sinon, nous pouvons y mettre fin. Définissons une fonction de routage. Ensuite, nous pouvons ajouter d'autres bords.

 def Route_Tools (État: État,):
    "" "
    Utilisez dans le conditional_edge pour se rendre vers le ToolNode si le dernier message
    a des appels d'outils. Sinon, route jusqu'à la fin.
    "" "
    Si isInstance (état, liste):
        AI_MESSAGE = State [-1]
    elif messages: = state.get ("messages", []):
        AI_MESSAGE = Messages [-1]
    autre:
        River ValueError (f "Aucun message trouvé dans l'état d'entrée à Tool_edge: {State}")
    Si Hasattr (AI_MESSAGE, "TOLL_CALLS") et LEN (AI_MESSAGE.TOOL_CALLS)> 0:
        retourner "outils"
    retour
    
graph_builder.add_conditional_edges (
    "agent",
    Route_tools,
    {"Tools": "Tools", end: end},
)

graph_builder.add_edge ("outils", "agent")

6. Ajoutons également la mémoire afin que nous puissions discuter avec l'agent.

 mémoire = mémoire ()

graph = graph_builder.

7. Compiler et afficher le graphique.

 graph = graph_builder.

affichage (image (graph.get_graph (). draw_mermaid_png ()))

8. Maintenant, nous pouvons commencer le chat. Étant donné que nous avons ajouté de la mémoire, nous donnerons à chaque conversation un thread_id unique et commencerons la conversation sur ce fil.

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

def Stream_graph_updates (user_input: str):
    événements = graph.stream (
        {"messages": [("utilisateur", user_input)]}, config, stream_mode = "valeurs"
    )
    pour l'événement dans les événements:
        événement ["Messages"] [- 1] .pretty_print ()
        
Bien que vrai:
    user_input = entrée ("utilisateur:")
    si user_input.lower () dans ["QUIT", "Exit", "Q"]:
        imprimer ("Au revoir!")
        casser
    stream_graph_updates (user_input)

Pendant que la boucle est en cours d'exécution, nous commençons par donner le chemin du fichier, puis posant toutes les questions basées sur les données.

La sortie sera la suivante:

Comme nous l'avons inclus de la mémoire, nous pouvons poser des questions sur l'ensemble de données dans le chat. L'agent générera le code requis et le code sera exécuté. Le résultat de l'exécution du code sera renvoyé au LLM. Un exemple est indiqué ci-dessous:

Lire aussi: comment créer votre agent de digest de nouvelles personnalisés avec Langgraph

Construire un agent d'analyse des données avec Crewai

Maintenant, nous utiliserons Crewai pour la tâche d'analyse des données.

1. Importez les bibliothèques nécessaires.

 de l'agent d'importation de Crewai, tâche, équipage
à partir de l'outil d'importation de Crewai.tools
De Crewai_Tools Import DirectoryReadTool, FileReadTool
de Langchain_experimental.Utilities Importer Pythonrepl

2. Nous allons créer un agent pour générer le code et un autre pour exécuter ce code.

 coding_agent = agent (
	role = "python développeur",
	but = "Craft Code bien conçu et pensé pour répondre au problème donné",
	Backstory = "" "Vous êtes un développeur Python senior avec une vaste expérience dans les logiciels et ses meilleures pratiques.
            	Vous avez une expertise dans la rédaction du code propre, efficace et évolutif. "" ",
	llm = 'gpt-4o',
	humain_input = true,
)
coding_task = tâche (
	description = "" "Écrire du code pour répondre au problème donné
                	Attribuez la sortie du code à la variable «Résultat»
                    	Problème: {problème},
                    	"" ",
	attendu_output = "code pour obtenir le résultat du problème.
	agent = coding_agent
)

3. Pour exécuter le code, nous utiliserons PythonRepl (). Définissez-le comme un outil Crewai.

 @Tool ("REPT")
Def REP (Code: Str) -> Str:
	"" "Utile pour exécuter le code python" ""
	return pythonRepl (). run (commande = code)

4. Définir l'agent exécutif et les tâches avec accès à REPT et FileReadTool ()

 exécuting_agent = agent (
	role = "Python Exécuteur",
	but = "Exécutez le code reçu pour répondre au problème donné",
	Backstory = "" "Vous êtes un développeur Python avec une vaste expérience dans les logiciels et ses meilleures pratiques.
            	"Vous pouvez exécuter efficacement le code, déboguer et optimiser efficacement les solutions Python." "",
	llm = 'gpt-4o-mini',
	humain_input = true,
	Outils = [REPT, FileReadTool ()]
)
exécuting_task = tâche (
	description = "" "Exécutez le code pour répondre au problème donné
                	Attribuez la sortie du code à la variable «Résultat»
                    	Problème: {problème},
                    	"" ",
	attendu_output = 'Le résultat du problème',
	agent = exécuting_agent
)

5. Construisez l'équipage avec les deux agents et les tâches correspondantes.

 analyse_crew = Crew (
	agents = [coding_agent, exécutant_agent],
	tasks = [coding_task, exécuting_task],
	Verbose = vrai
)

6. Exécutez l'équipage avec les entrées suivantes.

 entrées = {'Problème': "" "Lisez ce fichier et renvoyez les noms de colonne et trouvez l'âge moyen
   "/home/santhosh/projects/code/langraph/gym_members_exercise_tracking.csv" "",}

result = analyse_crew.kickoff (entrées = entrées)

imprimer (result.raw)

Voici à quoi ressemblera la sortie:

Lire aussi: construire des agents LLM à la volée sans code avec Crewai

Construire un agent d'analyse des données avec Autogen

1. Importez les bibliothèques nécessaires.

 à partir d'importation automatique conversation
Depuis autogen.Codant l'importation localCommandlineCodeeExECUTOR, DockerCommandLeneCodeEEXECUTOR

2. Définissez l'exécuteur de code et un agent pour utiliser l'exécuteur de code.

 EMECTOR = localCommandLineCodeEExECUTOR (
	timeout = 10, # timeout pour chaque exécution de code en secondes.
	work_dir = '. / data', # Utilisez le répertoire pour stocker les fichiers de code.
)
code_executor_agent = conversableAgent (
	"code_executor_agent",
	llm_config = false,
	code_execution_config = {"exécuteur": exécuteur},
	human_input_mode = "toujours",
)

3. Définissez un agent pour écrire le code avec un message système personnalisé.

Prenez le message du système Code_Writer à partir de https://microsoft.github.io/autogen/0.2/docs/tutorial/code-executors/

code_writer_agent = conversableAgent (
    "code_writer_agent",
    System_Message = Code_Writer_System_Message,
    llm_config = {"config_list": [{"modèle": "gpt-4o-mini"}]},
    code_execution_config = false,
)

4. Définissez le problème pour résoudre et lancer le chat.

 problème = "" "Lisez le fichier sur le chemin '/home/santhosh/projects/code/langgraph/gym_members_exercise_tracking.csv'
        	et imprimer l'âge moyen du peuple. "" "

chat_result = code_executor_agent.iniate_chat (
	code_writer_agent,
	message = problème,
)

Une fois le chat au début, nous pouvons également poser toutes les questions ultérieures sur l'ensemble de données mentionné ci-dessus. Si le code rencontre une erreur, nous pouvons demander à modifier le code. Si le code est bien, nous pouvons simplement appuyer sur «Entrée» pour continuer à exécuter le code.

5. Nous pouvons également imprimer les questions de nous et leurs réponses, si nécessaire, en utilisant ce code.

 pour le message dans chat_result.chat_history:
    Si le message [«rôle»] == «Assistant»:
        Si 'exitcode' pas dans le message ['contenu']:
            imprimer (message ['contenu'])
            print ('\ n')
            
    autre:
        Si «terminer» dans le message [«contenu»]:        
            imprimer (message ['contenu'])
            imprimer("----------------------------------------")

Voici le résultat:

Lire aussi: Guide pratique pour construire des chatbots multi-agents avec Autogen

Langgraph vs Crewai vs Autogen

Maintenant que vous avez appris à créer un agent d'analyse de données avec tous les 3 cadres, explorons les différences entre eux, en ce qui concerne l'exécution du code:

Cadre	Caractéristiques clés	Forces	Mieux adapté à
Languette	- Structure basée sur les graphiques (les nœuds représentent des agents / outils, les bords définissent les interactions) - Intégration transparente avec Pythonrepl	- Très flexible pour créer des workflows structurés en plusieurs étapes - Exécution de code sûre et efficace avec préservation de la mémoire à travers les tâches	Des tâches analytiques complexes et axées sur les processus qui exigent des workflows clairs et personnalisables
Équipage	- axé sur la collaboration - plusieurs agents travaillant en parallèle avec des rôles prédéfinis - s'intégre aux outils Langchain	- Conception axée sur les tâches - Excellent pour le travail d'équipe et la spécialisation des rôles - prend en charge l'exécution de code sûre et fiable avec Pythonrepl	Analyse des données collaboratives, configurations d'examen du code, décomposition des tâches et exécution basée sur les rôles
Autogène	- Exécution dynamique et itérative du code - Agents conversables pour l'exécution interactive et le débogage - fonctionnalité de chat intégrée	- flux de travail adaptatifs et conversationnels - Focus sur l'interaction dynamique et le débogage - Idéal pour le prototypage rapide et le dépannage	Prototypage rapide, dépannage et environnements où les tâches et les exigences évoluent fréquemment

Conclusion

Dans cet article, nous avons démontré comment construire des agents d'analyse des données à l'aide de Langgraph, Crewai et Autogen. Ces cadres permettent aux agents de générer, d'exécuter et d'analyser le code pour répondre efficacement aux requêtes de données. En automatisant les tâches répétitives, ces outils rendent l'analyse des données plus rapide et plus évolutive. La conception modulaire permet la personnalisation pour des besoins spécifiques, ce qui les rend précieux pour les professionnels des données. Ces agents présentent le potentiel de l'IA pour simplifier facilement les workflows et extraire les informations des données.

Pour en savoir plus sur les agents de l'IA, consultez notre programme exclusif de Pioneer AI AIC!

Questions fréquemment posées

Q1. Quels sont les principaux avantages de l'utilisation de cadres d'IA comme Langgraph, Crewai et Autogen pour l'analyse des données?

A. Ces cadres automatisent la génération et l'exécution de code, permettant un traitement et des informations plus rapides des données. Ils rationalisent les flux de travail, réduisent les efforts manuels et améliorent la productivité des tâches basées sur les données.

Q2. Ces agents d'analyse des données peuvent-ils gérer plusieurs ensembles de données ou des requêtes complexes?

R. Oui, les agents peuvent être personnalisés pour gérer divers ensembles de données et des requêtes analytiques complexes en intégrant les outils appropriés et en ajustant leurs flux de travail.

Q3. Quelles précautions doivent être prises lors de l'exécution du code généré par LLM?

A. Le code généré par LLM peut inclure des erreurs ou des opérations dangereuses. Validez toujours le code dans un environnement contrôlé pour garantir l'exactitude et la sécurité avant l'exécution.

Q4. Comment l'intégration de la mémoire améliore-t-elle ces agents d'analyse des données?

A. L'intégration de la mémoire permet aux agents de conserver le contexte des interactions passées, permettant des réponses adaptatives et de la continuité dans des requêtes complexes ou en plusieurs étapes.

Q5. Quels types de tâches ces agents d'analyse des données peuvent-ils automatiser?

A. Ces agents peuvent automatiser des tâches telles que la lecture de fichiers, effectuer un nettoyage de données, générer des résumés, exécuter des analyses statistiques et répondre aux requêtes des utilisateurs sur les données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!