shellChatGPT

Shell wrapper for OpenAI's ChatGPT, DALL-E, Whisper, and TTS. Features LocalAI, Ollama, Gemini and Mistral integration.

Chat completions with streaming by defaults.

Markdown rendering of chat response (optional).

🚀 Features

Text and chat completions with gtp-4-vision support
Text editor interface, Bash readline, and cat input modes
Markdown rendering support in response
Preview, and regenerate responses
Manage sessions, print out previous sessions
Instruction prompt manager, easily create and set the initial system prompt
Voice in (Whisper) and voice out (TTS) chat / REPL mode (options -cczw)
Integration with awesome-chatgpt-prompts and Chinese awesome-chatgpt-prompts-zh, mudler's LocalAI, Ollama, Google AI, and Mistral AI.
Tiktoken for accurate tokenization (optional)
Colour scheme personalisation, and a configuration file
Stdin and text file input support
Should™ work on Linux, FreeBSD, MacOS, and Termux.

More Features

Generate images from text input (option -i)
Generate variations of images
Edit images, optionally edit with ImageMagick (generate alpha mask)
Transcribe audio from various languages (option -w)
Translate audio into English text (option -W)
Text-to-speeech functionality (option -z)

✨ Getting Started

✔️ Required Packages

Bash
cURL, and JQ

Optional Packages

These are required for specific features.

Base64 - Image endpoint, vision models
ImageMagick - Image edits and variations
Python - Tiktoken
mpv/SoX/Vlc/FFmpeg/afplay - Play TTS output
SoX/Arecord/FFmpeg - Record input (Whisper)
xdg-open/open/xsel/xclip/pbcopy - Open images, set clipboard
W3M/Lynx/ELinks/Links - Dump URL text
bat/Pygmentize/Glow/mdcat/mdless - Markdown support
termux-api/play-audio/termux-microphone-record/termux-clipboard-set - Termux system

💾 Installation

A. Download the stand-alone chatgpt.sh script and make it executable:

wget https://gitlab.com/fenixdragao/shellchatgpt/-/raw/main/chatgpt.sh

chmod +x ./chatgpt.sh

B. Or clone this repo:

git clone https://gitlab.com/fenixdragao/shellchatgpt.git

C. Optionally, download and set the configuration file ~/.chatgpt.conf:

#save configuration template:
chatgpt.sh -FF >> ~/.chatgpt.conf

#edit:
chatgpt.sh -F

# Or
vim ~/.chatgpt.conf

🔥 Usage Examples 🔥

💬 Native Chat Completions

With command line options -cc, some properties are set automatically to create a chat bot. Start a new session in chat mode, and set a different temperature (gpt-3.5 and gpt-4+ models):

chatgpt.sh -cc -t0.7

Create Marv, the sarcastic bot manually:

chatgpt.sh -60 -cc --frequency-penalty=0.5 --temp=0.5 --top_p=0.3 --restart-seq='\nYou: ' --start-seq='\nMarv:' --stop='You:' --stop='Marv:' -S'Marv is a factual chatbot that reluctantly answers questions with sarcastic responses:'

Start new chat session from the "unix.txt" Instruction file. The commands below are aliases for command line option -S .prompt_name.

chatgpt.sh -cc -S ..unix

chatgpt.sh -cc -..unix

chatgpt.sh -cc..unix

In this case, the custom prompt will be loaded, and the history will be recorded in the corresponding "unix.tsv" file at the cache directory.

The command below starts a chat session, loads the "unix" instruction, and changes to the defaults "chatgpt.tsv" history.

chatgpt.sh -cc..unix /chatgpt

chatgpt.sh -cc -S "..unix" /session chatgpt

Vision Models (GPT-4-Vision)

To send an image / url to vision models, start the script and then either set the image with the !img chat command with one or more filepaths / URLs separated by the operator pipe |.

chatgpt.sh -cc -m gpt-4-vision-preview '!img path/to/image.jpg'

Alternatively, set the image paths / URLs at the end of the prompt interactively:

chatgpt.sh -cc -m gpt-4-vision-preview

[...]
Q: In this first user prompt, what can you see? | https://i.imgur.com/wpXKyRo.jpeg

TIP: Run chat command !info to check model configuration!

DEBUG: Set option -VV to see the raw JSON request body.

Voice In and Out + Chat Completions

🗣️ Chat completion with Whisper:

chatgpt.sh -ccw

Chat in Portuguese with voice in and out:

chatgpt.sh -cczw pt

Chat Mode of Text Completions

When text completions is set for chatting with option -c, some properties are configured automatically to instruct the bot.

chatgpt.sh -c "Hello there! What is your name?"

📜 Text Completions

This is the pure text completions endpoint. It is typically used to complete input text, such as for completing part of an essay.

One-shot text completion:

chatgpt.sh "Hello there! What is your name?"

NOTE: For multiturn, set option -d.

A strong Instruction prompt may be needed for the language model to do what is required.

Set an instruction prompt for better results:

chatgpt.sh -d -S 'The following is a newspaper article.' "It all starts when FBI agents arrived at the governor house and"

chatgpt.sh -d -S'You are an AI assistant.'  "The list below contain the 10 biggest cities in the w"

Insert Mode of Text Completions

Set option -q to enable insert mode and add the string [insert] where the model should insert text:

chatgpt.sh -q 'It was raining when [insert] tomorrow.'

NOTE: This example works with no instruction prompt! An instruction prompt in this mode may interfere with insert completions.

NOTE: Insert mode works with model gpt-3.5-turbo-instruct. This endpoint may deprecate.

Markdown

To enable markdown rendering of responses, set command line option --markdown, or run /md in chat mode. To render last response in markdown once, run //md.

The markdown option uses bat as it has line buffering on by defaults, however other software is supported. Set it such as --markdown=glow or /md mdless on chat mode.

Type in any of the following markdown software as argument to the option: bat, pygmentize, glow, mdcat, or mdless.

⚙️ Prompts

Unless the chat option -c or -cc are set, no instruction is given to the language model. On chat mode, if no instruction is set, minimal instruction is given, and some options set, such as increasing temp and presence penalty, in order to un-lobotomise the bot.

Prompt engineering is an art on itself. Study carefully how to craft the best prompts to get the most out of text, code and chat completions models.

The model steering and capabilities require prompt engineering to even know that it should answer the questions.

⌨️ Custom Prompts

Set a one-shot instruction prompt with option -S:

chatgpt.sh -cc -S 'You are a PhD psycologist student.' 

chatgpt.sh -ccS'You are a professional software programmer.'

To create or load a prompt template file, set option -S with the operator dot and the name of the prompt as argument:

chatgpt.sh -cc -S.psycologist 

chatgpt.sh -cc -S..software_programmer

This will load the custom prompt, or create it if it does not yet exist. In the second example, single-shot editing will be skipped after loading prompt software_programmer.

🔌 Awesome Prompts

Set a prompt from awesome-chatgpt-prompts or awesome-chatgpt-prompts-zh, (use with davinci and gpt-3.5+ models):

chatgpt.sh -cc -S /linux_terminal

chatgpt.sh -cc -S /Relationship_Coach 

chatgpt.sh -cc -S '%担任雅思写作考官'

💡 Notes and Tips

Run chat commands with either operator ! or /.
Edit live history entries with command !hist, for context injection.
Add operator forward slash / to the end of prompt to trigger preview mode.
One can regenerate a response typing in a new prompt a single slash /, or // to have last prompt edited before new request.

More Examples and Script Modes (Endpoints)

🖼️ Image Generations

Generate image according to prompt:

chatgpt.sh -i "Dark tower in the middle of a field of red roses."

chatgpt.sh -i "512x512" "A tower."

Image Variations

Generate image variation:

chatgpt.sh -i path/to/image.png

Image Edits

chatgpt.sh -i path/to/image.png path/to/mask.png "A pink flamingo."

Outpaint - Canvas Extension

In this example, a mask is made from the white colour.

Inpaint - Fill in the Gaps

Adding a bat in the night sky.

🔊 Audio Transcriptions / Translations

Generate transcription from audio file. A prompt to guide the model's style is optional. The prompt should match the audio language:

chatgpt.sh -w path/to/audio.mp3

chatgpt.sh -w path/to/audio.mp3 "en" "This is a poem about X."

1. Generate transcription from voice recording, set Portuguese as the language to transcribe to:

chatgpt.sh -w pt

This also works to transcribe from one language to another.

2. Transcribe any language audio input to Japanese (prompt should be in the same language as the input audio language, preferably):

chatgpt.sh -w ja "A job interview is currently being done."

3.1 Translate English audio input to Japanese, and generate audio output from text.

chatgpt.sh -wz ja "Getting directions to famous places in the city."

3.2 Also doing it conversely, this gives an opportunity to (manual) conversation turns of two speakers of different languages. Below, a Japanese speaker can translate its voice and generate audio in the target language.

chatgpt.sh -wz en "Providing directions to famous places in the city."

4. Translate audio file or voice recording from any language to English:

chatgpt.sh -W [audio_file]

chatgpt.sh -W

NOTE: Generate phrasal-level timestamps double setting option -ww, or option -WW.

LocalAI

LocalAI Server

Make sure you have got mudler's LocalAI, server set up and running.

The server can be run as a docker container or a binary can be downloaded. Check LocalAI tutorials Container Images, and Run Models Manually for an idea on how to install, download a model and set it up.

 ┌───────────────────────────────────────────────────┐
 │                   Fiber v2.50.0                   │
 │               http://127.0.0.1:8080               │
 │       (bound on host 0.0.0.0 and port 8080)       │
 │                                                   │
 │ Handlers ............. 1  Processes ........... 1 │
 │ Prefork ....... Disabled  PID ..................1 │
 └───────────────────────────────────────────────────┘

Tips

1. Download a binary of localai for your system from Mudler's release GitHub repo.

2. Run localai run --help to check comamnd line options and environment variables.

3. Set up $GALLERIES before starting up the server:

export GALLERIES='[{"name":"localai", "url":"github:mudler/localai/gallery/index.yaml"}]'  #defaults

export GALLERIES='[{"name":"model-gallery", "url":"github:go-skynet/model-gallery/index.yaml"}]'

export GALLERIES='[{"name":"huggingface", "url": "github:go-skynet/model-gallery/huggingface.yaml"}]'

4. Install the model named phi-2-chat from a yaml file manually, while the server is running:

curl -L http://localhost:8080/models/apply -H "Content-Type: application/json" -d '{ "config_url": "https://raw.githubusercontent.com/mudler/LocalAI/master/embedded/models/phi-2-chat.yaml" }'

Running the shell wrapper

Finally, when running chatgpt.sh, set the model name:

chatgpt.sh --localai -cc -m luna-ai-llama2

Setting some stop sequences may be needed to prevent the model from generating text past context:

chatgpt.sh --localai -cc -m luna-ai-llama2  -s'### User:'  -s'### Response:'

Optionally set restart and start sequences for text completions endpoint (option -c), such as -s'\n### User: ' -s'\n### Response:' (do mind setting newlines \n and whitespaces correctly).

And that's it!

Installing Models

Model names may be printed with chatgpt.sh -l. A model may be supplied as argument, so that only that model details are shown.

NOTE: Model management (downloading and setting up) must follow the LocalAI and Ollama projects guidelines and methods.

For image generation, install Stable Diffusion from the URL github:go-skynet/model-gallery/stablediffusion.yaml, and for audio transcription, download Whisper from the URL github:go-skynet/model-gallery/whisper-base.yaml.

API Host Configuration

If the host address is different from the defaults, we need editing the script configuration file .chatgpt.conf.

vim ~/.chatgpt.conf

# Or

chatgpt.sh -F

Set the following variable:

# ~/.chatgpt.conf

OPENAI_API_HOST="http://127.0.0.1:8080"

Alternatively, set $OPENAI_API_HOST on invocation:

OPENAI_API_HOST="http://127.0.0.1:8080" chatgpt.sh -c -m luna-ai-llama2

Ollama

Visit Ollama repository, and follow the instructions to install, download models, and set up the server.

After having Ollama server running, set option -O (--ollama), and the name of the model in chatgpt.sh:

chatgpt.sh -cc -O -m llama2

If Ollama server URL is not the defaults http://localhost:11434, edit chatgpt.sh configuration file, and set the following variable:

# ~/.chatgpt.conf

OLLAMA_API_HOST="http://192.168.0.3:11434"

Google AI

Get a free API key for Google to be able to use Gemini and vision models. Users have a free bandwidth of 60 requests per minute, and the script offers a basic implementation of the API.

Set the enviroment variable $GOOGLE_API_KEY and run the script with option --google, such as:

chatgpt.sh --google -cc -m gemini-pro-vision

OBS: Google Gemini vision models are not enabled for multiturn at the API side, so we hack it.

To list all available models, run chatgpt.sh --google -l.

Mistral AI

Set up a Mistral AI account, declare the enviroment variable $MISTRAL_API_KEY, and run the script with option --mistral for complete integration.

Arch Linux Users

This project PKGBUILD is available at the Arch Linux User Repository (AUR) to install the software in Arch Linux and derivative distros.

To install the programme from the AUR, you can use an AUR helper like yay or paru. For example, with yay:

yay -S chatgpt.sh

Termux Users

Optional Dependencies

Install the termux-api package.

For recording audio (Whisper, option -w), we defaults to termux-microphone-record and for playing audio (TTS, option -z), optionally install play-audio.

To set the clipboard, it is required termux-clipboard-set from the termux-api package.

Tiktoken

Under Termux, make sure to have your system updated and installed with python, rust, and rustc-dev packages for building tiktoken.

pkg update

pkg upgrade

pkg install python rust rustc-dev

pip install tiktoken

🎯 Project Objectives

Implement nice features from OpenAI API version 1.
Provide the closest API defaults.
Let the user customise defaults (as homework).

⚠️ Limitations

OpenAI API version 1 is the focus of the present project implementation. Not all features of the API will be covered.
See BUGS AND LIMITS section in the man page.
Bash shell truncates input on \000 (null).
Bash "read command" may not correctly display input buffers larger than the TTY screen size during editing. However, input buffers remain unaffected. Use the text editor interface for big prompt editing.
Garbage in, garbage out. An idiot savant.

📖 Help Pages

Read the online man page here.

Alternatively, a help page snippet can be printed with chatgpt.sh -h.

💪 Contributors

Many Thanks to all that contributed to this project.

edshamis

Acknowledgements

The following projects are worth remarking. They were studied during development of this script and used as referencial code sources.

Everyone is welcome to submit issues, PRs, and new ideas!

The project home is at GitLab

https://gitlab.com/fenixdragao/shellchatgpt

Mirror

https://github.com/mountaineerbr/shellChatGPT

Name		Name	Last commit message	Last commit date
Latest commit History 339 Commits
man		man
.chatgpt.conf		.chatgpt.conf
LICENSE		LICENSE
PKGBUILD		PKGBUILD
README.md		README.md
chatgpt.sh		chatgpt.sh

License

mountaineerbr/shellChatGPT

Folders and files

Latest commit

History

Repository files navigation