GPT-Code UI

Translates natural language task descriptions into executable Python code by sending user prompts to OpenAI's API (GPT-3.5/GPT-4) with conversation history prepended for context. The system uses prompt engineering to structure requests and extracts generated code from API responses for display and execution. Supports model switching between different OpenAI model versions.

Executes generated Python code in a dedicated IPython kernel managed by a separate process, providing isolation from the web server and preventing code execution from crashing the Flask application. The kernel manager handles code submission, output capture, and error handling through a managed subprocess architecture.

Packages GPT-Code-UI as a Python package installable via pip with a command-line entry point 'gptcode' that launches the entire system (Flask API, kernel manager, and web interface) with a single command. The setup.py defines dependencies and configuration for easy installation and deployment.

Provides Docker configuration for containerized deployment of GPT-Code-UI, enabling consistent environments across development and production. The Docker setup encapsulates all dependencies and configuration, allowing deployment without manual environment setup.

Manages system configuration through environment variables (OPENAI_API_KEY, API_PORT, WEB_PORT, SNAKEMQ_PORT, OPENAI_BASE_URL) that can be set directly or via a .env file. This approach enables flexible deployment across different environments without code changes.

Displays the full conversation history in the React UI showing user prompts, generated code, execution results, and explanations in a chronological chat-like format. Users can scroll through history, reference previous interactions, and the system maintains this history for context in subsequent code generation requests.

Maintains conversation history across multiple user interactions by prepending previous prompts and responses to new API requests, enabling the LLM to generate code that references earlier context. The system stores conversation state in memory and includes it in subsequent OpenAI API calls to preserve context continuity.

Enables users to upload files through the web interface which are stored in a managed directory and made available to generated Python code for processing. The system handles file storage, path management, and cleanup, allowing generated code to read and manipulate uploaded files within the execution environment.

Allows users to download files created or modified by executed code through the web interface. The system exposes generated files for download by serving them through Flask endpoints, enabling users to retrieve analysis results, visualizations, or transformed data.

Allows users to select and switch between different OpenAI models (GPT-3.5-turbo, GPT-4, etc.) through the UI settings, with the selected model used for all subsequent code generation requests. The system stores the model selection in session state and passes it to OpenAI API calls.

Supports configuration of custom OpenAI API endpoints through the OPENAI_BASE_URL environment variable, enabling integration with Azure OpenAI, self-hosted OpenAI-compatible servers, or proxy services. The system passes the custom endpoint to all OpenAI API calls.

Provides a React-based web interface with a chat-like UI for interacting with the code generation and execution system. The frontend handles user input, displays conversation history, manages file uploads, and shows code execution results through a responsive web application served on a configurable port.

Implements a Flask web application serving REST API endpoints that handle user requests, manage sessions, and communicate asynchronously with the isolated IPython kernel via SnakeMQ message queue. The backend orchestrates code generation, execution, and result retrieval without blocking on long-running operations.

Implements inter-process communication between the Flask API server and the isolated IPython kernel manager using SnakeMQ message queue. Messages are exchanged asynchronously to submit code for execution, retrieve results, and handle errors without blocking either process.