szczyglis-dev/py-gpt

PyGPT - Desktop AI Assistant

Release: 2.8.27 | build: 2026-09-20 | Python: >=3.10, <3.14

Official website: https://pygpt.net | Documentation | Discord

Get it from: PyPi | Snap Store | Microsoft Store | AppImage

Compiled version for Linux and Windows: Download (64bit)

Donate: Buy Me A Coffee | GitHub Sponsors | PayPal

Overview

PyGPT is an all-in-one desktop AI assistant supporting models from OpenAI (GPT-6 Astra, GPT-5.6, GPT-4, etc.), Google Gemini, Anthropic Claude, xAI Grok, Perplexity / Sonar, DeepSeek, and models available through HuggingFace, LlamaIndex, OpenAI-compatible APIs, and local Ollama installations such as Gemma, Qwen, Llama, Mistral, DeepSeek, Bielik, Nemotron, and gpt-oss.

It supports chat, Chat with Agents and other agent workflows, completions, Chat with Files (RAG), image and video generation, and image analysis. Models can work with files, run Python and system or custom commands, transfer files, call external APIs, and search the web with DuckDuckGo, Google and Microsoft Bing.

PyGPT also provides speech synthesis through OpenAI, Microsoft Azure, Google Cloud / GenAI, Eleven Labs and xAI, plus speech recognition with OpenAI Whisper (API or local), Google / Google Cloud / GenAI, Bing and xAI Grok Voice. It stores conversation history and memory, supports reusable presets, and can be extended with built-in or custom plugins for tools, automation and external integrations.

Screenshots (version 2.8.23, build 2026-09-17):

Dark theme:

Light theme:

You can download compiled 64-bit versions for Windows and Linux here: https://pygpt.net/#download

Features

• Desktop AI Assistant for Linux, Windows and Mac, written in Python.
• Works similarly to ChatGPT, but locally (on a desktop computer).
• 11 modes of operation: Chat, Chat with Files, Chat with Agents, Realtime + audio, Research, Completion, Image and Video generation, Computer use, Experts, plus legacy Agent and Autonomous modes.
• Supports multiple models like OpenAI GPT-6 Astra, GPT-5.6, GPT-4, Google Gemini, Anthropic Claude, xAI Grok, DeepSeek V3/R1, Perplexity / Sonar, and any model accessible through Ollama such as Gemma, Qwen, Llama, Mistral, DeepSeek, Bielik, Nemotron, gpt-oss, etc.
• Chat with your own Files: integrated RAG LlamaIndex support: chat with data such as: txt, pdf, csv, html, md, docx, json, epub, xlsx, xml, webpages, Google, GitHub, video/audio, images and other data types, or use conversation history as additional context provided to the model.
• Built-in vector databases support and automated files, db context and data embedding.
• Image generation via models like gpt-image, Imagen, Gemini, and Nano Banana.
• Video generation via models like Veo3 and Sora2.
• Internet access via DuckDuckGo, Google and Microsoft Bing.
• Speech synthesis via OpenAI, Microsoft Azure, Google Cloud / GenAI, Eleven Labs and xAI Text-To-Speech services.
• Speech recognition via OpenAI Whisper (API or local), Google / Google Cloud / GenAI, Microsoft Bing and xAI Grok Voice.
• Plugins support with built-in plugins like Files I/O, Python interpreter, Web search, Google, Facebook, X/Twitter, Slack, Telegram, GitHub, MCP, and many more.
• MCP support.
• Built-in MCP Connectors manager with catalog browsing and import from common Claude, Codex, OpenClaw, Cursor, VS Code, OpenCode, MCPorter, and generic JSON/TOML/YAML configurations.
• Includes Chat with Agents, an advanced orchestrated multi-agent mode with a user-facing Orchestrator and dynamically managed worker agents.
• Supports project-specific AGENTS.md rules for the main agent in Chat with Agents.
• Supports portable SKILL.md-based Agent Skills, with GitHub/local import, an Explore catalog, per-profile enable/disable management, and on-demand use in Chat with Agents.
• Built-in Python/OS tool with real-time Python / IPython execution.
• Camera capture for real-time image analysis in Chat and other supported modes, controlled from the Audio / Video menu.
• Image analysis via vision models.
• Included support features for individuals with disabilities: customizable keyboard shortcuts, voice control, and translation of on-screen actions into audio via speech synthesis.
• Handles and stores the full context of conversations (short and long-term memory).
• Integrated calendar, day notes and search in contexts by selected date.
• Tools and commands execution (via plugins: access to the local filesystem, Python/OS, system commands execution, and more).
• Custom commands creation and execution.
• Crontab / Task scheduler included.
• Manages files and attachments with options to upload, download, and organize.
• Context history with the capability to revert to previous contexts (long-term memory), plus optional experimental advanced context handling for very long conversations.
• Allows you to easily manage prompts with handy editable presets.
• Provides an intuitive operation and interface.
• Includes a notepad.
• Includes simple painter / drawing tool.
• Includes the node-based Agent Builder (Legacy) for older agent modes.
• Supports multiple languages.
• Requires no previous knowledge of using AI models.
• Fully configurable.
• Themes support.
• Real-time code syntax highlighting.
• Built-in token usage calculation.
• Open source; source code is available on GitHub.
• Utilizes the user's own API key.
• and many more.

The application is free, open-source, and runs on PCs with Linux, Windows 10, Windows 11 and Mac. Full Python source code is available on GitHub.

PyGPT uses your own API credentials to connect to supported AI providers such as OpenAI, Google, Anthropic, xAI, Perplexity, Mistral, OpenRouter, and others. Depending on the selected model and provider, you may need an account and a valid API key for that service. Local models do not require external API credentials. You can also use built-it LlamaIndex support to connect to other Large Language Models (LLMs), such as those on HuggingFace. Additional API keys may be required.

Installation

Binaries (Linux, Windows 10 and 11)

You can download compiled binary versions for Linux and Windows (10/11).

PyGPT binaries require a PC with Windows 10, 11, or Linux. Simply download the installer or the archive with the appropriate version from the download page at https://pygpt.net, extract it, or install it, and then run the application. A binary version for Mac is not available, so you must run PyGPT from PyPi or from the source code on Mac. Currently, only 64-bit binaries are available.

Linux version requires GLIBC >= 2.35.

Microsoft Store (Windows)

For Windows 10/11, you can install PyGPT directly from Microsoft Store:

Link to MS Store: https://apps.microsoft.com/detail/XP99R4MX3X65VQ

AppImage (Linux)

You can download the latest PyGPT AppImage for Linux from the release page:

Releases: https://github.com/szczyglis-dev/py-gpt/releases

Tip: Remember to give execution permissions to the downloaded file:

```chmod +x ./PyGPT-X.X.X-x86_64.AppImage

To manage future updates you can use AppImageUpdate tool:

You can download it from: https://github.com/AppImage/AppImageUpdate/releases
After downloading, run the following command in terminal:

appimageupdatetool ./PyGPT-X.X.X-x86_64.AppImage

Snap Store (Linux)

You can install PyGPT directly from Snap Store:

commandline sudo snap install pygpt

To manage future updates use:

commandline sudo snap refresh pygpt

Using camera: to use camera in Snap version you must connect the camera with:

commandline sudo snap connect pygpt:camera

Using microphone: to use microphone in Snap version you must connect the microphone with:

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

Using audio output: to use audio output in Snap version you must connect the audio with:

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

Connecting the Docker sandbox in the Snap version:

To use Docker-backed plugin sandboxes in the Snap version, you must connect PyGPT to the Docker daemon:

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

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

PyPi (pip)

The application can also be installed from PyPi using pip install:
1. Create virtual environment:

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

2. Install from PyPi:

commandline pip install pygpt-net

3. Once installed run the command to start the application:

commandline pygpt

Running from GitHub source code

An alternative method is to download the source code from GitHub and execute the application using the Python interpreter (>=3.10, <3.14).
Install with pip
1. Clone git repository or download .zip file:

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

2. Create a new virtual environment:

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

3. Install requirements:

commandline pip install -r requirements.txt

4. Run the application:

commandline python3 run.py

Install with Poetry

1. Clone git repository or download .zip file:

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

2. Install Poetry (if not installed):

commandline pip install poetry

3. Create a new virtual environment that uses Python 3.10:

commandline poetry env use python3.10 poetry shell

or (Poetry >= 2.0):

commandline poetry env use python3.10 poetry env activate

4. Install requirements:

commandline poetry install

5. Run the application:

commandline poetry run python3 run.py

Tip: you can use PyInstaller to create a compiled version of
the application for your system (required version 6.4.0).

Troubleshooting
If you have a problems with xcb plugin with newer versions of PySide on Linux, e.g. like this:

commandline qt.qpa.plugin: Could not load the Qt platform plugin "xcb" in "" even though it was found. This application failed to start because no Qt platform plugin could be initialized. Reinstalling the application may fix this problem.

...then install libxcb:

commandline sudo apt install libxcb-cursor0

If you have a problems with audio on Linux, then try to install portaudio19-dev and/or libasound2:

commandline sudo apt install portaudio19-dev

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

Problems with GLIBC on Linux

If you encounter error:

commandline 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)

when trying to run the compiled version for Linux, try updating GLIBC to version 2.35, or use a newer operating system that has at least version 2.35 of GLIBC.

Access to camera in Snap version:

commandline sudo snap connect pygpt:camera

Access to microphone in Snap version:

To use microphone in Snap version you must connect the microphone with:

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

Snap and AppArmor permission denied

Snap installs AppArmor profiles for each application by default. The profile for PyGPT is created at:
/var/lib/snapd/apparmor/profiles/snap.pygpt.pygpt
The application should work with the default profile; however, if you encounter errors like:
PermissionError: [Errno 13] Permission denied: '/etc/httpd/conf/mime.types'
add the appropriate access rules to the profile file, for example:

/var/lib/snapd/apparmor/profiles/snap.pygpt.pygpt

...

/etc/httpd/conf/mime.types r

and reload the profiles.

Alternatively, you can try removing snap and reinstalling it:
sudo snap remove --purge pygpt
sudo snap install pygpt
Access to a microphone and audio in Windows version:
If you have a problems with audio or a microphone in the non-binary PIP/Python version on Windows, check to see if FFmpeg is installed. If it's not, install it and add it to the PATH. You can find a tutorial on how to do this here: https://phoenixnap.com/kb/ffmpeg-windows. The binary version already includes FFmpeg.
Windows and VC++ Redistributable
On Windows, the proper functioning requires the installation of the VC++ Redistributable, which can be found on the Microsoft website:
https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist
The libraries from this environment are used by PySide6 - one of the base packages used by PyGPT. 
The absence of the installed libraries may cause display errors or completely prevent the application from running.
It may also be necessary to add the path C:\path\to\venv\Lib\python3.x\site-packages\PySide6 to the PATH variable.
WebEngine/Chromium renderer and OpenGL problems
If you have a problems with WebEngine / Chromium renderer you can force the legacy mode by launching the app with command line arguments:

ini python3 run.py --legacy=1

and to force disable OpenGL hardware acceleration:

ini python3 run.py --disable-gpu=1

You can also manualy enable legacy mode by editing config file - open the %WORKDIR%/config.json config file in editor and set the following options:

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

Other requirements

For API-based models, an internet connection and the appropriate provider API key are required. Models from OpenAI, Google, Anthropic, and xAI require API keys for their respective providers. Local models, such as those served through Ollama, do not require external API keys.

Troubleshooting and diagnostics

See Debugging and Logging for logging and diagnostic options.

Quick Start

Setting-up API Key(s)

You can configure API keys for various providers, such as OpenAI, Anthropic, Google, xAI, Perplexity, OpenRouter, and more. This flexibility allows you to use different providers based on your needs.

During the initial setup, configure your API keys within the application.

To do so, navigate to the menu:

Config -> Settings -> API Keys

Here, you can add or manage API keys for any supported provider.

Configuring Provider

1. Select the Provider: Choose a tab with provider. 2. Enter the API Key: Paste the corresponding API key for the selected provider.

Example

• OpenAI: Obtain your API key by registering on the OpenAI website: https://platform.openai.com and navigating to https://platform.openai.com/account/api-keys.
• Anthropic, Google, etc.: Follow similar steps on their respective platforms.

Note: The ability to use models or services depends on your access level with the respective provider. If you wish to use custom API endpoints or local APIs that do not require API keys, simply enter any value into the API key field to bypass prompts about an empty key.

Work modes

Chat

+ Inline vision and image generation

In PyGPT, this mode lets you chat with models such as GPT-6 Astra, GPT-5.6, GPT-4, o1, o3, Claude, Gemini, Grok, Perplexity (Sonar), DeepSeek, and many others. PyGPT can use native SDKs from supported providers, including OpenAI, Google, Anthropic, and xAI, when enabled. It can also connect to providers and local services through OpenAI-compatible APIs, including Responses API and ChatCompletions API compatible endpoints where supported.

Tip: This mode uses the provider SDK directly. If there's no native client built into the app, models like Sonar or local Ollama models such as Qwen 3.6 and Gemma 4 are supported in Chat mode via LlamaIndex or OpenAI-compatible API endpoints. The app automatically switches to these endpoints when using non-OpenAI models. You can enable or disable the use of the native API SDK (per provider) in Settings -> API Keys. If the native SDK is disabled, the OpenAI SDK will be used via the compatible ChatCompletions API endpoint.

Currently built-in native clients:

• Anthropic SDK
• OpenAI SDK
• Google GenAI SDK
• xAI SDK

Local Ollama models and models from other configured providers are also supported.

The main part of the interface is a chat window where you see your conversations. Below it is a message box for typing. On the right side, you can set up or change the model and system prompt. You can also save these settings as presets to easily switch between models or tasks.

Above where you type your messages, the interface shows you the number of tokens your message will use up as you type it – this helps to keep track of usage. There is also a feature to attach and upload files in this area. Go to the Files and Attachments section for more information on how to use attachments.

Vision: If you want to analyze photos from disk, screenshots, or camera captures and the currently selected model cannot accept image input, enable the Vision (inline) plugin in the Plugins menu. The plugin uses a separately configured image-capable Chat model only for the image-analysis turn. The fallback model can come from any supported provider (for example OpenAI, Google, Anthropic, xAI, OpenRouter, or another OpenAI-compatible provider), as long as the model is configured for Chat and image input.

With this plugin, you can capture an image with your camera or attach an image and send it for analysis. Camera controls are available from the main Audio / Video menu under the Video section. Use Enable camera to start the live preview. Enable Auto capture to automatically capture the current frame for compatible vision turns; with auto capture disabled, click the live camera preview to take a manual snapshot. Camera device, resolution, and JPEG quality are configured in Settings -> Vision and camera -> Camera:

Image generation: If you want to generate images directly in chat, enable the Image generation (inline) plugin in the Plugins menu. The plugin allows you to generate images in Chat mode.

For supported models/providers, you can alternatively enable the provider-side image-generation remote tool in Config -> Settings -> Remote Tools. When available, this lets the model generate images natively without the inline plugin.

Chat with Files (LlamaIndex)

This mode enables chat interaction with your documents and entire context history through conversation. It seamlessly incorporates LlamaIndex into the chat interface, allowing for immediate querying of your indexed documents.

Tip: If you do not want to call tools/commands, disable the Tools switch. It will speed up the response time when using local models. When tools are enabled, PyGPT prefers native tool calls whenever the current model/provider supports them. If native tool calls are unavailable, Chat with Files automatically falls back to a LlamaIndex ReAct agent. The ReAct fallback is non-streaming, so stream mode is disabled automatically only on that path; there is no separate ReAct setting.

Querying single files

You can also query individual files "on the fly" using the query_file command from the Files I/O plugin. This allows you to query any file by simply asking a question about that file. A temporary index will be created in memory for the file being queried, and an answer will be returned from it. A similar command is available for querying web and external content: Directly query web content with LlamaIndex.

For example:

If you have a file: data/my_cars.txt with content My car is red.

You can ask for: Query the file my_cars.txt about what color my car is.

And you will receive the response: Red.

Note: this command indexes the file only for the current query and does not persist it in the database. To store queried files also in the standard index you must enable the option Auto-index readed files in plugin settings. Remember to enable the Tools switch to allow the use of tools and commands from plugins.

Using Chat with Files mode

In this mode, you are querying the whole index, stored in a vector store database. To start, you need to index (embed) the files you want to use as additional context. Embedding transforms your text data into vectors. If you're unfamiliar with embeddings and how they work, check out this article:

https://stackoverflow.blog/2023/11/09/an-intuitive-introduction-to-text-embeddings/

For a visualization from OpenAI's page, see this picture:

Source: https://cdn.openai.com/new-and-improved-embedding-model/draft-20221214a/vectors-3.svg

To index your files, copy or upload them into the active data directory and initiate indexing (embedding) by clicking the Index all button, or right-click on a file and select Embed into index. Normally this is /data; if the current conversation belongs to a project with a custom data workdir, the project directory is used instead. Additionally, you have the option to utilize data from indexed files in any Chat mode by activating the RAG (inline) plugin.

After the file(s) are indexed (embedded in vector store), you can use context from them in chat mode.

Built-in file loaders:

Files:

• CSV files (csv)
• Epub files (epub)
• Excel .xlsx spreadsheets (xlsx)
• HTML files (html, htm)
• IPYNB Notebook files (ipynb)
• Image (vision) (jpg, jpeg, png, gif, bmp, tiff, webp)
• JSON files (json)
• Markdown files (md)
• PDF documents (pdf)
• Plain-text files (txt)
• Video/audio (mp4, avi, mov, mkv, webm, mp3, mpeg, mpga, m4a, wav)
• Word .docx documents (docx)
• XML files (xml)

Web/external content:

• Bitbucket
• ChatGPT Retrieval Plugin
• GitHub Issues
• GitHub Repository
• Google Calendar
• Google Docs
• Google Drive
• Google Gmail
• Google Keep
• Google Sheets
• Microsoft OneDrive
• RSS
• SQL Database
• Sitemap (XML)
• Twitter/X posts
• Webpages (crawling any webpage content)
• YouTube (transcriptions