Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/mountaineerbr/shellchatgpt
Shell wrapper for OpenAI's ChatGPT, DALL-E, Whisper, and TTS. Features LocalAI, Ollama, Gemini, Mistral, Groq, and Anthropic integration.
https://github.com/mountaineerbr/shellchatgpt
awesome-chatgpt-prompts awesome-chatgpt-prompts-zh bash chat-completions chatbot claude-3 davinci gemini-api gemini-pro gpt-4-vision gpt-4o groq llama3 localai mistral-api o1-preview ollama terminal text-completions tts
Last synced: 4 days ago
JSON representation
Shell wrapper for OpenAI's ChatGPT, DALL-E, Whisper, and TTS. Features LocalAI, Ollama, Gemini, Mistral, Groq, and Anthropic integration.
- Host: GitHub
- URL: https://github.com/mountaineerbr/shellchatgpt
- Owner: mountaineerbr
- License: gpl-3.0
- Created: 2023-08-23T22:36:48.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2024-10-29T13:03:19.000Z (3 months ago)
- Last Synced: 2024-10-29T15:14:46.321Z (3 months ago)
- Topics: awesome-chatgpt-prompts, awesome-chatgpt-prompts-zh, bash, chat-completions, chatbot, claude-3, davinci, gemini-api, gemini-pro, gpt-4-vision, gpt-4o, groq, llama3, localai, mistral-api, o1-preview, ollama, terminal, text-completions, tts
- Language: Shell
- Homepage: https://gitlab.com/fenixdragao/shellchatgpt
- Size: 1.81 MB
- Stars: 68
- Watchers: 0
- Forks: 3
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# shellChatGPT
Shell wrapper for OpenAI's ChatGPT, DALL-E, Whisper, and TTS. Features LocalAI, Ollama, Gemini, Mistral, and more service providers.
Chat completions with streaming by defaults.
Expand Markdown Processing
Markdown processing on response is triggered automatically for some time now!
Markdown rendering of chat response (_optional_).
Expand Text Completions
In pure text completions, start by typing some text that is going to be completed, such as news, stories, or poems.
Expand Insert Mode
Add the insert tag `[insert]` where it is going to be completed.
Mistral `code models` work well with the insert / fill-in-the-middel (FIM) mode!
If no suffix is provided, it works as plain text completions.
## Index
โ
Click to expand! โ
- 1. [Index](#index)
- 2. [Features](#-features)
- 3. [Getting Started](#-getting-started)
- 3.1 [Required Packages](#-required-packages)
- 3.2 [Optional Packages](#optional-packages)
- 3.3 [Installation](#-installation)
- 3.4 [Usage Examples](#-usage-examples-)
- 4. [Native Chat Completions](#-native-chat-completions)
- 4.1 [Vision and Multimodal Models](#vision-and-multimodal-models)
- 4.2 [Text, PDF, Doc, and URL Dumps](#text-pdf-doc-and-url-dumps)
- 4.3 [File Picker and Shell Dump](#file-picker-and-shell-dump)
- 4.4 [Voice In and Out + Chat Completions](#voice-in-and-out-chat-completions)
- 4.5 [Audio Models](#audio-models)
- 5. [Chat Mode of Text Completions](#chat-mode-of-text-completions)
- 6. [Text Completions](#-text-completions)
- 6.1 [Insert Mode of Text Completions](#insert-mode-of-text-completions)
- 7. [Markdown](#markdown)
- 8. [Prompts](#-prompts)
- 8.1 [Instruction Prompt](#instruction-prompt)
- 8.2 [Custom Prompts](#-custom-prompts)
- 8.3 [Awesome Prompts](#-awesome-prompts)
- 9. [Shell Completion](#shell-completion)
- 9.1 [Bash](#bash)
- 9.2 [Zsh](#zsh)
- 9.3 [Troubleshoot](#troubleshoot-shell)
- 10. [Notes and Tips](#-notes-and-tips)
- 11. [More Script Modes](#more-script-modes)
- 11.1 [Image Generations](#-image-generations)
- 11.2 [Image Variations](#image-variations)
- 11.3 [Image Edits](#image-edits)
- 11.3.1 [Outpaint - Canvas Extension](#outpaint---canvas-extension)
- 11.3.2 [Inpaint - Fill in the Gaps](#inpaint---fill-in-the-gaps)
- 11.4 [Speech Transcriptions / Translations](#-speech-transcriptions--translations)
- 12. [Service Providers](#service-providers)
- 12.1 [LocalAI](#localai)
- 12.1.1 [LocalAI Server](#localai-server)
- 12.1.2 [Tips](#tips)
- 12.1.3 [Running the shell wrapper](#running-the-shell-wrapper)
- 12.1.4 [Installing Models](#installing-models)
- 12.1.5 [Host API Configuration](#base-url-configuration)
- 12.2 [Ollama](#ollama)
- 12.3 [Google AI](#google-ai)
- 12.4 [Mistral AI](#mistral-ai)
- 12.5 [Groq](#groq)
- 12.6 [Anthropic](#anthropic)
- 12.7 [GitHub Models](#github-models)
- 12.8 [Novita AI](#novita-ai)
- 12.9 [xAI](#xai)
- 13. [Arch Linux Users](#arch-linux-users)
- 14. [Termux Users](#termux-users)
- 14.1 [Dependencies](#dependencies-termux)
- 14.2 [TTS Chat - Removal of Markdown](#tts-chat---removal-of-markdown)
- 14.3 [Tiktoken](#tiktoken)
- 14.4 [Troubleshoot](#troubleshoot-termux)
- 15. [Project Objectives](#--project-objectives)
- 16. [Roadmap](#roadmap)
- 17. [Limitations](#%EF%B8%8F-limitations)
- 18. [Bug report](#bug-report)
- 19. [Help Pages](#-help-pages)
- 20. [Contributors](#-contributors)
- 21. [Acknowledgements](#acknowledgements)
## ๐ Features
- Text and chat completions.
- [Vision](#vision-models-gpt-4-vision), **reasoning** and [**audio models**](#audio-models)
- **Voice-in** (Whisper) plus **voice out** (TTS) [_chatting mode_](#voice-in-and-out--chat-completions) (`options -cczw`)
- **Text editor interface**, _Bash readline_, and _multiline/cat_ modes
- [**Markdown rendering**](#markdown) support in response
- Easily [**regenerate responses**](#--notes-and-tips)
- **Manage sessions**, _print out_ previous sessions
- Set [Custom Instruction prompts](#%EF%B8%8F--custom-prompts)
- Integration with [various service providers](#service-providers) and [custom BaseUrl](#base-url-configuration).
- Support for [awesome-chatgpt-prompts](#-awesome-prompts) & the
[Chinese variant](https://github.com/PlexPt/awesome-chatgpt-prompts-zh)
- Stdin and text file input support
- Shouldโข work on Linux, FreeBSD, MacOS, and [Termux](#termux-users)
- **Fast** shell code for a responsive experience! โก๏ธ
## โจ Getting Started
### โ๏ธ Required Packages
- `Bash`
- `cURL`, and `JQ`
### Optional Packages
Packages required for specific features.
Click to expand!
- `Base64` - Image endpoint, multimodal models
- `Python` - Modules tiktoken, markdown, bs4
- `ImageMagick`/`fbida` - Image edits and variations
- `SoX`/`Arecord`/`FFmpeg` - Record input (Whisper)
- `mpv`/`SoX`/`Vlc`/`FFplay`/`afplay` - Play TTS output
- `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`/`termux-tools`/`play-audio` - Termux system
- `poppler`/`gs`/`abiword`/`ebook-convert`/`LibreOffice` - Dump PDF or Doc as text
- `dialog`/`kdialog`/`zenity`/`osascript`/`termux-dialog` - File picker
### ๐พ Installation
**A.** Download the stand-alone
[`chatgpt.sh` script](https://gitlab.com/fenixdragao/shellchatgpt/-/raw/main/chatgpt.sh)
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`](https://gitlab.com/fenixdragao/shellchatgpt/-/raw/main/.chatgpt.conf):
#save configuration template:
chatgpt.sh -FF >> ~/.chatgpt.conf
#edit:
chatgpt.sh -F
# Or
nano ~/.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:
chatgpt.sh -cc -t0.7
Change the maximum response length to 4k tokens:
chatgpt.sh -cc -4000
chatgpt.sh -cc -M 4000
And change a model token capacity to 200k tokens:
chatgpt.sh -cc -N 200000
Create **Marv, the sarcastic bot**:
chatgpt.sh -512 -cc --frequency-penalty=0.7 --temp=0.8 --top_p=0.4 --restart-seq='\nYou: ' --start-seq='\nMarv:' --stop='You:' --stop='Marv:' -S'Marv is a factual chatbot that reluctantly answers questions with sarcastic responses.'
Load the custom *unix instruction file* ("unix.pr") for a new session.
The command line syntaxes below are all aliases:
chatgpt.sh -cc .unix
chatgpt.sh -cc.unix
chatgpt.sh -cc -.unix
chatgpt.sh -cc -S .unix
To only change the history file that the session will be recorded,
set the first positional argument in the command line with the operator forward slash "`/`"
and the name of the history file (this executes the `/session` command).
chatgpt.sh -cc /test
chatgpt.sh -cc /stest
chatgpt.sh -cc "/session test"
There is a shortcut to load an older session from the defaults (or current)
history file. This opens a basic interactive interface.
chatgpt.sh -cc .
Technically, this copies an old session from the target history file to the tail of it, so we can resume the session.
In order to grep for sessions with a regex, it is easier to enter chat mode
and then type in the chat command `/grep [regex]`.
Print out last session, optionally set the history name:
chatgpt.sh -P
chatgpt.sh -P /test
### Vision and Multimodal Models
To send an `image` / `url` to vision models, start the script interactively
and then either set the image with the `!img`.
Alternatively, set the image paths / URLs at the end of the prompt:
chatgpt.sh -cc -m gpt-4-vision-preview
[...]
Q: !img https://i.imgur.com/wpXKyRo.jpeg
Q: What can you see? https://i.imgur.com/wpXKyRo.jpeg
**TIP:** Run command `!info` to check configuration!
**DEBUG:** Set `option -V` to see the raw JSON request body.
### Text, PDF, Doc, and URL Dumps
To make an easy workflow, the user may add a filepath or text URL at the end
of the prompt. The file is then read and the text content appended
to the user prompt.
This is a basic text feature that works with any model.
chatgpt.sh -cc
[...]
Q: What is this page: https://example.com
Q: Help me study this paper. ~/Downloads/Prigogine\ Perspective\ on\ Nature.pdf
In the **second example** above, the _PDF_ will be dumped as text.
For PDF text dump support, `poppler/abiword` is required.
For _doc_ and _odt_ files, `LibreOffice` is required.
See the [Optional Packages](#optional-packages) section.
Also note that file paths containing white spaces must be
**blackslash-escaped**, or the filepath must be preceded by a pipe `|` character.
My text prompt. | path/to the file.jpg
Multiple images and audio files may be appended the prompt in this way!
### File Picker and Shell Dump
The `/pick` command opens a file picker (command-line or GUI
file manager). The selected file's path is then appended to the
current prompt.
The `/pick` and `/sh` commands may be run when typed at the end of
the current prompt, such as `[PROMPT] /pick`,
When the `/sh` command is run at the end of the prompt, a new
shell instance to execute commands interactively is opened.
The command dumps are appended to the current prompt.
_File paths_ that contain white spaces need backslash-escaping
in some functions.
### Voice In and Out + Chat Completions
๐ฃ๏ธ Chat completion with speech in and out (Whisper plus TTS):
chatgpt.sh -ccwz
Chat in Portuguese with Whisper and set _onyx_ as the TTS voice:
chatgpt.sh -ccwz -- pt -- onyx
**Chat mode** provides a conversational experience,
prompting the user to confirm each step.
For a more automated execution, set `option -v`,
or `-vv` for hands-free experience (_live chat_ with silence detection),
such as:
chatgpt.sh -cc -w -z -v
chatgpt.sh -cc -w -z -vv
### Audio Models
Audio models, such as `gpt-4o-audio`, deal with audio input and output directly, thus reducing latency in a conversation turn.
To activate the microphone recording function of the script, set command line `option -w`.
Otherwise, the audio model accepts any compatible audio file (such as **mp3**, **wav**, and **opus**).
These files can be added to be loaded at the very end of the user prompt
or added with chat command `/audio path/to/file.mp3`.
To activate the audio output mode of an audio model, do set command line `option -z` to make sure the speech synthesis function is enabled!
chatgpt.sh -cc -w -z -vv -m "gpt-4o-audio-preview"
Mind that this _does not_ implement the _realtime models_.
## 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.
To complete text from the command line input prompt, either
set `option -d` or set a text completion model name.
chatgpt.sh -128 -m gpt-3.5-turbo-instruct "Hello there! Your name is"
chatgpt.sh -128 -d "The journalist loo"
The above examples also set maximum response value to 128 tokens.
Enter single-turn interactive mode:
chatgpt.sh -d
**NOTE:** For multi-turn mode with history support, set `option -dd`.
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` (or `-qq` for multiturn) 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](https://openai.com/blog/gpt-3-edit-insert)
works with model `instruct models`.
Mistral AI has a nice FIM (fill-in-the-middle) endpoint that works
with `code` models and is really good!
## 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 the software of choice such as `--markdown=glow` or `/md mdless`.
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
temperature 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.
### Instruction Prompt
When the script is run in **chat mode**, the instruction is set
automatically if none explicitly set by the user on invocation.
The chat instruction will be updated according to the user locale
after reading envar `$LANG`.
Translations are available for the languages: `en`, `pt`, `es`, `it`,
`fr`, `de`, `ru`, `ja`, `zh`, `zh_TW`, and `hi`.
To run the script with the Hindi prompt, for example, the user may execute:
chatgpt.sh -cc .hi
LANG=hi_IN.UTF-8 chatgpt.sh -cc
Note: custom prompts with colliding names such as "hi"
have precedence over this feature.
### โจ๏ธ 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 the first positional argument
as `.prompt_name` or `,prompt_name`.
In the second case, load the prompt and single-shot edit it.
chatgpt.sh -cc .psycologist
chatgpt.sh -cc ,software_programmer
Alternatively, set `option -S` with the operator and the name of
the prompt as an 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 available after
loading prompt _software_programmer_.
Please note and make sure to backup your important custom prompts!
They are located at "`~/.cache/chatgptsh/`" with the extension "_.pr_".
### ๐ Awesome Prompts
Set a prompt from [awesome-chatgpt-prompts](https://github.com/f/awesome-chatgpt-prompts)
or [awesome-chatgpt-prompts-zh](https://github.com/PlexPt/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 '%ๆ
ไปป้
ๆๅไฝ่ๅฎ'
## Shell Completion
This project includes shell completions to enhance the user command-line experience.
### Bash
**Install** following one of the methods below.
**System-wide**
```
sudo cp comp/bash/chatgpt.sh /usr/share/bash-completion/completions/
```
**User-specific**
```
mkdir -p ~/.local/share/bash-completion/completions/
cp comp/bash/chatgpt.sh ~/.local/share/bash-completion/completions/
```
Visit the [bash-completion repository](https://github.com/scop/bash-completion).
### Zsh
**Install** at the **system location**
```
sudo cp comp/zsh/_chatgpt.sh /usr/share/zsh/site-functions/
```
**User-specific** location
To set **user-specific** completion, make sure to place the completion
script under a directory in the `$fpath` array.
The user may create the `~/.zfunc/` directory, for example, and
add the following lines to her `~/.zshrc`:
```
[[ -d ~/.zfunc ]] && fpath=(~/.zfunc $fpath)
autoload -Uz compinit
compinit
```
Make sure `compinit` is run **after setting `$fpath`**!
Visit the [zsh-completion repository](https://github.com/zsh-users/zsh-completions).
### Troubleshoot Shell
Bash and Zsh completions should be active in new terminal sessions.
If not, ensure your `~/.bashrc` and `~/.zshrc` source
the completion files correctly.
## ๐ก Notes and Tips
- The YouTube feature will get YouTube videos heading title and its transcripts (when available) information only.
- The PDF support feature extracts PDF text ([_no images_](https://docs.anthropic.com/en/docs/build-with-claude/pdf-support#how-pdf-support-works)) and appends it to the user request.
- Run chat commands with either _operator_ `!` or `/`.
- Edit live history entries with command `!hist` (comment out entries or context injection).
- One can **regenerate a response** by typing in a new prompt a single slash `/`,
or `//` to have last prompt edited before the new request.
## More Script Modes
### ๐ผ๏ธ 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.
### ๐ Speech Transcriptions / Translations
Generate transcription from audio file speech. A prompt to guide the model's style is optional.
The prompt should match the speech 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 speech 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 speech input to Japanese, and generate speech output from the text response.
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 speech from any language to English:
chatgpt.sh -W [audio_file]
chatgpt.sh -W
To retry with the last microphone recording saved in the cache, set
_audio_file_ as `last` or `retry`.
**NOTE:** Generate **phrasal-level timestamps** double setting `option -ww` or `option -WW`.
For **word-level timestamps**, set option `-www` or `-WWW`.
## Service Providers
Other than [Ollama](#ollama) and [LocalAI](#localai) local servers,
the free service providers are
[GitHub Models](#github-models),
[Google Vertex](#google-ai), and
[Groq](#groq).
### LocalAI
#### LocalAI Server
Make sure you have got [mudler's LocalAI](https://github.com/mudler/LocalAI),
server set up and running.
The server can be run as a docker container or a
[binary can be downloaded](https://github.com/mudler/LocalAI/releases).
Check LocalAI tutorials
[Container Images](https://localai.io/basics/getting_started/#container-images),
and [Run Models Manually](https://localai.io/docs/getting-started/manual)
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](https://github.com/mudler/LocalAI/releases).
*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.
#### BASE URL Configuration
If the service provider Base URL is different from the defaults.
The environment variable `$OPENAI_BASE_URL` is read at invocation.
export OPENAI_BASE_URL="http://127.0.0.1:8080/v1"
chatgpt.sh -c -m luna-ai-llama2
To set it a in a more permanent fashion, edit the script
configuration file `.chatgpt.conf`.
Use vim:
vim ~/.chatgpt.conf
Or edit the configuration with a command line option.
chatgpt.sh -F
And set the following variable:
# ~/.chatgpt.conf
OPENAI_BASE_URL="http://127.0.0.1:8080/v1"
### Ollama
Visit [Ollama repository](https://github.com/ollama/ollama/),
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_BASE_URL="http://192.168.0.3:11434"
### Google AI
Get a free [API key for Google](https://gemini.google.com/) 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 environment 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](https://mistral.ai/),
declare the environment variable `$MISTRAL_API_KEY`,
and run the script with `option --mistral` for complete integration.
### Groq
Sign in to [Groq](https://console.groq.com/playground).
Create a new API key or use an existing one to set
the environmental variable `$GROQ_API_KEY`.
Run the script with `option --groq`.
Currently, **llamma3.1** models are available at lightening speeds!
### Anthropic
Sign in to [Antropic AI](https://docs.anthropic.com/).
Create a new API key or use an existing one to set
the environmental variable `$ANTHROPIC_API_KEY`.
Run the script with `option --anthropic` or `--ant`.
Check the **Claude-3** models! Run the script as:
```
chatgpt.sh --anthropic -cc -m claude-3-5-sonnet-20240620
```
The script also works on **text completions** with models such as
`claude-2.1`, although the API documentation flags it as deprecated.
Try:
```
chatgpt.sh --ant -c -m claude-2.1
```
### GitHub Models
GitHub has partnered with Azure to use its infrastructure.
As a GitHub user, join the [wait list](https://github.com/marketplace/models/waitlist/join)
and then generate a [personal token](https://github.com/settings/tokens).
Set the environmental variable `$GITHUB_TOKEN` and run the
script with `option --github` or `--git`.
Check the [on-line model list](https://github.com/marketplace/models)
or list the available models and their original names with `chatgpt.sh --github -l`.
```
chatgpt.sh --github -cc -m Phi-3-small-8k-instruct
```
See also the [GitHub Model Catalog - Getting Started](https://techcommunity.microsoft.com/t5/educator-developer-blog/github-model-catalog-getting-started/ba-p/4212711) page.
### Novita AI
Novita AI offers a range of LLM models at exceptional value, including the
highly recommended **Llama 3.3** model, which provides the best balance
of price and performance!
For an uncensored model, consider **sao10k/l3-70b-euryale-v2.1**
(creative assistant and role-playing) or
**cognitivecomputations/dolphin-mixtral-8x22b**.
Create an API key as per the
[Quick Start Guide](https://novita.ai/docs/get-started/quickstart.html)
and export your key as `$NOVITA_API_KEY` to your environment.
Next, run the script such as `chatgpt.sh --novita -cc`.
Check the [model list web page](https://novita.ai/model-api/product/llm-api)
and the [price of each model](https://novita.ai/model-api/pricing).
To list all available models, run `chatgpt.sh --novita -l`. Optionally set a model name with `option -l` to dump model details.
Some models work with the `/completions` endpoint, while others
work with the `/chat/completions` endpoint, so the script _does not set the endpoint automatically_! Check model details and web pages to understand their capabilities, and then either run the script with `option -c` (**text completions**) or `options -cc` (**chat completions**).
---
As an exercise, instead of setting command-line `option --novita`,
set Novita AI integration manually instead:
```
export OPENAI_API_KEY=novita-api-key
export OPENAI_BASE_URL="https://api.novita.ai/v3/openai"
chatgpt.sh -cc -m meta-llama/llama-3.1-405b-instruct
```
We are grateful to Novita AI for their support and collaboration. For more
information, visit [Novita AI](https://novita.ai/).
### xAI
Visit [xAI Grok](https://docs.x.ai/docs/quickstart#creating-api-key)
to generate an API key (environment `$XAI_API_KEY`).
Run the script with `option --xai` and also with `option -cc` (chat completions.).
Some models also work with native text completions. For that,
set command-line `option -c` instead.
## Arch Linux Users
This project PKGBUILD is available at the
[Arch Linux User Repository (*AUR*)](https://aur.archlinux.org/packages/chatgpt.sh)
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
### Dependencies Termux
Install the `Termux` and `Termux:API` apps from the *F-Droid store*.
Give all permissions to `Termux:API` in your phone app settings.
We reccommend to also install `sox`, `ffmpeg`, `pulseaudio`, `imagemagick`, and `vim` (or `nano`).
Remember to execute `termux-setup-storage` to set up access to the phone storage.
In Termux proper, install the `termux-api` and `termux-tools` packages (`pkg install termux-api termux-tools`).
When recording audio (Whisper, `option -w`),
if `pulseaudio` is configured correctly,
the script uses `sox`, `ffmpeg` or other competent software,
otherwise it defaults to `termux-microphone-record`
Likewise, when playing audio (TTS, `option -z`),
depending on `pulseaudio` configuration use `sox`, `mpv` or
fallback to termux wrapper playback (`play-audio` is optional).
To set the clipboard, it is required `termux-clipboard-set` from the `termux-api` package.
### TTS Chat - Removal of Markdown
*Markdown in TTS input* may stutter the model speech generation a little.
If `python` modules `markdown` and `bs4` are available, TTS input will
be converted to plain text. As fallback, `pandoc` is used if present
(chat mode only).
### 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
### Troubleshoot Termux
In order to set Termux access to recording the microphone and playing audio
(with `sox` and `ffmpeg`), follow the instructions below.
**A.** Set `pulseaudio` one time only, execute:
pulseaudio -k
pulseaudio -L "module-sles-source" -D
**B.** To set a permanent configuration:
1. Kill the process with `pulseaudio -k`.
2. Add `load-module module-sles-source` to _one of the files_:
```
~/.config/pulse/default.pa
/data/data/com.termux/files/usr/etc/pulse/default.pa
```
3. Restart the server with `pulseaudio -D`.
**C.** To create a new user `~/.config/pulse/default.pa`, you may start with the following template:
#!/usr/bin/pulseaudio -nF
.include /data/data/com.termux/files/usr/etc/pulse/default.pa
load-module module-sles-source
## ๐ฏ Project Objectives
- Main focus on **chat models** (multi-turn, text, image, and audio).
- Implementation of selected features from **OpenAI API version 1**.
- Provide the closest API defaults and let the user customise settings.
## Roadmap
- We shall decrease development frequency in 2025, hopefully.
- We plan to gradually wind down development of new features in the near future.
The project will enter a maintenance phase from 2025 onwards, focusing primarily
on bug fixes and stability.
- We plan to deprecate the _image generation and image editing_ endpoints
when script code becomes obsolete to work with images.
- Text completions endpoint is planned to be deprecated when there are
no models compatible with this endpoint anymore.
- The warper is deemed finished in the sense any further updates must
not change the user interface significantly.
## โ ๏ธ Limitations
- OpenAI **API version 1** is the focus of the present project implementation.
Only selected features of the API will be covered.
- The script _will not execute commands_ on behalf of users.
- This project _doesn't_ support "Function Calling" or "Structured Outputs".
- We _will not support_ "Real-Time" chatting, or video generation / editing.
- 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.
- The script logic resembles a bowl of spaghetti code after a cat fight.
- See _LIMITS AND BUGS_ section in the [man page](man/README.md#bugs).
## Bug report
Please leave bug reports at the
[GitHub issues page](https://github.com/mountaineerbr/shellChatGPT/issues).
## ๐ Help Pages
Read the online [**man page here**](man/README.md).
Alternatively, a help page snippet can be printed with `chatgpt.sh -h`.
## ๐ช Contributors
***Many Thanks*** to everyone who contributed to this project.
- [edshamis](https://www.github.com/edshamis)
- [johnd0e](https://github.com/johnd0e)
- [Novita AI's GTM Leo](https://novita.ai/model-api/product/llm-api)
Everyone is [welcome to submit issues, PRs, and new ideas](https://github.com/mountaineerbr/shellChatGPT/discussions/1)!
## Acknowledgements
The following projects are worth remarking.
They were studied during development of this script and used as referencial code sources.
1. [sigoden's aichat](https://github.com/sigoden/aichat)
2. [xenodium's chatgpt-shell](https://github.com/xenodium/chatgpt-shell)
3. [andrew's tgpt](https://github.com/aandrew-me/tgpt)
4. [TheR1D's shell_gpt](https://github.com/TheR1D/shell_gpt/)
5. [ErikBjare's gptme](https://github.com/ErikBjare/gptme)
6. [llm-workflow-engine](https://github.com/llm-workflow-engine/llm-workflow-engine)
7. [0xacx's chatGPT-shell-cli](https://github.com/0xacx/chatGPT-shell-cli)
8. [mudler's LocalAI](https://github.com/mudler/LocalAI)
9. [Ollama](https://github.com/ollama/ollama/)
10. [Google Gemini](https://gemini.google.com/)
11. [Groq](https://console.groq.com/docs/api-reference)
12. [Antropic AI](https://docs.anthropic.com/)
13. [Novita AI](https://novita.ai/)
14. [xAI](https://docs.x.ai/docs/quickstart)
15. [f's awesome-chatgpt-prompts](https://github.com/f/awesome-chatgpt-prompts)
16. [PlexPt's awesome-chatgpt-prompts-zh](https://github.com/PlexPt/awesome-chatgpt-prompts-zh)
---
**[The project home is at GitLab](https://gitlab.com/fenixdragao/shellchatgpt)**
_Mirror_
