AutoGPT handbook
1.0.0
Auto-GPT est un outil d'IA open source qui exploite les API GPT-4 ou GPT-3.5 d'OpenAI pour atteindre les objectifs définis par l'utilisateur exprimés en langage naturel. Il le fait en disséquant la tâche principale en composants plus petits et en utilisant de manière autonome diverses ressources dans un processus cyclique.
Dans ce guide, nous explorerons les différentes fonctionnalités d'Autogpt et décrivons les meilleures pratiques et conseils pour utiliser Autogpt pour le codage.
git clone https://github.com/significant-gravitas/auto-gpt.git sur votre terminal ou en cliquant sur le bouton "Code" sur la page du référentiel et en téléchargeant le fichier zip.autogpt --version . Vous devriez voir le numéro de version affiché dans le terminal.Vous pouvez également utiliser un environnement virtuel pour contenir l'installation d'Autogpt et pour vous assurer de ne pas avoir d'erreurs lors de l'installation de dépendances ou de l'exécution d'autogpt.
Assurez-vous de mettre à jour «.env» avec vos propres configurations et vos propres clés API. Le fichier contient chaque API dont vous pourriez avoir besoin. Vous pouvez en être en train de les utiliser si vous ne les utilisez pas, comme pour la génération d'images, mais assurez-vous que vous avez:
Clé API OpenAI - Cette clé est nécessaire pour utiliser l'API OpenAI dont Autogpt est construit au-dessus de. Vous pouvez obtenir une clé API en vous inscrivant au programme API OpenAI:
Github_api_key - Cette clé est requise pour autoriser votre accès à l'API GitHub. Vous pouvez obtenir cette clé en suivant les étapes sur le site Web de GitHub.
Votre github_username
Vous pouvez ajouter toutes les API ici. Le '.env' est explicite une fois que vous avez obtenu ces clés, vous devez modifier le fichier .env dans le référentiel et ajouter les clés API répertoriées ci-dessus.
Faites également attention à ce qui précède:
Vous devez modifier le fichier .env dans le référentiel et ajouter les touches API répertoriées ci-dessus. En effet, les touches API sont des informations sensibles qui ne devraient pas être codées en dur dans l'application.
Vous devez également ajouter vos propres invites au fichier prompts.json pour rendre Autogpt plus utile pour votre cas d'utilisation particulier. Les invites fournies dans le référentiel sont des invites générales qui peuvent ne pas être applicables à votre projet. En ajoutant vos propres invites, vous pouvez former Autogpt pour générer des réponses adaptées à votre cas d'utilisation spécifique.
Pour inviter Autogpt, utilisez la commande python -m autogpt dans votre terminal. Assurez-vous que vous êtes dans le bon chemin. Sinon, réglez-le par «Path CD»
Pour de meilleurs résultats, assurez-vous que vos invites sont spécifiques et bien définies. Cela donnera à Autogpt une compréhension claire de ce que vous essayez de réaliser et de l'aider à générer des réponses plus précises.
Lors de l'examen des réponses du modèle, gardez à l'esprit qu'Autogpt est un modèle de langue et non un humain. En tant que tel, il peut générer des réponses qui ne sont pas entièrement précises ou adaptées à votre cas d'utilisation. C'est à vous de revoir les réponses et d'apporter toutes les modifications nécessaires.
Une autre façon d'utiliser Autogpt est de l'intégrer dans votre code. Vous pouvez jeter un œil aux commandes dans le dossier cloné et l'utiliser pour générer des réponses par programme. Cela peut être utile si vous souhaitez générer des réponses dans un contexte spécifique.
Voici quelques-unes des meilleures façons d'utiliser Autogpt pour une ingénierie rapide:
Le décorateur @command est utilisé pour définir les commandes personnalisées. Il faut trois arguments:
name : le nom de la commande.description : Une brève description de la commande.params : une chaîne représentant les paramètres attendus pour la commande. Voici un exemple d'utilisation du décorateur @command pour définir une commande personnalisée appelée execute_python_file :
@ command ( "execute_python_file" , "Execute Python File" , '"filename": "<filename>"' )
def execute_python_file ( filename : str ) -> str :
# Implementation of the command Pour exécuter des commandes shell, vous pouvez utiliser le module subprocess . Voici deux méthodes pour exécuter les commandes de shell:
subprocess.run() :Cette méthode exécute la commande et attend qu'elle se termine. Il renvoie la sortie (stdout et stderr) de la commande.
result = subprocess . run ( command_line , capture_output = True , shell = True )
output = f"STDOUT: n { result . stdout } n STDERR: n { result . stderr } " subprocess.Popen() :Cette méthode lance la commande en tant que processus distinct et revient immédiatement. Il peut être utile pour exécuter des commandes non bloquantes.
process = subprocess . Popen (
command_line , shell = True , stdout = subprocess . DEVNULL , stderr = subprocess . DEVNULL
)
return f"Subprocess started with PID:' { str ( process . pid ) } '" Pour créer une commande personnalisée qui exécute des commandes shell, vous pouvez utiliser le décorateur @command avec les méthodes subprocess :
@ command ( "execute_shell" , "Execute Shell Command" , '"command_line": "<command_line>"' )
def execute_shell ( command_line : str ) -> str :
result = subprocess . run ( command_line , capture_output = True , shell = True )
output = f"STDOUT: n { result . stdout } n STDERR: n { result . stderr } "
return output Le module analyze_code est conçu pour analyser un extrait de code donné et fournir des suggestions d'améliorations. Il utilise le décorateur @command pour définir une commande personnalisée appelée analyze_code . La fonction prend une chaîne contenant le code à analyser et renvoie une liste de suggestions.
Voici une explication simplifiée du code:
analyze_code avec le décorateur @command : @ command ( "analyze_code" , "Analyze Code" , '"code": "<full_code_string>"' )
def analyze_code ( code : str ) -> list [ str ]: function_string = "def analyze_code(code: str) -> list[str]:"
args = [ code ]
description_string = (
"Analyzes the given code and returns a list of suggestions for improvements."
) return call_ai_function ( function_string , args , description_string ) La fonction improve_code est conçue pour améliorer un extrait de code donné en fonction d'une liste des suggestions fournies. Il utilise le décorateur @command pour définir une commande personnalisée appelée improve_code . La fonction prend une liste de suggestions et une chaîne contenant le code à améliorer, et il renvoie une nouvelle chaîne de code avec les améliorations suggérées appliquées.
Voici une explication simplifiée du code:
improve_code avec le décorateur @command : @ command ( "improve_code" , "Get Improved Code" , '"suggestions": "<list_of_suggestions>", "code": "<full_code_string>"' )
def improve_code ( suggestions : list [ str ], code : str ) -> str : function_string = "def generate_improved_code(suggestions: list[str], code: str) -> str:"
args = [ json . dumps ( suggestions ), code ]
description_string = (
"Improves the provided code based on the suggestions"
" provided, making no other changes."
) return call_ai_function ( function_string , args , description_string ) Pour utiliser la fonction improve_code , passez une liste de suggestions et une chaîne contenant l'extrait de code que vous souhaitez améliorer:
suggestions = [
"Replace the print statement with a return statement." ,
"Add type hints to the function."
]
code_to_improve = '''
def some_function():
print("Hello, World!")
'''
improved_code = improve_code ( suggestions , code_to_improve )
print ( improved_code ) La fonction improve_code appellera ensuite la fonction AI, qui à son tour utilise l'API OpenAI pour appliquer les améliorations suggérées au code et générer une nouvelle version améliorée du code. Notez que la qualité des améliorations dépend de la compréhension du modèle linguistique des suggestions et de sa capacité à les appliquer correctement.
prompt = "Generate documentation for the function 'Function name'"
generator = response = openai.Completion.create(
engine=engine,
prompt=prompt,
max_tokens=150,
n=1,
stop=None,
temperature=1.2,
presence_penalty=0.5,
frequency_penalty=0.5,
)
Utilisez la fonction improve_code pour le débogage, vous pouvez suivre les étapes ci-dessous:
Identifiez les problèmes ou les bogues de votre code. Vous pouvez le faire manuellement, ou vous pouvez utiliser des outils tels que des liners, des analyseurs statiques ou des débogueurs pour aider à identifier les problèmes.
Créez une liste de suggestions basées sur les problèmes identifiés. Chaque suggestion doit décrire comment corriger un problème ou un bug spécifique dans le code.
Appelez la fonction improve_code , en passant la liste des suggestions et l'extrait de code avec des problèmes comme arguments:
suggestions = [
"Fix the IndexError by using a conditional statement." ,
"Handle the ZeroDivisionError exception."
]
buggy_code = '''
def buggy_function(a, b):
result = a / b
return result
def another_buggy_function(lst):
return lst[0]
'''
improved_code = improve_code ( suggestions , buggy_code )
print ( improved_code )improve_code . Assurez-vous que les améliorations générées par l'IA s'alignent avec vos suggestions et résolvez correctement les problèmes identifiés. Vérifiez que le code amélioré fonctionne comme prévu. - Choose the search function: `google_search` for DuckDuckGo or `google_official_search` for the official Google API.
- Call the chosen function with your search query:
```python
query = "example search query"
num_results = 5
# Perform the search using DuckDuckGo
search_results = google_search(query, num_results)
print(search_results)
# Or, perform the search using the official Google API
# search_results = google_official_search(query, num_results)
# print(search_results)
La fonction renvoie une liste des URL de résultat de recherche qui correspondent à la requête donnée. Assurez-vous que l'API Google enregistre dans secrets.json
Appelez la fonction browse_website avec l'URL du site Web que vous souhaitez gratter et une question liée au contenu que vous recherchez:
url = "https://example.com"
question = "What is the main purpose of the website?"
answer_and_links = browse_website ( url , question )
print ( answer_and_links ) La fonction browse_website utilise scrape_text_with_selenium pour gratter le contenu texte du site Web et scrape_links_with_selenium pour extraire les liens.
list_files avec le répertoire que vous souhaitez rechercher: directory = "path/to/directory"
all_files = list_files ( directory ) search_criteria = "example"
matching_files = [ file for file in all_files if search_criteria in file ]
print ( matching_files ) Dans cet exemple, matching_files contiendra une liste de tous les fichiers du répertoire spécifié (et de ses sous-répertoires) qui ont la chaîne search_criteria dans leur nom. Modifiez la condition de filtrage au besoin pour répondre à vos exigences de recherche spécifiques.
Autogpt a une fonction clone_repository qui vous permet de cloner un référentiel git d'une URL donnée à un répertoire local sur votre machine. Pour l'inviter à l'entrée et à cloner un référentiel GIT à l'aide de la fonction clone_repository , suivez ces étapes:
repo_url = "repository URL"
clone_path = "the path to clone the repository"clone_repository avec l'URL et le chemin fourni: result = clone_repository ( repo_url , clone_path ) Ce code appelle la fonction clone_repository , qui clones le référentiel à l'aide des informations d'authentification GitHub fournies à partir de l'objet Config .
Utilisez Autogpt pour générer automatiquement des commentaires descriptifs pour votre code. Cela peut aider à rendre votre code plus lisible et plus facile à comprendre, en particulier pour les membres de l'équipe qui ne connaissent peut-être pas la base de code.
Utilisez AutoGPT pour générer du code de passe-partout pour votre projet. Par exemple, vous pouvez utiliser Autogpt pour générer du code pour configurer la journalisation, créer des fichiers de configuration ou initialiser la base de données.
Utilisez Autogpt pour générer des cas de test pour votre code. Cela peut aider à garantir que votre code fonctionne comme prévu et que les modifications que vous apportez au code n'introduisent pas de nouveaux bogues.
Utilisez Autogpt pour générer de la documentation pour votre projet. Autogpt peut générer automatiquement la documentation de l'API, les guides utilisateur et d'autres types de documentation, ce qui vous permet de gagner du temps et des efforts.
Autogpt est un outil puissant qui peut vous aider dans le codage et l'ingénierie rapide. Il peut générer des extraits de code, vérifier la syntaxe du code, améliorer le code, générer des cas de test, générer des documents et exécuter des fichiers Python. En utilisant Autogpt, vous pouvez gagner du temps et augmenter la productivité.
