Create app.py

app.py

@@ -0,0 +1,469 @@
+import gradio as gr
+import os
+from typing import Dict, List, Tuple
+from openai import OpenAI
+import time
+
+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.
+"""
+        
+        # Initialize OpenAI client
+        self.client = None
+        self._setup_openai()
+    
+    def _setup_openai(self):
+        """Initialize OpenAI client with API key"""
+        api_key = os.getenv("OPENAI_API_KEY")
+        if api_key:
+            try:
+                self.client = OpenAI(api_key=api_key)
+                # Test the connection
+                self.client.models.list()
+                print("✅ OpenAI client initialized successfully")
+            except Exception as e:
+                print(f"❌ Error initializing OpenAI client: {e}")
+                self.client = None
+        else:
+            print("⚠️ OPENAI_API_KEY not found in environment variables")
+            self.client = None
+
+    def _call_openai(self, prompt: str, max_tokens: int = 2000) -> str:
+        """Make a call to OpenAI GPT-4"""
+        if not self.client:
+            return "❌ OpenAI API key not configured. Please add your OPENAI_API_KEY to the environment variables in Hugging Face Spaces settings."
+        
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"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,
+                top_p=1,
+                frequency_penalty=0,
+                presence_penalty=0
+            )
+            return response.choices[0].message.content.strip()
+        
+        except Exception as e:
+            return f"❌ Error calling OpenAI API: {str(e)}"
+
+    def generate_new_content(self, term: str, context: str = "", target_audience: str = "general") -> str:
+        """Generate new glossary content for a given term"""
+        
+        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(prompt, max_tokens=2500)
+
+    def update_existing_content(self, term: str, existing_content: str, update_instructions: str = "") -> Tuple[str, str]:
+        """Analyze existing content and provide update recommendations"""
+        
+        # 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(analysis_prompt, max_tokens=1500)
+        
+        # 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(update_prompt, max_tokens=2500)
+        
+        return recommendations, updated_content
+
+    def create_outline_brief(self, topic: str, scope: str = "comprehensive") -> str:
+        """Create an outline or brief for new glossary content"""
+        
+        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(prompt, max_tokens=3000)
+
+def create_gradio_interface():
+    """Create the Gradio interface for the glossary generator"""
+    
+    generator = GlossaryGenerator()
+    
+    def generate_new_wrapper(term, context, audience):
+        if not term.strip():
+            return "Please enter a term to generate content for."
+        return generator.generate_new_content(term, context, audience)
+    
+    def update_existing_wrapper(term, existing_content, update_instructions):
+        if not term.strip() or not existing_content.strip():
+            return "Please provide both term and existing content.", ""
+        recommendations, updated_content = generator.update_existing_content(term, existing_content, update_instructions)
+        return recommendations, updated_content
+    
+    def create_outline_wrapper(topic, scope):
+        if not topic.strip():
+            return "Please enter a topic for the outline."
+        return generator.create_outline_brief(topic, scope)
+    
+    # Create the Gradio interface
+    with gr.Blocks(title="Glossary Content Generator", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 📚 Glossary Content Generator
+        
+        **Powered by OpenAI GPT-4** - Professional glossary content creation and optimization tool.
+        
+        > 🔑 **Setup Required:** Add your `OPENAI_API_KEY` in the Hugging Face Spaces settings under "Repository secrets"
+        """)
+        
+        # Add API key status indicator
+        api_status = "✅ OpenAI Connected" if generator.client else "❌ OpenAI API Key Required"
+        gr.Markdown(f"**Status:** {api_status}")
+        
+        with gr.Tabs():
+            # Tab 1: Generate New Content
+            with gr.TabItem("🆕 Generate New Content"):
+                gr.Markdown("### Create a new glossary entry from scratch using GPT-4")
+                
+                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"
+                        )
+                        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=[new_term, new_context, new_audience],
+                    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 AI-powered recommendations")
+                
+                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_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=[update_term, existing_content, update_instructions],
+                    outputs=[recommendations_output, updated_content_output]
+                )
+            
+            # 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_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=[outline_topic, outline_scope],
+                    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("""
+        ---
+        ## 🔧 Setup Instructions for Hugging Face Spaces:
+        
+        1. **Add OpenAI API Key:**
+           - Go to your Space settings
+           - Navigate to "Repository secrets"
+           - Add: `OPENAI_API_KEY` = `your-openai-api-key-here`
+           - Restart the Space
+        
+        2. **Get OpenAI API Key:**
+           - Visit [platform.openai.com](https://platform.openai.com)
+           - Create account and navigate to API keys
+           - Generate new secret key
+           - Add billing information (GPT-4 requires paid account)
+        
+        ## ✨ Features:
+        - 🤖 **GPT-4 Powered**: High-quality, professional content generation
+        - 📝 **Template Consistency**: Follows your exact 6-section structure
+        - 🔍 **Content Analysis**: Detailed improvement recommendations
+        - 📊 **Strategic Planning**: Comprehensive content briefs and roadmaps
+        - 🎯 **SEO Optimized**: Includes PAA questions and keyword strategies
+        - 📋 **Copy-Friendly**: Easy copy buttons for all outputs
+        
+        **Cost Estimate**: ~$0.02-0.10 per generation (depending on content length)
+        """)
+    
+    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
+    )