### Installing PyGPT via Snap Store (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command installs the PyGPT application directly from the Snap Store. It requires `sudo` privileges and an active internet connection. This is the initial step to get PyGPT running from Snap.

```commandline
sudo snap install pygpt
```

--------------------------------

### Installing PyGPT from PyPI (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command installs the PyGPT application and its dependencies from the Python Package Index (PyPI) using pip. It should be executed within an activated virtual environment to ensure proper dependency management.

```commandline
pip install pygpt-net
```

--------------------------------

### Installing PyGPT Dependencies with Poetry (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command installs all project dependencies as defined in PyGPT's `pyproject.toml` file using Poetry. It should be run within the Poetry shell to ensure proper dependency resolution and environment setup.

```commandline
poetry install
```

--------------------------------

### Cloning PyGPT GitHub Repository (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

These commands clone the PyGPT source code repository from GitHub and then navigate into the newly created 'py-gpt' directory. This is the initial step for running the application directly from source.

```commandline
git clone https://github.com/szczyglis-dev/py-gpt.git
cd py-gpt
```

--------------------------------

### Installing libxcb-cursor0 for Qt Plugin Issues (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command installs the `libxcb-cursor0` package on Debian/Ubuntu-based systems. It is a common fix for `qt.qpa.plugin` errors related to the `xcb` platform plugin when running PySide6 applications on Linux.

```commandline
sudo apt install libxcb-cursor0
```

--------------------------------

### Running PyGPT from Source Code (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command executes the `run.py` script, which is the main entry point for the PyGPT application when running directly from its source code. It requires Python 3.10 or higher and all dependencies to be installed.

```commandline
python3 run.py
```

--------------------------------

### Installing PyGPT Source Code Dependencies (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command installs all required Python packages listed in the `requirements.txt` file. It should be run within an activated virtual environment after cloning the source code to ensure all dependencies are met.

```commandline
pip install -r requirements.txt
```

--------------------------------

### Installing Poetry Package Manager (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command installs Poetry, a Python dependency management and packaging tool. It is a prerequisite for managing PyGPT's dependencies and running the application using Poetry.

```commandline
pip install poetry
```

--------------------------------

### Installing ALSA Libraries for Audio Issues (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

These commands install various `libasound2` packages on Debian/Ubuntu-based systems. They provide essential ALSA (Advanced Linux Sound Architecture) libraries, which are crucial for resolving audio playback and recording issues on Linux.

```commandline
sudo apt install libasound2
sudo apt install libasound2-data 
sudo apt install libasound2-plugins
```

--------------------------------

### Running PyGPT Application (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command launches the PyGPT application after it has been successfully installed via pip. It assumes the `pygpt` executable is available in the system's PATH or the active virtual environment.

```commandline
pygpt
```

--------------------------------

### Connecting Camera for PyGPT Snap Version (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command grants the PyGPT Snap application access to the system's camera. It is necessary for features that utilize camera input, such as Vision mode. Requires `sudo` privileges.

```commandline
sudo snap connect pygpt:camera
```

--------------------------------

### Installing portaudio19-dev for Audio Issues (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command installs the `portaudio19-dev` package on Debian/Ubuntu-based systems. It is often required to resolve audio-related problems in applications that use PortAudio, such as PyGPT.

```commandline
sudo apt install portaudio19-dev
```

--------------------------------

### Updating PyGPT via Snap Store (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command refreshes the PyGPT application installed via Snap, ensuring it is updated to the latest version available in the Snap Store. It requires `sudo` privileges to execute.

```commandline
sudo snap refresh pygpt
```

--------------------------------

### Running PyGPT from PyPi Installation

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command starts the PyGPT application after it has been successfully installed via pip from PyPi.

```console
$ pygpt
```

--------------------------------

### Creating and Activating Python Virtual Environment (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

These commands create a new Python virtual environment named 'venv' and then activate it. A virtual environment isolates project dependencies, preventing conflicts with global Python packages. This is a prerequisite for pip installation.

```commandline
python3 -m venv venv
source venv/bin/activate
```

--------------------------------

### Installing PyGPT from PyPi

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command installs the 'pygpt-net' package from the Python Package Index (PyPi) into the active virtual environment. It fetches and installs all required dependencies.

```commandline
pip install pygpt-net
```

--------------------------------

### Running PyGPT with Poetry (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command executes the `run.py` script within the Poetry-managed environment. It ensures that the application runs with the correct dependencies and Python version as managed by Poetry.

```commandline
poetry run python3 run.py
```

--------------------------------

### Installing PyGPT via Snap Store

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command installs the PyGPT application directly from the Snap Store on Linux systems. Snap is a universal Linux package manager, simplifying software deployment and updates.

```commandline
sudo snap install pygpt
```

--------------------------------

### Configuring Poetry Environment for Python 3.10 (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

These commands instruct Poetry to use Python 3.10 for the project's virtual environment and then activate the Poetry shell. This ensures the correct Python version is used for dependency resolution and execution.

```commandline
poetry env use python3.10
poetry shell
```

--------------------------------

### Running PyGPT from Source (Poetry)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command executes the `run.py` script within the Poetry environment, starting the PyGPT application when managed with Poetry.

```console
$ poetry run python3 run.py
```

--------------------------------

### Installing PyGPT via Snap Store

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs the PyGPT application directly from the Snap Store on Linux systems. It requires `sudo` privileges.

```console
$ sudo snap install pygpt
```

--------------------------------

### Connecting Microphone for PyGPT Snap Version (Command Line)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command grants the PyGPT Snap application access to the system's microphone. It is essential for features requiring audio input, such as voice commands or transcription. Requires `sudo` privileges.

```commandline
sudo snap connect pygpt:audio-record :audio-record
```

--------------------------------

### Running PyGPT from Source (pip)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command executes the `run.py` script to start the PyGPT application when running from source code after installing dependencies with pip.

```console
$ python3 run.py
```

--------------------------------

### Navigating to API Key Settings (INI)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/quick_start.rst

This snippet illustrates the menu path within the application where the OpenAI API key needs to be pasted. It's presented in an INI-like format, indicating a hierarchical configuration setting.

```ini
Config -> Settings -> API Keys
```

--------------------------------

### Cloning PyGPT Git Repository

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

These commands clone the PyGPT source code repository from GitHub and then navigate into the newly created directory. This is the first step for running from source.

```console
$ git clone https://github.com/szczyglis-dev/py-gpt.git
$ cd py-gpt
```

--------------------------------

### Launching py-gpt with Custom Components - Python

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet demonstrates how to initialize and run the `pygpt_net` application by injecting custom plugins, Large Language Models (LLMs), and vector stores. It shows the setup of lists for each component type and their passing to the `run` function, allowing for extended functionality beyond default configurations.

```Python
from pygpt_net.app import run
from plugins import CustomPlugin, OtherCustomPlugin
from llms import CustomLLM
from vector_stores import CustomVectorStore

plugins = [
    CustomPlugin(),
    OtherCustomPlugin(),
]
llms = [
    CustomLLM(),
]
vector_stores = [
    CustomVectorStore(),
]

run(
    plugins=plugins,
    llms=llms,
    vector_stores=vector_stores,
)
```

--------------------------------

### Installing Ollama on Linux

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command downloads and executes the Ollama installation script. It's a common method for installing Ollama on Linux systems, enabling the local hosting of large language models.

```Shell
curl -fsSL https://ollama.com/install.sh | sh
```

--------------------------------

### Installing libxcb-cursor0 for Qt Plugin Fix

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command installs the 'libxcb-cursor0' package on Debian/Ubuntu-based Linux systems. It resolves issues with the 'xcb' Qt platform plugin, which can prevent PySide-based applications from starting.

```commandline
sudo apt install libxcb-cursor0
```

--------------------------------

### Connecting Audio Playback for PyGPT Snap

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command connects the audio-playback interface to the PyGPT Snap application, enabling audio output. It requires `sudo` privileges.

```console
$ sudo snap connect pygpt:audio-playback
```

--------------------------------

### Installing PyGPT from PyPi

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs the PyGPT application and its dependencies from the Python Package Index (PyPi) using pip within the active virtual environment.

```console
$ pip install pygpt-net
```

--------------------------------

### Forcing Legacy Renderer for WebEngine Issues (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command launches PyGPT with the `--legacy=1` argument, forcing the application to use a legacy rendering engine for WebEngine/Chromium components. This can resolve display problems related to modern renderer incompatibilities.

```commandline
python3 run.py --legacy=1
```

--------------------------------

### Configuring Legacy Renderer and Disabling OpenGL (JSON)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

These JSON key-value pairs, when added to the `config.json` file (located at `%WORKDIR%/config.json`), manually enable the legacy rendering engine and disable OpenGL. This provides a persistent solution for display issues without command-line arguments.

```json
"render.engine": "legacy",
"render.open_gl": false,
```

--------------------------------

### Installing PyGPT Source Requirements (Poetry)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs all project dependencies defined in `pyproject.toml` using Poetry, ensuring all required packages are available for running PyGPT from source.

```console
$ poetry install
```

--------------------------------

### Installing PyGPT Requirements with Poetry

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command installs all project dependencies defined in the 'pyproject.toml' file using Poetry. It ensures all necessary packages are available within the Poetry-managed virtual environment.

```commandline
poetry install
```

--------------------------------

### Connecting Camera for PyGPT Snap

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command connects the camera interface to the PyGPT Snap application, allowing PyGPT to access the system's camera.

```console
$ snap connect pygpt:camera
```

--------------------------------

### Installing Poetry Package Manager

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command installs Poetry, a Python dependency management and packaging tool, using pip. Poetry is required for managing dependencies and running the application if you choose the Poetry installation method.

```commandline
pip install poetry
```

--------------------------------

### Installing libasound2-plugins for Audio Troubleshooting

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs `libasound2-plugins` on Linux, providing additional ALSA plugins that can be necessary to fix complex audio issues with PyGPT.

```console
$ sudo apt install libasound2-plugins
```

--------------------------------

### Installing libasound2-data for Audio Troubleshooting

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs `libasound2-data` on Linux, providing essential data files for the ALSA library, which can help resolve audio problems.

```console
$ sudo apt install libasound2-data
```

--------------------------------

### Connecting Microphone (audio-record) for PyGPT Snap

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command connects the audio-record interface to the PyGPT Snap application, enabling microphone input. It requires `sudo` privileges.

```console
$ sudo snap connect pygpt:audio-record :audio-record
```

--------------------------------

### Installing PyGPT Source Requirements (pip)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs all necessary Python dependencies listed in the `requirements.txt` file for running PyGPT from source code using pip.

```console
$ pip install -r requirements.txt
```

--------------------------------

### Running PyGPT after PyPi Installation

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

After successful installation from PyPi, this command launches the PyGPT application. It assumes the 'pygpt' executable is available in the system's PATH or the active virtual environment.

```commandline
pygpt
```

--------------------------------

### Installing libxcb-cursor0 for PySide Troubleshooting

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs the `libxcb-cursor0` package on Linux, which resolves issues related to the `xcb` Qt platform plugin when using newer versions of PySide.

```console
$ sudo apt install libxcb-cursor0
```

--------------------------------

### Registering Custom Plugins and LLMs in PyGPT (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This example shows how to create a custom `launcher.py` file to register custom plugins and LLM wrappers with the PyGPT application. It passes instances of `CustomPlugin`, `OtherCustomPlugin`, and `CustomLLM` to the `run` function via keyword arguments, enabling extensibility beyond default components.

```Python
# launcher.py

from pygpt_net.app import run
from plugins import CustomPlugin, OtherCustomPlugin
from llms import CustomLLM

plugins = [
    CustomPlugin(),
    OtherCustomPlugin(),
]
llms = [
    CustomLLM(),  # <--- custom LLM provider (wrapper)
]
vector_stores = []

run(
    plugins=plugins, 
    llms=llms, 
    vector_stores=vector_stores,
)
```

--------------------------------

### Installing portaudio19-dev for Audio Troubleshooting

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs `portaudio19-dev` on Linux, which can help resolve common audio-related problems when running PyGPT.

```console
$ sudo apt install portaudio19-dev
```

--------------------------------

### Creating Python Virtual Environment for PyGPT (PyPi)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

These commands create a new Python virtual environment named 'venv' and activate it. This isolates project dependencies from the system Python installation.

```console
$ python3 -m venv venv
$ source venv/bin/activate
```

--------------------------------

### Installing Poetry for PyGPT Source

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs Poetry, a Python dependency management and packaging tool, which is an alternative method for managing PyGPT's dependencies from source.

```console
$ pip install poetry
```

--------------------------------

### Connecting Docker Executables for PyGPT Snap

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command connects the Docker executables interface to the PyGPT Snap application, allowing PyGPT to interact with Docker commands. It requires `sudo` privileges.

```console
$ sudo snap connect pygpt:docker-executables docker:docker-executables
```

--------------------------------

### Installing PyGPT Requirements from Source (pip)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command installs all Python dependencies listed in the 'requirements.txt' file. This is crucial for running the PyGPT application from its source code when using pip.

```commandline
pip install -r requirements.txt
```

--------------------------------

### Creating Poetry Virtual Environment for PyGPT (Python 3.10)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

These commands configure Poetry to use Python 3.10 for the project's virtual environment and then activate the Poetry shell, preparing for dependency installation.

```console
$ poetry env use python3.10
$ poetry shell
```

--------------------------------

### Connecting ALSA Interface for PyGPT Snap

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command connects the ALSA (Advanced Linux Sound Architecture) interface to the PyGPT Snap application, which is essential for both microphone input and audio output functionalities on Linux. It requires `sudo` privileges.

```console
$ sudo snap connect pygpt:alsa
```

--------------------------------

### Installing libasound2 for Audio Troubleshooting

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command installs `libasound2` on Linux, a core ALSA library, which is often required to fix audio issues with applications like PyGPT.

```console
$ sudo apt install libasound2
```

--------------------------------

### Running Llama 3.1 Model with Ollama

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command initiates the Llama 3.1 model using the locally installed Ollama server. It downloads the model if not already present and makes it available for interaction.

```Shell
ollama run llama3.1
```

--------------------------------

### Disabling OpenGL for GPU Rendering Issues (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/INSTALL.md

This command launches PyGPT with the `--disable-gpu=1` argument, which forces the application to disable OpenGL. This can help resolve display or rendering issues caused by GPU driver incompatibilities or problems with OpenGL acceleration.

```commandline
python3 run.py --disable-gpu=1
```

--------------------------------

### Connecting Docker Daemon for PyGPT Snap

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command connects the Docker daemon interface to the PyGPT Snap application, enabling PyGPT to communicate with the Docker service. It requires `sudo` privileges.

```console
$ sudo snap connect pygpt:docker docker:docker-daemon
```

--------------------------------

### Connecting Microphone in PyGPT Snap Version

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command provides microphone access to the PyGPT Snap application, allowing it to record audio. It is essential for features that require audio input within the Snap sandboxed environment.

```console
$ sudo snap connect pygpt:audio-record :audio-record
```

--------------------------------

### Updating PyGPT via Snap Store

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command refreshes the PyGPT application installed via Snap, ensuring it is updated to the latest version. It requires `sudo` privileges.

```console
$ sudo snap refresh pygpt
```

--------------------------------

### Creating Python Virtual Environment for PyGPT (Source - pip)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

These commands create and activate a new Python virtual environment, which is essential for managing dependencies when running PyGPT from source code using pip.

```console
$ python3 -m venv venv
$ source venv/bin/activate
```

--------------------------------

### Arduino Serial Communication Example (C++)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/plugins.rst

This C++ code snippet for Arduino Uno demonstrates basic serial communication. It initializes the serial port at 9600 baud rate in the `setup` function. The `loop` function continuously checks for incoming serial data, reads a string until a newline character, and then echoes it back with an 'OK, response for:' prefix. This allows an external system to send commands and receive responses via USB.

```cpp
// example.ino

void setup() {
  Serial.begin(9600);
}

void loop() {
  if (Serial.available() > 0) {
    String input = Serial.readStringUntil('\n');
    if (input.length() > 0) {
      Serial.println("OK, response for: " + input);
    }
  }
}
```

--------------------------------

### Creating Virtual Environment for PyPi Installation

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command-line snippet creates a new Python virtual environment named 'venv' and then activates it. A virtual environment isolates project dependencies, preventing conflicts with system-wide Python packages.

```commandline
python3 -m venv venv
source venv/bin/activate
```

--------------------------------

### Installing Ollama on Linux

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/models.rst

This snippet demonstrates how to install Ollama on a Linux system using a curl command to download and execute the installation script. Ollama is required to run local LLM models like Llama 3 or Mistral with PyGPT.

```sh
$ curl -fsSL https://ollama.com/install.sh | sh
```

--------------------------------

### Cloning PyGPT GitHub Repository (Poetry)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command clones the official PyGPT GitHub repository to the local machine and then changes the current directory into the newly cloned 'py-gpt' folder. This is the initial step for Poetry-based source installation.

```commandline
git clone https://github.com/szczyglis-dev/py-gpt.git
cd py-gpt
```

--------------------------------

### Running PyGPT from GitHub Source (pip)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command executes the main application script 'run.py' using the Python interpreter. This starts the PyGPT application when running directly from the cloned source code with pip dependencies.

```commandline
python3 run.py
```

--------------------------------

### Installing libasound2 for Audio Fix

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

These commands install various 'libasound2' packages on Debian/Ubuntu-based Linux systems. These libraries are part of ALSA (Advanced Linux Sound Architecture) and are essential for resolving audio playback and recording issues.

```commandline
sudo apt install libasound2
sudo apt install libasound2-data 
sudo apt install libasound2-plugins
```

--------------------------------

### Listing Installed Python Packages

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/CONTRIBUTING.md

This command is used to display a list of all installed Python packages and their versions in the current environment. It is crucial for providing detailed environment information when reporting bugs to help diagnose issues.

```Shell
pip list
```

--------------------------------

### Connecting Camera in PyGPT Snap Version

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command grants camera access to the PyGPT Snap application, enabling its Vision mode functionality. It is a necessary step for the application to interact with the camera hardware within the Snap environment.

```console
$ sudo snap connect pygpt:camera
```

--------------------------------

### PyGPT Internal Command Syntax Example

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet demonstrates PyGPT's internal syntax for defining commands and their parameters. It's a JSON object wrapped between `~###~` delimiters, which the application extracts and executes. This specific example shows a `send_email` command with a `quote` parameter.

```JSON
~###~{"cmd": "send_email", "params": {"quote": "Why don't skeletons fight each other? They don't have the guts!"}}~###~
```

--------------------------------

### Triggering PyGPT Tutorial Command

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/plugins.rst

This console input demonstrates how a user can prompt PyGPT to execute a specific tutorial command. It serves as an example of the natural language interface for triggering predefined or custom commands within the PyGPT environment.

```Console
> please execute tutorial test command
```

--------------------------------

### Configuring Legacy WebEngine and Disabling OpenGL in JSON

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

These JSON configuration options, when set in the `config.json` file, manually enable the legacy rendering engine and disable OpenGL hardware acceleration. This provides an alternative method to resolve WebEngine/Chromium display issues without using command-line arguments.

```json
"render.engine": "legacy",
"render.open_gl": false,
```

--------------------------------

### Example PyGPT-Net Spanish Locale File Name (INI)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet provides an example of the naming convention for PyGPT-Net locale files. Creating a file like `locale.es.ini` in the appropriate directory will add Spanish as a selectable language option within the application's language menu.

```ini
locale.es.ini
```

--------------------------------

### Example Wikipedia Search API Call (Resolved)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet demonstrates a resolved Wikipedia API call URL after the PyGPT model has replaced the placeholders with specific values (limit=5, search=Nikola Tesla) based on user input, showing a live example of the API interaction.

```URL
https://en.wikipedia.org/w/api.php?action=opensearch&limit=5&format=json&search=Nikola%20Tesla
```

--------------------------------

### Installing portaudio19-dev for Audio Fix

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command installs the 'portaudio19-dev' package on Debian/Ubuntu-based Linux systems. It is a development library for PortAudio, often required to fix audio-related problems in applications like PyGPT.

```commandline
sudo apt install portaudio19-dev
```

--------------------------------

### Initializing PyGPT Application with Default LLMs (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet demonstrates the core `run` function in `app.py` responsible for initializing the PyGPT application. It sets up the `Launcher`, registers various built-in LLM providers (OpenAI, Azure OpenAI, Anthropic, Hugging Face, Ollama, Google), and then launches the application. It also includes a placeholder for plugin registration.

```Python
from pygpt_net.provider.llms.openai import OpenAILLM
from pygpt_net.provider.llms.azure_openai import AzureOpenAILLM
from pygpt_net.provider.llms.anthropic import AnthropicLLM
from pygpt_net.provider.llms.hugging_face import HuggingFaceLLM
from pygpt_net.provider.llms.ollama import OllamaLLM
from pygpt_net.provider.llms.google import GoogleLLM


def run(**kwargs):
    """Runs the app."""
    # Initialize the app
    launcher = Launcher()
    launcher.init()

    # Register plugins
    ...

    # Register langchain and llama-index LLMs wrappers
    launcher.add_llm(OpenAILLM())
    launcher.add_llm(AzureOpenAILLM())
    launcher.add_llm(AnthropicLLM())
    launcher.add_llm(HuggingFaceLLM())
    launcher.add_llm(OllamaLLM())
    launcher.add_llm(GoogleLLM())

    # Launch the app
    launcher.run()
```

--------------------------------

### Forcing Legacy WebEngine Mode via Command Line

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command line argument forces PyGPT to use its legacy WebEngine rendering mode. It is useful for troubleshooting display issues related to the Chromium renderer, providing an alternative rendering path.

```console
$ python3 run.py --legacy=1
```

--------------------------------

### Custom Font Directory Structure Example (INI)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/configuration.rst

This example illustrates the recommended directory structure for adding custom fonts to PyGPT. Fonts should be placed within a 'fonts' subdirectory inside the working directory, organized by font family.

```INI
%workdir%\n|_css\n|_data\n|_fonts\n   |_MyFont\n     |_MyFont-Regular.ttf\n     |_MyFont-Bold.ttf\n     |...
```

--------------------------------

### Connecting PyGPT Snap to Docker Executables

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command establishes a connection between the PyGPT Snap package and the Docker executables on the system. It is a prerequisite for using IPython in sandbox mode within a Docker container when PyGPT is installed via Snap, ensuring PyGPT can interact with Docker commands.

```commandline
sudo snap connect pygpt:docker-executables docker:docker-executables
```

--------------------------------

### Configuring Wikipedia Search API Call Template

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet shows the template for configuring a GET request to the Wikipedia API within PyGPT. It defines placeholders for query and limit parameters, which the model replaces before making the actual API call.

```URL
https://en.wikipedia.org/w/api.php?action=opensearch&limit={limit}&format=json&search={query}
```

--------------------------------

### Connecting PyGPT to Docker Executables (Snap)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/plugins.rst

This shell command connects the 'pygpt' snap package to the Docker executables, granting PyGPT the necessary permissions to execute Docker commands. This is a crucial step for enabling IPython's sandbox mode when PyGPT is installed as a Snap.

```Shell
$ sudo snap connect pygpt:docker-executables docker:docker-executables
```

--------------------------------

### Updating PyGPT via Snap Store

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command refreshes or updates the PyGPT application installed via Snap Store to its latest available version. It ensures the application benefits from the newest features and bug fixes.

```commandline
sudo snap refresh pygpt
```

--------------------------------

### PyGPT Internal Command Syntax Example - Console

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/functions.rst

This snippet shows the internal JSON-based command syntax used by PyGPT, wrapped in `~###~` delimiters. The application parses this format to extract and execute the appropriate function based on the provided command name and parameters.

```console
~###~{"cmd": "send_email", "params": {"quote": "Why don't skeletons fight each other? They don't have the guts!"}}~###~
```

--------------------------------

### Registering Custom LLM Providers via Custom Launcher in PyGPT (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/extending.rst

This `custom_launcher.py` example demonstrates how to register custom Large Language Model (LLM) providers when launching a PyGPT application with a custom launcher. It shows passing a list containing instances of custom LLM wrappers (like `CustomLLM()`) to the `llms` keyword argument of the `run()` function. This allows developers to integrate their own LLM implementations seamlessly.

```python
# custom_launcher.py

from pygpt_net.app import run
from plugins import CustomPlugin, OtherCustomPlugin
from llms import CustomLLM

plugins = [
    CustomPlugin(),
    OtherCustomPlugin(),
]
llms = [
    CustomLLM(),  # <--- custom LLM provider (wrapper)
]
vector_stores = []

run(
    plugins=plugins,
    llms=llms,
    vector_stores=vector_stores,
)
```

--------------------------------

### Registering Custom Data Loaders in PyGPT-Net - Python

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet extends the previous example by demonstrating how to integrate custom data loaders into the PyGPT-Net application. It shows how to define a list of `CustomLoader` instances and pass them to the `run` function alongside other custom components. The custom data loader must be an instance of `pygpt_net.provider.loaders.base.BaseLoader`.

```Python
# custom_launcher.py

from pygpt_net.app import run
from plugins import CustomPlugin, OtherCustomPlugin
from llms import CustomLLM
from vector_stores import CustomVectorStore
from loaders import CustomLoader

plugins = [
    CustomPlugin(),
    OtherCustomPlugin(),
]
llms = [
    CustomLLM(),
]
vector_stores = [
    CustomVectorStore(),
]
loaders = [
    CustomLoader(),  # <---- custom data loader
]

run(
    plugins=plugins,
    llms=llms,
    vector_stores=vector_stores,  # <--- list with custom vector store providers
    loaders=loaders  # <--- list with custom data loaders
)
```

--------------------------------

### Enabling Audio Notification for Microphone Activity - Bash

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet indicates the configuration option to enable short sound notifications when voice recording starts and stops. This provides auditory feedback to the user, confirming the microphone's listening status for voice input.

```bash
Audio notify microphone listening start/stop
```

--------------------------------

### Connecting PyGPT to Docker Daemon (Snap)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/plugins.rst

This shell command establishes a connection between the 'pygpt' snap package and the Docker daemon, allowing PyGPT to manage Docker containers. This connection is vital for running IPython in a Dockerized sandbox environment within the Snap installation.

```Shell
$ sudo snap connect pygpt:docker docker:docker-daemon
```

--------------------------------

### User Prompt for Generating and Emailing a Quote - INI

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/functions.rst

This is an example user prompt given to GPT in Chat mode, instructing it to create a funny quote and then email it. This prompt triggers the defined `send_email` function, demonstrating how user input can invoke custom functionality.

```ini
Create a funny quote and email it
```

--------------------------------

### Arduino Serial Communication Setup (C++)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This C++ code snippet for Arduino Uno initializes serial communication at 9600 baud. It continuously checks for incoming serial data, reads a string until a newline character, and then echoes it back prefixed with 'OK, response for: '. This enables basic two-way communication between the Arduino and a connected device, such as a computer via USB.

```cpp
// example.ino

void setup() {
  Serial.begin(9600);
}

void loop() {
  if (Serial.available() > 0) {
    String input = Serial.readStringUntil('\n');
    if (input.length() > 0) {
      Serial.println("OK, response for: " + input);
    }
  }
}
```

--------------------------------

### Querying Context History (Natural Language)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

These examples demonstrate natural language queries for interacting with the context history database. Users can retrieve day notes, save or update them, and access lists or specific content of past conversations by ID. This functionality simplifies interaction with historical data through conversational commands.

```natural language
Give me today day note
Save a new note for today
Update my today note with...
Get the list of yesterday conversations
Get contents of conversation ID 123
```

--------------------------------

### PyGPT Internal Command Output Example

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet illustrates the format of a command generated by PyGPT in response to a user prompt when native API function calls are disabled. It's an internal JSON command wrapped in `~###~` delimiters, containing the `send_email` command and a generated `quote` parameter.

```JSON
~###~{"cmd": "send_email", "params": {"quote": "Why do we tell actors to 'break a leg?' Because every play has a cast!"}}~###~
```

--------------------------------

### Enabling Global Voice Control - Bash

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet represents the configuration option to enable global voice control in PyGPT via the 'Config / Accessibility' menu. Activating this option makes the 'Voice Control' button appear, allowing users to start and stop microphone listening for voice commands across the application.

```bash
Enable voice control (using microphone)
```

--------------------------------

### PyGPT Custom Command Execution Example

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet shows a shell command configured in PyGPT's `Custom Commands` plugin. It uses `echo` to print a confirmation message, dynamically inserting the value of the `quote` parameter received from the model. This command is executed by PyGPT when the corresponding function call is triggered.

```Shell
echo "OK. Email sent: {quote}"
```

--------------------------------

### Handling Dispatched Events in a Custom Plugin - Python

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet illustrates how to implement the `handle` method within a custom plugin to intercept and process dispatched events from the `pygpt_net` core. It shows how to access event name, data, and context, and provides examples of conditional logic for specific event types like `INPUT_BEFORE` and `CTX_BEGIN`.

```Python
# custom_plugin.py

from pygpt_net.core.events import Event

def handle(self, event: Event, *args, **kwargs):
    """
    Handle dispatched events

    :param event: event object
    """
    name = event.name
    data = event.data
    ctx = event.ctx

    if name == Event.INPUT_BEFORE:
        self.some_method(data['value'])
    elif name == Event.CTX_BEGIN:
        self.some_other_method(ctx)
    else:
    	# ...
```

--------------------------------

### Configuring Wikipedia API Call in PyGPT

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/plugins.rst

This configuration snippet demonstrates how to define a custom API call within PyGPT to interact with the Wikipedia API. It specifies the call's name, a descriptive instruction for the model, required GET parameters, the request type, and the full endpoint URL with dynamic placeholders. This setup enables the PyGPT model to perform Wikipedia searches by dynamically constructing the API request.

```Configuration
Name: search_wiki
Instruction: send API call to Wikipedia to search pages by query
GET params: query, limit
Type: GET
API endpoint: https://en.wikipedia.org/w/api.php?action=opensearch&limit={limit}&format=json&search={query}
```

--------------------------------

### Creating a Custom PyGPT Launcher in Python

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/extending.rst

This snippet demonstrates how to create a custom Python launcher file (`custom_launcher.py`) for the PyGPT application. It shows how to import and instantiate custom plugin, LLM, and vector store classes, and then pass these instances to the `run` function of the PyGPT application. This allows for dynamic loading of custom components at application startup.

```python
# custom_launcher.py

from pygpt_net.app import run
from plugins import CustomPlugin, OtherCustomPlugin
from llms import CustomLLM
from vector_stores import CustomVectorStore

plugins = [
    CustomPlugin(),
    OtherCustomPlugin(),
]
llms = [
    CustomLLM(),
]
vector_stores = [
    CustomVectorStore(),
]

run(
    plugins=plugins,
    llms=llms,
    vector_stores=vector_stores,
)
```

--------------------------------

### Registering Custom Components in PyGPT-Net (Plugins, LLMs, Vector Stores) - Python

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet demonstrates how to initialize and register custom plugins, language models (LLMs), and vector store providers with the PyGPT-Net application. It shows the basic structure for passing lists of custom instances to the `run` function, enabling extended functionality. The custom vector store provider must inherit from `pygpt_net.provider.vector_stores.base.BaseStore`.

```Python
from pygpt_net.app import run
from plugins import CustomPlugin, OtherCustomPlugin
from llms import CustomLLM
from vector_stores import CustomVectorStore

plugins = [
    CustomPlugin(),
    OtherCustomPlugin(),
]
llms = [
    CustomLLM(),
]
vector_stores = [
    CustomVectorStore(),  # <--- custom vector store provider
]

run(
    plugins=plugins,
    llms=llms,
    vector_stores=vector_stores,
)
```

--------------------------------

### Setting PyGPT-Net Working Directory via Binary (Shell)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command-line snippet shows how to launch the PyGPT-Net executable and specify a custom working directory. Similar to the Python script, the `--workdir` argument allows the binary version of the application to use an alternative location for its files.

```shell
pygpt.exe --workdir="/path/to/workdir"
```

--------------------------------

### Invoking PyGPT Tutorial Command

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet shows the natural language prompt used to trigger the built-in tutorial command in PyGPT. Users can type this phrase to initiate a demonstration of how custom commands work within the PyGPT environment.

```Natural Language
> please execute tutorial test command
```

--------------------------------

### Running PyGPT from GitHub Source (Poetry)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command executes the 'run.py' script within the Poetry-managed virtual environment. It's the standard way to launch the PyGPT application when using Poetry for dependency management.

```commandline
poetry run python3 run.py
```

--------------------------------

### Setting PyGPT-Net Working Directory via Python Script (Shell)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command-line snippet demonstrates how to launch PyGPT-Net using the `run.py` script and specify a custom working directory. The `--workdir` argument allows users to direct the application to use a different location for its configuration and data files.

```shell
python3 ./run.py --workdir="/path/to/workdir"
```

--------------------------------

### Creating Virtual Environment for GitHub Source (pip)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command-line snippet creates a new Python virtual environment named 'venv' and then activates it. This is a standard practice for managing dependencies when running Python projects from source via pip.

```commandline
python3 -m venv venv
source venv/bin/activate
```

--------------------------------

### Disabling OpenGL Hardware Acceleration via Command Line

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This command line argument disables OpenGL hardware acceleration for PyGPT. It can help resolve rendering problems or crashes that occur due to GPU-related issues with the WebEngine/Chromium renderer.

```console
$ python3 run.py --disable-gpu=1
```

--------------------------------

### Defining Custom Command for Smart Home Lights (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet illustrates how to define a custom command in PyGPT to control smart home lights. It uses a Python script, `smart_home_lights.py`, and accepts an argument (`arg`) to toggle the lights on (1) or off (0). PyGPT replaces the `{arg}` placeholder with the provided value before execution.

```Python
python /path/to/smart_home_lights.py {arg}
```

```Python
python /path/to/smart_home_lights.py 1
```

--------------------------------

### Registering Vector Store Providers in PyGPT (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This snippet from `app.py` illustrates how to register both built-in and custom vector store providers within the PyGPT application. It demonstrates adding default providers like Chroma, Elasticsearch, Pinecone, Redis, and Simple, and also includes logic to dynamically register custom vector store instances passed via the `vector_stores` keyword argument.

```Python
# app.py

# vector stores
from pygpt_net.provider.vector_stores.chroma import ChromaProvider
from pygpt_net.provider.vector_stores.elasticsearch import ElasticsearchProvider
from pygpt_net.provider.vector_stores.pinecode import PinecodeProvider
from pygpt_net.provider.vector_stores.redis import RedisProvider
from pygpt_net.provider.vector_stores.simple import SimpleProvider

def run(**kwargs):
    # ...
    # register base vector store providers (llama-index)
    launcher.add_vector_store(ChromaProvider())
    launcher.add_vector_store(ElasticsearchProvider())
    launcher.add_vector_store(PinecodeProvider())
    launcher.add_vector_store(RedisProvider())
    launcher.add_vector_store(SimpleProvider())

    # register custom vector store providers (llama-index)
    vector_stores = kwargs.get('vector_stores', None)
    if isinstance(vector_stores, list):
        for store in vector_stores:
            launcher.add_vector_store(store)

    # ...
```

--------------------------------

### Creating Poetry Virtual Environment for PyGPT

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

These commands configure Poetry to use Python 3.10 for the project's virtual environment and then activate the Poetry shell. This ensures the correct Python version and environment are used for dependency management.

```commandline
poetry env use python3.10
poetry shell
```

--------------------------------

### Resolving GLIBC Version Not Found Error on Linux

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/requirements.rst

This console output indicates a 'GLIBC_2.35' version dependency issue when running PyGPT on Linux. The error suggests that the required GLIBC version is not found, necessitating an update of GLIBC or the use of a newer operating system.

```console
Error loading Python lib libpython3.10.so.1.0: dlopen: /lib/x86_64-linux-gnu/libm.so.6: version GLIBC_2.35 not found (required by libpython3.10.so.1.0)
```

--------------------------------

### Running Llama 3.1 Locally with Ollama

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/models.rst

This command initiates the Llama 3.1 model locally using the Ollama CLI. After running, PyGPT can connect to this local Ollama instance to interact with the model.

```sh
$ ollama run llama3.1
```

--------------------------------

### Cloning PyGPT GitHub Repository (pip)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command clones the official PyGPT GitHub repository to the local machine and then changes the current directory into the newly cloned 'py-gpt' folder. This is the first step for running from source using pip.

```commandline
git clone https://github.com/szczyglis-dev/py-gpt.git
cd py-gpt
```

--------------------------------

### Connecting Audio Output for PyGPT Snap Version

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

These commands grant the PyGPT Snap package access to the system's audio playback and ALSA audio subsystem. This is necessary for features like speech synthesis (Text-To-Speech).

```commandline
sudo snap connect pygpt:audio-playback
sudo snap connect pygpt:alsa
```

--------------------------------

### Connecting Camera for PyGPT Snap Version

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command grants the PyGPT Snap package access to the system's camera. It is required for features like real-time video camera capture in Vision mode.

```commandline
sudo snap connect pygpt:camera
```

--------------------------------

### Available OpenAI TTS Models

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

Lists the available Text-to-Speech models provided by OpenAI for use with the Audio Output plugin. These models offer different quality and performance characteristics for speech generation.

```Configuration
  - tts-1
  - tts-1-hd
```

--------------------------------

### Registering Custom Data Loader in PyGPT-Net (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/extending.rst

This example illustrates how to register a custom data loader within the `pygpt_net` application. It imports `CustomLoader` and passes an instance to the `loaders` argument of the `run` function, enabling the application to use the custom data loading mechanism. The data loader must be an instance of `pygpt_net.provider.loaders.base.BaseLoader`.

```Python
# custom_launcher.py

from pygpt_net.app import run
from plugins import CustomPlugin, OtherCustomPlugin
from llms import CustomLLM
from vector_stores import CustomVectorStore
from loaders import CustomLoader

plugins = [
    CustomPlugin(),
    OtherCustomPlugin(),
]
llms = [
    CustomLLM(),
]
vector_stores = [
    CustomVectorStore(),
]
loaders = [
    CustomLoader(),  # <---- custom data loader
]

run(
    plugins=plugins,
    llms=llms,
    vector_stores=vector_stores,  # <--- list with custom vector store providers
    loaders=loaders  # <--- list with custom data loaders
)
```

--------------------------------

### Registering Base and Custom Vector Store Providers in PyGPT-Net (Python)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/extending.rst

This snippet shows the internal `run` function's mechanism for registering both built-in and custom vector store providers. It demonstrates how default providers like Chroma, Elasticsearch, Pinecode, Redis, and Simple are added, and how additional custom providers passed via `kwargs['vector_stores']` are dynamically registered if they are provided as a list.

```Python
from pygpt_net.provider.vector_stores.redis import RedisProvider
from pygpt_net.provider.vector_stores.simple import SimpleProvider

def run(**kwargs):
    # ...
    # register base vector store providers (llama-index)
    launcher.add_vector_store(ChromaProvider())
    launcher.add_vector_store(ElasticsearchProvider())
    launcher.add_vector_store(PinecodeProvider())
    launcher.add_vector_store(RedisProvider())
    launcher.add_vector_store(SimpleProvider())

    # register custom vector store providers (llama-index)
    vector_stores = kwargs.get('vector_stores', None)
    if isinstance(vector_stores, list):
        for store in vector_stores:
            launcher.add_vector_store(store)

    # ...
```

--------------------------------

### Connecting PyGPT Snap to Docker Daemon

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command grants the PyGPT Snap package access to the Docker daemon. It is essential for enabling PyGPT to manage and execute Docker containers, particularly for running IPython in a sandboxed environment, by allowing direct communication with the Docker service.

```commandline
sudo snap connect pygpt:docker docker:docker-daemon
```

--------------------------------

### Enabling Audio Notification for Microphone State - INI

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/accessibility.rst

This INI configuration enables audio notifications for the microphone's listening state in PyGPT. When activated, a short sound will play to indicate when voice recording starts and stops, providing clear auditory feedback to the user. This enhances accessibility by confirming microphone activity.

```ini
Audio notify microphone listening start/stop
```

--------------------------------

### Setting Working Directory via Command Line (Binary)

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/docs/source/configuration.rst

This command-line argument allows users to specify a custom working directory for the PyGPT application when launching its compiled binary version. This is useful for managing multiple configurations or data sets.

```Shell
pygpt.exe --workdir="/path/to/workdir"
```

--------------------------------

### Connecting Camera for PyGPT Snap Version

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command grants the PyGPT Snap package access to the system's camera. It is necessary for features that require camera input when running the application as a Snap.

```commandline
sudo snap connect pygpt:camera
```

--------------------------------

### Connecting Docker Executables for PyGPT Snap Version

Source: https://github.com/szczyglis-dev/py-gpt/blob/master/README.md

This command connects the PyGPT Snap package to Docker executables. It is required for PyGPT to interact with Docker, specifically for using IPython within a Docker environment.

```commandline
sudo snap connect pygpt:docker-executables docker:docker-executables
```