shell_gpt
1.4.4
Ein Befehlszeilenproduktivitätstool, das von KI-Großsprachenmodellen (LLM) betrieben wird. Dieses Befehlszeilen-Tool bietet eine optimierte Generation von Shell-Befehlen, Codeausschnitten und Dokumentationen , die die Notwendigkeit externer Ressourcen (wie Google Search) beseitigen. Unterstützt Linux, MacOS, Windows und kompatibel mit allen wichtigen Shells wie Powershell, CMD, Bash, ZSH usw.
pip install shell-gpt Standardmäßig verwendet ShellGPT OpenAs API und GPT-4-Modell. Sie benötigen einen API -Schlüssel, Sie können hier einen generieren. Sie werden für Ihren Schlüssel aufgefordert, der dann in ~/.config/shell_gpt/.sgptrc gespeichert wird. Die OpenAI -API ist nicht kostenlos. Weitere Informationen finden Sie in der OpenAI -Preise.
Tipp
Alternativ können Sie lokal gehostete Open -Source -Modelle verwenden, die kostenlos verfügbar sind. Um lokale Modelle zu verwenden, müssen Sie Ihren eigenen LLM -Backend -Server wie Ollama ausführen. Um Shellgpt mit Ollama einzurichten, folgen Sie diesem umfassenden Leitfaden.
❗️ Wenn ShellGPT für lokale Modelle nicht optimiert ist und möglicherweise nicht wie erwartet funktioniert.
Shellgpt wurde entwickelt, um Informationen schnell zu analysieren und abzurufen. Es ist nützlich für einfache Anforderungen, die von technischen Konfigurationen bis hin zu allgemeinem Wissen reichen.
sgpt " What is the fibonacci sequence "
# -> The Fibonacci sequence is a series of numbers where each number ... ShellGPT akzeptiert die Eingabeaufforderung sowohl vom Stdin- als auch vom Befehlszeilenargument. Unabhängig davon, ob Sie die Rohrleitungseingaben über das Terminal bevorzugen oder direkt als Argumente angeben, hat sgpt Sie abgedeckt. Beispielsweise können Sie problemlos eine Git -Commit -Nachricht basierend auf einem Diff erstellen:
git diff | sgpt " Generate git commit message, for my changes "
# -> Added main feature details into README.mdSie können Protokolle aus verschiedenen Quellen analysieren, indem Sie sie mit Stdin zusammen mit einer Eingabeaufforderung übergeben. Zum Beispiel können wir es verwenden, um Protokolle schnell zu analysieren, Fehler zu identifizieren und Vorschläge für mögliche Lösungen zu erhalten:
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.
Sie können auch alle Arten von Umleitungsoperatoren verwenden, um die Eingaben zu übergeben:
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... Haben Sie jemals gemeinsame Shell -Befehle vergessen, z. B. find und die Syntax online nachschlagen? Mit der Option --shell oder Shortcut -s können Sie die Befehle, die Sie direkt im Terminal benötigen, schnell generieren und ausführen.
sgpt --shell " find all json files in current folder "
# -> find . -type f -name "*.json"
# -> [E]xecute, [D]escribe, [A]bort: e Shell GPT ist sich des von Ihnen verwendeten Betriebssystems und $SHELL bewusst. Sie werden den Befehl Shell für ein bestimmtes System bereitgestellt, das Sie haben. Wenn Sie beispielsweise sgpt bitten, Ihr System zu aktualisieren, wird ein Befehl basierend auf Ihrem Betriebssystem zurückgegeben. Hier ist ein Beispiel mit macOS:
sgpt -s " update my system "
# -> sudo softwareupdate -i -a
# -> [E]xecute, [D]escribe, [A]bort: eDie gleiche Eingabeaufforderung erzeugt, wenn sie auf Ubuntu verwendet wird, einen anderen Vorschlag:
sgpt -s " update my system "
# -> sudo apt update && sudo apt upgrade -y
# -> [E]xecute, [D]escribe, [A]bort: eVersuchen wir es mit 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 Wir können immer noch Rohre verwenden, um die Eingabe an sgpt zu übergeben und Shell -Befehle zu generieren:
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 Anwenden zusätzlicher Shellmagie in unserer Eingabeaufforderung in diesem Beispiel übergebene Dateinamen an 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 Wenn Sie mit Pipe den Befehl generierter Shell übergeben möchten, können Sie eine Option --no-interaction verwenden. Dadurch wird der interaktive Modus deaktiviert und den Befehl generierter STDOut gedruckt. In diesem Beispiel verwenden wir pbcopy , um den Befehl generiert in die Clipboard zu kopieren:
sgpt -s " find all json files in current folder " --no-interaction | pbcopy Dies ist eine sehr praktische Funktion , mit der Sie sgpt -Shell -Abschlüsse direkt in Ihrem Terminal verwenden können, ohne dass sgpt mit Eingabeaufforderung und Argumenten eingeben werden muss. Die Shell -Integration ermöglicht die Verwendung von ShellGPT mit Hotkeys in Ihrem Terminal, die sowohl von Bash- als auch von ZSH -Schalen unterstützt werden. In dieser Funktion wird sgpt -Abschlüsse direkt in den Terminalpuffer (Eingabestelle) eingebaut und ermöglicht eine sofortige Bearbeitung der vorgeschlagenen Befehle.
Um die Shell-Integration zu installieren, führen Sie sgpt --install-integration aus und starten Sie Ihr Terminal neu, um Änderungen anzuwenden. Dadurch werden Ihre .bashrc oder .zshrc -Datei nur wenige Zeilen hinzugefügt. Danach können Sie Ctrl+l (standardmäßig) zum Aufrufen von ShellGPT verwenden. Wenn Sie Ctrl+l drücken, ersetzt dies die aktuelle Eingangsleitung (Puffer) durch den empfohlenen Befehl. Sie können es dann bearbeiten und einfach Enter drücken, um auszuführen.
Durch die Verwendung des Parameters --code oder -c können Sie beispielsweise spezifisch reine Codeausgabe anfordern:
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 )Da es sich um einen gültigen Python -Code handelt, können wir die Ausgabe in eine Datei umleiten:
sgpt --code " solve classic fizz buzz problem using Python " > fizz_buzz.py
python fizz_buzz.py
# 1
# 2
# Fizz
# 4
# Buzz
# ...Wir können auch Rohre verwenden, um Eingaben zu übergeben:
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 ) Oft ist es wichtig, ein Gespräch zu erhalten und sich zu erinnern. sgpt erstellt mit jedem angeforderten LLM -Abschluss einen Gesprächsdialog. Der Dialog kann eins von einem (Chat-Modus) oder interaktiv in einer Reply-Schleife (Reply-Modus) entwickeln. Beide Möglichkeiten stützen sich auf das gleiche zugrunde liegende Objekt, das als Chat -Sitzung bezeichnet wird. Die Sitzung befindet sich am konfigurierbaren CHAT_CACHE_PATH .
Verwenden Sie die Option --chat -Option, gefolgt von einem eindeutigen Sitzungsnamen und einer Eingabeaufforderung.
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. Sie können Chat -Sitzungen verwenden, um die GPT -Vorschläge iterativ zu verbessern, indem Sie zusätzliche Details angeben. Es ist möglich, --code oder --shell -Optionen zu initiieren --chat :
sgpt --chat conversation_2 --code " make a request to localhost using python " import requests
response = requests . get ( 'http://localhost' )
print ( response . text )Bitten wir LLM, unsere Anfrage zu Caching hinzuzufügen:
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 )Gleiches gilt für Shell -Befehle:
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 Verwenden Sie die Option --list-chats oder -lc , um alle Sitzungen entweder aus dem Konversationsmodus aufzulisten:
sgpt --list-chats
# .../shell_gpt/chat_cache/conversation_1
# .../shell_gpt/chat_cache/conversation_2 Um alle Nachrichten zu einer bestimmten Konversation zu zeigen, verwenden Sie die Option --show-chat gefolgt vom Sitzungsnamen:
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. Es gibt einen sehr praktischen Reply -Modus (Read -E -E -Druck -Loop), mit dem Sie interaktiv mit GPT -Modellen chatten können. Um eine Chat -Sitzung im Reply -Modus zu starten, verwenden Sie die Option --repl , gefolgt von einem eindeutigen Sitzungsnamen. Sie können auch "Temp" als Sitzungsname verwenden, um eine temporäre Replement -Sitzung zu starten. Beachten Sie, dass --chat und --repl verwenden das gleiche zugrunde liegende Objekt, sodass Sie --chat verwenden können, um eine Chat -Sitzung zu starten und sie dann mit --repl zu abholen, um die Konversation im Reply -Modus fortzusetzen.
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 ...
Der ReP -Modus kann mit Optionen --shell und --code funktionieren, was es für interaktive Shell -Befehle und Codegenerierung sehr praktisch macht:
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)
Um multiline prompt zu liefern, verwenden Sie dreifache Zitate """ :
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.
Sie können den ReP -Modus auch mit der ersten Eingabeaufforderung eingeben, indem Sie ihn als Argument oder Stdin oder sogar beides übergeben:
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...
Funktionsaufrufe ist eine leistungsstarke Funktion, die Openai bietet. Es ermöglicht LLM, Funktionen in Ihrem System auszuführen, mit denen verschiedene Aufgaben ausgeführt werden können. So installieren Sie Standardfunktionen Ausführen:
sgpt --install-functions Shellgpt hat eine bequeme Möglichkeit, Funktionen zu definieren und zu verwenden. Um Ihre benutzerdefinierte Funktion zu erstellen, navigieren Sie zu ~/.config/shell_gpt/functions und erstellen Sie eine neue .py -Datei mit dem Funktionsnamen. In dieser Datei können Sie Ihre Funktion mit der folgenden Syntax definieren:
# 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 } " Der DocString -Kommentar in der Klasse wird zusammen mit den Beschreibungen title und der Parameter an die OpenAI -API als Beschreibung für die Funktion übergeben. Die execute wird aufgerufen, wenn LLM beschließt, Ihre Funktion zu verwenden. In diesem Fall erlauben wir LLM, alle Shell -Befehle in unserem System auszuführen. Da wir die Ausgabe des Befehls zurückgeben, kann LLM ihn analysieren und entscheiden, ob es gut für die Eingabeaufforderung passt. Hier ist ein Beispiel, wie die Funktion von LLM ausgeführt werden kann:
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 Beachten Sie, dass wenn die Funktion (execute_shell_command) aus irgendeinem Grund einen Fehler zurückgibt, möglicherweise versucht, die Aufgabe basierend auf der Ausgabe zu erfüllen. Nehmen wir an, wir haben jq in unserem System nicht installiert, und wir bitten LLM, die JSON -Datei zu analysieren:
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.Es ist auch möglich, mehrere Funktionsaufrufe in der Eingabeaufforderung zu ketten:
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!Dies ist nur ein einfaches Beispiel dafür, wie Sie Funktionsaufrufe verwenden können. Es ist wirklich eine leistungsstarke Funktion, mit der eine Vielzahl komplexer Aufgaben erledigt werden können. Wir haben eine dedizierte Kategorie in GitHub -Diskussionen zum Teilen und Diskussion von Funktionen. LLM kann zerstörerische Befehle ausführen. Verwenden Sie es also auf eigenes Risiko.
Mit ShellGPT können Sie benutzerdefinierte Rollen erstellen, die verwendet werden können, um Code, Shell -Befehle zu generieren oder Ihre spezifischen Anforderungen zu erfüllen. Um eine neue Rolle zu erstellen, verwenden Sie die Option --create-role Option, gefolgt vom Rollennamen. Sie werden aufgefordert, zusammen mit anderen Details eine Beschreibung für die Rolle bereitzustellen. Dadurch wird eine JSON -Datei in ~/.config/shell_gpt/roles mit dem Rollennamen erstellt. In diesem Verzeichnis können Sie auch Standard sgpt -Rollen wie Shell , Code und Standard bearbeiten. Verwenden Sie die Option --list-roles , um alle verfügbaren Rollen und die Option --show-role aufzulisten, um die Details einer bestimmten Rolle anzuzeigen. Hier ist ein Beispiel für eine benutzerdefinierte Rolle:
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 "
}
}Wenn die Beschreibung der Rolle die Wörter "Marke anwenden" (Fallempfindlichkeit) enthält, werden Chats mithilfe der Markdown -Formatierung angezeigt.
Steuern Sie den Cache mit --cache (Standard) und --no-cache -Optionen. Dieses Caching gilt für alle sgpt -Anfragen zur OpenAI -API:
sgpt " what are the colors of a rainbow "
# -> The colors of a rainbow are red, orange, yellow, green, blue, indigo, and violet. Das nächste Mal wird die gleiche genaue Abfrage sofort aus dem lokalen Cache Ergebnisse erzielt. Beachten Sie, dass sgpt "what are the colors of a rainbow" --temperature 0.5 wird eine neue Anfrage stellen, da wir auf frühere Anfrage keine --temperature (dasselbe gilt für --top-probability ).
Dies sind nur einige Beispiele für das, was wir mit OpenAI -GPT -Modellen tun können. Ich bin sicher, dass Sie es für Ihre spezifischen Anwendungsfälle nützlich finden.
Sie können einige Parameter in der Laufzeitkonfigurationsdatei ~/.config/shell_gpt/.sgptrc einrichten:
# 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
Mögliche Optionen für DEFAULT_COLOR : Schwarz, Rot, Grün, Gelb, Blau, Magenta, Cyan, Weiß, Bright_black, Bright_red, Bright_Green, Bright_yellow, Bright_Blue, Bright_Magenta, Bright_Cyan, Bright_white. Mögliche Optionen für 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. │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Führen Sie den Container mit der Umgebungsvariablen OPENAI_API_KEY und einem Docker -Volumen aus, um Cache zu speichern. Betrachten Sie die Umgebungsvariablen OS_NAME und SHELL_NAME gemäß Ihren Vorlieben.
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 " Beispiel für eine Konversation unter Verwendung eines Alias und der Umgebungsvariablen 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 " Sie können auch die bereitgestellte Dockerfile verwenden, um Ihr eigenes Bild zu erstellen:
docker build -t sgpt .Wenn Sie Ihre Anfragen an eine Ollama -Instanz senden und Shellgpt in einem Docker -Container ausführen möchten, müssen Sie die Dockerfile anpassen und den Container selbst erstellen: Das LitellM -Paket wird benötigt und Env -Variablen müssen korrekt eingestellt werden.
Beispiel 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"]
