shell_gpt
1.4.4
Uma ferramenta de produtividade da linha de comando alimentada por Modelos de Idiomas de AI (LLM). Esta ferramenta de linha de comando oferece geração simplificada de comandos de shell, trechos de código, documentação , eliminando a necessidade de recursos externos (como a pesquisa do Google). Suporta Linux, MacOS, Windows e compatível com todas as principais conchas como PowerShell, CMD, Bash, Zsh, etc.
pip install shell-gpt Por padrão, o ShellGPT usa o modelo API e GPT-4 do OpenAI. Você precisará de uma chave da API, poderá gerar uma aqui. Você será solicitado à sua chave que será armazenada em ~/.config/shell_gpt/.sgptrc . A API OpenAI não é gratuita, consulte o preço do OpenAI para obter mais informações.
Dica
Como alternativa, você pode usar modelos de código aberto hospedados localmente que estão disponíveis gratuitamente. Para usar modelos locais, você precisará executar seu próprio servidor de back -end LLM, como o Ollama. Para configurar o Shellgpt com Ollama, siga este guia abrangente.
❗️ Noto que o ShellGPT não é otimizado para modelos locais e pode não funcionar conforme o esperado.
O ShellGPT foi projetado para analisar e recuperar rapidamente informações. É útil para solicitações diretas que variam de configurações técnicas a conhecimento geral.
sgpt " What is the fibonacci sequence "
# -> The Fibonacci sequence is a series of numbers where each number ... O shellgpt aceita o prompt do argumento do stdin e da linha de comando. Se você prefere a entrada da tubulação através do terminal ou especificando -o diretamente como argumentos, sgpt o abordou. Por exemplo, você pode gerar facilmente uma mensagem de comprometimento Git com base em um diferencial:
git diff | sgpt " Generate git commit message, for my changes "
# -> Added main feature details into README.mdVocê pode analisar logs de várias fontes, passando -os usando o Stdin, juntamente com um prompt. Por exemplo, podemos usá -lo para analisar rapidamente logs, identificar erros e obter sugestões para possíveis soluções:
docker logs -n 20 my_app | sgpt " check logs, find errors, provide possible solutions " Error Detected: Connection timeout at line 7.
Possible Solution: Check network connectivity and firewall settings.
Error Detected: Memory allocation failed at line 12.
Possible Solution: Consider increasing memory allocation or optimizing application memory usage.
Você também pode usar todo tipo de operadores de redirecionamento para passar a entrada:
sgpt " summarise " < document.txt
# -> The document discusses the impact...
sgpt << EOF
What is the best way to lear Golang?
Provide simple hello world example.
EOF
# -> The best way to learn Golang...
sgpt <<< " What is the best way to learn shell redirects? "
# -> The best way to learn shell redirects is through... Você já se viu esquecendo comandos comuns do shell, como find e precisar procurar a sintaxe online? Com a opção --shell ou atalho -s , você pode gerar e executar rapidamente os comandos necessários no terminal.
sgpt --shell " find all json files in current folder "
# -> find . -type f -name "*.json"
# -> [E]xecute, [D]escribe, [A]bort: e O Shell GPT está ciente do OS e $SHELL você está usando, ele fornecerá o comando Shell para um sistema específico que você possui. Por exemplo, se você pedir sgpt para atualizar seu sistema, ele retornará um comando com base no seu sistema operacional. Aqui está um exemplo usando macOS:
sgpt -s " update my system "
# -> sudo softwareupdate -i -a
# -> [E]xecute, [D]escribe, [A]bort: eO mesmo aviso, quando usado no Ubuntu, gerará uma sugestão diferente:
sgpt -s " update my system "
# -> sudo apt update && sudo apt upgrade -y
# -> [E]xecute, [D]escribe, [A]bort: eVamos tentar com o Docker:
sgpt -s " start nginx container, mount ./index.html "
# -> docker run -d -p 80:80 -v $(pwd)/index.html:/usr/share/nginx/html/index.html nginx
# -> [E]xecute, [D]escribe, [A]bort: e Ainda podemos usar tubos para passar a entrada para sgpt e gerar comandos do shell:
sgpt -s " POST localhost with " < data.json
# -> curl -X POST -H "Content-Type: application/json" -d '{"a": 1, "b": 2}' http://localhost
# -> [E]xecute, [D]escribe, [A]bort: e Aplicando magia adicional da Shell em nosso prompt, neste exemplo, passando nomes de arquivos para ffmpeg :
ls
# -> 1.mp4 2.mp4 3.mp4
sgpt -s " ffmpeg combine $( ls -m ) into one video file without audio. "
# -> ffmpeg -i 1.mp4 -i 2.mp4 -i 3.mp4 -filter_complex "[0:v] [1:v] [2:v] concat=n=3:v=1 [v]" -map "[v]" out.mp4
# -> [E]xecute, [D]escribe, [A]bort: e Se você deseja aprovar o comando de shell gerado usando o Pipe, pode usar --no-interaction da opção. Isso desativará o modo interativo e imprimirá o comando gerado para o stdout. Neste exemplo, estamos usando pbcopy para copiar o comando gerado para a Clipboard:
sgpt -s " find all json files in current folder " --no-interaction | pbcopy Esse é um recurso muito útil , que permite usar as conclusões do shell sgpt diretamente no seu terminal, sem a necessidade de digitar sgpt com prompt e argumentos. A integração do shell permite o uso de shellgpt com teclas de atalho no seu terminal, suportadas pelas conchas Bash e Zsh. Esse recurso coloca as conclusões sgpt diretamente no buffer de terminal (linha de entrada), permitindo a edição imediata de comandos sugeridos.
Para instalar a integração do Shell, execute sgpt --install-integration e reinicie seu terminal para aplicar alterações. Isso adicionará poucas linhas ao seu arquivo .bashrc ou .zshrc . Depois disso, você pode usar Ctrl+l (por padrão) para invocar o Shellgpt. Quando você pressiona Ctrl+l ele substituirá sua linha de entrada atual (buffer) pelo comando sugerido. Você pode editá -lo e apenas pressionar Enter para executar.
Usando o parâmetro --code ou -c , você pode solicitar especificamente saída de código puro, por exemplo:
sgpt --code " solve fizz buzz problem using python " for i in range ( 1 , 101 ):
if i % 3 == 0 and i % 5 == 0 :
print ( "FizzBuzz" )
elif i % 3 == 0 :
print ( "Fizz" )
elif i % 5 == 0 :
print ( "Buzz" )
else :
print ( i )Como é um código python válido, podemos redirecionar a saída para um arquivo:
sgpt --code " solve classic fizz buzz problem using Python " > fizz_buzz.py
python fizz_buzz.py
# 1
# 2
# Fizz
# 4
# Buzz
# ...Também podemos usar tubos para passar a entrada:
cat fizz_buzz.py | sgpt --code " Generate comments for each line of my code " # Loop through numbers 1 to 100
for i in range ( 1 , 101 ):
# Check if number is divisible by both 3 and 5
if i % 3 == 0 and i % 5 == 0 :
# Print "FizzBuzz" if number is divisible by both 3 and 5
print ( "FizzBuzz" )
# Check if number is divisible by 3
elif i % 3 == 0 :
# Print "Fizz" if number is divisible by 3
print ( "Fizz" )
# Check if number is divisible by 5
elif i % 5 == 0 :
# Print "Buzz" if number is divisible by 5
print ( "Buzz" )
# If number is not divisible by 3 or 5, print the number itself
else :
print ( i ) Muitas vezes, é importante preservar e lembrar uma conversa. sgpt cria diálogo conversacional com cada conclusão do LLM solicitada. O diálogo pode desenvolver um a um (modo de bate-papo) ou interativamente, em um loop repl (modo REPL). Ambas as maneiras confiam no mesmo objeto subjacente, chamado de sessão de bate -papo. A sessão está localizada no CHAT_CACHE_PATH configurável.
Para iniciar uma conversa, use a opção --chat seguida de um nome de sessão exclusivo e um prompt.
sgpt --chat conversation_1 " please remember my favorite number: 4 "
# -> I will remember that your favorite number is 4.
sgpt --chat conversation_1 " what would be my favorite number + 4? "
# -> Your favorite number is 4, so if we add 4 to it, the result would be 8. Você pode usar sessões de bate -papo para melhorar iterativamente as sugestões de GPT, fornecendo detalhes adicionais. É possível usar -opções --code ou --shell para iniciar --chat :
sgpt --chat conversation_2 --code " make a request to localhost using python " import requests
response = requests . get ( 'http://localhost' )
print ( response . text )Vamos pedir ao LLM que adicione cache ao nosso pedido:
sgpt --chat conversation_2 --code " add caching " import requests
from cachecontrol import CacheControl
sess = requests . session ()
cached_sess = CacheControl ( sess )
response = cached_sess . get ( 'http://localhost' )
print ( response . text )O mesmo se aplica aos comandos do shell:
sgpt --chat conversation_3 --shell " what is in current folder "
# -> ls
sgpt --chat conversation_3 " Sort by name "
# -> ls | sort
sgpt --chat conversation_3 " Concatenate them using FFMPEG "
# -> ffmpeg -i "concat:$(ls | sort | tr 'n' '|')" -codec copy output.mp4
sgpt --chat conversation_3 " Convert the resulting file into an MP3 "
# -> ffmpeg -i output.mp4 -vn -acodec libmp3lame -ac 2 -ab 160k -ar 48000 final_output.mp3 Para listar todas as sessões do modo de conversação, use a opção --list-chats ou -lc :
sgpt --list-chats
# .../shell_gpt/chat_cache/conversation_1
# .../shell_gpt/chat_cache/conversation_2 Para mostrar todas as mensagens relacionadas a uma conversa específica, use a opção --show-chat seguida pelo nome da sessão:
sgpt --show-chat conversation_1
# user: please remember my favorite number: 4
# assistant: I will remember that your favorite number is 4.
# user: what would be my favorite number + 4?
# assistant: Your favorite number is 4, so if we add 4 to it, the result would be 8. Há o modo muito útil Repl (leia -o Eval -Print), que permite que você converse interativamente com os modelos GPT. Para iniciar uma sessão de bate -papo no modo REPL, use a opção --repl seguida de um nome de sessão exclusivo. Você também pode usar o "Temp" como um nome de sessão para iniciar uma sessão temporária de repl. Observe que --chat e --repl estão usando o mesmo objeto subjacente, para que você possa usar --chat para iniciar uma sessão de bate -papo e, em seguida, pegá -lo com --repl para continuar a conversa no modo REPL.
sgpt --repl temp
Entering REPL mode, press Ctrl+C to exit.
>>> What is REPL?
REPL stands for Read-Eval-Print Loop. It is a programming environment ...
>>> How can I use Python with REPL?
To use Python with REPL, you can simply open a terminal or command prompt ...
O modo REPL pode funcionar com opções --shell e --code , o que torna muito útil para comandos interativos do shell e geração de código:
sgpt --repl temp --shell
Entering shell REPL mode, type [e] to execute commands or press Ctrl+C to exit.
>>> What is in current folder?
ls
>>> Show file sizes
ls -lh
>>> Sort them by file sizes
ls -lhS
>>> e (enter just e to execute commands, or d to describe them)
Para fornecer as cotações triplas de plenomias de várias multilinas """ :
sgpt --repl temp
Entering REPL mode, press Ctrl+C to exit.
>>> """
... Explain following code:
... import random
... print(random.randint(1, 10))
... """
It is a Python script that uses the random module to generate and print a random integer.
Você também pode entrar no modo REPL com o prompt inicial, passando -o como um argumento ou stdin ou até os dois:
sgpt --repl temp < my_app.py Entering REPL mode, press Ctrl+C to exit.
──────────────────────────────────── Input ────────────────────────────────────
name = input("What is your name?")
print(f"Hello {name}")
───────────────────────────────────────────────────────────────────────────────
>>> What is this code about?
The snippet of code you've provided is written in Python. It prompts the user...
>>> Follow up questions...
As chamadas de função são um recurso poderoso que o OpenAI fornece. Ele permite que o LLM execute funções em seu sistema, que podem ser usadas para realizar uma variedade de tarefas. Para instalar funções padrão executadas:
sgpt --install-functions O Shellgpt tem uma maneira conveniente de definir funções e usá -las. Para criar sua função personalizada, navegue para ~/.config/shell_gpt/functions e crie um novo arquivo .py com o nome da função. Dentro deste arquivo, você pode definir sua função usando a seguinte sintaxe:
# execute_shell_command.py
import subprocess
from pydantic import Field
from instructor import OpenAISchema
class Function ( OpenAISchema ):
"""
Executes a shell command and returns the output (result).
"""
shell_command : str = Field (..., example = "ls -la" , descriptions = "Shell command to execute." )
class Config :
title = "execute_shell_command"
@ classmethod
def execute ( cls , shell_command : str ) -> str :
result = subprocess . run ( shell_command . split (), capture_output = True , text = True )
return f"Exit code: { result . returncode } , Output: n { result . stdout } " O comentário de Docstring dentro da classe será passado para a API OpenAI como uma descrição da função, juntamente com o atributo title e as descrições de parâmetros. A função execute será chamada se o LLM decidir usar sua função. Nesse caso, estamos permitindo que o LLM execute quaisquer comandos de shell em nosso sistema. Como estamos retornando a saída do comando, a LLM poderá analisá -lo e decidir se é uma boa opção para o prompt. Aqui está um exemplo de como a função pode ser executada pelo LLM:
sgpt " What are the files in /tmp folder? "
# -> @FunctionCall execute_shell_command(shell_command="ls /tmp")
# -> The /tmp folder contains the following files and directories:
# -> test.txt
# -> test.json Observe que, por algum motivo, a função (Execute_shell_Command) retornará um erro, o LLM poderá tentar realizar a tarefa com base na saída. Digamos que não instalamos jq em nosso sistema e pedimos ao LLM que analise o arquivo JSON:
sgpt " parse /tmp/test.json file using jq and return only email value "
# -> @FunctionCall execute_shell_command(shell_command="jq -r '.email' /tmp/test.json")
# -> It appears that jq is not installed on the system. Let me try to install it using brew.
# -> @FunctionCall execute_shell_command(shell_command="brew install jq")
# -> jq has been successfully installed. Let me try to parse the file again.
# -> @FunctionCall execute_shell_command(shell_command="jq -r '.email' /tmp/test.json")
# -> The email value in /tmp/test.json is johndoe@example.Também é possível encadear múltiplas chamadas de função no prompt:
sgpt " Play music and open hacker news "
# -> @FunctionCall play_music()
# -> @FunctionCall open_url(url="https://news.ycombinator.com")
# -> Music is now playing, and Hacker News has been opened in your browser. Enjoy!Este é apenas um exemplo simples de como você pode usar chamadas de função. É realmente um recurso poderoso que pode ser usado para realizar uma variedade de tarefas complexas. Temos categoria dedicada em discussões no Github para compartilhar e discutir funções. O LLM pode executar comandos destrutivos, por isso, use -o por sua conta e risco
O ShellGPT permite criar funções personalizadas, que podem ser utilizadas para gerar código, comandos do shell ou atender às suas necessidades específicas. Para criar uma nova função, use a opção --create-role seguida pelo nome do função. Você será solicitado a fornecer uma descrição para a função, juntamente com outros detalhes. Isso criará um arquivo json em ~/.config/shell_gpt/roles com o nome de função. Dentro deste diretório, você também pode editar funções de sgpt padrão, como shell , código e padrão . Use a opção --list-roles para listar todas as funções disponíveis e a opção --show-role para exibir os detalhes de uma função específica. Aqui está um exemplo de uma função personalizada:
sgpt --create-role json_generator
# Enter role description: Provide only valid json as response.
sgpt --role json_generator " random: user, password, email, address " {
"user" : " JohnDoe " ,
"password" : " p@ssw0rd " ,
"email" : " [email protected] " ,
"address" : {
"street" : " 123 Main St " ,
"city" : " Anytown " ,
"state" : " CA " ,
"zip" : " 12345 "
}
}Se a descrição da função contiver as palavras "Apply Markdown" (Case Sensitive), os bate -papos serão exibidos usando a formatação de Markdown.
Controle o cache usando --cache (padrão) e --no-cache opções. Este cache se aplica a todas as solicitações sgpt para o OpenAI API:
sgpt " what are the colors of a rainbow "
# -> The colors of a rainbow are red, orange, yellow, green, blue, indigo, and violet. Da próxima vez, a mesma consulta exata obterá resultados do cache local instantaneamente. Observe que sgpt "what are the colors of a rainbow" --temperature 0.5 fará uma nova solicitação, pois não fornecemos --temperature (o mesmo se aplica a --top-probability ) em solicitação anterior.
Esses são apenas alguns exemplos do que podemos fazer usando modelos OpenAI GPT, tenho certeza de que você achará útil para seus casos de uso específicos.
Você pode configurar alguns parâmetros no arquivo de configuração de tempo de execução ~/.config/shell_gpt/.sgptrc :
# API key, also it is possible to define OPENAI_API_KEY env.
OPENAI_API_KEY=your_api_key
# Base URL of the backend server. If "default" URL will be resolved based on --model.
API_BASE_URL=default
# Max amount of cached message per chat session.
CHAT_CACHE_LENGTH=100
# Chat cache folder.
CHAT_CACHE_PATH=/tmp/shell_gpt/chat_cache
# Request cache length (amount).
CACHE_LENGTH=100
# Request cache folder.
CACHE_PATH=/tmp/shell_gpt/cache
# Request timeout in seconds.
REQUEST_TIMEOUT=60
# Default OpenAI model to use.
DEFAULT_MODEL=gpt-4o
# Default color for shell and code completions.
DEFAULT_COLOR=magenta
# When in --shell mode, default to "Y" for no input.
DEFAULT_EXECUTE_SHELL_CMD=false
# Disable streaming of responses
DISABLE_STREAMING=false
# The pygment theme to view markdown (default/describe role).
CODE_THEME=default
# Path to a directory with functions.
OPENAI_FUNCTIONS_PATH=/Users/user/.config/shell_gpt/functions
# Print output of functions when LLM uses them.
SHOW_FUNCTIONS_OUTPUT=false
# Allows LLM to use functions.
OPENAI_USE_FUNCTIONS=true
# Enforce LiteLLM usage (for local LLMs).
USE_LITELLM=false
Opções possíveis para DEFAULT_COLOR : preto, vermelho, verde, amarelo, azul, magenta, ciano, branco, bright_black, bright_red, bright_green, bright_yellow, bright_blue, bright_magenta, bright_cyan, bright_white. Opções possíveis para CODE_THEME : https://pygments.org/styles/
╭─ Arguments ──────────────────────────────────────────────────────────────────────────────────────────────╮
│ prompt [PROMPT] The prompt to generate completions for. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────╮
│ --model TEXT Large language model to use. [default: gpt-4o] │
│ --temperature FLOAT RANGE [0.0<=x<=2.0] Randomness of generated output. [default: 0.0] │
│ --top-p FLOAT RANGE [0.0<=x<=1.0] Limits highest probable tokens (words). [default: 1.0] │
│ --md --no-md Prettify markdown output. [default: md] │
│ --editor Open $EDITOR to provide a prompt. [default: no-editor] │
│ --cache Cache completion results. [default: cache] │
│ --version Show version. │
│ --help Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Assistance Options ─────────────────────────────────────────────────────────────────────────────────────╮
│ --shell -s Generate and execute shell commands. │
│ --interaction --no-interaction Interactive mode for --shell option. [default: interaction] │
│ --describe-shell -d Describe a shell command. │
│ --code -c Generate only code. │
│ --functions --no-functions Allow function calls. [default: functions] │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Chat Options ───────────────────────────────────────────────────────────────────────────────────────────╮
│ --chat TEXT Follow conversation with id, use "temp" for quick session. [default: None] │
│ --repl TEXT Start a REPL (Read–eval–print loop) session. [default: None] │
│ --show-chat TEXT Show all messages from provided chat id. [default: None] │
│ --list-chats -lc List all existing chat ids. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭─ Role Options ───────────────────────────────────────────────────────────────────────────────────────────╮
│ --role TEXT System role for GPT model. [default: None] │
│ --create-role TEXT Create role. [default: None] │
│ --show-role TEXT Show role. [default: None] │
│ --list-roles -lr List roles. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Execute o contêiner usando a variável de ambiente OPENAI_API_KEY e um volume do Docker para armazenar o cache. Considere definir as variáveis de ambiente OS_NAME e SHELL_NAME de acordo com suas preferências.
docker run --rm
--env OPENAI_API_KEY=api_key
--env OS_NAME= $( uname -s )
--env SHELL_NAME= $( echo $SHELL )
--volume gpt-cache:/tmp/shell_gpt
ghcr.io/ther1d/shell_gpt -s " update my system " Exemplo de conversa, usando um pseudônimo e a variável de ambiente OPENAI_API_KEY :
alias sgpt= " docker run --rm --volume gpt-cache:/tmp/shell_gpt --env OPENAI_API_KEY --env OS_NAME= $( uname -s ) --env SHELL_NAME= $( echo $SHELL ) ghcr.io/ther1d/shell_gpt "
export OPENAI_API_KEY= " your OPENAI API key "
sgpt --chat rainbow " what are the colors of a rainbow "
sgpt --chat rainbow " inverse the list of your last answer "
sgpt --chat rainbow " translate your last answer in french " Você também pode usar o Dockerfile fornecido para construir sua própria imagem:
docker build -t sgpt .Se você deseja enviar suas solicitações para uma instância do ollama e executar o Shellgpt dentro de um contêiner do Docker, precisará ajustar o Dockerfile e criar o contêiner mesmo: o pacote Litellm é necessário e as variáveis ENV precisam ser definidas corretamente.
Exemplo Dockerfile:
FROM python:3-slim
ENV DEFAULT_MODEL=ollama/mistral:7b-instruct-v0.2-q4_K_M
ENV API_BASE_URL=http://10.10.10.10:11434
ENV USE_LITELLM=true
ENV OPENAI_API_KEY=bad_key
ENV SHELL_INTERACTION=false
ENV PRETTIFY_MARKDOWN=false
ENV OS_NAME="Arch Linux"
ENV SHELL_NAME=auto
WORKDIR /app
COPY . /app
RUN apt-get update && apt-get install -y gcc
RUN pip install --no-cache /app[litellm] && mkdir -p /tmp/shell_gpt
VOLUME /tmp/shell_gpt
ENTRYPOINT ["sgpt"]
