shell_gpt
1.4.4
Un outil de productivité en ligne de commande propulsé par les modèles de grande langue AI (LLM). Cet outil de ligne de commande offre une génération rationalisée de commandes de shell, des extraits de code, une documentation , éliminant le besoin de ressources externes (comme Google Search). Prend en charge Linux, MacOS, Windows et compatible avec tous les principaux obus comme PowerShell, CMD, Bash, Zsh, etc.
pip install shell-gpt Par défaut, Shellgpt utilise l'API d'OpenAI et le modèle GPT-4. Vous aurez besoin d'une clé API, vous pouvez en générer une ici. Vous serez invité à votre clé qui sera ensuite stockée dans ~/.config/shell_gpt/.sgptrc . L'API OpenAI n'est pas gratuite, veuillez vous référer au prix OpenAI pour plus d'informations.
Conseil
Alternativement, vous pouvez utiliser des modèles open source hébergés localement qui sont disponibles gratuitement. Pour utiliser des modèles locaux, vous devrez exécuter votre propre serveur de backend LLM tel que Olllama. Pour configurer Shellgpt avec Olllama, veuillez suivre ce guide complet.
❗️ Not que Shellgpt n'est pas optimisé pour les modèles locaux et peut ne pas fonctionner comme prévu.
Shellgpt est conçu pour analyser et récupérer rapidement des informations. Il est utile pour des demandes simples allant des configurations techniques aux connaissances générales.
sgpt " What is the fibonacci sequence "
# -> The Fibonacci sequence is a series of numbers where each number ... Shellgpt accepte l'invite de STDIN et de l'argument de la ligne de commande. Que vous préfériez la tuyauterie de la tuyauterie via le terminal ou que vous le spécifiez directement sous forme d'arguments, sgpt vous a couvert. Par exemple, vous pouvez facilement générer un message Git Commit basé sur un DIFF:
git diff | sgpt " Generate git commit message, for my changes "
# -> Added main feature details into README.mdVous pouvez analyser les journaux à partir de diverses sources en les passant en utilisant STDIN, ainsi qu'une invite. Par exemple, nous pouvons l'utiliser pour analyser rapidement les journaux, identifier les erreurs et obtenir des suggestions pour des solutions possibles:
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.
Vous pouvez également utiliser toutes sortes d'opérateurs de redirection pour passer l'entrée:
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... Vous êtes-vous déjà retrouvé à oublier des commandes de shell communes, comme find et avoir besoin de rechercher la syntaxe en ligne? Avec l'option --shell ou raccourci -s , vous pouvez rapidement générer et exécuter les commandes dont vous avez besoin dans le terminal.
sgpt --shell " find all json files in current folder "
# -> find . -type f -name "*.json"
# -> [E]xecute, [D]escribe, [A]bort: e Shell GPT est conscient du système d'exploitation et $SHELL que vous utilisez, il fournira une commande shell pour un système spécifique que vous avez. Par exemple, si vous demandez sgpt de mettre à jour votre système, il renverra une commande en fonction de votre système d'exploitation. Voici un exemple en utilisant macOS:
sgpt -s " update my system "
# -> sudo softwareupdate -i -a
# -> [E]xecute, [D]escribe, [A]bort: eLa même invite, lorsqu'elle est utilisée sur Ubuntu, générera une suggestion différente:
sgpt -s " update my system "
# -> sudo apt update && sudo apt upgrade -y
# -> [E]xecute, [D]escribe, [A]bort: eEssayons-le avec 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 Nous pouvons toujours utiliser des tuyaux pour transmettre l'entrée à sgpt et générer des commandes de 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 En appliquant une magie de shell supplémentaire dans notre invite, dans cet exemple de passage de noms de fichiers à 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 Si vous souhaitez passer la commande shell générée à l'aide de tuyau, vous pouvez utiliser l'option --no-interaction . Cela désactivera le mode interactif et imprimera la commande générée sur stdout. Dans cet exemple, nous utilisons pbcopy pour copier la commande générée dans le presse-papiers:
sgpt -s " find all json files in current folder " --no-interaction | pbcopy Il s'agit d'une fonctionnalité très pratique , qui vous permet d'utiliser les compléments sgpt Shell directement dans votre terminal, sans avoir besoin de taper sgpt avec des arguments invite et. L'intégration de la coquille permet l'utilisation de Shellgpt avec des raccourcis clavier dans votre terminal, pris en charge par les coquilles Bash et Zsh. Cette fonctionnalité met les compléments sgpt directement dans le tampon terminal (ligne d'entrée), permettant l'édition immédiate des commandes suggérées.
Pour installer l'intégration du shell, exécutez sgpt --install-integration et redémarrez votre terminal pour appliquer les modifications. Cela ajoutera quelques lignes à votre fichier .bashrc ou .zshrc . Après cela, vous pouvez utiliser Ctrl+l (par défaut) pour invoquer Shellgpt. Lorsque vous appuyez sur Ctrl+l il remplacera votre ligne d'entrée actuelle (tampon) par la commande suggérée. Vous pouvez ensuite le modifier et simplement appuyer sur Enter pour exécuter.
En utilisant le paramètre --code ou -c , vous pouvez demander spécifiquement la sortie de code pur, par exemple:
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 )Puisqu'il est un code Python valide, nous pouvons rediriger la sortie vers un fichier:
sgpt --code " solve classic fizz buzz problem using Python " > fizz_buzz.py
python fizz_buzz.py
# 1
# 2
# Fizz
# 4
# Buzz
# ...Nous pouvons également utiliser des tuyaux pour passer l'entrée:
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 ) Il est souvent important de préserver et de rappeler une conversation. sgpt crée un dialogue conversationnel avec chaque complétion LLM demandée. Le dialogue peut se développer un par un (mode de chat) ou de manière interactive, dans une boucle REP (mode REP). Les deux façons reposent sur le même objet sous-jacent, appelé une session de chat. La session est située sur le CHAT_CACHE_PATH configurable_cache_path.
Pour démarrer une conversation, utilisez l'option --chat suivie d'un nom de session unique et d'une invite.
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. Vous pouvez utiliser des sessions de chat pour améliorer itérativement les suggestions GPT en fournissant des détails supplémentaires. Il est possible d'utiliser --code ou - Options --shell pour initier --chat :
sgpt --chat conversation_2 --code " make a request to localhost using python " import requests
response = requests . get ( 'http://localhost' )
print ( response . text )Prenons à LLM d'ajouter de la mise en cache à notre demande:
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 )Il en va de même pour les commandes 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 Pour répertorier toutes les sessions à partir du mode conversationnel, utilisez l'option --list-chats ou -lc :
sgpt --list-chats
# .../shell_gpt/chat_cache/conversation_1
# .../shell_gpt/chat_cache/conversation_2 Pour afficher tous les messages liés à une conversation spécifique, utilisez l'option --show-chat suivie du nom de la session:
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. Il existe un mode REPL (LIRE-EVAL-IMPRINT) très pratique, qui vous permet de discuter de manière interactive avec les modèles GPT. Pour démarrer une session de chat en mode REP, utilisez l'option --repl suivie d'un nom de session unique. Vous pouvez également utiliser "Temp" comme nom de session pour démarrer une session de REP temporaire. Notez que --chat et --repl utilisent le même objet sous-jacent, afin que vous puissiez utiliser --chat pour démarrer une session de chat, puis le ramasser avec --repl pour continuer la conversation en mode REP.
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 ...
Le mode REP peut fonctionner avec les options --shell --code , ce qui le rend très pratique pour les commandes de shell interactives et la génération de code:
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)
Pour fournir des citations triples invites multilines """ :
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.
Vous pouvez également saisir le mode REP avec une invite initiale en le faisant passer en tant qu'argument ou stdin ou même les deux:
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...
Les appels de fonction sont une fonctionnalité puissante OpenAI. Il permet à LLM d'exécuter des fonctions de votre système, qui peuvent être utilisées pour accomplir une variété de tâches. Pour installer les fonctions par défaut exécutées:
sgpt --install-functions Shellgpt a un moyen pratique de définir les fonctions et de les utiliser. Afin de créer votre fonction personnalisée, accédez à ~/.config/shell_gpt/functions et créez un nouveau fichier .py avec le nom de la fonction. À l'intérieur de ce fichier, vous pouvez définir votre fonction à l'aide de la syntaxe suivante:
# 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 } " Le commentaire docstring à l'intérieur de la classe sera transmis à l'API OpenAI comme description de la fonction, ainsi que l'attribut title et les descriptions de paramètres. La fonction execute sera appelée si LLM décide d'utiliser votre fonction. Dans ce cas, nous permettons à LLM d'exécuter toutes les commandes de shell dans notre système. Étant donné que nous renvoyons la sortie de la commande, LLM sera en mesure de l'analyser et de décider s'il convient à l'invite. Voici un exemple comment la fonction pourrait être exécutée par 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 Notez que si pour une raison quelconque, la fonction (EXECUTE_SHELL_COMMAND) renvoie une erreur, LLM pourrait essayer d'accomplir la tâche en fonction de la sortie. Disons que nous n'avons pas installé jq dans notre système, et nous demandons à LLM d'analyser le fichier 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.Il est également possible de chaîner plusieurs appels de fonction dans l'invite:
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!Ce n'est qu'un exemple simple de la façon dont vous pouvez utiliser les appels de fonction. C'est vraiment une fonctionnalité puissante qui peut être utilisée pour accomplir une variété de tâches complexes. Nous avons une catégorie dédiée dans les discussions GitHub pour partager et discuter des fonctions. LLM peut exécuter des commandes destructrices, veuillez donc l'utiliser à vos risques risques❗️
Shellgpt vous permet de créer des rôles personnalisés, qui peuvent être utilisés pour générer du code, des commandes shell ou pour répondre à vos besoins spécifiques. Pour créer un nouveau rôle, utilisez l'option --create-role suivie du nom de rôle. Vous serez invité à fournir une description du rôle, ainsi que d'autres détails. Cela créera un fichier JSON dans ~/.config/shell_gpt/roles avec le nom de rôle. À l'intérieur de ce répertoire, vous pouvez également modifier les rôles sgpt par défaut, tels que shell , code et défaut . Utilisez l'option --list-roles pour répertorier tous les rôles disponibles et l'option --show-role pour afficher les détails d'un rôle spécifique. Voici un exemple de rôle personnalisé:
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 "
}
}Si la description du rôle contient les mots "Appliquer Markdown" (Care sensible), les chats seront affichés à l'aide de la mise en forme de Markdown.
CONTRÔLE CACHE À l'aide de --cache (par défaut) et --no-cache . Cette mise en cache s'applique à toutes les demandes sgpt à l'Openai API:
sgpt " what are the colors of a rainbow "
# -> The colors of a rainbow are red, orange, yellow, green, blue, indigo, and violet. La prochaine fois, la même requête exacte obtiendra instantanément les résultats du cache local. Notez que sgpt "what are the colors of a rainbow" --temperature 0.5 fera une nouvelle demande, car nous n'avons pas fourni --temperature (il en va de même pour --top-probability ) sur la demande précédente.
Ce ne sont que quelques exemples de ce que nous pouvons faire en utilisant des modèles Openai GPT, je suis sûr que vous le trouverez utile pour vos cas d'utilisation spécifiques.
Vous pouvez configurer certains paramètres dans le fichier de configuration d'exécution ~/.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
Options possibles pour DEFAULT_COLOR : noir, rouge, vert, jaune, bleu, magenta, cyan, blanc, bright_black, bright_red, brigh_green, bright_yellow, brigh_blue, brigh_magenta, brigh_cyan, brigh_white. Options possibles pour 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. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Exécutez le conteneur à l'aide de la variable d'environnement OPENAI_API_KEY et un volume Docker pour stocker le cache. Considérez pour définir les variables d'environnement OS_NAME et SHELL_NAME en fonction de vos préférences.
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 " Exemple de conversation, en utilisant un alias et la variable d'environnement 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 " Vous pouvez également utiliser le Dockerfile fourni pour créer votre propre image:
docker build -t sgpt .Si vous souhaitez envoyer vos demandes à une instance Olllama et exécuter Shellgpt dans un conteneur Docker, vous devez ajuster le DockerFile et construire le conteneur vous-même: le package Litellm est nécessaire et les variables Env doivent être définies correctement.
Exemple de 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"]
