shell_gpt
1.4.4
Una herramienta de productividad de línea de comandos alimentada por AI Language Models (LLM). Esta herramienta de línea de comandos ofrece una generación optimizada de comandos de shell, fragmentos de código, documentación , eliminando la necesidad de recursos externos (como la búsqueda de Google). Admite Linux, macOS, Windows y compatible con todas las capas principales como PowerShell, CMD, BASH, ZSH, etc.
pip install shell-gpt De forma predeterminada, Shellgpt utiliza la API de OpenAI y el modelo GPT-4. Necesitará una clave API, puede generar una aquí. Se le solicitará su clave que luego se almacenará en ~/.config/shell_gpt/.sgptrc . Operai API no es gratuita, consulte el precio de Operai para obtener más información.
Consejo
Alternativamente, puede usar modelos de código abierto alojados localmente que están disponibles de forma gratuita. Para usar modelos locales, deberá ejecutar su propio servidor de backend de LLM, como Ollama. Para configurar ShellPpt con Ollama, siga esta guía completa.
❗️note que Shellgpt no está optimizado para los modelos locales y puede no funcionar como se esperaba.
ShellGPT está diseñado para analizar y recuperar rápidamente información. Es útil para solicitudes directas que van desde configuraciones técnicas hasta conocimiento general.
sgpt " What is the fibonacci sequence "
# -> The Fibonacci sequence is a series of numbers where each number ... ShellGPT acepta el indicador tanto del argumento STDIN como del argumento de la línea de comandos. Ya sea que prefiera la entrada de la tubería a través del terminal o especifique directamente como argumentos, sgpt lo cubrió. Por ejemplo, puede generar fácilmente un mensaje de confirmación Git basado en una diferencia:
git diff | sgpt " Generate git commit message, for my changes "
# -> Added main feature details into README.mdPuede analizar registros de varias fuentes pasándolos usando Stdin, junto con un aviso. Por ejemplo, podemos usarlo para analizar rápidamente los registros, identificar errores y obtener sugerencias para posibles soluciones:
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.
También puede usar todo tipo de operadores de redirección para pasar la 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... ¿Alguna vez se ha encontrado olvidando los comandos de Shell Common, como find y necesitar buscar la sintaxis en línea? Con la opción --shell o atajo -s , puede generar rápidamente y ejecutar los comandos que necesita en el terminal.
sgpt --shell " find all json files in current folder "
# -> find . -type f -name "*.json"
# -> [E]xecute, [D]escribe, [A]bort: e Shell GPT es consciente de OS y $SHELL que está utilizando, proporcionará el comando Shell para el sistema específico que tiene. Por ejemplo, si le pide sgpt que actualice su sistema, devolverá un comando basado en su sistema operativo. Aquí hay un ejemplo usando macOS:
sgpt -s " update my system "
# -> sudo softwareupdate -i -a
# -> [E]xecute, [D]escribe, [A]bort: eEl mismo aviso, cuando se usa en Ubuntu, generará una sugerencia diferente:
sgpt -s " update my system "
# -> sudo apt update && sudo apt upgrade -y
# -> [E]xecute, [D]escribe, [A]bort: eProbémoslo con 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 Todavía podemos usar tuberías para pasar la entrada a sgpt y generar comandos 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 Aplicando Magia de Shell adicional en nuestro aviso, en este ejemplo, pasando los nombres de archivo a 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 desea pasar el comando de shell generado con Pipe, puede usar la opción --no-interaction . Esto deshabilitará el modo interactivo e imprimirá el comando generado en stdout. En este ejemplo estamos utilizando pbcopy para copiar el comando generado al portapapeles:
sgpt -s " find all json files in current folder " --no-interaction | pbcopy Esta es una característica muy útil , que le permite utilizar las terminaciones de shell sgpt directamente en su terminal, sin la necesidad de escribir sgpt con los argumentos y argumentos. La integración de shell permite el uso de Shellgpt con teclas de acceso rápido en su terminal, soportado por capas Bash y ZSH. Esta característica coloca las terminaciones sgpt directamente en el tampón terminal (línea de entrada), lo que permite la edición inmediata de los comandos sugeridos.
Para instalar la integración de shell, ejecute sgpt --install-integration y reinicie su terminal para aplicar cambios. Esto agregará pocas líneas a su archivo .bashrc o .zshrc . Después de eso, puede usar Ctrl+l (por defecto) para invocar Shellgpt. Cuando presione Ctrl+l reemplazará su línea de entrada actual (búfer) con el comando sugerido. Luego puede editarlo y simplemente presionar Enter para ejecutar.
Al usar el parámetro --code o -c , puede solicitar específicamente la salida de código puro, por ejemplo:
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 )Dado que es un código Python válido, podemos redirigir la salida a un archivo:
sgpt --code " solve classic fizz buzz problem using Python " > fizz_buzz.py
python fizz_buzz.py
# 1
# 2
# Fizz
# 4
# Buzz
# ...También podemos usar tuberías para pasar la 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 ) A menudo es importante preservar y recordar una conversación. sgpt crea un diálogo conversacional con cada finalización de LLM solicitada. El diálogo puede desarrollar uno por uno (modo de chat) o de manera interactiva, en un bucle REPL (modo REPL). En ambos sentidos, confía en el mismo objeto subyacente, llamada sesión de chat. La sesión se encuentra en el CHAT_CACHE_PATH configurable.
Para comenzar una conversación, use la opción --chat seguida de un nombre de sesión único y un mensaje.
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. Puede usar sesiones de chat para mejorar iterativamente las sugerencias de GPT proporcionando detalles adicionales. Es posible usar opciones --code o --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 )Pidamos a LLM que agregue almacenamiento en caché a nuestra solicitud:
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 )Lo mismo se aplica para los comandos de 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 enumerar todas las sesiones desde el modo de conversación, use la opción --list-chats o -lc :
sgpt --list-chats
# .../shell_gpt/chat_cache/conversation_1
# .../shell_gpt/chat_cache/conversation_2 Para mostrar todos los mensajes relacionados con una conversación específica, use la opción --show-chat seguida del nombre de la sesión:
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. Hay un modo REPL muy útil (Read - Eval -Print Loop), que le permite chatear interactivamente con los modelos GPT. Para iniciar una sesión de chat en modo REPL, use la opción --repl seguida de un nombre de sesión único. También puede usar "Temp" como nombre de sesión para iniciar una sesión de replica temporal. Tenga en cuenta que --chat y --repl están utilizando el mismo objeto subyacente, por lo que puede usar --chat para comenzar una sesión de chat y luego recogerla con --repl para continuar la conversación en 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 ...
El modo replica puede funcionar con --shell y -opciones --code , lo que lo hace muy útil para los comandos de shell interactivos y la generación 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 proporcionar una rápida inmediata, use cotizaciones triples """ :
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.
También puede ingresar el modo Replio con el aviso inicial pasándolo como argumento o stdin o incluso ambos:
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...
Las llamadas de funciones son una característica potente que ofrece OpenAI. Permite a LLM ejecutar funciones en su sistema, que pueden usarse para realizar una variedad de tareas. Para instalar funciones predeterminadas ejecutando:
sgpt --install-functions Shellgpt tiene una forma conveniente de definir funciones y usarlas. Para crear su función personalizada, navegue a ~/.config/shell_gpt/functions y cree un nuevo archivo .py con el nombre de la función. Dentro de este archivo, puede definir su función utilizando la siguiente sintaxis:
# 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 } " El comentario de documentos dentro de la clase se pasará a la API de OpenAI como una descripción de la función, junto con el atributo title y las descripciones de parámetros. Se llamará a la función execute si LLM decide usar su función. En este caso, estamos permitiendo que LLM ejecute cualquier comando de shell en nuestro sistema. Dado que estamos devolviendo la salida del comando, LLM podrá analizarlo y decidir si es un buen ajuste para el aviso. Aquí hay un ejemplo de cómo la función podría ser ejecutada por 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 Tenga en cuenta que si por alguna razón la función (Execute_shell_command) devolverá un error, LLM podría intentar lograr la tarea en función de la salida. Digamos que no hemos instalado jq en nuestro sistema, y le pedimos a LLM que analice el archivo 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.También es posible encadenar las llamadas de funciones múltiples en el aviso:
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 es solo un ejemplo simple de cómo puede usar llamadas de funciones. Es realmente una característica poderosa que se puede usar para lograr una variedad de tareas complejas. Tenemos una categoría dedicada en discusiones de Github para compartir y discutir funciones. LLM podría ejecutar comandos destructivos, así que úselo bajo su propio riesgo❗️
ShellGPT le permite crear roles personalizados, que se pueden utilizar para generar código, comandos de shell o para satisfacer sus necesidades específicas. Para crear un nuevo rol, use la opción --create-role seguida del nombre de roles. Se le solicitará que proporcione una descripción para el rol, junto con otros detalles. Esto creará un archivo JSON en ~/.config/shell_gpt/roles con el nombre de rol. Dentro de este directorio, también puede editar los roles sgpt predeterminados, como Shell , Code y Predeterminado . Use la opción --list-roles para enumerar todos los roles disponibles y la opción --show-role para mostrar los detalles de un papel específico. Aquí hay un ejemplo de un rol personalizado:
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 descripción del rol contiene las palabras "Aplicar markdown" (sensible a la caja), los chats se mostrarán utilizando el formato de Markdown.
Controlación de caché usando --cache (predeterminado) y --no-cache opciones. Este almacenamiento en caché se aplica para todas las solicitudes de sgpt para 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 próxima vez, la misma consulta exacta obtendrá resultados de la caché local al instante. Tenga en cuenta que sgpt "what are the colors of a rainbow" --temperature 0.5 hará una nueva solicitud, ya que no proporcionamos --temperature (lo mismo se aplica a --top-probability ) en la solicitud anterior.
Esto es solo algunos ejemplos de lo que podemos hacer utilizando modelos Operai GPT, estoy seguro de que lo encontrará útil para sus casos de uso específicos.
Puede configurar algunos parámetros en el archivo de configuración de tiempo de ejecución ~/.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
Posibles opciones para DEFAULT_COLOR : negro, rojo, verde, amarillo, azul, magenta, cian, blanco, bright_black, bright_red, bright_green, bright_yellow, bright_blue, bright_magenta, bright_cyan, bright_white. Opciones posibles 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. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Ejecute el contenedor utilizando la variable de entorno OPENAI_API_KEY y un volumen de Docker para almacenar caché. Considere establecer las variables de entorno OS_NAME y SHELL_NAME de acuerdo con sus preferencias.
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 " Ejemplo de una conversación, utilizando un alias y la variable de entorno 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 " También puede usar el Dockerfile provisto para construir su propia imagen:
docker build -t sgpt .Si desea enviar sus solicitudes a una instancia de Ollama y ejecutar Shellgpt dentro de un contenedor de Docker, debe ajustar el DockerFile y construir el contenedor usted mismo: el paquete Litellm es necesario y las variables Env deben configurarse correctamente.
Ejemplo 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"]
