Upload 4 files

README.md

@@ -1,15 +1,51 @@
 ---
-title: ENG328
+title: Paratext Analysis
 emoji: 💬
-colorFrom: yellow
-colorTo: purple
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: 5.42.0
 app_file: app.py
 pinned: false
-hf_oauth: true
-hf_oauth_scopes:
-- inference-api
+license: mit
+short_description: Support for Paratext Editions Assignment
 ---
 
-An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+# Paratext Analysis
+
+This bot...
+
+## Quick Setup
+
+### Step 1: Configure API Key (Required)
+1. Get your API key from https://openrouter.ai/keys
+2. In Settings → Variables and secrets
+3. Add secret: `API_KEY`
+4. Paste your OpenRouter API key
+
+### Step 2: Configure HuggingFace Token (Optional)
+1. Get your token from https://huggingface.co/settings/tokens
+2. In Settings → Variables and secrets
+3. Add secret: `HF_TOKEN`
+4. Paste your HuggingFace token (needs write permissions)
+5. This enables automatic configuration updates
+
+
+### Step 3: Set Access Code
+1. In Settings → Variables and secrets
+2. Add secret: `ACCESS_CODE`
+3. Set your chosen password
+4. Share with authorized users
+
+
+### Step 3: Test Your Space
+Your Space should now be running! Try the example prompts or ask your own questions.
+
+## Configuration
+- **Model**: nvidia/llama-3.1-nemotron-70b-instruct
+- **API Key Variable**: API_KEY
+- **HF Token Variable**: HF_TOKEN (for auto-updates)
+- **Access Control**: Enabled (ACCESS_CODE)
+
+## Support
+For help, visit the HuggingFace documentation or community forums.

app.py

@@ -1,70 +1,1048 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
+import tempfile
+import os
+import requests
+import json
+import re
+from bs4 import BeautifulSoup
+from datetime import datetime
+import urllib.parse
+from pathlib import Path
+from typing import List, Dict, Optional, Any, Tuple
 
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+# Configuration
+SPACE_NAME = 'Paratext Analysis'
+SPACE_DESCRIPTION = 'Support for Paratext Editions Assignment'
 
-    messages = [{"role": "system", "content": system_message}]
+# Default configuration values
+DEFAULT_CONFIG = {
+    'name': SPACE_NAME,
+    'description': SPACE_DESCRIPTION,
+    'system_prompt': 'You are a Socratic research partner for students in an advance undergraduate elective, English 328: Medieval and Renaissance Literature.  Your model is  pebble-in-the-pond learning, responsive teaching, and constructivist learning principles. Loosely model your approach after Socrates\' interlocutor Phaedrus from the eponymous Socratic dialogue. Guide students to understand and analyze paratextual materials, helping them recognize differences between text and paratext.\n Concentrate on questions to get students thinking about what they notice, what they want to ask, rather than on content questions.  Ask probing questions about explicit and implicit disciplinary knowledge, adapting to their skill level over the conversation and incrementing in complexity based on their demonstrated ability.  Help students strengthen their arguments by asking about the author of the text, the purpose of the content they are analyzing, and helping them find sources. Pose reasonable counter arguments and ask them to respond to them.  Help students develop sub arguments by asking questions.   Always ask open-ended questions that promote higher-order thinking—analysis, synthesis, or evaluation—rather than recall.    Do not ask students to consider theoretical approaches. \n\nRESTRICTIONS and PARAMETERS\nIf student asks for answers to the questions posed in URL 2, refuse to answer, and explain that you are not here to generate content for them but to help them find reliable sources and deepen their arguments. IF STUDENTS ASK FOR A TOPIC AND/OR RESEARCH QUESTIONS AND/OR THESIS STATEMENT, DO NOT PROVIDE THEM.  If students ask for a topic and/or research questions, and/or argument/thesis statement,  remind them that you are there to help, not provide them with ready-made answers.    Students must propose an idea before getting feedback in the form of questions.  Ask scaffolded questions to help them expand their ideas.     If you do not have enough tokens for a complete answer, divide the answer into parts and offer them in sequence to the student. \n\nTONE\nSelect timely moments to include the quip, "how about that?" in your answers.  Encourage students to remember that you are a prediction-making machine and have no original thoughts.   Make it clear that you are an AI and meant to support their thinking process and not replace that thinking process.  ',
+    'temperature': 0.7,
+    'max_tokens': 400,
+    'model': 'nvidia/llama-3.1-nemotron-70b-instruct',
+    'api_key_var': 'API_KEY',
+    'theme': 'Default',
+    'grounding_urls': ["https://classics.mit.edu/Plato/phaedrus.1b.txt", "https://docs.google.com/document/d/1HzwhQ0kvPaKYDQHH_PaiRHXwLbqequWn_QGUqIJVtmY/edit?usp=sharing", "https://english-studies.net/paratext-in-literature-literary-theory/", "https://en.wikipedia.org/wiki/Socratic_method"],
+    'enable_dynamic_urls': True,
+    'enable_file_upload': True,
+    'examples': ['What is a paratext?', 'What are some examples of paratexts?', 'Help me think through my argument', "I'm confused about methodology - where do I start?", 'Why does theory matter in practice?'],
+    'language': 'English',
+    'locked': False
+}
 
-    messages.extend(history)
+# Available themes with proper instantiation
+AVAILABLE_THEMES = {
+    "Default": gr.themes.Default(),
+    "Soft": gr.themes.Soft(),
+    "Glass": gr.themes.Glass(),
+    "Monochrome": gr.themes.Monochrome(),
+    "Base": gr.themes.Base()
+}
 
-    messages.append({"role": "user", "content": message})
 
-    response = ""
+class ConfigurationManager:
+    """Manage configuration with validation and persistence"""
+    
+    def __init__(self):
+        self.config_path = "config.json"
+        self.backup_dir = "config_backups"
+        self._config = None
+    
+    def load(self) -> Dict[str, Any]:
+        """Load configuration from file with fallback to defaults"""
+        try:
+            with open(self.config_path, 'r') as f:
+                self._config = json.load(f)
+                print("✅ Loaded configuration from config.json")
+                return self._config
+        except FileNotFoundError:
+            print("ℹ️ No config.json found, using default configuration")
+            self._config = DEFAULT_CONFIG.copy()
+            self.save(self._config)
+            return self._config
+        except Exception as e:
+            print(f"⚠️ Error loading config.json: {e}, using defaults")
+            self._config = DEFAULT_CONFIG.copy()
+            return self._config
+    
+    def save(self, config: Dict[str, Any]) -> bool:
+        """Save configuration with automatic backup"""
+        try:
+            # Create backup if config exists
+            if os.path.exists(self.config_path):
+                self._create_backup()
+            
+            # Save new configuration
+            with open(self.config_path, 'w') as f:
+                json.dump(config, f, indent=2)
+            
+            self._config = config
+            return True
+        except Exception as e:
+            print(f"❌ Error saving configuration: {e}")
+            return False
+    
+    def _create_backup(self):
+        """Create timestamped backup"""
+        try:
+            os.makedirs(self.backup_dir, exist_ok=True)
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            backup_path = os.path.join(self.backup_dir, f"config_{timestamp}.json")
+            
+            with open(self.config_path, 'r') as source:
+                config_data = json.load(source)
+                with open(backup_path, 'w') as backup:
+                    json.dump(config_data, backup, indent=2)
+            
+            self._cleanup_old_backups()
+        except Exception as e:
+            print(f"⚠️ Error creating backup: {e}")
+    
+    def _cleanup_old_backups(self, keep=10):
+        """Keep only the most recent backups"""
+        try:
+            backups = sorted([
+                f for f in os.listdir(self.backup_dir)
+                if f.startswith('config_') and f.endswith('.json')
+            ])
+            
+            if len(backups) > keep:
+                for old_backup in backups[:-keep]:
+                    os.remove(os.path.join(self.backup_dir, old_backup))
+        except Exception as e:
+            print(f"⚠️ Error cleaning up backups: {e}")
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get configuration value"""
+        if self._config is None:
+            self.load()
+        return self._config.get(key, default)
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
 
-        response += token
-        yield response
+# Initialize configuration manager
+config_manager = ConfigurationManager()
+config = config_manager.load()
 
+# Load configuration values
+SPACE_NAME = config.get('name', DEFAULT_CONFIG['name'])
+SPACE_DESCRIPTION = config.get('description', DEFAULT_CONFIG['description'])
+SYSTEM_PROMPT = config.get('system_prompt', DEFAULT_CONFIG['system_prompt'])
+temperature = config.get('temperature', DEFAULT_CONFIG['temperature'])
+max_tokens = config.get('max_tokens', DEFAULT_CONFIG['max_tokens'])
+MODEL = config.get('model', DEFAULT_CONFIG['model'])
+THEME = config.get('theme', DEFAULT_CONFIG['theme'])
+GROUNDING_URLS = config.get('grounding_urls', DEFAULT_CONFIG['grounding_urls'])
+ENABLE_DYNAMIC_URLS = config.get('enable_dynamic_urls', DEFAULT_CONFIG['enable_dynamic_urls'])
+ENABLE_FILE_UPLOAD = config.get('enable_file_upload', DEFAULT_CONFIG.get('enable_file_upload', True))
+LANGUAGE = config.get('language', DEFAULT_CONFIG.get('language', 'English'))
+
+# Environment variables
+ACCESS_CODE = os.environ.get("ACCESS_CODE")
+API_KEY_VAR = config.get('api_key_var', DEFAULT_CONFIG['api_key_var'])
+API_KEY = os.environ.get(API_KEY_VAR, "").strip() or None
+HF_TOKEN = os.environ.get('HF_TOKEN', '')
+SPACE_ID = os.environ.get('SPACE_ID', '')
+
+
+# Utility functions
+def validate_api_key() -> bool:
+    """Validate API key configuration"""
+    if not API_KEY:
+        print(f"⚠️  API KEY CONFIGURATION ERROR:")
+        print(f"   Variable name: {API_KEY_VAR}")
+        print(f"   Status: Not set or empty")
+        print(f"   Action needed: Set '{API_KEY_VAR}' in HuggingFace Space secrets")
+        return False
+    elif not API_KEY.startswith('sk-or-'):
+        print(f"⚠️  API KEY FORMAT WARNING:")
+        print(f"   Variable name: {API_KEY_VAR}")
+        print(f"   Note: OpenRouter keys should start with 'sk-or-'")
+        return True
+    else:
+        print(f"✅ API Key configured successfully")
+        return True
+
+
+def validate_url_domain(url: str) -> bool:
+    """Validate URL domain"""
+    try:
+        from urllib.parse import urlparse
+        parsed = urlparse(url)
+        return bool(parsed.netloc and parsed.scheme in ['http', 'https'])
+    except:
+        return False
+
+
+def fetch_url_content(url: str, max_length: int = 3000) -> str:
+    """Fetch and convert URL content to text"""
+    try:
+        if not validate_url_domain(url):
+            return f"❌ Invalid URL format: {url}"
+        
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (compatible; HuggingFace-Space/1.0)'
+        }
+        
+        response = requests.get(url, headers=headers, timeout=5)
+        response.raise_for_status()
+        
+        content_type = response.headers.get('content-type', '').lower()
+        
+        if 'text/html' in content_type:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Remove script and style elements
+            for script in soup(["script", "style"]):
+                script.extract()
+            
+            # Get text content
+            text = soup.get_text(separator=' ', strip=True)
+            
+            # Clean up whitespace
+            text = ' '.join(text.split())
+            
+            # Limit content length
+            if len(text) > max_length:
+                text = text[:max_length] + "... [truncated]"
+            
+            return f"📄 **Content from:** {url}\n\n{text}\n"
+        
+        elif any(ct in content_type for ct in ['text/plain', 'application/json']):
+            text = response.text
+            if len(text) > max_length:
+                text = text[:max_length] + "... [truncated]"
+            return f"📄 **Content from:** {url}\n\n{text}\n"
+        
+        else:
+            return f"⚠️ Unsupported content type at {url}: {content_type}"
+            
+    except requests.exceptions.Timeout:
+        return f"⏱️ Timeout accessing {url}"
+    except requests.exceptions.RequestException as e:
+        return f"❌ Error accessing {url}: {str(e)}"
+    except Exception as e:
+        return f"❌ Unexpected error with {url}: {str(e)}"
+
+
+def extract_urls_from_text(text: str) -> List[str]:
+    """Extract URLs from message text"""
+    url_pattern = r'https?://[^\s<>"{}|\\^`\[\]]+(?:\.[^\s<>"{}|\\^`\[\]])*'
+    urls = re.findall(url_pattern, text)
+    return [url.rstrip('.,;:)?!') for url in urls]
+
+
+def process_file_upload(file_path: str) -> str:
+    """Process uploaded file with Gradio best practices"""
+    if not file_path or not os.path.exists(file_path):
+        return "❌ File not found"
+    
+    try:
+        file_size = os.path.getsize(file_path)
+        file_name = os.path.basename(file_path)
+        _, ext = os.path.splitext(file_path.lower())
+        
+        # Text file extensions
+        text_extensions = {
+            '.txt', '.md', '.markdown', '.rst',
+            '.py', '.js', '.jsx', '.ts', '.tsx', '.json', '.yaml', '.yml',
+            '.html', '.htm', '.xml', '.css', '.scss',
+            '.java', '.c', '.cpp', '.h', '.cs', '.go', '.rs',
+            '.sh', '.bash', '.log', '.csv', '.sql'
+        }
+        
+        max_chars = 5000  # Define max_chars limit for file reading
+        
+        if ext in text_extensions:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read(max_chars)
+                if len(content) == max_chars:
+                    content += "\n... [truncated]"
+                return f"📄 **{file_name}** ({file_size:,} bytes)\n```{ext[1:]}\n{content}\n```"
+        
+        # Special file types
+        elif ext == '.pdf':
+            return f"📑 **{file_name}** (PDF, {file_size:,} bytes)\n⚠️ PDF support requires PyPDF2"
+        elif ext in {'.jpg', '.jpeg', '.png', '.gif', '.webp'}:
+            return f"🖼️ **{file_name}** (Image, {file_size:,} bytes)"
+        elif ext in {'.xlsx', '.xls'}:
+            return f"📊 **{file_name}** (Spreadsheet, {file_size:,} bytes)"
+        elif ext in {'.zip', '.tar', '.gz', '.rar'}:
+            return f"🗜️ **{file_name}** (Archive, {file_size:,} bytes)"
+        else:
+            return f"📎 **{file_name}** ({ext or 'no extension'}, {file_size:,} bytes)"
+            
+    except Exception as e:
+        return f"❌ Error processing file: {str(e)}"
+
+
+# URL content cache
+_url_content_cache = {}
+
+
+def get_grounding_context() -> str:
+    """Get grounding context from configured URLs with caching"""
+    urls = GROUNDING_URLS
+    if isinstance(urls, str):
+        try:
+            urls = json.loads(urls)
+        except:
+            return ""
+    
+    if not urls:
+        return ""
+    
+    context_parts = []
+    
+    # Process primary sources (first 2 URLs with 8000 char limit)
+    primary_urls = urls[:2]
+    if primary_urls:
+        context_parts.append("📚 **PRIMARY SOURCES:**\n")
+        for i, url in enumerate(primary_urls, 1):
+            if url in _url_content_cache:
+                content = _url_content_cache[url]
+            else:
+                content = fetch_url_content(url, max_length=8000)
+                _url_content_cache[url] = content
+            
+            if not content.startswith("❌") and not content.startswith("⏱️"):
+                context_parts.append(f"\n**Primary Source {i} - {url}:**\n{content}")
+    
+    # Process secondary sources (URLs 3+ with 2500 char limit)
+    secondary_urls = urls[2:]
+    if secondary_urls:
+        context_parts.append("\n\n📎 **SECONDARY SOURCES:**\n")
+        for i, url in enumerate(secondary_urls, 1):
+            if url in _url_content_cache:
+                content = _url_content_cache[url]
+            else:
+                content = fetch_url_content(url, max_length=2500)
+                _url_content_cache[url] = content
+            
+            if not content.startswith("❌") and not content.startswith("⏱️"):
+                context_parts.append(f"\n**Secondary Source {i} - {url}:**\n{content}")
+    
+    if len(context_parts) > 0:
+        return "\n".join(context_parts)
+    return ""
+
+
+def export_conversation_to_markdown(history: List[Dict[str, str]]) -> str:
+    """Export conversation history to markdown"""
+    if not history:
+        return "No conversation to export."
+    
+    markdown_content = f"""# Conversation Export
+Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+Space: {SPACE_NAME}
+Model: {MODEL}
+
+---
 
 """
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
+    
+    message_count = 0
+    for message in history:
+        if isinstance(message, dict):
+            role = message.get('role', 'unknown')
+            content = message.get('content', '')
+            
+            if role == 'user':
+                message_count += 1
+                markdown_content += f"## User Message {message_count}\n\n{content}\n\n"
+            elif role == 'assistant':
+                markdown_content += f"## Assistant Response {message_count}\n\n{content}\n\n---\n\n"
+    
+    return markdown_content
+
+
+def generate_response(message: str, history: List[Dict[str, str]], files: Optional[List] = None) -> str:
+    """Generate response using OpenRouter API with file support"""
+    
+    # API key validation
+    if not API_KEY:
+        return f"""🔑 **API Key Required**
+
+Please configure your OpenRouter API key:
+1. Go to Settings (⚙️) in your HuggingFace Space
+2. Click 'Variables and secrets'
+3. Add secret: **{API_KEY_VAR}**
+4. Value: Your OpenRouter API key (starts with `sk-or-`)
+
+Get your API key at: https://openrouter.ai/keys"""
+    
+    # Process files if provided
+    file_context = ""
+    file_notification = ""
+    
+    if files:
+        file_contents = []
+        file_names = []
+        
+        for file_info in files:
+            if isinstance(file_info, dict):
+                file_path = file_info.get('path', file_info.get('name', ''))
+            else:
+                file_path = str(file_info)
+            
+            if file_path and os.path.exists(file_path):
+                try:
+                    content = process_file_upload(file_path)
+                    file_contents.append(content)
+                    file_names.append(os.path.basename(file_path))
+                    print(f"📄 Processed file: {os.path.basename(file_path)}")
+                except Exception as e:
+                    print(f"❌ Error processing file: {e}")
+        
+        if file_contents:
+            file_context = "\n\n[UPLOADED FILES]\n" + "\n\n".join(file_contents) + "\n"
+            file_notification = f"\n\n[Note: Uploaded files: {', '.join(file_names)}]"
+    
+    # Get grounding context
+    grounding_context = get_grounding_context()
+    
+    # Check for dynamic URLs in message
+    if ENABLE_DYNAMIC_URLS:
+        urls_in_message = extract_urls_from_text(message)
+        if urls_in_message:
+            print(f"🔗 Found {len(urls_in_message)} URLs in message")
+            dynamic_context = "\n📎 **Dynamic Context:**\n"
+            for url in urls_in_message[:3]:  # Limit to 3 URLs
+                content = fetch_url_content(url)
+                if not content.startswith("❌"):
+                    dynamic_context += f"\n{content}"
+            grounding_context += dynamic_context
+    
+    # Build messages with grounding context and file context in system prompt
+    system_content = SYSTEM_PROMPT
+    
+    # Add language instruction if not English
+    if LANGUAGE != 'English':
+        system_content += f"\n\nIMPORTANT: You must respond EXCLUSIVELY in {LANGUAGE}. All your responses should be written entirely in {LANGUAGE}, even when user input is in a different language, particularly English."
+    
+    if grounding_context:
+        system_content += "\n\nIMPORTANT: When providing information from the reference sources below, please cite the specific URL(s) where the information can be found. Format citations as plain URLs without brackets, or use markdown link format like [text](url). Never use hard brackets like 【url】 as they break the links."
+        system_content = f"{system_content}\n\n{grounding_context}"
+    if file_context:
+        system_content = f"{system_content}\n\n{file_context}"
+    
+    messages = [{"role": "system", "content": system_content}]
+    
+    # Add conversation history
+    for msg in history:
+        if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
+            messages.append({
+                "role": msg['role'],
+                "content": msg['content']
+            })
+    
+    # Add current message
+    messages.append({
+        "role": "user",
+        "content": message
+    })
+    
+    # Make API request
+    try:
+        # Make API request
+        headers = {
+            "Authorization": f"Bearer {API_KEY}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": f"https://huggingface.co/spaces/{SPACE_ID}" if SPACE_ID else "https://huggingface.co",
+            "X-Title": SPACE_NAME
+        }
+        
+        data = {
+            "model": MODEL,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": False
+        }
+        
+        response = requests.post(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers=headers,
+            json=data,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            ai_response = result['choices'][0]['message']['content']
+            
+            # Add file notification if files were uploaded
+            if file_notification:
+                ai_response += file_notification
+            
+            return ai_response
+        else:
+            error_data = response.json()
+            error_message = error_data.get('error', {}).get('message', 'Unknown error')
+            return f"❌ API Error ({response.status_code}): {error_message}"
+            
+    except requests.exceptions.Timeout:
+        return "⏰ Request timeout (30s limit). Try a shorter message or different model."
+    except requests.exceptions.ConnectionError:
+        return "🌐 Connection error. Check your internet connection and try again."
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+
+# Chat history for export
+chat_history_store = []
+
+
+def verify_hf_token_access() -> Tuple[bool, str]:
+    """Verify HuggingFace token and access"""
+    if not HF_TOKEN:
+        return False, "No HF_TOKEN found"
+    
+    if not SPACE_ID:
+        return False, "No SPACE_ID found - running locally?"
+    
+    try:
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+        response = requests.get(
+            f"https://huggingface.co/api/spaces/{SPACE_ID}",
+            headers=headers,
+            timeout=5
+        )
+        if response.status_code == 200:
+            return True, f"HF Token valid for {SPACE_ID}"
+        else:
+            return False, f"HF Token invalid or no access to {SPACE_ID}"
+    except Exception as e:
+        return False, f"Error verifying HF token: {str(e)}"
+
+
+# Create main interface with clean tab structure
+def create_interface():
+    """Create the Gradio interface with clean tab structure"""
+    
+    # Get theme
+    theme = AVAILABLE_THEMES.get(THEME, gr.themes.Default())
+    
+    # Validate API key on startup
+    API_KEY_VALID = validate_api_key()
+    
+    # Check HuggingFace access
+    HF_ACCESS_VALID, HF_ACCESS_MESSAGE = verify_hf_token_access()
+    
+    # Access control check
+    has_access = ACCESS_CODE is None  # No access code required
+    
+    with gr.Blocks(title=SPACE_NAME, theme=theme) as demo:
+        # State for access control
+        access_granted = gr.State(has_access)
+        
+        # Header - always visible
+        gr.Markdown(f"# {SPACE_NAME}")
+        gr.Markdown(SPACE_DESCRIPTION)
+        
+        # Access control panel (visible when access not granted)
+        with gr.Column(visible=(not has_access)) as access_panel:
+            gr.Markdown("### 🔐 Access Required")
+            gr.Markdown("Please enter the access code:")
+            
+            with gr.Row():
+                access_input = gr.Textbox(
+                    label="Access Code",
+                    placeholder="Enter access code...",
+                    type="password",
+                    scale=3
+                )
+                access_btn = gr.Button("Submit", variant="primary", scale=1)
+            
+            access_status = gr.Markdown()
+        
+        # Main interface (visible when access granted)
+        with gr.Column(visible=has_access) as main_panel:
+            with gr.Tabs() as tabs:
+                # Chat Tab
+                with gr.Tab("💬 Chat"):
+                    # Get examples
+                    examples = config.get('examples', [])
+                    if isinstance(examples, str):
+                        try:
+                            examples = json.loads(examples)
+                        except:
+                            examples = []
+                    
+                    # State to hold uploaded files
+                    uploaded_files = gr.State([])
+                    
+                    # Create chat interface
+                    chatbot = gr.Chatbot(type="messages", height=400)
+                    msg = gr.Textbox(label="Message", placeholder="Type your message here...", lines=2)
+                    
+                    with gr.Row():
+                        submit_btn = gr.Button("Send", variant="primary")
+                        clear_btn = gr.Button("Clear")
+                    
+                    # Export functionality
+                    with gr.Row():
+                        # Use a regular Button for triggering export
+                        export_trigger_btn = gr.Button(
+                            "📥 Export Conversation",
+                            variant="secondary",
+                            size="sm"
+                        )
+                        # Hidden file component for actual download
+                        export_file = gr.File(
+                            visible=False,
+                            label="Download Export"
+                        )
+                    
+                    # Export handler
+                    def prepare_export(chat_history):
+                        if not chat_history:
+                            gr.Warning("No conversation history to export.")
+                            return None
+                        
+                        try:
+                            content = export_conversation_to_markdown(chat_history)
+                            
+                            # Create filename
+                            space_name_safe = re.sub(r'[^a-zA-Z0-9]+', '_', SPACE_NAME).lower()
+                            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                            filename = f"{space_name_safe}_conversation_{timestamp}.md"
+                            
+                            # Save to temp file
+                            temp_path = Path(tempfile.gettempdir()) / filename
+                            temp_path.write_text(content, encoding='utf-8')
+                            
+                            # Return the file component with visibility and value
+                            return gr.File(visible=True, value=str(temp_path))
+                        except Exception as e:
+                            gr.Error(f"Failed to export conversation: {str(e)}")
+                            return None
+                    
+                    export_trigger_btn.click(
+                        prepare_export,
+                        inputs=[chatbot],
+                        outputs=[export_file]
+                    )
+                    
+                    # Examples section
+                    if examples:
+                        gr.Examples(examples=examples, inputs=msg)
+                    
+                    # Chat functionality
+                    def respond(message, chat_history, files_state, is_granted):
+                        if not is_granted:
+                            return chat_history, "", is_granted
+                        
+                        if not message:
+                            return chat_history, "", is_granted
+                        
+                        # Format history for the generate_response function
+                        formatted_history = []
+                        for h in chat_history:
+                            if isinstance(h, dict):
+                                formatted_history.append(h)
+                        
+                        # Get response
+                        response = generate_response(message, formatted_history, files_state)
+                        
+                        # Update chat history
+                        chat_history = chat_history + [
+                            {"role": "user", "content": message},
+                            {"role": "assistant", "content": response}
+                        ]
+                        
+                        # Update stored history for export
+                        global chat_history_store
+                        chat_history_store = chat_history
+                        
+                        return chat_history, "", is_granted
+                    
+                    # Wire up the interface
+                    msg.submit(respond, [msg, chatbot, uploaded_files, access_granted], [chatbot, msg, access_granted])
+                    submit_btn.click(respond, [msg, chatbot, uploaded_files, access_granted], [chatbot, msg, access_granted])
+                    
+                    def clear_chat():
+                        global chat_history_store
+                        chat_history_store = []
+                        return [], ""
+                    
+                    clear_btn.click(clear_chat, outputs=[chatbot, msg])
+                    
+                    # File upload accordion
+                    if ENABLE_FILE_UPLOAD:
+                        with gr.Accordion("📎 Upload Files", open=False):
+                            file_upload = gr.File(
+                                label="Upload Files",
+                                file_types=None,
+                                file_count="multiple",
+                                visible=True,
+                                interactive=True
+                            )
+                            clear_files_btn = gr.Button("Clear Files", size="sm", variant="secondary")
+                            uploaded_files_display = gr.Markdown("", visible=False)
+                            
+                            def handle_file_upload(files):
+                                if not files:
+                                    return [], "", gr.update(visible=False)
+                                
+                                file_names = []
+                                for file_info in files:
+                                    if isinstance(file_info, dict):
+                                        file_path = file_info.get('path', file_info.get('name', ''))
+                                    else:
+                                        file_path = str(file_info)
+                                    
+                                    if file_path and os.path.exists(file_path):
+                                        file_names.append(os.path.basename(file_path))
+                                
+                                if file_names:
+                                    display_text = f"📎 **Uploaded files:** {', '.join(file_names)}"
+                                    return files, display_text, gr.update(visible=True)
+                                return [], "", gr.update(visible=False)
+                            
+                            def clear_files():
+                                return None, [], "", gr.update(visible=False)
+                            
+                            file_upload.change(
+                                handle_file_upload,
+                                inputs=[file_upload],
+                                outputs=[uploaded_files, uploaded_files_display, uploaded_files_display]
+                            )
+                            
+                            clear_files_btn.click(
+                                clear_files,
+                                outputs=[file_upload, uploaded_files, uploaded_files_display, uploaded_files_display]
+                            )
+                    
+                    # Configuration accordion
+                    with gr.Accordion("ℹ️ Configuration", open=False):
+                        gr.JSON(
+                            value=config,
+                            label="config.json",
+                            show_label=True
+                        )
+                
+                # Configuration Tab
+                with gr.Tab("⚙️ Configuration"):
+                    gr.Markdown("## Configuration Management")
+                    
+                    # State for config tab authentication
+                    config_authenticated = gr.State(False)
+                    
+                    # Authentication panel
+                    with gr.Column(visible=True) as config_auth_panel:
+                        gr.Markdown("### 🔐 Authentication Required")
+                        gr.Markdown("Enter your HF_TOKEN to access configuration settings:")
+                        
+                        with gr.Row():
+                            config_password = gr.Textbox(
+                                label="HF Token",
+                                placeholder="Enter your HF_TOKEN...",
+                                type="password",
+                                scale=3
+                            )
+                            config_auth_btn = gr.Button("Authenticate", variant="primary", scale=1)
+                        
+                        config_auth_status = gr.Markdown()
+                    
+                    # Configuration panel (hidden until authenticated)
+                    with gr.Column(visible=False) as config_panel:
+                        # Show authentication status
+                        if HF_ACCESS_VALID:
+                            gr.Markdown(f"✅ {HF_ACCESS_MESSAGE}")
+                            gr.Markdown("Configuration changes will be saved to the HuggingFace repository.")
+                        else:
+                            gr.Markdown(f"ℹ️ {HF_ACCESS_MESSAGE}")
+                            gr.Markdown("Set HF_TOKEN in Space secrets to enable auto-save.")
+                        
+                        # Configuration editor
+                        gr.Markdown("### ⚙️ Configuration Editor")
+                        
+                        # Show lock status if locked
+                        if config.get('locked', False):
+                            gr.Markdown("⚠️ **Note:** Configuration is locked.")
+                        
+                        # Basic settings
+                        with gr.Column():
+                            edit_name = gr.Textbox(
+                            label="Space Name",
+                            value=config.get('name', ''),
+                            max_lines=1
+                        )
+                        edit_model = gr.Dropdown(
+                            label="Model",
+                            choices=[
+                                # Google models
+                                "google/gemini-2.0-flash-001",
+                                "google/gemma-3-27b-it",
+                                # Anthropic models
+                                "anthropic/claude-3.5-sonnet",
+                                "anthropic/claude-3.5-haiku",
+                                # OpenAI models
+                                "openai/gpt-4o-mini",
+                                "openai/gpt-4o-mini-search-preview",
+                                "openai/gpt-oss-120b",
+                                # MistralAI models
+                                "mistralai/mistral-medium-3",
+                                # DeepSeek models
+                                "deepseek/deepseek-r1-distill-qwen-32b",
+                                # NVIDIA models
+                                "nvidia/llama-3.1-nemotron-70b-instruct",
+                                # Qwen models
+                                "qwen/qwen3-30b-a3b-instruct-2507"
+                            ],
+                            value=config.get('model', ''),
+                            allow_custom_value=True
+                        )
+                        
+                        edit_language = gr.Dropdown(
+                            label="Language",
+                            choices=[
+                                "Arabic",
+                                "Bengali",
+                                "English",
+                                "French",
+                                "German",
+                                "Hindi",
+                                "Italian",
+                                "Japanese",
+                                "Korean",
+                                "Mandarin",
+                                "Portuguese",
+                                "Russian",
+                                "Spanish",
+                                "Turkish"
+                            ],
+                            value=config.get('language', 'English')
+                        )
+                        
+                        edit_description = gr.Textbox(
+                            label="Description",
+                            value=config.get('description', ''),
+                            max_lines=2
+                        )
+                        
+                        edit_system_prompt = gr.Textbox(
+                            label="System Prompt",
+                            value=config.get('system_prompt', ''),
+                            lines=5
+                        )
+                        
+                        with gr.Row():
+                            edit_temperature = gr.Slider(
+                                label="Temperature",
+                                minimum=0,
+                                maximum=2,
+                                value=config.get('temperature', 0.7),
+                                step=0.1
+                            )
+                            edit_max_tokens = gr.Slider(
+                                label="Max Tokens",
+                                minimum=50,
+                                maximum=4096,
+                                value=config.get('max_tokens', 750),
+                                step=50
+                            )
+                        
+                        edit_examples = gr.Textbox(
+                            label="Example Prompts (one per line)",
+                            value='\n'.join(config.get('examples', [])),
+                            lines=3
+                        )
+                        
+                        # URL Grounding
+                        gr.Markdown("### URL Grounding")
+                        edit_grounding_urls = gr.Textbox(
+                            label="Grounding URLs (one per line)",
+                            placeholder="https://example.com/docs\nhttps://example.com/api",
+                            value='\n'.join(config.get('grounding_urls', [])),
+                            lines=5,
+                            info="First 2 URLs: Primary sources (8000 chars). URLs 3+: Secondary sources (2500 chars)."
+                        )
+                        
+                        with gr.Row():
+                            edit_enable_dynamic_urls = gr.Checkbox(
+                                label="Enable Dynamic URL Extraction",
+                                value=config.get('enable_dynamic_urls', True),
+                                info="Extract and fetch URLs from user messages"
+                            )
+                            edit_enable_file_upload = gr.Checkbox(
+                                label="Enable File Upload",
+                                value=config.get('enable_file_upload', True),
+                                info="Allow users to upload files for context"
+                            )
+                        
+                        # Configuration actions
+                        with gr.Row():
+                            save_btn = gr.Button("💾 Save Configuration", variant="primary")
+                            reset_btn = gr.Button("↩️ Reset to Defaults", variant="secondary")
+                        
+                        config_status = gr.Markdown()
+                        
+                        def save_configuration(name, description, system_prompt, model, language, temp, tokens, examples, grounding_urls, enable_dynamic_urls, enable_file_upload):
+                            """Save updated configuration"""
+                            try:
+                                updated_config = config.copy()
+                                updated_config.update({
+                                    'name': name,
+                                    'description': description,
+                                    'system_prompt': system_prompt,
+                                    'model': model,
+                                    'language': language,
+                                    'temperature': temp,
+                                    'max_tokens': int(tokens),
+                                    'examples': [ex.strip() for ex in examples.split('\n') if ex.strip()],
+                                    'grounding_urls': [url.strip() for url in grounding_urls.split('\n') if url.strip()],
+                                    'enable_dynamic_urls': enable_dynamic_urls,
+                                    'enable_file_upload': enable_file_upload,
+                                    'locked': config.get('locked', False)
+                                })
+                                
+                                if config_manager.save(updated_config):
+                                    # Auto-commit if HF token is available
+                                    if HF_TOKEN and SPACE_ID:
+                                        try:
+                                            from huggingface_hub import HfApi, CommitOperationAdd
+                                            api = HfApi(token=HF_TOKEN)
+                                            
+                                            operations = [
+                                                CommitOperationAdd(
+                                                    path_or_fileobj=config_manager.config_path,
+                                                    path_in_repo="config.json"
+                                                )
+                                            ]
+                                            
+                                            api.create_commit(
+                                                repo_id=SPACE_ID,
+                                                operations=operations,
+                                                commit_message="Update configuration via web UI",
+                                                commit_description=f"Configuration update at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+                                                repo_type="space",
+                                                token=HF_TOKEN
+                                            )
+                                            return "✅ Configuration saved and committed to repository!"
+                                        except Exception as e:
+                                            return f"✅ Configuration saved locally. ⚠️ Auto-commit failed: {str(e)}"
+                                    else:
+                                        return "✅ Configuration saved locally (no HF token for auto-commit)"
+                                else:
+                                    return "❌ Failed to save configuration"
+                                    
+                            except Exception as e:
+                                return f"❌ Error: {str(e)}"
+                        
+                        save_btn.click(
+                            save_configuration,
+                            inputs=[edit_name, edit_description, edit_system_prompt, edit_model, edit_language,
+                                   edit_temperature, edit_max_tokens, edit_examples, edit_grounding_urls,
+                                   edit_enable_dynamic_urls, edit_enable_file_upload],
+                            outputs=[config_status]
+                        )
+                        
+                        def reset_configuration():
+                            """Reset to default configuration"""
+                            try:
+                                if config_manager.save(DEFAULT_CONFIG):
+                                    return (
+                                        DEFAULT_CONFIG['name'],
+                                        DEFAULT_CONFIG['description'],
+                                        DEFAULT_CONFIG['system_prompt'],
+                                        DEFAULT_CONFIG['model'],
+                                        DEFAULT_CONFIG.get('language', 'English'),
+                                        DEFAULT_CONFIG['temperature'],
+                                        DEFAULT_CONFIG['max_tokens'],
+                                        '\n'.join(DEFAULT_CONFIG['examples']),
+                                        '\n'.join(DEFAULT_CONFIG['grounding_urls']),
+                                        DEFAULT_CONFIG['enable_dynamic_urls'],
+                                        DEFAULT_CONFIG['enable_file_upload'],
+                                        "✅ Reset to default configuration"
+                                    )
+                                else:
+                                    return (*[gr.update() for _ in range(11)], "❌ Failed to reset")
+                            except Exception as e:
+                                return (*[gr.update() for _ in range(11)], f"❌ Error: {str(e)}")
+                        
+                        reset_btn.click(
+                            reset_configuration,
+                            outputs=[edit_name, edit_description, edit_system_prompt, edit_model, edit_language,
+                                    edit_temperature, edit_max_tokens, edit_examples, edit_grounding_urls,
+                                    edit_enable_dynamic_urls, edit_enable_file_upload, config_status]
+                        )
+                        
+                        # Configuration tab authentication handler
+                        def handle_config_auth(password):
+                            """Handle configuration tab authentication"""
+                            if not HF_TOKEN:
+                                return (
+                                    gr.update(visible=True),   # Keep auth panel visible
+                                    gr.update(visible=False),  # Keep config panel hidden
+                                    gr.update(value="❌ No HF_TOKEN is set in Space secrets. Configuration cannot be enabled."),
+                                    False
+                                )
+                            
+                            if password == HF_TOKEN:
+                                return (
+                                    gr.update(visible=False),  # Hide auth panel
+                                    gr.update(visible=True),   # Show config panel
+                                    gr.update(value="✅ Authentication successful!"),
+                                    True
+                                )
+                            else:
+                                return (
+                                    gr.update(visible=True),   # Keep auth panel visible
+                                    gr.update(visible=False),  # Keep config panel hidden
+                                    gr.update(value="❌ Invalid HF_TOKEN. Please try again."),
+                                    False
+                                )
+                        
+                        config_auth_btn.click(
+                            handle_config_auth,
+                            inputs=[config_password],
+                            outputs=[config_auth_panel, config_panel, config_auth_status, config_authenticated]
+                        )
+                        
+                        config_password.submit(
+                            handle_config_auth,
+                            inputs=[config_password],
+                            outputs=[config_auth_panel, config_panel, config_auth_status, config_authenticated]
+                        )
+        
+        # Access control handler
+        if ACCESS_CODE:
+            def handle_access(code, current_state):
+                if code == ACCESS_CODE:
+                    return (
+                        gr.update(visible=False),  # Hide access panel
+                        gr.update(visible=True),   # Show main panel
+                        gr.update(value="✅ Access granted!"),  # Status message
+                        True  # Update state
+                    )
+                else:
+                    return (
+                        gr.update(visible=True),   # Keep access panel visible
+                        gr.update(visible=False),  # Keep main panel hidden
+                        gr.update(value="❌ Invalid access code. Please try again."),  # Status message
+                        False  # State remains false
+                    )
+            
+            access_btn.click(
+                handle_access,
+                inputs=[access_input, access_granted],
+                outputs=[access_panel, main_panel, access_status, access_granted]
+            )
+            
+            access_input.submit(
+                handle_access,
+                inputs=[access_input, access_granted],
+                outputs=[access_panel, main_panel, access_status, access_granted]
+            )
+    
+    return demo
 
 
+# Create and launch the interface
 if __name__ == "__main__":
+    demo = create_interface()
     demo.launch()

config.json

@@ -0,0 +1,27 @@
+{
+  "name": "Paratext Analysis",
+  "tagline": "Support for Paratext Editions Assignment",
+  "description": "This bot...",
+  "system_prompt": "You are a Socratic research partner for students in an advance undergraduate elective, English 328: Medieval and Renaissance Literature.  Your model is  pebble-in-the-pond learning, responsive teaching, and constructivist learning principles. Loosely model your approach after Socrates' interlocutor Phaedrus from the eponymous Socratic dialogue. Guide students to understand and analyze paratextual materials, helping them recognize differences between text and paratext.\n Concentrate on questions to get students thinking about what they notice, what they want to ask, rather than on content questions.  Ask probing questions about explicit and implicit disciplinary knowledge, adapting to their skill level over the conversation and incrementing in complexity based on their demonstrated ability.  Help students strengthen their arguments by asking about the author of the text, the purpose of the content they are analyzing, and helping them find sources. Pose reasonable counter arguments and ask them to respond to them.  Help students develop sub arguments by asking questions.   Always ask open-ended questions that promote higher-order thinking\u2014analysis, synthesis, or evaluation\u2014rather than recall.    Do not ask students to consider theoretical approaches. \n\nRESTRICTIONS and PARAMETERS\nIf student asks for answers to the questions posed in URL 2, refuse to answer, and explain that you are not here to generate content for them but to help them find reliable sources and deepen their arguments. IF STUDENTS ASK FOR A TOPIC AND/OR RESEARCH QUESTIONS AND/OR THESIS STATEMENT, DO NOT PROVIDE THEM.  If students ask for a topic and/or research questions, and/or argument/thesis statement,  remind them that you are there to help, not provide them with ready-made answers.    Students must propose an idea before getting feedback in the form of questions.  Ask scaffolded questions to help them expand their ideas.     If you do not have enough tokens for a complete answer, divide the answer into parts and offer them in sequence to the student. \n\nTONE\nSelect timely moments to include the quip, \"how about that?\" in your answers.  Encourage students to remember that you are a prediction-making machine and have no original thoughts.   Make it clear that you are an AI and meant to support their thinking process and not replace that thinking process.  ",
+  "model": "nvidia/llama-3.1-nemotron-70b-instruct",
+  "language": "English",
+  "api_key_var": "API_KEY",
+  "temperature": 0.7,
+  "max_tokens": 400,
+  "examples": [
+    "What is a paratext?",
+    "What are some examples of paratexts?",
+    "Help me think through my argument",
+    "I'm confused about methodology - where do I start?",
+    "Why does theory matter in practice?"
+  ],
+  "grounding_urls": [
+    "https://classics.mit.edu/Plato/phaedrus.1b.txt",
+    "https://docs.google.com/document/d/1HzwhQ0kvPaKYDQHH_PaiRHXwLbqequWn_QGUqIJVtmY/edit?usp=sharing",
+    "https://english-studies.net/paratext-in-literature-literary-theory/",
+    "https://en.wikipedia.org/wiki/Socratic_method"
+  ],
+  "enable_dynamic_urls": true,
+  "enable_file_upload": true,
+  "theme": "Default"
+}

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=5.42.0
+requests>=2.32.3
+beautifulsoup4>=4.12.3
+python-dotenv>=1.0.0
+huggingface-hub>=0.20.0