Construisez un programmeur de paire AI avec Crewai - Analytics Vidhya

Introduction

La demande de développement de logiciels efficace stimule l'adoption de l'intelligence artificielle en tant que précieux partenaire de programmation. Les assistants de codage alimentés par l'IA révolutionnent le développement en simplifiant l'écriture, le débogage et l'optimisation du code, un peu comme un programmeur de paires humaines. Cet article montre la construction d'un programmeur de paires d'IA utilisant des agents de Crewai pour rationaliser les tâches de codage et stimuler la productivité des développeurs.

Aperçu

Ce guide couvre:

• Comprendre le rôle de Crewai dans l'aide aux tâches de codage.
• Identifier les composants clés: agents, tâches, outils et équipages, et leurs interactions.
• Expérience pratique mettant en place des agents d'IA pour la génération et l'examen du code.
• Configuration de plusieurs agents d'IA pour le codage collaboratif.
• Utilisation de Crewai pour évaluer et optimiser la qualité du code.

Table des matières

• Exemples qualitatifs de NVLM 1.0 D 74B
• Comparaison de la NVLM avec d'autres LLM
• Limites des autres LLM multimodaux
• S'attaquer à ces limitations
• NVLM: modèles et méthodes de formation
• Données de formation
• Résultats
• Accéder à NVLM D 72B
  • Importation de bibliothèques nécessaires
  • Modèle de rupture
  • Prétraitement d'image
  • Carrelage d'image dynamique
  • Images de chargement et de prétraitement
  • Chargement et utilisation du modèle
  • Conversations de texte et d'image
• Questions fréquemment posées

Capacités du programmeur AI

Un programmeur de paires d'IA offre plusieurs avantages:

1. Génération de code: générer du code pour un problème donné en utilisant un agent AI et le réviser avec un autre.
2. Amélioration du code: évaluer le code existant en fonction des critères spécifiés.
3. Optimisation du code: demandez des améliorations de code, telles que l'ajout de commentaires ou de docstrings.
4. Débogage: recevez des suggestions pour résoudre les erreurs de code.
5. Génération de cas de test: générer des cas de test pour divers scénarios, y compris le développement axé sur les tests.

Cet article se concentre sur les deux premières capacités.

Qu'est-ce que Crewai?

Crewai est un cadre pour créer des agents d'IA. Ses composantes clés sont:

• Agent: Un agent utilise un modèle de langage grand (LLM) pour produire des sorties en fonction des invites d'entrée. Il interagit avec les outils, accepte la saisie des utilisateurs et communique avec d'autres agents.
• Tâche: définit l'objectif de l'agent, y compris la description, l'agent et les outils utilisables.
• Outil: les agents utilisent des outils pour des tâches telles que les recherches Web, la lecture de fichiers et l'exécution de code.
• Équipage: Un groupe d'agents collaborant sur des tâches, définissant l'interaction, le partage d'informations et la délégation de la responsabilité.

Lire aussi: construire des agents d'IA collaboratifs avec Crewai

Construisons un agent pour illustrer ces concepts.

Condition préalable

Avant de construire un programmeur de paire AI, obtenez des touches API pour les LLM.

Accéder à un LLM via l'API

Générez une clé API pour votre LLM choisi et stockez-la en toute sécurité dans un fichier .env pour l'accès au projet tout en maintenant la confidentialité.

Exemple .env Fichier

Un exemple de fichier .env :

Bibliothèques requises

Les versions de bibliothèque suivantes sont utilisées:

• Crewai - 0,66.0
• Crewai-Tools - 0.12.1

Création de code automatisée

Cette section démontre l'importation de bibliothèques et la définition des agents pour la génération et l'examen de code.

Importation de bibliothèques

 à partir de Dotenv Import Load_Dotenv
load_dotenv ('/. env')

de l'agent d'importation de Crewai, tâche, équipage

Définir l'agent de rédacteur de code

Un agent génère du code, un autre l'examine.

 code_writer_agent = agent (role = "ingénieur logiciel",
                          but = 'Écrire du code optimisé et maintenable, y compris les docstrings et les commentaires', 
                          backstory = "" "Vous êtes un ingénieur logiciel écrivant un code optimisé et maintenable avec des docstrings et des commentaires." "",
                          llm = 'gpt-4o-mini',
                          Verbose = true)

Paramètres d'agent expliqués

• Rôle: définit la fonction de l'agent.
• Objectif: Spécifie l'objectif de l'agent.
• Backstory: fournit un contexte pour une meilleure interaction.
• LLM: Spécifie le LLM utilisé (voir la documentation Litellm pour les options).
• Verbose: Active la journalisation détaillée des entrées / sorties.

Définir la tâche de l'écrivain de code

 code_writer_task = tâche (description = 'écrire du code pour résoudre le problème en {langage}. Problème: {problème}',
                        attendu_output = 'Code bien formaté avec la distinction de type',
                        agent = code_writer_agent)

Paramètres de tâche expliqués

• Description: Clear Task Objectif avec Variables ({Language}, {Problème}).
• attendu_output: format de sortie souhaité.
• Agent: l'agent affecté à la tâche.

Définition de l'agent et de la tâche du réviseur de code

De même, définissez code_reviewer_agent et code_reviewer_task .

 code_reviewer_agent = agent (role = "ingénieur logiciel senior",
                            but = 's'assurer que le code est optimisé et maintenable', 
                            backstory = "" "Vous êtes un ingénieur principal en revue le code pour la lisibilité, la maintenabilité et les performances." "",
                            llm = 'gpt-4o-mini',
                            Verbose = true)

code_reviewer_task = tâche (Description = "" "Review Code écrit pour le problème dans {language}. Problème: {problème}" "",
                          attendu_output = 'Code examiné',
                          agent = code_reviewer_agent)

Construire et gérer l'équipage

Créer et exécuter l'équipage:

 Crew = Crew (Agents = [Code_Writer_Agent, Code_Reviewer_Agent], 
            tasks = [code_writer_task, code_reviewer_task], 
            Verbose = true)

result = Crew.Kickoff (entrées = {'Problème': 'Créer un jeu tic-tac-toe', 'Langue': 'Python'})

Exemple de sortie:

Analyse des résultats

L'objet result contient:

 résultat.dict (). keys ()
>>> dict_keys (['brut', 'pydontic', 'json_dict', 'tasks_output', 'token_usage']))

# Utilisation de jetons
result.dict () ['token_usage']
>>> {'total_tokens': 2656, ...}

# Sortie finale
imprimer (result.raw)

Le code généré peut ensuite être exécuté.

Évaluation du code automatisé

Cette section couvre l'évaluation du code existant.

Définition des exigences d'évaluation

Tout d'abord, rassemblez les exigences à l'aide d'un agent, puis évaluez le code en fonction de ces exigences à l'aide d'un autre agent.

Utilisation d'outils

Le FileReadTool lit les fichiers. Les outils améliorent les capacités des agents. Des outils peuvent être affectés aux tâches et aux agents; Affectations au niveau des tâches Remplacer les affectations au niveau de l'agent.

Configuration de l'agent et de la tâche de rassemblement des exigences

 De Crewai_Tools Importer FileReadtool

code_requirements_agent = agent (role = "data scientist",
                          but = 'définir les exigences du code pour un problème donné.', 
                          backstory = "" "Vous êtes un scientifique des données définissant les exigences pour que le code résolve un problème." "",
                          llm = 'gpt-4o-mini',
                          Verbose = true)

code_requiment_task = tâche (description = 'Écrivez les exigences étape par étape. Problème: {problème}',
                            attendu_output = 'Texte des exigences formatées.',
                            agent = code_requirements_agent,
                            humain_input = true)

human_input=True permet une entrée utilisateur pour les ajustements.

Évaluation du code

Cet exemple utilise FileReadTool et gpt-4o pour une meilleure gestion de contextes plus grands.

 file_read_tool = filereadtool ('eda.py')

code_evaluator_agent = agent (role = "Data Science Evaluator",
                            but = 'Évaluer le code en fonction des exigences fournies', 
                            backstory = "" "Vous êtes un évaluateur de la science des données de révision du code basé sur les exigences données." "",
                            llm = 'gpt-4o',
                            Verbose = true)

code_evaluator_task = tâche (description = "" "Évaluer le fichier de code en fonction des exigences. Ne fournissez que l'évaluation, pas le code." "",
                           attendu_output = 'Évaluation détaillée basée sur les exigences.',
                           tools = [file_read_tool],
                           agent = code_evaluator_agent)

Construire l'équipe d'évaluation

Créez l'équipage et définissez le problème:

 Crew = Crew (Agents = [Code_Requirements_Agent, code_evaluator_agent], 
            tasks = [code_requiance_task, code_evaluator_task], 
            Verbose = true)

Problème = "" "Effectuer EDA sur le jeu de données de la durée de la durée de voyage en taxi ..." "" # (Datas Description Omise for Brevity)

result = Crew.Kickoff (entrées = {'Problème': Problème})

Sortir

La sortie montre des invites d'entrée humaines:

Les sorties de la tâche sont accessibles individuellement:

 print (code_requirement_task.output.raw)
imprimer (result.raw)

Conclusion

Crewai fournit un cadre puissant pour améliorer le développement de logiciels grâce à la génération, à la révision et à l'évaluation du code axé sur l'IA. En définissant des rôles, des objectifs et des tâches, les développeurs peuvent rationaliser les flux de travail et stimuler la productivité. L'intégration d'un programmeur de paires d'IA avec Crewai améliore l'efficacité et la qualité du code. La flexibilité de Crewai facilite la collaboration d'agent AI sans couture, résultant en un code optimisée, maintenable et sans erreur. À mesure que l'IA évolue, les capacités de programmation de Crewai de Crewai deviendront de plus en plus précieuses pour les développeurs.

Questions fréquemment posées

Q1. Qu'est-ce que Crewai et son rôle dans le développement de logiciels? Crewai est un cadre d'agent d'IA aidant les développeurs dans la rédaction, l'examen et l'évaluation du code, stimulant la productivité.

Q2. Quels sont les composants clés de Crewai? Agents, tâches, outils et équipages. Les agents effectuent des actions; Les tâches définissent les objectifs; Les outils étendent les capacités des agents; Les équipages permettent à l'agent de collaboration.

Q3. Comment configurer un agent AI générant du code? Définissez le rôle, l'objectif, l'objectif, la trame de fond et LLM de l'agent, puis créez une tâche correspondante spécifiant le problème et la sortie attendue.

Q4. Les agents de Crewai peuvent-ils collaborer? Oui, à travers "Crews", permettant aux agents de gérer efficacement différents aspects d'une tâche.

Q5. Quels outils sont disponibles? Divers outils améliorent les capacités de l'agent, y compris la lecture de fichiers, les recherches sur le Web et l'exécution de code.

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!