Update app.py

app.py

@@ -1,96 +1,172 @@
+import gradio as gr
+import os
+from typing import Dict, List, Tuple
 import time
 import requests
 import json
-from typing import Optional
 
-def _call_openai_with_retry(self, api_key: str, prompt: str, model: str = "gpt-4", max_tokens: int = 2000, max_retries: int = 3) -> str:
-    """OpenAI API call with exponential backoff retry logic"""
-    
-    if not api_key or not api_key.strip():
-        return "🔑 Please enter your OpenAI API key above to generate content."
-    
-    clean_key = api_key.strip()
-    url = "https://api.openai.com/v1/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {clean_key}",
-        "Content-Type": "application/json"
-    }
-    
-    # Start with GPT-3.5-turbo if GPT-4 is not available
-    models_to_try = [model]
-    if model == "gpt-4":
-        models_to_try = ["gpt-4", "gpt-3.5-turbo"]
-    
-    for current_model in models_to_try:
-        print(f"🤖 Trying model: {current_model}")
+class GlossaryGenerator:
+    def __init__(self):
+        self.template = """
+**Glossary Page Template**
+Use this template to create individual glossary pages for specific terms. Fill in each section with relevant information.
+**[TERM NAME]**
+**1. Introduction / Brief Definition (AI Overview)**
+* **Purpose:** Provide the absolute clearest, most concise, and direct answer to "What is [TERM NAME]?" This should be a short, no-fluff definition, similar to an AI overview or a quick dictionary entry.
+* **Content:** Start immediately with the core definition. Get straight to the point.
+**2. Detailed Explanation**
+* **Purpose:** Expand on the brief definition, offering a comprehensive explanation of the term. This section should follow a "reverse pyramid" structure, meaning the most critical information is presented first, followed by supporting details.
+* **Content:**
+   * **Elaborate on the core concept:** Build upon the initial definition, providing more depth and context.
+   * **Explore related questions (PAA / Query Fans):** Anticipate what users might ask next or what related topics they might search for. Integrate answers to "People Also Ask" (PAA) type questions or expand into "query fan" concepts that naturally branch off the main term.
+   * Provide context, background, or the purpose of the term.
+   * Include key characteristics, functions, or processes associated with the term.
+   * Use examples to illustrate the concept clearly.
+   * Break down complex ideas into simpler parts.
+**3. Key Concepts / Components (Optional)**
+* **Purpose:** If the term has distinct sub-sections, components, or related key ideas that warrant separate discussion, list and explain them here.
+* **Content:**
+   * Use bullet points or sub-headings for each key concept.
+   * Briefly define and explain each component.
+**4. Importance / Application (Optional)**
+* **Purpose:** Explain why the term is significant, its impact, or how it is applied in real-world scenarios.
+* **Content:** Discuss the relevance, benefits, challenges, or practical uses of the term.
+**5. Related Terms / Concepts**
+* **Purpose:** Link to other relevant terms within your glossary or related concepts that readers might find useful for further understanding.
+* **Content:**
+   * List terms that are closely associated or often discussed alongside the current term.
+**6. Sources / References**
+* **Purpose:** Cite the sources from which the information was gathered. This adds credibility and allows readers to explore further.
+* **Content:**
+   * List URLs, book titles, or other references.
+"""
+        # Track request timing to avoid rate limits
+        self.last_request_time = 0
+        self.min_request_interval = 2.0  # Minimum 2 seconds between requests
+
+    def _test_api_key(self, api_key: str) -> bool:
+        """Test OpenAI API key with minimal request"""
+        if not api_key or not api_key.strip():
+            return False
+        
+        try:
+            # Test with minimal request using GPT-3.5-turbo (cheaper and more reliable)
+            test_result = self._call_openai_safe(api_key.strip(), "Hi", "gpt-3.5-turbo", 1)
+            return not test_result.startswith("❌")
+            
+        except Exception as e:
+            print(f"API test error: {e}")
+            return False
+
+    def _wait_for_rate_limit(self):
+        """Ensure minimum time between requests"""
+        current_time = time.time()
+        time_since_last = current_time - self.last_request_time
+        
+        if time_since_last < self.min_request_interval:
+            sleep_time = self.min_request_interval - time_since_last
+            print(f"⏰ Waiting {sleep_time:.1f}s to respect rate limits...")
+            time.sleep(sleep_time)
+        
+        self.last_request_time = time.time()
+
+    def _call_openai_safe(self, api_key: str, prompt: str, model: str = "gpt-3.5-turbo", max_tokens: int = 2000, max_retries: int = 2) -> str:
+        """Safe OpenAI API call with proper rate limiting and error handling"""
+        
+        if not api_key or not api_key.strip():
+            return "🔑 Please enter your OpenAI API key above to generate content."
+        
+        clean_key = api_key.strip()
+        
+        # Wait to respect rate limits
+        self._wait_for_rate_limit()
+        
+        url = "https://api.openai.com/v1/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {clean_key}",
+            "Content-Type": "application/json"
+        }
         
         data = {
-            "model": current_model,
+            "model": model,
             "messages": [
-                {"role": "system", "content": "You are a professional content writer specializing in creating high-quality glossary entries."},
+                {"role": "system", "content": "You are a professional content writer specializing in creating high-quality glossary entries. You follow templates precisely and create comprehensive, well-structured content."},
                 {"role": "user", "content": prompt}
             ],
             "max_tokens": max_tokens,
-            "temperature": 0.7
+            "temperature": 0.7,
+            "top_p": 1,
+            "frequency_penalty": 0,
+            "presence_penalty": 0
         }
         
         for attempt in range(max_retries):
             try:
-                print(f"📡 Attempt {attempt + 1}/{max_retries} for {current_model}")
+                print(f"🚀 Making API call to {model} (attempt {attempt + 1}/{max_retries})")
+                
                 response = requests.post(url, headers=headers, json=data, timeout=60)
+                print(f"📊 Response status: {response.status_code}")
                 
                 if response.status_code == 200:
                     result = response.json()
                     content = result['choices'][0]['message']['content'].strip()
-                    print(f"✅ Success with {current_model}")
+                    print("✅ API call successful")
                     return content
                 
+                elif response.status_code == 401:
+                    return "❌ Invalid API key. Please check your OpenAI API key."
+                
                 elif response.status_code == 429:
-                    # Rate limit hit
+                    # Rate limit hit - get retry time from headers
                     try:
                         error_data = response.json()
-                        error_msg = error_data.get('error', {}).get('message', '')
+                        error_msg = error_data.get('error', {}).get('message', 'Rate limit exceeded')
                     except:
                         error_msg = "Rate limit exceeded"
                     
                     print(f"⏳ Rate limit hit: {error_msg}")
                     
-                    # Extract wait time from headers or use exponential backoff
+                    # Get retry-after from headers or use exponential backoff
                     retry_after = response.headers.get('retry-after')
                     if retry_after:
-                        wait_time = int(retry_after)
-                        print(f"⏰ Waiting {wait_time} seconds as suggested by API...")
+                        wait_time = min(int(retry_after), 60)  # Cap at 60 seconds
                     else:
-                        wait_time = (2 ** attempt) * 2  # Exponential backoff: 2, 4, 8 seconds
-                        print(f"⏰ Waiting {wait_time} seconds (exponential backoff)...")
+                        wait_time = min((2 ** attempt) * 3, 30)  # Exponential backoff, capped at 30s
                     
-                    if attempt < max_retries - 1:  # Don't wait on the last attempt
+                    if attempt < max_retries - 1:
+                        print(f"⏰ Waiting {wait_time} seconds before retry...")
                         time.sleep(wait_time)
                         continue
                     else:
-                        return f"❌ Rate limit exceeded after {max_retries} attempts. Please wait a few minutes and try again."
-                
-                elif response.status_code == 401:
-                    return "❌ Invalid API key. Please check your OpenAI API key."
+                        return f"❌ Rate limit exceeded. Please wait a few minutes and try again. (Try using a different model or reducing request frequency)"
                 
                 elif response.status_code == 404:
-                    print(f"❌ Model {current_model} not available, trying next...")
-                    break  # Try next model
+                    return f"❌ Model '{model}' not available. Try using 'gpt-3.5-turbo' or 'gpt-4o-mini' instead."
+                
+                elif response.status_code == 403:
+                    try:
+                        error_data = response.json()
+                        error_msg = error_data.get('error', {}).get('message', 'Access denied')
+                        if "insufficient_quota" in error_msg.lower():
+                            return "❌ OpenAI API quota exceeded. Please check your billing at https://platform.openai.com/usage"
+                        else:
+                            return f"❌ Access denied: {error_msg}"
+                    except:
+                        return "❌ Access denied. Check your API key permissions."
                 
                 else:
                     # Other errors
                     try:
                         error_data = response.json()
-                        error_msg = error_data.get('error', {}).get('message', 'Unknown error')
+                        error_msg = error_data.get('error', {}).get('message', f'HTTP {response.status_code}')
                     except:
                         error_msg = f"HTTP {response.status_code}"
                     
-                    if "insufficient_quota" in error_msg.lower():
-                        return "❌ OpenAI API quota exceeded. Please check your billing at https://platform.openai.com/usage"
-                    
                     print(f"❌ API Error: {error_msg}")
+                    
                     if attempt < max_retries - 1:
-                        time.sleep(2)  # Short wait for other errors
+                        print(f"⏰ Waiting 3 seconds before retry...")
+                        time.sleep(3)
                         continue
                     else:
                         return f"❌ API Error: {error_msg}"
@@ -98,10 +174,18 @@ def _call_openai_with_retry(self, api_key: str, prompt: str, model: str = "gpt-4
             except requests.exceptions.Timeout:
                 print(f"⏰ Request timeout on attempt {attempt + 1}")
                 if attempt < max_retries - 1:
-                    time.sleep(2)
+                    time.sleep(5)
+                    continue
+                else:
+                    return "❌ Request timeout. Please try again."
+                    
+            except requests.exceptions.ConnectionError:
+                print(f"🌐 Connection error on attempt {attempt + 1}")
+                if attempt < max_retries - 1:
+                    time.sleep(3)
                     continue
                 else:
-                    return "❌ Request timeout after multiple attempts. Please try again."
+                    return "❌ Connection error. Please check your internet connection."
                     
             except Exception as e:
                 print(f"❌ Unexpected error on attempt {attempt + 1}: {str(e)}")
@@ -110,22 +194,453 @@ def _call_openai_with_retry(self, api_key: str, prompt: str, model: str = "gpt-4
                     continue
                 else:
                     return f"❌ Unexpected error: {str(e)}"
-    
-    return "❌ All models failed. Please check your API key and try again."
+        
+        return "❌ All retry attempts failed. Please try again later."
+
+    def generate_new_content(self, api_key: str, term: str, context: str = "", target_audience: str = "general", preferred_model: str = "gpt-3.5-turbo") -> str:
+        """Generate new glossary content for a given term"""
+        
+        if not term.strip():
+            return "Please enter a term to generate content for."
+        
+        # Choose appropriate max_tokens based on model
+        max_tokens = 2500 if "gpt-4" in preferred_model else 2000
+        
+        prompt = f"""
+Create a comprehensive glossary entry for the term "{term}" following this EXACT template structure:
+{self.template}
+**Requirements:**
+- Replace [TERM NAME] with "{term}"
+- Target Audience: {target_audience}
+- Additional Context: {context if context else "No additional context provided"}
+- Fill in ALL sections with relevant, accurate information
+- Use the "reverse pyramid" structure - most important info first
+- Include relevant PAA (People Also Ask) questions in section 2
+- Remove optional sections only if truly not applicable
+- Maintain clear, concise language
+- Provide at least 3 related terms in section 5
+- Include credible sources/references in section 6
+**Focus Areas:**
+- Make the brief definition crystal clear and direct
+- Expand thoroughly in the detailed explanation
+- Include practical examples and use cases
+- Address common questions people might have
+- Ensure professional, authoritative tone
+Generate the complete glossary entry now:
+"""
+        
+        return self._call_openai_safe(api_key, prompt, preferred_model, max_tokens)
+
+    def update_existing_content(self, api_key: str, term: str, existing_content: str, update_instructions: str = "", preferred_model: str = "gpt-3.5-turbo") -> Tuple[str, str]:
+        """Analyze existing content and provide update recommendations"""
+        
+        if not term.strip() or not existing_content.strip():
+            return "Please provide both term and existing content.", ""
+        
+        # Choose appropriate max_tokens based on model
+        max_tokens = 1500 if "gpt-4" in preferred_model else 1200
+        
+        # First, analyze the content
+        analysis_prompt = f"""
+Analyze this existing glossary content for "{term}" against the template standard and provide specific improvement recommendations.
+**EXISTING CONTENT:**
+{existing_content}
+**TEMPLATE STANDARD:**
+{self.template}
+**UPDATE INSTRUCTIONS:** {update_instructions if update_instructions else "General content improvement"}
+**Provide a detailed analysis covering:**
+1. **STRUCTURAL ANALYSIS:**
+   - Does it follow the template structure?
+   - Which sections are missing or incomplete?
+   - Is the reverse pyramid structure implemented?
+2. **CONTENT QUALITY ASSESSMENT:**
+   - Clarity and conciseness of the brief definition
+   - Depth and comprehensiveness of detailed explanation
+   - Relevance and usefulness of examples
+   - Quality of related terms and references
+3. **SPECIFIC RECOMMENDATIONS (prioritized):**
+   - HIGH PRIORITY: Critical improvements needed
+   - MEDIUM PRIORITY: Important enhancements
+   - LOW PRIORITY: Nice-to-have improvements
+4. **SEO & USER EXPERIENCE:**
+   - Missing PAA questions to address
+   - Keyword opportunities
+   - Cross-linking possibilities
+   - Readability improvements
+5. **SOURCES & CREDIBILITY:**
+   - Quality of current references
+   - Missing authoritative sources
+   - Fact-checking requirements
+Format as a professional content analysis report.
+"""
+        
+        recommendations = self._call_openai_safe(api_key, analysis_prompt, preferred_model, max_tokens)
+        
+        if recommendations.startswith("❌"):
+            return recommendations, ""
+        
+        # Add extra wait time between the two requests
+        print("⏰ Waiting between analysis and content generation...")
+        time.sleep(3)
+        
+        # Then generate updated content
+        update_prompt = f"""
+Create an improved version of the glossary entry for "{term}" based on the analysis and recommendations.
+**ORIGINAL CONTENT:**
+{existing_content}
+**ANALYSIS & RECOMMENDATIONS:**
+{recommendations}
+**TEMPLATE TO FOLLOW:**
+{self.template}
+**UPDATE INSTRUCTIONS:** {update_instructions if update_instructions else "Apply the key recommendations from the analysis"}
+**Create the improved glossary entry that:**
+1. Follows the template structure exactly
+2. Implements the high and medium priority recommendations
+3. Maintains the best elements from the original
+4. Adds missing sections or information
+5. Improves clarity, structure, and usefulness
+6. Includes better examples and explanations
+7. Enhances SEO and user experience
+Generate the complete, improved glossary entry:
+"""
+        
+        updated_content = self._call_openai_safe(api_key, update_prompt, preferred_model, max_tokens + 500)
+        
+        return recommendations, updated_content
+
+    def create_outline_brief(self, api_key: str, topic: str, scope: str = "comprehensive", preferred_model: str = "gpt-3.5-turbo") -> str:
+        """Create an outline or brief for new glossary content"""
+        
+        if not topic.strip():
+            return "Please enter a topic for the outline."
+        
+        # Choose appropriate max_tokens based on model
+        max_tokens = 3000 if "gpt-4" in preferred_model else 2500
+        
+        prompt = f"""
+Create a comprehensive content brief for developing a glossary focused on "{topic}".
+**Scope:** {scope}
+**Template Standard:** Follow the 6-section template structure provided
+**Create a detailed brief covering:**
+**1. TOPIC OVERVIEW & STRATEGY**
+- Comprehensive topic definition and boundaries
+- Target audience analysis and segmentation
+- Content complexity and depth recommendations
+- Competitive landscape and differentiation opportunities
+**2. TERM IDENTIFICATION & PRIORITIZATION**
+- **Primary Terms (10-15 key terms):** Most important, high-search volume terms
+- **Secondary Terms (8-12 supporting terms):** Important supporting concepts
+- **Long-tail Terms (5-10 specific terms):** Niche but valuable terms
+- **Priority Matrix:** High/Medium/Low priority for each term with reasoning
+**3. CONTENT ARCHITECTURE**
+- Template section recommendations for each term type
+- Suggested content depth and length for each priority level
+- Cross-linking strategy between terms
+- Information hierarchy and user journey mapping
+**4. RESEARCH & DEVELOPMENT PLAN**
+- **Primary Sources:** Authoritative websites, publications, studies
+- **Expert Sources:** Industry leaders, academic researchers, practitioners
+- **User Research:** Common questions, search patterns, knowledge gaps
+- **Competitive Analysis:** What others are doing well/poorly
+**5. SEO & DISCOVERABILITY STRATEGY**
+- **Primary Keywords:** Main search terms for each priority level
+- **Long-tail Keywords:** Specific phrases users search for
+- **PAA Questions:** "People Also Ask" questions to address
+- **Content Gap Analysis:** Opportunities competitors are missing
+- **Internal Linking Strategy:** How terms connect to each other
+**6. PRODUCTION ROADMAP**
+- **Phase 1:** High-priority terms (timeline and resource allocation)
+- **Phase 2:** Secondary terms and enhancements
+- **Phase 3:** Long-tail terms and optimization
+- **Resource Requirements:** Estimated hours per term type
+- **Quality Assurance:** Review process and standards
+- **Maintenance Plan:** Update frequency and monitoring
+**7. SUCCESS METRICS & KPIs**
+- Content quality indicators
+- User engagement metrics
+- SEO performance targets
+- Conversion and utility measurements
+Create a comprehensive, actionable brief that will guide the entire glossary development process.
+"""
+        
+        return self._call_openai_safe(api_key, prompt, preferred_model, max_tokens)
 
-# Also add a rate limit checker
-def check_rate_limits(self, api_key: str) -> str:
-    """Check current rate limit status"""
-    try:
-        # Make a minimal request to check status
-        response = self._call_openai_with_retry(api_key, "test", "gpt-3.5-turbo", 1)
-        
-        if "Rate limit" in response:
-            return "❌ Currently rate limited"
-        elif "❌" in response:
-            return response
+def create_gradio_interface():
+    """Create the Gradio interface for the glossary generator"""
+    
+    generator = GlossaryGenerator()
+    
+    def test_api_key(api_key):
+        """Test if the API key is valid"""
+        if not api_key or not api_key.strip():
+            return "❌ Please enter your OpenAI API key"
+        
+        # Basic format check
+        clean_key = api_key.strip()
+        if not clean_key.startswith('sk-'):
+            return "❌ Invalid format - OpenAI API keys should start with 'sk-'"
+        
+        if len(clean_key) < 20:
+            return "❌ API key too short - check if you copied the full key"
+        
+        # Test the key
+        if generator._test_api_key(clean_key):
+            return "✅ API key is valid and connected!"
         else:
-            return "✅ Rate limits OK"
+            return "❌ API key test failed - check your key and try again"
+    
+    def generate_new_wrapper(api_key, term, context, audience, model):
+        if not term.strip():
+            return "Please enter a term to generate content for."
+        return generator.generate_new_content(api_key, term, context, audience, model)
+    
+    def update_existing_wrapper(api_key, term, existing_content, update_instructions, model):
+        if not term.strip() or not existing_content.strip():
+            return "Please provide both term and existing content.", ""
+        recommendations, updated_content = generator.update_existing_content(api_key, term, existing_content, update_instructions, model)
+        return recommendations, updated_content
+    
+    def create_outline_wrapper(api_key, topic, scope, model):
+        if not topic.strip():
+            return "Please enter a topic for the outline."
+        return generator.create_outline_brief(api_key, topic, scope, model)
+    
+    # Create the Gradio interface
+    with gr.Blocks(title="Glossary Content Generator", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 📚 Glossary Content Generator (Rate-Limit Safe)
+        
+        **Powered by OpenAI** - Professional glossary content creation and optimization tool.
+        
+        🔑 **Enter your OpenAI API key below to get started!**
+        ✅ **Now with improved rate limiting and error handling**
+        """)
+        
+        # API Key Section
+        with gr.Row():
+            with gr.Column(scale=2):
+                api_key_input = gr.Textbox(
+                    label="🔑 OpenAI API Key",
+                    placeholder="sk-proj-... or sk-...",
+                    type="password",
+                    info="Get your API key at https://platform.openai.com/api-keys"
+                )
+            with gr.Column(scale=1):
+                test_key_btn = gr.Button("Test Key", variant="secondary")
+                manual_test_btn = gr.Button("Skip Test & Try Anyway", variant="outline", size="sm")
+            with gr.Column(scale=1):
+                key_status = gr.Textbox(
+                    label="Status",
+                    value="❌ No API key provided",
+                    interactive=False,
+                    max_lines=2
+                )
+        
+        def manual_override(api_key):
+            if api_key and api_key.strip():
+                return "⚠️ Test skipped - trying anyway..."
+            return "❌ Please enter an API key first"
+        
+        test_key_btn.click(
+            test_api_key,
+            inputs=[api_key_input],
+            outputs=[key_status]
+        )
+        
+        manual_test_btn.click(
+            manual_override,
+            inputs=[api_key_input],
+            outputs=[key_status]
+        )
+        
+        gr.Markdown("---")
+        
+        with gr.Tabs():
+            # Tab 1: Generate New Content
+            with gr.TabItem("🆕 Generate New Content"):
+                gr.Markdown("### Create a new glossary entry from scratch")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        new_term = gr.Textbox(
+                            label="Term to Define",
+                            placeholder="e.g., Machine Learning, CPQ, SEO, API",
+                            lines=1
+                        )
+                        new_context = gr.Textbox(
+                            label="Additional Context (Optional)",
+                            placeholder="Provide industry context, specific use cases, or background information",
+                            lines=3
+                        )
+                        new_audience = gr.Dropdown(
+                            label="Target Audience",
+                            choices=["general", "technical", "business", "beginner", "expert"],
+                            value="general"
+                        )
+                        new_model = gr.Dropdown(
+                            label="AI Model",
+                            choices=["gpt-3.5-turbo", "gpt-4o-mini", "gpt-4", "gpt-4-turbo"],
+                            value="gpt-3.5-turbo",
+                            info="gpt-3.5-turbo is recommended for speed and cost"
+                        )
+                        generate_btn = gr.Button("🚀 Generate Content", variant="primary", size="lg")
+                    
+                    with gr.Column(scale=2):
+                        new_output = gr.Textbox(
+                            label="Generated Glossary Entry",
+                            lines=25,
+                            max_lines=30,
+                            show_copy_button=True
+                        )
+                
+                generate_btn.click(
+                    generate_new_wrapper,
+                    inputs=[api_key_input, new_term, new_context, new_audience, new_model],
+                    outputs=[new_output]
+                )
+                
+                # Add examples
+                gr.Markdown("**💡 Example Terms:** API, Machine Learning, Blockchain, SaaS, Customer Journey, A/B Testing")
+            
+            # Tab 2: Update Existing Content
+            with gr.TabItem("🔄 Update Existing Content"):
+                gr.Markdown("### Analyze and improve existing glossary entries")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        update_term = gr.Textbox(
+                            label="Term Name",
+                            placeholder="Name of the term being updated",
+                            lines=1
+                        )
+                        existing_content = gr.Textbox(
+                            label="Existing Content",
+                            placeholder="Paste your current glossary entry here",
+                            lines=10
+                        )
+                        update_instructions = gr.Textbox(
+                            label="Update Instructions (Optional)",
+                            placeholder="e.g., 'Add more technical details', 'Include recent developments', 'Improve SEO focus'",
+                            lines=3
+                        )
+                        update_model = gr.Dropdown(
+                            label="AI Model",
+                            choices=["gpt-3.5-turbo", "gpt-4o-mini", "gpt-4", "gpt-4-turbo"],
+                            value="gpt-3.5-turbo",
+                            info="Note: This makes 2 API calls (analysis + update)"
+                        )
+                        update_btn = gr.Button("🔍 Analyze & Update", variant="primary", size="lg")
+                    
+                    with gr.Column(scale=2):
+                        with gr.Row():
+                            recommendations_output = gr.Textbox(
+                                label="📊 Analysis & Recommendations",
+                                lines=12,
+                                max_lines=15,
+                                show_copy_button=True
+                            )
+                        with gr.Row():
+                            updated_content_output = gr.Textbox(
+                                label="✨ Updated Content",
+                                lines=12,
+                                max_lines=15,
+                                show_copy_button=True
+                            )
+                
+                update_btn.click(
+                    update_existing_wrapper,
+                    inputs=[api_key_input, update_term, existing_content, update_instructions, update_model],
+                    outputs=[recommendations_output, updated_content_output]
+                )
             
-    except Exception as e:
-        return f"❌ Error checking rate limits: {str(e)}"
+            # Tab 3: Create Outline/Brief
+            with gr.TabItem("📋 Create Content Brief"):
+                gr.Markdown("### Generate a comprehensive strategy brief for glossary development")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        outline_topic = gr.Textbox(
+                            label="Topic/Subject Area",
+                            placeholder="e.g., Digital Marketing, Cloud Computing, Artificial Intelligence, E-commerce",
+                            lines=1
+                        )
+                        outline_scope = gr.Dropdown(
+                            label="Scope & Depth",
+                            choices=["comprehensive", "focused", "basic", "advanced", "specialized"],
+                            value="comprehensive"
+                        )
+                        outline_model = gr.Dropdown(
+                            label="AI Model",
+                            choices=["gpt-3.5-turbo", "gpt-4o-mini", "gpt-4", "gpt-4-turbo"],
+                            value="gpt-3.5-turbo",
+                            info="Larger briefs may benefit from GPT-4"
+                        )
+                        outline_btn = gr.Button("📋 Create Strategic Brief", variant="primary", size="lg")
+                    
+                    with gr.Column(scale=2):
+                        outline_output = gr.Textbox(
+                            label="📈 Content Strategy Brief",
+                            lines=25,
+                            max_lines=30,
+                            show_copy_button=True
+                        )
+                
+                outline_btn.click(
+                    create_outline_wrapper,
+                    inputs=[api_key_input, outline_topic, outline_scope, outline_model],
+                    outputs=[outline_output]
+                )
+                
+                gr.Markdown("**💡 Example Topics:** Digital Marketing, FinTech, SaaS Operations, Data Science, Cybersecurity")
+            
+            # Tab 4: Template Reference
+            with gr.TabItem("📄 Template Reference"):
+                gr.Markdown("### Official Glossary Template Structure")
+                template_display = gr.Textbox(
+                    label="Template Guidelines",
+                    value=generator.template,
+                    lines=35,
+                    max_lines=40,
+                    interactive=False,
+                    show_copy_button=True
+                )
+        
+        gr.Markdown("""
+        ---
+        ## 🔧 How to Get Your OpenAI API Key:
+        
+        1. **Visit** [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
+        2. **Sign up** or log in to your OpenAI account
+        3. **Add billing information** (GPT-4 requires a paid account)
+        4. **Create a new secret key**
+        5. **Copy and paste** it into the field above
+        
+        ## 💰 **Cost Information:**
+        - **GPT-3.5-turbo**: ~$0.0015 per 1K input tokens, ~$0.002 per 1K output tokens (Recommended)
+        - **GPT-4**: ~$0.03 per 1K input tokens, ~$0.06 per 1K output tokens
+        - **Per generation**: $0.003-0.10 depending on model and content length
+        
+        ## ✨ **New Features & Fixes:**
+        - 🛡️ **Rate Limit Protection**: 2-second delays between requests
+        - 🔄 **Smart Retry Logic**: Exponential backoff on rate limits
+        - 🚫 **No More Double Requests**: Removed automatic model fallbacks
+        - ⚡ **Model Selection**: Choose your preferred AI model
+        - 📊 **Better Error Messages**: Clear feedback on what went wrong
+        - 🎯 **GPT-3.5 Default**: Faster, cheaper, and more reliable for most tasks
+        
+        ## 📊 **Model Recommendations:**
+        - **GPT-3.5-turbo**: Best for most glossary content (fast, cheap, high quality)
+        - **GPT-4o-mini**: Good balance of quality and cost
+        - **GPT-4**: Use for complex technical content or when highest quality needed
+        """)
+    
+    return demo
+
+# Launch the application
+if __name__ == "__main__":
+    app = create_gradio_interface()
+    app.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860
+    )