AutoGPT handbook
1.0.0
Auto-GPT es una herramienta AI de código abierto que aprovecha las API GPT-4 o GPT-3.5 de OpenAI para lograr los objetivos definidos por el usuario expresados en el lenguaje natural. Lo hace diseccionando la tarea principal en componentes más pequeños y utilizando de forma autónoma varios recursos en un proceso cíclico.
En esta guía, exploraremos las diversas características de AutoGPT y describiremos las mejores prácticas y consejos para utilizar AutoGPT para la codificación.
git clone https://github.com/significant-gravitas/auto-gpt.git en su terminal o haciendo clic en el botón "Código" en la página del repositorio y descargando el archivo zip.autogpt --version . Debería ver el número de versión que se muestra en el terminal.También puede usar un entorno virtual para contener la instalación de AutoGPT y para asegurarse de no encontrar ningún error al instalar dependencias o ejecutar AutoGPT.
Asegúrese de actualizar '.env' con sus propias configuraciones y sus propias claves API. El archivo contiene cada API que pueda necesitar. Puede omitir algunos si no los usa, como para la generación de imágenes, sin embargo, asegúrese de tener:
Clave de la API de OpenAI : se requiere esta clave para usar la API de OpenAI que AutoGPT está construida en la parte superior. Puede obtener una clave API registrándose para el programa API de OpenAI:
GitHub_api_Key : se requiere esta clave para autorizar su acceso a la API GitHub. Puede obtener esta clave siguiendo los pasos en el sitio web de GitHub.
tu github_username
Puede agregar todas las API aquí. '.env' se explica por sí mismo Una vez que haya obtenido estas claves, debe editar el archivo .env en el repositorio y agregar las teclas API enumeradas anteriormente.
También preste atención a lo siguiente:
Debe editar el archivo .env en el repositorio y agregar las teclas API enumeradas anteriormente. Esto se debe a que las teclas API son información confidencial que no debe codificarse en la aplicación.
También debe agregar sus propias indicaciones al archivo prompts.json para hacer que AutoGPT sea más útil para su caso de uso particular. Las indicaciones proporcionadas en el repositorio son indicaciones generales que pueden no ser aplicables a su proyecto. Al agregar sus propias indicaciones, puede capacitar a AutoGpt para generar respuestas que se adapten a su caso de uso específico.
Para solicitar AutoGPT, use el comando python -m autogpt en su terminal. Asegúrese de estar en el camino correcto. Si no, configúrelo por 'ruta de CD'
Para obtener los mejores resultados, asegúrese de que sus indicaciones sean específicas y bien definidas. Esto le dará a Autogpt una comprensión clara de lo que está tratando de lograr y ayudará a generar respuestas más precisas.
Al revisar las respuestas del modelo, tenga en cuenta que AutoGpt es un modelo de lenguaje y no un humano. Como tal, puede generar respuestas que no son del todo precisas o adecuadas para su caso de uso. Depende de usted revisar las respuestas y hacer las modificaciones necesarias.
Otra forma de usar AutoGPT es integrándolo en su código. Puede echar un vistazo a los comandos en la carpeta clonada y usarla para generar respuestas programáticamente. Esto puede ser útil si desea generar respuestas en un contexto específico.
Estas son algunas de las mejores formas de usar AutoGpt para ingeniería rápida:
El decorador @command se usa para definir comandos personalizados. Se necesitan tres argumentos:
name : El nombre del comando.description : Una breve descripción del comando.params : una cadena que representa los parámetros esperados para el comando. Aquí hay un ejemplo de usar el decorador @command para definir un comando personalizado llamado execute_python_file :
@ command ( "execute_python_file" , "Execute Python File" , '"filename": "<filename>"' )
def execute_python_file ( filename : str ) -> str :
# Implementation of the command Para ejecutar comandos de shell, puede usar el módulo subprocess . Aquí hay dos métodos para ejecutar comandos de shell:
subprocess.run() :Este método ejecuta el comando y espera a que se complete. Devuelve la salida (stdout y stderr) del comando.
result = subprocess . run ( command_line , capture_output = True , shell = True )
output = f"STDOUT: n { result . stdout } n STDERR: n { result . stderr } " subprocess.Popen() :Este método inicia el comando como un proceso separado y devuelve inmediatamente. Puede ser útil para ejecutar comandos que no son de bloqueo.
process = subprocess . Popen (
command_line , shell = True , stdout = subprocess . DEVNULL , stderr = subprocess . DEVNULL
)
return f"Subprocess started with PID:' { str ( process . pid ) } '" Para crear un comando personalizado que ejecute comandos de shell, puede usar el decorador @command junto con los métodos 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 El módulo analyze_code está diseñado para analizar un fragmento de código dado y proporcionar sugerencias de mejoras. Utiliza el decorador @command para definir un comando personalizado llamado analyze_code . La función toma una cadena que contiene el código para analizar y devuelve una lista de sugerencias.
Aquí hay una explicación simplificada del código:
analyze_code con el decorador @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 función improve_code está diseñada para mejorar un fragmento de código dado en función de una lista de sugerencias proporcionadas. Utiliza el decorador @command para definir un comando personalizado llamado improve_code . La función toma una lista de sugerencias y una cadena que contiene el código que se mejorará, y devuelve una nueva cadena de código con las mejoras sugeridas aplicadas.
Aquí hay una explicación simplificada del código:
improve_code con el decorador @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 ) Para usar la función improve_code , pase una lista de sugerencias y una cadena que contiene el fragmento de código que desea mejorar:
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 función improve_code luego llamará a la función AI, que a su vez usa la API de OpenAI para aplicar las mejoras sugeridas al código y generar una nueva versión mejorada del código. Tenga en cuenta que la calidad de las mejoras depende de la comprensión del modelo de idioma de las sugerencias y su capacidad para aplicarlas correctamente.
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,
)
Use la función improve_code para la depuración, puede seguir los pasos a continuación:
Identifique los problemas o errores en su código. Puede hacer esto manualmente, o puede usar herramientas como revestimientos, analizadores estáticos o depuradores para ayudar a determinar los problemas.
Cree una lista de sugerencias basadas en los problemas identificados. Cada sugerencia debe describir cómo solucionar un problema o error específico en el código.
Llame a la función improve_code , pasando la lista de sugerencias y el fragmento de código con problemas como argumentos:
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 . Asegúrese de que las mejoras generadas por IA se alineen con sus sugerencias y corran correctamente los problemas identificados. Verifique que el código mejorado funcione como se esperaba. - 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 función devuelve una lista de URL de resultados de búsqueda que coinciden con la consulta dada. Asegúrese de tener la API de Google guardada en Secrets.json
Llame a la función browse_website con la URL del sitio web que desea raspar y una pregunta relacionada con el contenido que está buscando:
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 función browse_website usa scrape_text_with_selenium para raspar el contenido de texto del sitio web y scrape_links_with_selenium para extraer los enlaces.
list_files con el directorio que desea buscar: 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 ) En este ejemplo, matching_files contendrá una lista de todos los archivos en el directorio especificado (y sus subdirectorios) que tienen la cadena search_criteria en sus nombres. Modifique la condición de filtrado según sea necesario para que coincida con sus requisitos de búsqueda específicos.
AutoGPT tiene una función clone_repository que le permite clonar un repositorio Git de una URL dada a un directorio local en su máquina. Para solicitarlo para la entrada y clonar un repositorio de git utilizando la función clone_repository , siga estos pasos:
repo_url = "repository URL"
clone_path = "the path to clone the repository"clone_repository con la URL y la ruta proporcionadas: result = clone_repository ( repo_url , clone_path ) Este código llama a la función clone_repository , que clona el repositorio utilizando las credenciales de autenticación GitHub proporcionadas desde el objeto Config .
Use AutoGPT para generar comentarios descriptivos para su código automáticamente. Esto puede ayudar a que su código sea más legible y más fácil de entender, especialmente para los miembros del equipo que pueden no estar familiarizados con la base de código.
Use AutoGPT para generar el código Boilerplate para su proyecto. Por ejemplo, puede usar AutoGPT para generar código para configurar el registro, crear archivos de configuración o inicializar la base de datos.
Use AutoGPT para generar casos de prueba para su código. Esto puede ayudar a garantizar que su código funcione como se esperaba y que cualquier cambio que realice en el código no introduzca nuevos errores.
Use AutoGPT para generar documentación para su proyecto. AutoGPT puede generar documentación de API, guías de usuario y otros tipos de documentación automáticamente, ahorrándole tiempo y esfuerzo.
AutoGPT es una herramienta poderosa que puede ayudarlo a codificar e ingeniería rápida. Puede generar fragmentos de código, verificar la sintaxis del código, mejorar el código, generar casos de prueba, generar documentación y ejecutar archivos de Python. Al usar AutoGPT, puede ahorrar tiempo y aumentar la productividad.
