gipity-py 0.1.0

Gipity

Features · Demo · Modes · Architecture · Structure · Install · LLM · Running · Keys · Workflows · Data · Requirements ·

Gipity is a Streamlit application for multimodal AI workflows centered on OpenAI GPT models, OpenAI platform services, local document retrieval, vector search, prompt engineering, and local SQLite-backed data management. It provides a single workspace for text generation, image generation and vision, audio transcription and speech generation, embeddings, document-grounded question answering, OpenAI Files, OpenAI Vector Stores, prompt templates, export workflows, and structured local data operations.

🎥 Demo

☁️ Cloud

Gipity combines:

• Cloud-hosted OpenAI workflows for text, images, audio, embeddings, files, and vector stores.
• Local document ingestion and retrieval for Document Q&A.
• SQLite and sqlite-vec infrastructure for local persistence and vector search.
• Sentence-transformers support for semantic retrieval workflows.
• Prompt engineering tools backed by local prompt-template storage.
• Data export and local data-management utilities for operational workflows.

Custom LLM

Gipity uses a local LLM available on Hugging Face based on OpenAI's ChatGPT 5.x

• Fine-tuned
• Post-trained

📥 Local Model Setup

The README and configuration reference a local GGUF fallback model path. Place the GGUF model file under the project models directory when local fallback support is enabled.

models/gipity-3-270m-it-Q4_K_M.gguf

✨ Key Features

🧭 Application Modes

The attached app.py exposes the following Streamlit modes.

🏛️ Architecture

Streamlit UI
    │
    ├── Text / Images / Audio ───────────────► OpenAI platform wrappers in gpt.py
    │
    ├── Document Q&A ────────────────────────► Local files, OpenAI Files, or Vector Stores
    │                                            │
    │                                            ├── PyMuPDF / text extraction
    │                                            ├── sentence-transformers
    │                                            ├── sqlite-vec
    │                                            └── OpenAI file_search
    │
    ├── Embeddings ──────────────────────────► OpenAI Embeddings API + token-aware chunking
    │
    ├── Files / Vector Stores ───────────────► OpenAI Files API and Vector Stores API
    │
    ├── Prompt Engineering ──────────────────► SQLite prompt template table
    │
    └── Data Management / Export ────────────► SQLite, pandas, ReportLab, Streamlit outputs

🗂 Repository Structure

Gipity/
├─ app.py                         # Main Streamlit application
├─ config.py                      # Application configuration, model lists, paths, constants
├─ gpt.py                         # OpenAI wrappers: Chat, Images, Embeddings, Audio, Files, Vector Stores
├─ requirements.txt               # Python dependencies
├─ models/
│  └─ gipity-3-270m-it-Q4_K_M.gguf # Optional local fallback model path
├─ resources/
│  ├─ images/
│  │  ├─ favicon.ico
│  │  ├─ gipity_logo.png
│  │  └─ gpt.png
│  └─ audio/
│     └─ conditions.mp3           # Audio API test asset
├─ stores/
│  └─ sqlite/
│     └─ gipity.db                # Local SQLite database
└─ README.md

🚀 Installation & Setup

1️⃣ Clone the Repository

git clone https://github.com/is-leeroy-jenkins/Gipity.git
cd Gipity

2️⃣ Create and Activate a Virtual Environment

Windows PowerShell

python -m venv .venv
.venv\Scripts\Activate.ps1

Linux / macOS

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

3️⃣ Install Dependencies

python -m pip install --upgrade pip
python -m pip install -r requirements.txt

▶️ Running Gipity

Run Streamlit through Python so the active virtual environment is used.

python -m streamlit run app.py

The application starts with a collapsed sidebar and a wide layout. Select the active workflow from AI Mode in the sidebar.

🔑 API KEY SETUP

Data Services

🔑 Environment Variables

At minimum, Gipity supports the following environment variables and configuration values.

Example: OpenAI API Key

Windows PowerShell

$env:OPENAI_API_KEY="your_api_key_here"

Linux / macOS

export OPENAI_API_KEY="your_api_key_here"

🧩 Mode Details

Text

Text mode is the primary GPT workflow. It supports model selection, response formatting, structured JSON schema output, conversation IDs, previous response IDs, tool selection, include fields, vector store IDs for file search, and configurable generation parameters.

Images

Images mode supports generation, editing, and analysis. It exposes model, analysis model, output size, quality, MIME type, background, detail, and compression controls. It can render bytes, URLs, or markdown-style image outputs.

Audio

Audio mode supports transcription, translation, and text-to-speech. It manages audio task selection, model selection, language, voice, rate/speed, uploaded audio files, generated output bytes, and response metadata.

Document Q&A

Document Q&A supports three source paths:

Supported local document extraction includes PDF, DOCX, TXT, Markdown, CSV, JSON, XML, Python, C#, SQL, YAML, HTML, CSS, JavaScript, and TypeScript-style text files.

Embeddings

Embeddings mode normalizes text, performs token-aware chunking, calls the OpenAI Embeddings API, and displays metrics and embedding vectors. It supports float and base64 encoding formats and model-specific dimension limits.

Files

Files mode supports OpenAI Files API operations:

Vector Stores

Vector Stores mode supports OpenAI vector store lifecycle and retrieval workflows:

Prompt Engineering

Prompt Engineering mode stores prompt templates in SQLite and supports search, sorting, editing, versioning, and cascade into mode-specific system instructions.

Data Export

Data Export mode supports export-oriented application workflows for generated outputs and stored content.

📄 Document and Retrieval Workflows

Gipity includes local and cloud-backed retrieval paths. Local retrieval extracts text, creates chunks, and ranks chunks against a user query. Cloud-backed retrieval can use OpenAI Files and OpenAI Vector Stores for file search. This allows Gipity to support both lightweight local document analysis and OpenAI-managed retrieval backends.

🗄️ Data Management

Gipity uses SQLite for local persistence. The application initializes and uses local database paths from config.py, stores prompt templates, tracks chat history, and supports local data workflows through the Data Management mode.

📦 Requirements

The table below reflects the active imports and runtime features used by the attached app.py. Version pins should follow the repository requirements.txt when present.

🔒 Privacy and Deployment Notes

🧪 Local Inference Notes

The local GGUF fallback is a practical companion path for offline or lower-cost text workflows, but OpenAI-backed workflows remain the primary path for multimodal capabilities, Files API operations, Vector Stores, audio processing, and managed embeddings.

📜 License

Gipity is published under the MIT license for open-source use:

🙌 Acknowledgements

• OpenAI
• Hugging Face
• llama.cpp and llama-cpp-python
• Streamlit
• sentence-transformers
• sqlite-vec
• The broader open-source Python and machine-learning tooling ecosystem