init

.gitignore

@@ -0,0 +1,161 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+*.stackdump
+[Dd]esktop.ini
+$RECYCLE.BIN/
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+*.lnk
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Logs
+*.log
+logs/
+
+# Local config files
+config/local_*

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,157 @@
+# 🚀 Hugging Face Spaces Deployment Guide
+
+This guide will walk you through deploying your OpenAI PDF Chatbot to Hugging Face Spaces.
+
+## Prerequisites
+
+- A Hugging Face account (sign up at https://huggingface.co)
+- An OpenAI API key
+- Git installed on your system
+
+## Step 1: Create a New Space
+
+1. Go to https://huggingface.co/new-space
+2. Fill in the details:
+   - **Space name**: `openai-pdf-chatbot` (or your preferred name)
+   - **License**: MIT
+   - **SDK**: Select "Gradio"
+   - **Hardware**: CPU Basic (free tier) is sufficient
+   - **Visibility**: Public or Private (your choice)
+3. Click "Create Space"
+
+## Step 2: Clone Your Space Repository
+
+After creating the space, you'll see a Git repository URL. Clone it:
+
+```bash
+git clone https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+cd YOUR_SPACE_NAME
+```
+
+## Step 3: Copy Your Application Files
+
+Copy all the files from your `openai_chatbot` directory to the cloned space repository:
+
+```bash
+# From your openai_chatbot directory
+cp -r * /path/to/your/cloned/space/
+```
+
+Make sure these files are in the root of your space repository:
+- `app.py` (main entry point)
+- `requirements.txt`
+- `README_SPACES.md` (rename this to `README.md`)
+- `backend/` directory
+- `frontend/` directory
+- `config/` directory
+
+## Step 4: Rename README File
+
+```bash
+mv README_SPACES.md README.md
+```
+
+## Step 5: Set Up Your OpenAI API Key
+
+1. Go to your Space on Hugging Face
+2. Click on "Settings" tab
+3. Scroll down to "Variables and secrets"
+4. Click "Add a new secret"
+5. Set:
+   - **Name**: `OPENAI_API_KEY`
+   - **Value**: Your OpenAI API key
+6. Click "Add secret"
+
+## Step 6: Commit and Push Your Code
+
+```bash
+git add .
+git commit -m "Initial deployment of OpenAI PDF Chatbot"
+git push origin main
+```
+
+## Step 7: Wait for Deployment
+
+- Hugging Face Spaces will automatically build and deploy your app
+- You can monitor the build process in the "App" tab of your Space
+- The build typically takes 2-5 minutes
+
+## Step 8: Test Your Deployment
+
+Once deployed, your app will be available at:
+`https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME`
+
+Test the following features:
+- Model selection dropdown
+- Document querying toggle
+- Custom prompt input
+- Token usage and cost tracking
+
+## Troubleshooting
+
+### Common Issues:
+
+1. **"No module named 'openai'" error**
+   - Check that `requirements.txt` includes `openai>=1.0.0`
+   - Verify the file is in the root directory
+
+2. **"No assistant configured" error**
+   - Make sure `config/openai_config.json` is included
+   - Verify the assistant_id in the config file
+
+3. **API key not found**
+   - Double-check the secret name is exactly `OPENAI_API_KEY`
+   - Restart the space after adding the secret
+
+4. **Build timeout**
+   - Reduce the requirements.txt dependencies
+   - Check for any large files that might be causing issues
+
+### Debug Steps:
+
+1. Check the "Logs" tab in your Space for error messages
+2. Verify all required files are present in the repository
+3. Check that your OpenAI API key has sufficient credits
+
+## Post-Deployment
+
+### Customize Your Space:
+- Edit the `README.md` to add your own description
+- Update the emoji and colors in the YAML frontmatter
+- Add screenshots or demo videos
+
+### Monitor Usage:
+- Check the "Analytics" tab for usage statistics
+- Monitor your OpenAI API usage through the OpenAI dashboard
+
+### Updates:
+- To update your app, simply push new commits to the repository
+- The Space will automatically rebuild and redeploy
+
+## File Structure for Deployment
+
+Your space repository should look like this:
+
+```
+your-space/
+├── app.py                    # Main entry point
+├── requirements.txt          # Python dependencies
+├── README.md                # Space description (from README_SPACES.md)
+├── backend/
+│   └── chatbot_backend.py   # Backend logic
+├── frontend/
+│   └── gradio_app.py        # Gradio UI
+└── config/
+    └── openai_config.json   # OpenAI configuration
+```
+
+## Success!
+
+If everything is set up correctly, you should have a working OpenAI PDF Chatbot deployed on Hugging Face Spaces with:
+- ✅ Model selection with pricing information
+- ✅ Real-time token tracking and cost calculation
+- ✅ Document querying capabilities
+- ✅ Custom prompt support
+- ✅ Clean, responsive UI
+
+Share your Space URL with others to let them interact with your chatbot!

app.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Spaces App Entry Point
+"""
+
+import sys
+from pathlib import Path
+
+# Add current directory to path
+sys.path.append(str(Path(__file__).parent))
+
+# Import and run the existing Gradio app
+from frontend.gradio_app import main
+
+if __name__ == "__main__":
+    main()

backend/chatbot_backend.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""
+OpenAI Chatbot Backend with Model Switching and Token Tracking
+"""
+
+import os
+import json
+import time
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Tuple
+from openai import OpenAI
+import tiktoken
+
+class ChatbotBackend:
+    """Backend for OpenAI chatbot with vector store integration."""
+    
+    # Model configurations with pricing (per 1M tokens)
+    MODEL_CONFIGS = {
+        "gpt-4.1-2025-04-14": {
+            "name": "GPT-4.1 (Latest)",
+            "model_id": "gpt-4.1-2025-04-14",
+            "input_cost": 2.0,  # $2 per 1M input tokens
+            "output_cost": 8.0,  # $8 per 1M output tokens
+            "context_window": 32768,
+            "supports_file_search": True
+        },
+        "gpt-4.1-mini-2025-04-14": {
+            "name": "GPT-4.1 Mini",
+            "model_id": "gpt-4.1-mini-2025-04-14",
+            "input_cost": 0.4,  # $0.4 per 1M input tokens
+            "output_cost": 1.6,  # $1.6 per 1M output tokens
+            "context_window": 16384,
+            "supports_file_search": True
+        },
+        "gpt-4.1-nano-2025-04-14": {
+            "name": "GPT-4.1 Nano",
+            "model_id": "gpt-4.1-nano-2025-04-14",
+            "input_cost": 0.1,  # $0.1 per 1M input tokens
+            "output_cost": 0.4,  # $0.4 per 1M output tokens
+            "context_window": 8192,
+            "supports_file_search": True
+        },
+        "o4-mini-2025-04-16": {
+            "name": "O4 Mini",
+            "model_id": "o4-mini-2025-04-16",
+            "input_cost": 1.1,  # $1.1 per 1M input tokens
+            "output_cost": 4.4,  # $4.4 per 1M output tokens
+            "context_window": 16384,
+            "supports_file_search": True
+        }
+    }
+    
+    def __init__(self, config_path: str = None):
+        """Initialize the chatbot backend."""
+        self.client = OpenAI()
+        
+        # Try to find config file
+        if config_path is None:
+            # Look for config in standard locations
+            possible_paths = [
+                Path(__file__).parent.parent / "config" / "openai_config.json",
+                Path(__file__).parent / "openai_config.json",
+                Path("config/openai_config.json"),
+                Path("openai_config.json")
+            ]
+            
+            for path in possible_paths:
+                if path.exists():
+                    config_path = str(path)
+                    break
+        
+        self.config = self._load_config(config_path) if config_path else None
+        self.assistant_id = self.config.get('assistant_id') if self.config else None
+        self.current_model = "gpt-4.1-mini-2025-04-14"  # Default model
+        
+    def _load_config(self, config_path: str) -> Optional[Dict[str, Any]]:
+        """Load the configuration file."""
+        config_file = Path(config_path)
+        
+        if not config_file.exists():
+            print(f"Warning: Configuration file {config_file} not found")
+            return None
+        
+        try:
+            with open(config_file, 'r') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Error loading config file: {str(e)}")
+            return None
+    
+    def set_model(self, model_id: str) -> bool:
+        """Set the current model."""
+        if model_id in self.MODEL_CONFIGS:
+            self.current_model = model_id
+            return True
+        return False
+    
+    def get_available_models(self) -> Dict[str, Dict[str, Any]]:
+        """Get available models and their configurations."""
+        return self.MODEL_CONFIGS
+    
+    def count_tokens(self, text: str, model: str = None) -> int:
+        """Count tokens in text for the specified model."""
+        if model is None:
+            model = self.current_model
+        
+        try:
+            # Map model names to encoding names
+            encoding_map = {
+                "gpt-4.1-2025-04-14": "cl100k_base",
+                "gpt-4.1-mini-2025-04-14": "cl100k_base",
+                "gpt-4.1-nano-2025-04-14": "cl100k_base",
+                "o4-mini-2025-04-16": "cl100k_base"
+            }
+            
+            encoding_name = encoding_map.get(model, "cl100k_base")
+            encoding = tiktoken.get_encoding(encoding_name)
+            return len(encoding.encode(text))
+        except Exception:
+            # Fallback: rough estimate (1 token ≈ 4 characters)
+            return len(text) // 4
+    
+    def calculate_cost(self, input_tokens: int, output_tokens: int, model: str = None) -> Dict[str, float]:
+        """Calculate the cost for the given token counts."""
+        if model is None:
+            model = self.current_model
+        
+        config = self.MODEL_CONFIGS.get(model, self.MODEL_CONFIGS["gpt-4.1-mini-2025-04-14"])
+        
+        input_cost = (input_tokens / 1_000_000) * config["input_cost"]
+        output_cost = (output_tokens / 1_000_000) * config["output_cost"]
+        total_cost = input_cost + output_cost
+        
+        return {
+            "input_cost": input_cost,
+            "output_cost": output_cost,
+            "total_cost": total_cost,
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens
+        }
+    
+    def query_with_documents(self, question: str, custom_prompt: str = None) -> Tuple[str, Dict[str, Any]]:
+        """Query using the vector store documents."""
+        if not self.assistant_id:
+            return "Error: No assistant configured. Please upload documents first.", {}
+        
+        try:
+            start_time = time.time()
+            
+            # Create a thread
+            thread = self.client.beta.threads.create()
+            
+            # Prepare the message content
+            if custom_prompt:
+                content = f"{custom_prompt}\n\nUser Question: {question}"
+            else:
+                content = question
+            
+            # Count input tokens
+            input_tokens = self.count_tokens(content)
+            
+            # Add the question to the thread
+            self.client.beta.threads.messages.create(
+                thread_id=thread.id,
+                role="user",
+                content=content
+            )
+            
+            # Run the assistant with the specified model
+            run = self.client.beta.threads.runs.create(
+                thread_id=thread.id,
+                assistant_id=self.assistant_id,
+                model=self.current_model
+            )
+            
+            # Wait for completion
+            while True:
+                run_status = self.client.beta.threads.runs.retrieve(
+                    thread_id=thread.id,
+                    run_id=run.id
+                )
+                
+                if run_status.status == 'completed':
+                    break
+                elif run_status.status in ['failed', 'cancelled', 'expired']:
+                    return f"Error: Assistant run {run_status.status}", {}
+                
+                time.sleep(0.5)
+            
+            # Get the response
+            messages = self.client.beta.threads.messages.list(
+                thread_id=thread.id,
+                order="desc",
+                limit=1
+            )
+            
+            if messages.data:
+                response = messages.data[0].content[0].text.value
+                output_tokens = self.count_tokens(response)
+                
+                # Calculate costs
+                cost_info = self.calculate_cost(input_tokens, output_tokens)
+                cost_info["duration"] = time.time() - start_time
+                cost_info["model"] = self.current_model
+                
+                return response, cost_info
+            else:
+                return "Error: No response received", {}
+                
+        except Exception as e:
+            return f"Error: {str(e)}", {}
+    
+    def query_without_documents(self, question: str, custom_prompt: str = None) -> Tuple[str, Dict[str, Any]]:
+        """Query without using documents."""
+        try:
+            start_time = time.time()
+            
+            # Prepare messages
+            messages = []
+            
+            if custom_prompt:
+                messages.append({
+                    "role": "system",
+                    "content": custom_prompt
+                })
+            else:
+                messages.append({
+                    "role": "system",
+                    "content": "You are a helpful assistant. Answer questions based on your training knowledge."
+                })
+            
+            messages.append({
+                "role": "user",
+                "content": question
+            })
+            
+            # Count input tokens
+            input_text = " ".join([msg["content"] for msg in messages])
+            input_tokens = self.count_tokens(input_text)
+            
+            # Make the API call
+            response = self.client.chat.completions.create(
+                model=self.current_model,
+                messages=messages,
+                temperature=0.7,
+                max_tokens=2000
+            )
+            
+            answer = response.choices[0].message.content
+            output_tokens = self.count_tokens(answer)
+            
+            # Calculate costs
+            cost_info = self.calculate_cost(input_tokens, output_tokens)
+            cost_info["duration"] = time.time() - start_time
+            cost_info["model"] = self.current_model
+            
+            return answer, cost_info
+            
+        except Exception as e:
+            return f"Error: {str(e)}", {}
+    
+    def update_assistant_model(self, model_id: str) -> bool:
+        """Update the assistant to use a specific model."""
+        if not self.assistant_id:
+            return False
+        
+        try:
+            self.client.beta.assistants.update(
+                assistant_id=self.assistant_id,
+                model=model_id
+            )
+            return True
+        except Exception as e:
+            print(f"Error updating assistant model: {str(e)}")
+            return False

backend/upload_pdfs.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Upload PDFs to OpenAI Vector Store
+Command-line tool to upload PDF files from a specified directory to OpenAI's vector store.
+"""
+
+import os
+import sys
+import json
+import time
+import argparse
+from pathlib import Path
+from typing import List, Dict, Any
+from openai import OpenAI
+
+def init_openai_client() -> OpenAI:
+    """Initialize OpenAI client."""
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("❌ Error: OPENAI_API_KEY environment variable not set")
+        sys.exit(1)
+    return OpenAI()
+
+def upload_file(client: OpenAI, file_path: Path) -> str:
+    """Upload a single file to OpenAI."""
+    print(f"📤 Uploading {file_path.name}...")
+    try:
+        with open(file_path, 'rb') as file:
+            response = client.files.create(
+                file=file,
+                purpose='assistants'
+            )
+        print(f"   ✅ Uploaded successfully (ID: {response.id})")
+        return response.id
+    except Exception as e:
+        print(f"   ❌ Failed to upload: {str(e)}")
+        return None
+
+def create_vector_store(client: OpenAI, name: str, file_ids: List[str]) -> str:
+    """Create a vector store with the uploaded files."""
+    print(f"\n🗄️  Creating vector store '{name}'...")
+    try:
+        vector_store = client.beta.vector_stores.create(
+            name=name,
+            file_ids=file_ids
+        )
+        print(f"✅ Vector store created (ID: {vector_store.id})")
+        return vector_store.id
+    except Exception as e:
+        print(f"❌ Failed to create vector store: {str(e)}")
+        return None
+
+def create_or_update_assistant(client: OpenAI, vector_store_id: str, existing_assistant_id: str = None) -> str:
+    """Create a new assistant or update existing one with the vector store."""
+    try:
+        if existing_assistant_id:
+            print(f"\n🤖 Updating existing assistant (ID: {existing_assistant_id})...")
+            assistant = client.beta.assistants.update(
+                assistant_id=existing_assistant_id,
+                tool_resources={
+                    "file_search": {
+                        "vector_store_ids": [vector_store_id]
+                    }
+                }
+            )
+        else:
+            print("\n🤖 Creating new assistant...")
+            assistant = client.beta.assistants.create(
+                name="PDF Document Assistant",
+                instructions="You are a helpful assistant that answers questions based on the provided PDF documents. Use the file search tool to find relevant information in the documents.",
+                model="gpt-4-turbo",
+                tools=[{"type": "file_search"}],
+                tool_resources={
+                    "file_search": {
+                        "vector_store_ids": [vector_store_id]
+                    }
+                }
+            )
+        print(f"✅ Assistant ready (ID: {assistant.id})")
+        return assistant.id
+    except Exception as e:
+        print(f"❌ Failed to create/update assistant: {str(e)}")
+        return None
+
+def save_config(config_path: Path, config: Dict[str, Any]):
+    """Save configuration to file."""
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(config_path, 'w') as f:
+        json.dump(config, f, indent=2)
+    print(f"\n💾 Configuration saved to {config_path}")
+
+def load_existing_config(config_path: Path) -> Dict[str, Any]:
+    """Load existing configuration if available."""
+    if config_path.exists():
+        try:
+            with open(config_path, 'r') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"⚠️  Warning: Could not load existing config: {str(e)}")
+    return {}
+
+def main():
+    """Main function to upload PDFs to vector store."""
+    parser = argparse.ArgumentParser(description='Upload PDFs to OpenAI Vector Store')
+    parser.add_argument('directory', help='Directory containing PDF files')
+    parser.add_argument('--name', default='PDF Documents', help='Name for the vector store')
+    parser.add_argument('--config', default='config/openai_config.json', help='Config file path')
+    parser.add_argument('--update', action='store_true', help='Update existing assistant instead of creating new')
+    parser.add_argument('--assistant-id', help='Existing assistant ID to update')
+    
+    args = parser.parse_args()
+    
+    # Validate directory
+    pdf_dir = Path(args.directory)
+    if not pdf_dir.exists():
+        print(f"❌ Error: Directory '{pdf_dir}' does not exist")
+        sys.exit(1)
+    
+    # Find PDF files
+    pdf_files = list(pdf_dir.glob('*.pdf'))
+    if not pdf_files:
+        print(f"❌ Error: No PDF files found in '{pdf_dir}'")
+        sys.exit(1)
+    
+    print(f"🔍 Found {len(pdf_files)} PDF files in '{pdf_dir}'")
+    for pdf in pdf_files:
+        print(f"   • {pdf.name}")
+    
+    # Initialize client
+    client = init_openai_client()
+    
+    # Load existing config
+    config_path = Path(args.config)
+    if not config_path.is_absolute():
+        config_path = Path(__file__).parent.parent / config_path
+    
+    existing_config = load_existing_config(config_path)
+    
+    # Upload files
+    print("\n📚 Uploading PDF files...")
+    file_mapping = {}
+    file_ids = []
+    
+    for pdf_file in pdf_files:
+        file_id = upload_file(client, pdf_file)
+        if file_id:
+            file_mapping[str(pdf_file.absolute())] = file_id
+            file_ids.append(file_id)
+        else:
+            print(f"⚠️  Skipping {pdf_file.name} due to upload failure")
+    
+    if not file_ids:
+        print("❌ Error: No files were successfully uploaded")
+        sys.exit(1)
+    
+    print(f"\n✅ Successfully uploaded {len(file_ids)} files")
+    
+    # Create vector store
+    vector_store_id = create_vector_store(client, args.name, file_ids)
+    if not vector_store_id:
+        sys.exit(1)
+    
+    # Create or update assistant
+    assistant_id = args.assistant_id or existing_config.get('assistant_id')
+    if args.update and assistant_id:
+        assistant_id = create_or_update_assistant(client, vector_store_id, assistant_id)
+    else:
+        assistant_id = create_or_update_assistant(client, vector_store_id)
+    
+    if not assistant_id:
+        sys.exit(1)
+    
+    # Save configuration
+    config = {
+        "vector_store_id": vector_store_id,
+        "assistant_id": assistant_id,
+        "file_mapping": file_mapping,
+        "file_ids": file_ids,
+        "upload_timestamp": time.time(),
+        "directories": [str(pdf_dir.absolute())]
+    }
+    
+    save_config(config_path, config)
+    
+    print("\n🎉 Success! Your PDFs are ready to query.")
+    print(f"   Vector Store ID: {vector_store_id}")
+    print(f"   Assistant ID: {assistant_id}")
+    print(f"   Config saved to: {config_path}")
+
+if __name__ == "__main__":
+    main()

config/openai_config.json

@@ -0,0 +1,32 @@
+{
+  "vector_store_id": "vs_68672a4750c48191aa3109c01f105aa2",
+  "assistant_id": "asst_3zyFE63fZnAUytz2Yf74Gy7u",
+  "file_mapping": {
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Chorus R1.1 Quick Start Guide.pdf": "file-EAqEizav5wZm1LTnsLHyhD",
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Chorus R1.1 User Guide.pdf": "file-AaF5zZ3gYZaNqEQsVj2jRJ",
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Harmony R1.2 Installation Guide.pdf": "file-CHTXYTXXx1LV422DXQAaXP",
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Harmony R1.2 User Guide.pdf": "file-T8VuVTraBJyuGk3TnT4i6Y",
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Harmony R1.5 Installation Guide.pdf": "file-MuAFSRE6zDevVVB6xxqmKg",
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Harmony R1.5 User Guide.pdf": "file-RHRyiwyEJCMHeUc2AWTsY3",
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Harmony R1.6 Installation Guide.pdf": "file-39uzQpefL9bCgyzgPWdViH",
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Harmony R1.6 User Guide.pdf": "file-VejBx1Vsk2psJcZUNGrkjB",
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Harmony R1.8 Installation Guide.pdf": "file-LrbRm4ojftfqSfSLx7uz4U",
+    "/Users/jsv/Work/ataya/concert-master/pdfs/Harmony R1.8 User Guide.pdf": "file-PPcDiSxLDo8KsqZ2cPKKmz"
+  },
+  "file_ids": [
+    "file-EAqEizav5wZm1LTnsLHyhD",
+    "file-AaF5zZ3gYZaNqEQsVj2jRJ",
+    "file-CHTXYTXXx1LV422DXQAaXP",
+    "file-T8VuVTraBJyuGk3TnT4i6Y",
+    "file-MuAFSRE6zDevVVB6xxqmKg",
+    "file-RHRyiwyEJCMHeUc2AWTsY3",
+    "file-39uzQpefL9bCgyzgPWdViH",
+    "file-VejBx1Vsk2psJcZUNGrkjB",
+    "file-LrbRm4ojftfqSfSLx7uz4U",
+    "file-PPcDiSxLDo8KsqZ2cPKKmz"
+  ],
+  "upload_timestamp": 1751591502.519109,
+  "directories": [
+    "/Users/jsv/Work/ataya/concert-master/pdfs"
+  ]
+}

frontend/gradio_app.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+Gradio Frontend for OpenAI Chatbot with Model Selection and Token Tracking
+"""
+
+import gradio as gr
+import sys
+from pathlib import Path
+
+# Add backend to path
+sys.path.append(str(Path(__file__).parent.parent))
+
+from backend.chatbot_backend import ChatbotBackend
+
+class ChatbotUI:
+    """Gradio UI for the chatbot."""
+    
+    def __init__(self):
+        """Initialize the UI."""
+        self.backend = ChatbotBackend()
+        self.use_documents = True
+        
+    def format_cost_info(self, cost_info: dict) -> str:
+        """Format cost information for display."""
+        if not cost_info:
+            return ""
+        
+        return f"""
+**Token Usage:**
+- Input: {cost_info.get('input_tokens', 0):,} tokens
+- Output: {cost_info.get('output_tokens', 0):,} tokens
+
+**Cost Breakdown:**
+- Input Cost: ${cost_info.get('input_cost', 0):.6f}
+- Output Cost: ${cost_info.get('output_cost', 0):.6f}
+- **Total Cost: ${cost_info.get('total_cost', 0):.6f}**
+
+**Performance:**
+- Model: {cost_info.get('model', 'Unknown')}
+- Response Time: {cost_info.get('duration', 0):.1f}s
+"""
+    
+    def chat_response(self, message: str, history: list, model: str, custom_prompt: str, use_docs: bool):
+        """Generate a chat response."""
+        # Set the model
+        self.backend.set_model(model)
+        
+        # Get response based on document usage
+        if use_docs:
+            response, cost_info = self.backend.query_with_documents(message, custom_prompt)
+        else:
+            response, cost_info = self.backend.query_without_documents(message, custom_prompt)
+        
+        # Format cost info
+        cost_display = self.format_cost_info(cost_info)
+        
+        # Return response and cost info
+        return response, cost_display
+    
+    def create_interface(self):
+        """Create the Gradio interface."""
+        with gr.Blocks(title="OpenAI PDF Chatbot", theme=gr.themes.Soft()) as demo:
+            gr.Markdown("""
+            # 🤖 OpenAI PDF Chatbot
+            
+            Chat with your PDF documents using different OpenAI models. Track token usage and costs in real-time.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(
+                        label="Chat History",
+                        height=500,
+                        show_copy_button=True
+                    )
+                    
+                    with gr.Row():
+                        msg = gr.Textbox(
+                            label="Your Question",
+                            placeholder="Ask a question about your documents...",
+                            lines=2,
+                            scale=4
+                        )
+                        submit_btn = gr.Button("Send", variant="primary", scale=1)
+                
+                with gr.Column(scale=1):
+                    # Model selection
+                    model_options = list(self.backend.MODEL_CONFIGS.keys())
+                    model_names = [f"{self.backend.MODEL_CONFIGS[m]['name']} (${self.backend.MODEL_CONFIGS[m]['input_cost']}/${self.backend.MODEL_CONFIGS[m]['output_cost']})" 
+                                  for m in model_options]
+                    
+                    model_dropdown = gr.Dropdown(
+                        choices=list(zip(model_names, model_options)),
+                        value=model_options[1],  # Default to mini model
+                        label="Select Model",
+                        info="Prices shown as (Input/Output) per 1M tokens"
+                    )
+                    
+                    # Document usage toggle
+                    use_docs_checkbox = gr.Checkbox(
+                        value=True,
+                        label="Use PDF Documents",
+                        info="Toggle to query with or without document context"
+                    )
+                    
+                    # Custom prompt
+                    custom_prompt = gr.Textbox(
+                        label="Custom System Prompt (Optional)",
+                        placeholder="Enter a custom prompt to guide the AI's responses...",
+                        lines=3
+                    )
+                    
+                    # Cost display
+                    cost_display = gr.Markdown(
+                        label="Usage & Cost",
+                        value="*No queries yet*"
+                    )
+                    
+                    # Clear button
+                    clear_btn = gr.Button("Clear Chat", variant="secondary")
+            
+            # Response time display at bottom
+            response_time_display = gr.Markdown(value="", visible=False)
+            
+            # Event handlers
+            def respond(message, history, model, prompt, use_docs):
+                """Handle chat response."""
+                response, cost_info = self.chat_response(message, history, model, prompt, use_docs)
+                history.append((message, response))
+                
+                # Format response time
+                if isinstance(cost_info, dict):
+                    duration = cost_info.get('duration', 0)
+                    time_text = f"Responded in {duration:.1f} seconds"
+                else:
+                    time_text = ""
+                
+                return "", history, cost_info, time_text
+            
+            def clear_chat():
+                """Clear chat history."""
+                return [], "*No queries yet*", ""
+            
+            # Wire up events
+            submit_btn.click(
+                respond,
+                inputs=[msg, chatbot, model_dropdown, custom_prompt, use_docs_checkbox],
+                outputs=[msg, chatbot, cost_display, response_time_display]
+            )
+            
+            msg.submit(
+                respond,
+                inputs=[msg, chatbot, model_dropdown, custom_prompt, use_docs_checkbox],
+                outputs=[msg, chatbot, cost_display, response_time_display]
+            )
+            
+            clear_btn.click(
+                clear_chat,
+                outputs=[chatbot, cost_display, response_time_display]
+            )
+            
+            # Instructions
+            with gr.Accordion("📋 Instructions", open=False):
+                gr.Markdown("""
+                ### How to use this chatbot:
+                
+                1. **Select a Model**: Choose from different OpenAI models based on your needs and budget
+                2. **Toggle Document Usage**: Enable to search through your uploaded PDFs, disable for general queries
+                3. **Custom Prompt**: Optionally add instructions to guide the AI's behavior
+                4. **Ask Questions**: Type your question and press Enter or click Send
+                5. **Monitor Costs**: Track token usage and costs in real-time
+                
+                ### Model Comparison:
+                - **GPT-4.1 (Latest)**: Most capable, best for complex tasks
+                - **GPT-4.1 Mini**: Balanced performance and cost
+                - **GPT-4.1 Nano**: Most economical, good for simple queries
+                - **O4 Mini**: Alternative model with competitive pricing
+                """)
+        
+        return demo
+    
+def main():
+    """Main function to run the Gradio app."""
+    ui = ChatbotUI()
+    demo = ui.create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,3 @@
+openai>=1.0.0
+gradio>=4.0.0
+tiktoken>=0.5.0

run_chatbot.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""
+Main script to run the OpenAI PDF Chatbot
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add current directory to path
+sys.path.append(str(Path(__file__).parent))
+
+# Import and run the Gradio app
+from frontend.gradio_app import main
+
+if __name__ == "__main__":
+    print("🚀 Starting OpenAI PDF Chatbot...")
+    print("=" * 40)
+    print("📚 Using existing vector store with uploaded PDFs")
+    print("💡 Select different models to compare performance and costs")
+    print("=" * 40)
+    
+    # Check for OpenAI API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("⚠️  Warning: OPENAI_API_KEY environment variable not set")
+        print("   Make sure to set it before running the chatbot")
+    
+    main()