py-gpt

Abstracts 10+ AI providers (OpenAI, Anthropic, Google, Ollama, DeepSeek, Perplexity, Grok, Bielik) through a unified Chat mode interface that normalizes request/response formats across different SDK implementations. Uses a provider-agnostic message routing layer that maps provider-specific APIs (openai.ChatCompletion, anthropic.Anthropic, etc.) to a common internal message schema, enabling seamless model switching without code changes.

Implements a 'Chat with Files' mode that uses LlamaIndex to parse, chunk, and embed documents (PDF, DOCX, TXT, etc.) into a vector store, then retrieves relevant context for each user query before passing to the LLM. Uses a retrieval-augmented generation pipeline where document embeddings are indexed locally or in a vector database, and a retriever component fetches top-k similar chunks based on semantic similarity to the user query.

Implements a preset system that allows users to save and load configurations for prompts, system messages, model parameters, and mode-specific settings. Presets are stored as JSON files in the application's config directory and can be quickly switched to apply a consistent set of parameters across conversations. Assistants are a specialized preset type that include additional metadata (name, description, avatar) and can be shared or exported. The system handles preset versioning, import/export, and conflict resolution when loading presets.

Implements a localization system that translates the entire UI (menus, buttons, dialogs, help text) into multiple languages using JSON-based translation files. The system detects the user's system language and loads the appropriate translation file at startup; users can manually override the language in settings. Translations are applied dynamically to all UI elements without requiring application restart. Supports pluralization, context-specific translations, and fallback to English if a translation is missing.

Manages conversation history by storing messages in a structured format and intelligently selecting which messages to include in the LLM context window. Uses a sliding window approach (keep recent N messages) or summarization-based approach (summarize old messages and include summary) to stay within provider token limits. Handles message serialization, persistence to disk, and retrieval for multi-turn conversations. Supports conversation export (JSON, Markdown) and import for backup/sharing.

Provides a theming system that allows users to customize the application's appearance through CSS-like stylesheets (QSS - Qt Style Sheets). Includes built-in light and dark themes, and users can create custom themes by editing QSS files. The system handles theme persistence, dynamic theme switching without restart, and font/color customization. Uses PySide6's native styling engine for consistent cross-platform appearance.

Manages model configurations and API credentials through a centralized settings system. Stores provider API keys securely (encrypted at rest if possible), allows users to configure model parameters (temperature, max_tokens, top_p, etc.) per provider, and maintains a registry of available models per provider. Supports model discovery (fetching available models from provider APIs) and validation of credentials before use. Configuration is stored in JSON files with sensitive data optionally encrypted.

Implements a modular mode system where each operational mode (Chat, Chat with Files, Audio, Research, Completion, Image Generation, Assistants, Agents, Experts, Computer Use) encapsulates a distinct LLM workflow pattern. Each mode is a separate class (pygpt_net.core.modes.*) that defines its own message handling, context management, and provider integration, allowing users to switch between fundamentally different interaction patterns (e.g., from chat to agentic reasoning to image generation) within the same application.

Wraps the OpenAI Assistants API (pygpt_net.core.modes.assistant.Assistant) to enable stateful, multi-turn conversations with persistent thread management. Handles assistant creation, thread lifecycle (create, retrieve, update), message history, and run execution with automatic polling for completion. Supports file uploads, code interpreter, and retrieval augmentation through the Assistants API native features.

Implements two agent modes: Agent (LlamaIndex) uses LlamaIndex's agent framework to decompose tasks into tool-calling steps with automatic planning and execution, while Experts mode coordinates multiple specialized agents (each with different system prompts and tool sets) to solve complex problems through expert consensus or delegation. Both modes use LlamaIndex's ReActAgent or similar patterns to generate reasoning chains and tool calls, with support for custom tool registration and execution.

Implements a Realtime+Audio mode that handles bidirectional audio streaming using OpenAI's Realtime API or Google's speech services. Captures audio input via system microphone, streams to the provider's speech-to-text engine, passes transcribed text to the LLM, and streams the response back through text-to-speech synthesis with audio playback. Uses asynchronous I/O to manage concurrent audio capture, transcription, LLM inference, and synthesis without blocking the UI.

Implements a Research mode that augments LLM responses with real-time web search results from Perplexity API or OpenAI's web search capability. Before generating a response, the mode queries a search provider for current information, retrieves top results, and passes them as context to the LLM, enabling responses grounded in recent web data. Handles search query formulation, result ranking, and context injection into the LLM prompt.

Implements an Image Generation mode that supports multiple generative providers (OpenAI DALL-E, Google Imagen, Sora for video) through a unified interface. Accepts text prompts and optional image parameters (size, quality, style), routes requests to the selected provider's API, and returns generated images or videos. Handles image encoding, caching, and local storage of generated assets.

Implements a Computer Use mode that leverages Anthropic's computer use capability to enable the AI to autonomously control the desktop (take screenshots, click, type, scroll). The mode captures the current screen state, passes it to Claude with computer use instructions, receives action sequences (click coordinates, text input, etc.), and executes them on the user's desktop. Maintains a loop of perception (screenshot) → reasoning (Claude) → action (execute) until the task is complete.

Implements a plugin architecture (pygpt_net.core.plugins) that allows users to extend py-gpt with custom tools, modes, and integrations without modifying core code. Plugins are Python modules that register themselves with the plugin manager, exposing tool definitions (function signatures, descriptions) or custom modes (classes inheriting from Mode base class). The plugin system handles plugin discovery, loading, validation, and lifecycle management (enable/disable/uninstall).