AutoGPT handbook
1.0.0
Auto-GPT ist ein Open-Source-KI-Tool, das die GPT-4- oder GPT-3.5-APIs von OpenAI nutzt, um benutzerdefinierte Ziele in der natürlichen Sprache zu erreichen. Dies geschieht, indem die Hauptaufgabe in kleinere Komponenten analysiert und verschiedene Ressourcen in einem zyklischen Prozess autonom verwendet wird.
In diesem Leitfaden werden wir die verschiedenen Funktionen von Autogpt untersuchen und die besten Praktiken und Tipps für die Verwendung von Autogpt für die Codierung skizzieren.
git clone https://github.com/significant-gravitas/auto-gpt.git auf Ihrem Terminal oder durch Klicken auf die Schaltfläche "Code" auf der Repository-Seite und herunterladen und herunterladen der ZIP-Datei klonen.autogpt --version erfolgreich war. Sie sollten die im Terminal angezeigte Versionsnummer sehen.Sie können auch eine virtuelle Umgebung verwenden, um die Installation von AutogPT zu enthalten und sicherzustellen, dass Sie bei der Installation von Abhängigkeiten oder beim Ausführen von Autogpt keine Fehler treffen.
Stellen Sie sicher, dass Sie mit Ihren eigenen Konfigurationen und Ihren eigenen API -Schlüssel aktualisieren. Die Datei enthält jede API, die Sie möglicherweise benötigen. Sie können etwas besitzen, wenn Sie sie nicht verwenden, wie z. B. für die Bildgenerierung, stellen Sie jedoch sicher, dass Sie Folgendes haben:
OpenAI -API -Schlüssel - Dieser Schlüssel ist erforderlich, um die OpenAI -API zu verwenden, auf der Autogpt aufgebaut ist. Sie können einen API -Schlüssel erhalten, indem Sie sich für das OpenAI -API -Programm anmelden:
Github_api_key - Dieser Schlüssel ist erforderlich, um Ihren Zugriff auf die GitHub -API zu autorisieren. Sie können diesen Schlüssel erhalten, indem Sie die Schritte auf der GitHub -Website ausführen.
Dein Github_USERNAME
Hier können Sie alle APIs hinzufügen. Das '.env' ist selbsterklärend, sobald Sie diese Schlüssel erhalten haben. Sie müssen die .env -Datei im Repository bearbeiten und die oben aufgeführten API -Tasten hinzufügen.
Achten Sie auch auf die folgenden:
Sie müssen die .env -Datei im Repository bearbeiten und die oben aufgeführten API -Tasten hinzufügen. Dies liegt daran, dass die API -Schlüssel sensible Informationen sind, die nicht in die Anwendung festgelegt werden sollten.
Sie müssen außerdem Ihre eigenen Eingabeaufforderungen in die Datei prompts.json hinzufügen, um Autogpt für Ihren speziellen Anwendungsfall nützlicher zu machen. Die im Repository bereitgestellten Eingabeaufforderungen sind allgemeine Eingabeaufforderungen, die möglicherweise nicht für Ihr Projekt anwendbar sind. Durch das Hinzufügen Ihrer eigenen Eingabeaufforderungen können Sie Autogpt trainieren, um Antworten zu generieren, die auf Ihren speziellen Anwendungsfall zugeschnitten sind.
Verwenden Sie zum Einschalten von Autogpt den Befehl python -m autogpt in Ihrem Terminal. Stellen Sie sicher, dass Sie sich auf dem richtigen Weg befinden. Wenn nicht, setzen Sie es auf "CD -Pfad"
Stellen Sie für die besten Ergebnisse sicher, dass Ihre Eingabeaufforderungen spezifisch und genau definiert sind. Dadurch wird AutoGPT ein klares Verständnis dafür vermitteln, was Sie erreichen möchten, und es helfen, genauere Antworten zu erzeugen.
Beachten Sie bei der Überprüfung der Antworten des Modells, dass Autogpt ein Sprachmodell und kein Mensch ist. Daher kann es Antworten erzeugen, die nicht ganz genau oder für Ihren Anwendungsfall geeignet sind. Es liegt an Ihnen, die Antworten zu überprüfen und die erforderlichen Änderungen vorzunehmen.
Eine andere Möglichkeit, Autogpt zu verwenden, besteht darin, es in Ihren Code zu integrieren. Sie können sich die Befehle im geklonten Ordner ansehen und diese verwenden, um Antworten programmgesteuert zu generieren. Dies kann nützlich sein, wenn Sie Antworten in einem bestimmten Kontext generieren möchten.
Hier sind einige der besten Möglichkeiten, Autogpt für promptes Engineering zu verwenden:
Der @command Decorator wird verwendet, um benutzerdefinierte Befehle zu definieren. Es braucht drei Argumente:
name : Der Name des Befehls.description : Eine kurze Beschreibung des Befehls.params : Eine Zeichenfolge, die die erwarteten Parameter für den Befehl darstellt. Hier ist ein Beispiel für die Verwendung des @command Decorators, um einen benutzerdefinierten Befehl namens execute_python_file zu definieren:
@ command ( "execute_python_file" , "Execute Python File" , '"filename": "<filename>"' )
def execute_python_file ( filename : str ) -> str :
# Implementation of the command Um Shell -Befehle auszuführen, können Sie das subprocess -Modul verwenden. Hier sind zwei Methoden zum Ausführen von Shell -Befehlen:
subprocess.run() :Diese Methode führt den Befehl aus und wartet darauf, dass er abgeschlossen ist. Es gibt die Ausgabe (STDOut und Stderr) des Befehls zurück.
result = subprocess . run ( command_line , capture_output = True , shell = True )
output = f"STDOUT: n { result . stdout } n STDERR: n { result . stderr } " subprocess.Popen() :Diese Methode startet den Befehl als separater Prozess und kehrt sofort zurück. Es kann nützlich sein, um nicht blockierende Befehle auszuführen.
process = subprocess . Popen (
command_line , shell = True , stdout = subprocess . DEVNULL , stderr = subprocess . DEVNULL
)
return f"Subprocess started with PID:' { str ( process . pid ) } '" Um einen benutzerdefinierten Befehl zu erstellen, der Shell -Befehle ausführt, können Sie den @command Decorator zusammen mit den subprocess verwenden:
@ 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 Das Modul analyze_code ist so konzipiert, dass ein bestimmtes Code -Snippet analysiert und Verbesserungsvorschläge bereitgestellt werden. Es verwendet den @command Decorator, um einen benutzerdefinierten Befehl namens analyze_code zu definieren. Die Funktion nimmt eine Zeichenfolge, die den zu analysierenden Code enthält, und gibt eine Liste von Vorschlägen zurück.
Hier ist eine vereinfachte Erklärung des Code:
analyze_code mit dem @command Decorator: @ 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 ) Die Funktion improve_code wurde entwickelt, um einen bestimmten Code -Snippet basierend auf einer Liste der bereitgestellten Vorschläge zu verbessern. Es verwendet den @command Decorator, um einen benutzerdefinierten Befehl namens improve_code zu definieren. Die Funktion enthält eine Liste von Vorschlägen und eine Zeichenfolge, die den zu verbesserten Code enthält, und gibt eine neue Codezeichenfolge mit den vorgeschlagenen Verbesserungen zurück.
Hier ist eine vereinfachte Erklärung des Code:
improve_code mit dem @command Decorator: @ 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 ) Um die Funktion improve_code zu verwenden, geben Sie eine Liste von Vorschlägen und eine Zeichenfolge über, die den Code -Snippet enthält, den Sie verbessern möchten:
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 ) In der Funktion improve_code wird dann die AI -Funktion aufgerufen, die wiederum die OpenAI -API verwendet, um die vorgeschlagenen Verbesserungen im Code anzuwenden und eine neue, verbesserte Version des Codes zu generieren. Beachten Sie, dass die Qualität der Verbesserungen vom Verständnis des Sprachmodells für die Vorschläge und ihrer Fähigkeit abhängt, sie korrekt anzuwenden.
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,
)
Verwenden Sie die Funktion improve_code zum Debuggen. Sie können die folgenden Schritte ausführen:
Identifizieren Sie die Probleme oder Fehler in Ihrem Code. Sie können dies manuell oder Tools wie Linter, statische Analysatoren oder Debugger verwenden, um die Probleme zu bestimmen.
Erstellen Sie eine Liste von Vorschlägen basierend auf den identifizierten Problemen. Jeder Vorschlag sollte beschreiben, wie ein bestimmtes Problem oder Fehler im Code behoben werden kann.
Rufen Sie die Funktion improve_code auf, übergeben Sie die Liste der Vorschläge und den Code -Snippet mit Problemen als Argumente:
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 zurückgegeben wurde. Stellen Sie sicher, dass die Verbesserungen der AI-generierten Vorschläge mit Ihren Vorschlägen übereinstimmen, und beheben Sie die identifizierten Probleme korrekt. Stellen Sie sicher, dass der verbesserte Code wie erwartet funktioniert. - 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)
Die Funktion gibt eine Liste von Suchergebnis -URLs zurück, die der angegebenen Abfrage entsprechen. Stellen Sie sicher, dass die Google -API in Secrets.json gespeichert wird
Rufen Sie die Funktion browse_website mit der URL der Website auf, die Sie kratzen möchten, und eine Frage im Zusammenhang mit dem Inhalt, den Sie suchen:
url = "https://example.com"
question = "What is the main purpose of the website?"
answer_and_links = browse_website ( url , question )
print ( answer_and_links ) Die Funktion browse_website verwendet scrape_text_with_selenium , um den Textinhalt der Website und scrape_links_with_selenium zu kratzen, um die Links zu extrahieren.
list_files mit dem Verzeichnis auf, nach dem Sie suchen möchten: 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 ) In diesem Beispiel enthält matching_files eine Liste aller Dateien im angegebenen Verzeichnis (und seinen Unterverzeichnissen), in denen die search_criteria -Zeichenfolge in ihren Namen enthalten ist. Ändern Sie die Filterbedingung nach Bedarf, um Ihren spezifischen Suchanforderungen zu entsprechen.
AutoGPT verfügt über ein Funktion clone_repository , mit dem Sie ein Git -Repository aus einer bestimmten URL in ein lokales Verzeichnis auf Ihrem Computer klonen können. Befolgen Sie die clone_repository Schritte:
repo_url = "repository URL"
clone_path = "the path to clone the repository"clone_repository mit der bereitgestellten URL und dem bereitgestellten Pfad auf: result = clone_repository ( repo_url , clone_path ) Dieser Code ruft die Funktion clone_repository auf, die das Repository unter Verwendung der bereitgestellten GitHub -Authentifizierungsanmeldeinformationen aus dem Config kloniert.
Verwenden Sie Autogpt, um beschreibende Kommentare für Ihren Code automatisch zu generieren. Dies kann dazu beitragen, dass Ihr Code lesbarer und einfacher zu verstehen ist, insbesondere für Teammitglieder, die mit der Codebasis möglicherweise nicht vertraut sind.
Verwenden Sie Autogpt, um den Code für Ihr Projekt zu generieren. Sie können beispielsweise AutogPT verwenden, um Code zum Einrichten der Protokollierung, zum Erstellen von Konfigurationsdateien oder zur Initialisierung der Datenbank zu generieren.
Verwenden Sie Autogpt, um Testfälle für Ihren Code zu generieren. Dies kann dazu beitragen, dass Ihr Code wie erwartet funktioniert und dass Änderungen, die Sie am Code vornehmen, keine neuen Fehler einführen.
Verwenden Sie Autogpt, um Dokumentation für Ihr Projekt zu generieren. AutoGPT kann API -Dokumentation, Benutzerführer und andere Arten von Dokumentationen automatisch generieren und Ihnen Zeit und Mühe sparen.
AutoGPT ist ein leistungsstarkes Tool, das Ihnen bei der Codierung und zum schnellen Engineering helfen kann. Es kann Code -Snippets generieren, die Code -Syntax überprüfen, den Code verbessern, Testfälle generieren, Dokumentation generieren und Python -Dateien ausführen. Durch die Verwendung von AutoGPT können Sie Zeit sparen und die Produktivität steigern.
