AutoGPT handbook
1.0.0
O Auto-GPT é uma ferramenta de IA de código aberto que aproveita as APIs GPT-4 ou GPT-3.5 do OpenAI para atingir objetivos definidos pelo usuário expressos em linguagem natural. Faz isso dissecando a principal tarefa em componentes menores e utilizando autonomamente vários recursos em um processo cíclico.
Neste guia, exploraremos os vários recursos do AutoGPT e delinearemos as melhores práticas e dicas para utilizar o AutoGPT para codificação.
git clone https://github.com/significant-gravitas/auto-gpt.git no seu terminal ou clicando no botão "código" na página do repositório e baixando o arquivo ZIP.autogpt --version . Você deve ver o número da versão exibido no terminal.Você também pode usar um ambiente virtual para conter a instalação do AutoGPT e para garantir que você não apresente nenhum erro ao instalar dependências ou executar o AutoGPT.
Certifique -se de atualizar '.env' com suas próprias configurações e suas próprias teclas de API. O arquivo contém todas as API que você pode precisar. Você pode omitir alguns se você não os usar, como para geração de imagens, mas verifique se você tem:
Chave da API OpenAI - essa chave é necessária para usar a API OpenAI que a AutoGPT está construída sobre. Você pode obter uma chave de API se inscrevendo no programa API OpenAI:
Github_api_key - Esta chave é necessária para autorizar seu acesso à API do GitHub. Você pode obter essa chave seguindo as etapas no site do GitHub.
Seu github_username
Você pode adicionar todas as APIs aqui. O '.env' é auto -explicativo depois de obter essas chaves, você precisa editar o arquivo .env no repositório e adicionar as teclas da API listadas acima.
Também preste atenção ao abaixo:
Você precisa editar o arquivo .env no repositório e adicionar as teclas da API listadas acima. Isso ocorre porque as teclas da API são informações sensíveis que não devem ser codificadas no aplicativo.
Você também precisa adicionar seus próprios prompts ao arquivo de prompts.json para tornar o AutoGPT mais útil para o seu caso de uso específico. Os avisos fornecidos no repositório são avisos gerais que podem não ser aplicáveis ao seu projeto. Ao adicionar seus próprios prompts, você pode treinar a autogpt para gerar respostas adaptadas ao seu caso de uso específico.
Para solicitar o AutoGPT, use o comando python -m autogpt no seu terminal. Verifique se você está no caminho certo. Caso contrário, defina -o por 'CD Path'
Para obter melhores resultados, verifique se seus avisos são específicos e bem definidos. Isso dará à AutoGPT uma compreensão clara do que você está tentando alcançar e ajudá -lo a gerar respostas mais precisas.
Ao revisar as respostas do modelo, lembre -se de que o AutoGPT é um modelo de idioma e não é humano. Como tal, pode gerar respostas que não são totalmente precisas ou adequadas para o seu caso de uso. Cabe a você revisar as respostas e fazer as modificações necessárias.
Outra maneira de usar o AutoGPT é integrá -lo ao seu código. Você pode dar uma olhada nos comandos na pasta clonada e usá -los para gerar respostas programaticamente. Isso pode ser útil se você deseja gerar respostas em um contexto específico.
Aqui estão algumas das melhores maneiras de usar o AutoGPT para engenharia imediata:
O decorador @command é usado para definir comandos personalizados. São necessários três argumentos:
name : o nome do comando.description : Uma breve descrição do comando.params : uma string representando os parâmetros esperados para o comando. Aqui está um exemplo de usar o Decorador @command para definir um comando personalizado chamado execute_python_file :
@ command ( "execute_python_file" , "Execute Python File" , '"filename": "<filename>"' )
def execute_python_file ( filename : str ) -> str :
# Implementation of the command Para executar comandos de shell, você pode usar o módulo subprocess . Aqui estão dois métodos para executar comandos de shell:
subprocess.run() :Este método executa o comando e aguarda a conclusão. Ele retorna a saída (stdout e stderr) do 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 o comando como um processo separado e retorna imediatamente. Pode ser útil para executar comandos não bloqueadores.
process = subprocess . Popen (
command_line , shell = True , stdout = subprocess . DEVNULL , stderr = subprocess . DEVNULL
)
return f"Subprocess started with PID:' { str ( process . pid ) } '" Para criar um comando personalizado que execute os comandos do shell, você pode usar o Decorador @command junto com os métodos de 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 O módulo analyze_code foi projetado para analisar um determinado trecho de código e fornecer sugestões para melhorias. Ele usa o Decorador @command para definir um comando personalizado chamado analyze_code . A função leva uma string que contém o código a ser analisada e retorna uma lista de sugestões.
Aqui está uma explicação simplificada do código:
analyze_code com o @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 ) A função improve_code foi projetada para melhorar um determinado trecho de código com base em uma lista de sugestões fornecidas. Ele usa o decorador @command para definir um comando personalizado chamado improve_code . A função leva uma lista de sugestões e uma string que contém o código a ser aprimorada e retorna uma nova string de código com as melhorias sugeridas aplicadas.
Aqui está uma explicação simplificada do código:
improve_code com o @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 ) Para usar a função improve_code , passe uma lista de sugestões e uma string que contém o trecho de código que você deseja melhorar:
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 ) A função improve_code chamará a função AI, que por sua vez usa a API do OpenAI para aplicar as melhorias sugeridas ao código e gerar uma nova versão aprimorada do código. Observe que a qualidade das melhorias depende do entendimento do modelo de idioma das sugestões e de sua capacidade de aplicá -las corretamente.
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 a função improve_code para depuração, você pode seguir as etapas abaixo:
Identifique os problemas ou bugs em seu código. Você pode fazer isso manualmente, ou pode usar ferramentas como linters, analisadores estáticos ou depuradores para ajudar a identificar os problemas.
Crie uma lista de sugestões com base nos problemas identificados. Cada sugestão deve descrever como corrigir um problema ou bug específico no código.
Ligue para a função improve_code , passando a lista de sugestões e o snippet de código com 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 . Verifique se as melhorias geradas pela IA estão alinhadas com suas sugestões e corrige corretamente os problemas identificados. Verifique se o código aprimorado funciona conforme o esperado. - 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)
A função retorna uma lista de URLs de resultado da pesquisa que correspondem à consulta fornecida. Certifique -se de ter a API do Google salvada em Secrets.json
Ligue para a função browse_website com o URL do site que deseja raspar e uma pergunta relacionada ao conteúdo que você está procurando:
url = "https://example.com"
question = "What is the main purpose of the website?"
answer_and_links = browse_website ( url , question )
print ( answer_and_links ) A função browse_website usa scrape_text_with_selenium para raspar o conteúdo de texto do site e scrape_links_with_selenium para extrair os links.
list_files com o diretório que você deseja pesquisar: 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 ) Neste exemplo, matching_files conterá uma lista de todos os arquivos no diretório especificado (e seus subdiretos) que possuem a sequência de search_criteria em seus nomes. Modifique a condição de filtragem conforme necessário para corresponder aos seus requisitos de pesquisa específicos.
O AutoGPT possui um função clone_repository que permite clonar um repositório Git de um determinado URL para um diretório local em sua máquina. Para solicitá -lo para obter e clonar um repositório Git usando a função clone_repository , siga estas etapas:
repo_url = "repository URL"
clone_path = "the path to clone the repository"clone_repository com o URL e o caminho fornecido: result = clone_repository ( repo_url , clone_path ) Este código chama a função clone_repository , que clara o repositório usando as credenciais de autenticação do GitHub fornecidas do objeto Config .
Use o AutoGPT para gerar comentários descritivos para o seu código automaticamente. Isso pode ajudar a tornar seu código mais legível e fácil de entender, especialmente para membros da equipe que podem não estar familiarizados com a base de código.
Use o AutoGPT para gerar código de caldeira para o seu projeto. Por exemplo, você pode usar o AutoGPT para gerar código para configurar o log, criar arquivos de configuração ou inicializar o banco de dados.
Use o AutoGPT para gerar casos de teste para o seu código. Isso pode ajudar a garantir que seu código esteja funcionando conforme o esperado e que as alterações que você faça no código não introduzam novos bugs.
Use o AutoGPT para gerar documentação para o seu projeto. O AutoGPT pode gerar documentação da API, guias de usuário e outros tipos de documentação automaticamente, economizando tempo e esforço.
O AutoGPT é uma ferramenta poderosa que pode ajudá -lo a codificar e pronta a engenharia. Ele pode gerar trechos de código, verificar a sintaxe do código, melhorar o código, gerar casos de teste, gerar documentação e executar arquivos Python. Ao usar o AutoGPT, você pode economizar tempo e aumentar a produtividade.
