Limit model selection to three open-source options

- Reduced available models to: Gemma 27B, Mixtral 8x7B, and Llama 70B
- Ordered models by size from smallest to largest
- Focuses on providing quality open-source model options only

CLAUDE.md

@@ -0,0 +1,49 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+### Running the Application
+```bash
+python app.py
+```
+This starts the Gradio web interface on local port (default 7860).
+
+### Installing Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+## Code Architecture
+
+This is a single-file Gradio application (`app.py`) that helps users create and deploy chat interfaces on HuggingFace Spaces. The application has two main features:
+
+1. **Spaces Configuration Tool**: Generates complete deployment packages for chat interfaces
+   - Uses the `SPACE_TEMPLATE` string (lines 9-81) to generate Python code
+   - Creates zip files containing app.py, requirements.txt, and README.md
+   - Supports multiple LLM models via OpenRouter API
+
+2. **Chat Support Assistant**: Provides configuration help using Gemma-2-27B
+   - Located in the second tab of the interface
+   - Uses OpenRouter API with environment variable `OPENROUTER_API_KEY`
+
+### Key Functions
+- `create_readme()`: Generates deployment instructions (lines 99-117)
+- `create_requirements()`: Generates requirements.txt content (lines 119-127)
+- `generate_space_config()`: Main function that creates the deployment package (lines 129-180)
+- `create_support_assistant()`: Creates the chat support interface (lines 396-449)
+
+### Template System
+The app uses string templating to generate Python code. The main template (`SPACE_TEMPLATE`) contains placeholders that are filled with user configuration:
+- `{name}`, `{description}`, `{system_prompt}`, `{model}`
+- `{api_key_var}`, `{temperature}`, `{max_tokens}`, `{examples}`
+
+## Environment Variables
+- `OPENROUTER_API_KEY`: Required for the Chat Support feature to work
+
+## Important Notes
+- This is a HuggingFace Spaces application (see YAML frontmatter in README.md)
+- No test suite or linting configuration exists
+- The generated packages are self-contained chat applications ready for deployment
+- All generated code uses OpenRouter API for LLM access

app.py

@@ -82,18 +82,9 @@ if __name__ == "__main__":
 
 # Available models
 MODELS = [
-    "google/gemma-2-9b-it",
-    "google/gemma-2-27b-it", 
-    "meta-llama/llama-3.1-8b-instruct",
-    "meta-llama/llama-3.1-70b-instruct",
-    "anthropic/claude-3-haiku",
-    "anthropic/claude-3-sonnet",
-    "anthropic/claude-3.5-sonnet",
-    "openai/gpt-3.5-turbo",
-    "openai/gpt-4o-mini",
-    "openai/gpt-4o",
-    "mistralai/mistral-7b-instruct",
-    "mistralai/mixtral-8x7b-instruct"
+    "google/gemma-2-27b-it",
+    "mistralai/mixtral-8x7b-instruct",
+    "meta-llama/llama-3.1-70b-instruct"
 ]
 
 def create_readme(config):

local-files/claude.md

@@ -0,0 +1,108 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Architecture Overview
+
+This is a **Chat UI Helper** that generates ready-to-deploy HuggingFace Spaces for educational and research chat interfaces. The project combines a Gradio-based package generator with an AI-powered configuration assistant.
+
+### Core Components
+
+1. **Main Application (`app.py`)**: Two-tab Gradio interface:
+   - **Space Generator Tab**: Creates deployable HuggingFace Space packages
+   - **Chat UI Helper Tab**: AI assistant for configuration guidance (imported from `chat_helper.py`)
+
+2. **Template System**: 
+   - `SPACE_TEMPLATE` string contains complete deployable chat interface code
+   - Uses Python `.format()` to inject user configurations into template
+   - Generates zip packages with `app.py`, `requirements.txt`, `README.md`, and `config.json`
+
+3. **Chat Helper (`chat_helper.py`)**: 
+   - Modular AI assistant component for configuration guidance
+   - Rule-based responses for common educational/research chat UI questions
+   - Emphasizes Mixtral-8x7B as cost-effective recommended model
+
+### Key Architecture Patterns
+
+- **Template Injection**: Uses `{{}}` for literal braces in generated code, `{}` for template variables
+- **Modular Design**: Chat helper is separate module imported by main app
+- **Configuration-Driven**: All generated spaces use environment-based API key configuration
+- **Educational Focus**: Specialized for academic and research use cases
+
+## Development Commands
+
+### Local Development
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the main application
+python app.py
+
+# Test a basic assistant template
+python default.py
+```
+
+### Testing Generated Packages
+```bash
+# Extract and test a generated zip package
+unzip my_custom_space.zip
+cd extracted_package
+export OPENROUTER_API_KEY="your-key-here"
+python app.py
+```
+
+### Requirements
+- All generated chat interfaces require OpenRouter API keys
+- Current Gradio version: 5.34.0 (updated from legacy 4.16.0)
+- Template generates Gradio ChatInterface applications
+
+## Template System Details
+
+### SPACE_TEMPLATE Structure
+The template generates complete HuggingFace Spaces with:
+- OpenRouter API integration using configurable environment variables
+- Gradio 5.x compatible ChatInterface implementation  
+- Error handling for missing API keys
+- Configurable model, temperature, and token limits
+- Support for custom example prompts
+
+### Configuration Variables
+Standard variables injected into templates:
+- `{name}`: Space title/name
+- `{description}`: Space description
+- `{system_prompt}`: AI behavior instructions
+- `{model}`: OpenRouter model identifier
+- `{api_key_var}`: Environment variable name for API key
+- `{temperature}`: Model temperature setting
+- `{max_tokens}`: Maximum response tokens
+- `{examples}`: JSON array of example prompts
+
+### Template Compatibility
+- Template uses double braces `{{API_KEY}}` for variables that should appear literally in generated code
+- Single braces `{model}` are replaced during template formatting
+- Generated code is compatible with HuggingFace Spaces deployment
+
+## Model Configuration
+
+### Default Model List
+Available models prioritized by use case:
+- **Budget**: `google/gemma-2-9b-it`, `mistralai/mistral-7b-instruct`
+- **Recommended**: `mistralai/mixtral-8x7b-instruct` (balanced cost/performance)
+- **Premium**: `anthropic/claude-3.5-sonnet`, `openai/gpt-4o`
+
+### Chat Helper Integration
+The `chat_helper.py` module provides AI-powered guidance specifically recommending Mixtral-8x7B for most educational and research use cases, with configuration examples and cost considerations.
+
+## File Structure Patterns
+
+- `app.py`: Main two-tab application
+- `chat_helper.py`: Modular AI assistant component  
+- `default.py`: Basic working assistant template for testing
+- `config.json`: Example configuration file
+- `exp/`: Legacy experimental versions and documentation
+- Generated zip files follow pattern: `{name}_{timestamp}.zip` → `{name}.zip`
+
+## Current State
+
+The project has evolved from experimental multi-SDK generator (`exp/` folder) to focused educational/research chat UI helper. Current production stack generates HuggingFace Spaces optimized for academic use cases with built-in configuration guidance.

local-files/zip/cloze_reader_assistant_1750033320.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84aac5a482cc847c796d50298da89d3964f1e1cd954933aa163142d2741639c1
+size 2769

local-files/zip/my_ai_assistant_assistant_1750031622.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e5a395a4f5f7c871689c0b773249ac7ed3d1f484f8b7f3839662623f197186c
+size 2859

local-files/zip/my_ai_assistant_assistant_1750032133.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70d009797658f4eab0d4cb4e10fb7e5230d6d3ae2d839358cdabccc734ef4c99
+size 2838

local-files/zip/my_ai_assistant_assistant_1750033267.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f7871d5ca87f7d4ba97c0f6065a908e02c43a2794fd92fddd61252882d83f15
+size 2761

local-files/zip/my_custom_space.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:425aa4367155cde65095d7c930d2b4295ec5a0e2243badf924f21c21550ebed8
+size 2837

local-files/zip/professor_zach_assistant_1750033356.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59eee639803656a372b04affbada5007f221c7be9f534544f932b60a3ea5f116
+size 2775

local-files/zip/test_assistant_1750026513.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d5b897f2e81fca7bd64207ad86676725ad34005a72e9df3f7d754fffec69d5b
+size 2339

local-files/zip/zip.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""Test script to validate zip generation functionality"""
+
+import json
+import zipfile
+import io
+import os
+from datetime import datetime
+
+def create_requirements():
+    """Generate requirements.txt"""
+    return "gradio==4.16.0\nrequests==2.31.0"
+
+def create_readme(config):
+    """Generate README with deployment instructions"""
+    return f"""# {config['name']}
+
+{config['description']}
+
+## 🚀 Quick Deploy to HuggingFace Spaces
+
+### Step 1: Create the Space
+1. Go to https://huggingface.co/spaces
+2. Click "Create new Space"
+3. Choose a name for your assistant
+4. Select **Gradio** as the SDK
+5. Set visibility (Public/Private)
+6. Click "Create Space"
+
+### Step 2: Upload Files
+1. In your new Space, click "Files" tab
+2. Upload these files from the zip:
+   - `app.py`
+   - `requirements.txt`
+3. Wait for "Building" to complete
+
+### Step 3: Add API Key
+1. Go to Settings (⚙️ icon) 
+2. Click "Variables and secrets"
+3. Click "New secret"
+4. Name: `{config['api_key_var']}`
+5. Value: Your OpenRouter API key
+6. Click "Add"
+
+### Step 4: Get Your API Key
+1. Go to https://openrouter.ai/keys
+2. Sign up/login if needed
+3. Click "Create Key"
+4. Copy the key (starts with `sk-or-`)
+
+### Step 5: Test Your Assistant
+- Go back to "App" tab
+- Your assistant should be running!
+- Try the example prompts or ask a question
+
+## 📝 Configuration
+
+- **Model**: {config['model']}
+- **Temperature**: {config['temperature']}
+- **Max Tokens**: {config['max_tokens']}
+- **API Key Variable**: {config['api_key_var']}
+
+Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} with HF Assistant Converter
+"""
+
+# Fixed template based on mvp_simple.py
+ASSISTANT_TEMPLATE = '''import gradio as gr
+import os
+import requests
+import json
+
+# Configuration
+ASSISTANT_NAME = "{name}"
+ASSISTANT_DESCRIPTION = "{description}"
+SYSTEM_PROMPT = """{system_prompt}"""
+MODEL = "{model}"
+
+# Get API key from environment - customizable variable name
+API_KEY = os.environ.get("{api_key_var}")
+
+def generate_response(message, history):
+    """Generate response using OpenRouter API"""
+    
+    if not API_KEY:
+        return "Please set your {api_key_var} in the Space settings."
+    
+    # Build messages array for the API
+    messages = [{{"role": "system", "content": SYSTEM_PROMPT}}]
+    
+    # Add conversation history
+    for user_msg, assistant_msg in history:
+        messages.append({{"role": "user", "content": user_msg}})
+        if assistant_msg:
+            messages.append({{"role": "assistant", "content": assistant_msg}})
+    
+    # Add current message
+    messages.append({{"role": "user", "content": message}})
+    
+    # Make API request
+    try:
+        response = requests.post(
+            url="https://openrouter.ai/api/v1/chat/completions",
+            headers={{
+                "Authorization": f"Bearer {{API_KEY}}",
+                "Content-Type": "application/json"
+            }},
+            json={{
+                "model": MODEL,
+                "messages": messages,
+                "temperature": {temperature},
+                "max_tokens": {max_tokens}
+            }}
+        )
+        
+        if response.status_code == 200:
+            return response.json()['choices'][0]['message']['content']
+        else:
+            return f"Error: {{response.status_code}} - {{response.text}}"
+            
+    except Exception as e:
+        return f"Error: {{str(e)}}"
+
+# Create simple Gradio interface using ChatInterface
+demo = gr.ChatInterface(
+    fn=generate_response,
+    title=ASSISTANT_NAME,
+    description=ASSISTANT_DESCRIPTION,
+    examples={examples}
+)
+
+if __name__ == "__main__":
+    demo.launch(share=True)
+'''
+
+def test_zip_generation():
+    """Test the zip generation with sample data"""
+    print("🧪 Testing zip generation...")
+    
+    # Sample configuration
+    config = {
+        'name': 'Test Assistant',
+        'description': 'A helpful test assistant',
+        'system_prompt': 'You are a helpful assistant. Provide clear and accurate responses.',
+        'model': 'google/gemma-2-9b-it',
+        'api_key_var': 'OPENROUTER_API_KEY',
+        'temperature': 0.7,
+        'max_tokens': 1024,
+        'examples': json.dumps([
+            "Hello! How can you help me?",
+            "Tell me something interesting", 
+            "What can you do?"
+        ])
+    }
+    
+    print(f"📋 Config: {config}")
+    
+    try:
+        # Generate files
+        print("🔄 Generating app.py content...")
+        app_content = ASSISTANT_TEMPLATE.format(**config)
+        print("✅ App content generated")
+        
+        print("🔄 Generating README content...")
+        readme_content = create_readme(config)
+        print("✅ README content generated")
+        
+        print("🔄 Generating requirements content...")
+        requirements_content = create_requirements()
+        print("✅ Requirements content generated")
+        
+        # Create zip file
+        print("🔄 Creating zip file...")
+        import time
+        timestamp = int(time.time())
+        filename = f"test_assistant_{timestamp}.zip"
+        
+        zip_buffer = io.BytesIO()
+        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+            zip_file.writestr('app.py', app_content)
+            zip_file.writestr('requirements.txt', requirements_content)
+            zip_file.writestr('README.md', readme_content)
+            zip_file.writestr('config.json', json.dumps(config, indent=2))
+        
+        # Write to file
+        zip_buffer.seek(0)
+        with open(filename, 'wb') as f:
+            f.write(zip_buffer.getvalue())
+        
+        # Verify file
+        if os.path.exists(filename):
+            file_size = os.path.getsize(filename)
+            print(f"✅ Zip file created: {filename} ({file_size} bytes)")
+            
+            # Test zip contents
+            with zipfile.ZipFile(filename, 'r') as zip_file:
+                files_in_zip = zip_file.namelist()
+                print(f"📁 Files in zip: {files_in_zip}")
+                
+                # Test app.py content
+                app_py_content = zip_file.read('app.py').decode('utf-8')
+                print(f"📄 app.py first 100 chars: {app_py_content[:100]}...")
+                
+            return True, filename
+        else:
+            print("❌ Zip file not created")
+            return False, None
+            
+    except Exception as e:
+        print(f"❌ Error during zip generation: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return False, None
+
+if __name__ == "__main__":
+    success, filename = test_zip_generation()
+    if success:
+        print(f"🎉 Test successful! Generated: {filename}")
+    else:
+        print("💥 Test failed!")