Update app.py

app.py

@@ -1,328 +1,305 @@
-# VisualMind App - Fixed Version with Better Error Handling
 # Install required libraries
-#!pip install gradio>=3.50.2 transformers>=4.30.0 networkx>=3.0 matplotlib>=3.7.0 torch>=2.0.0
+# !pip install gradio>=3.50.2 transformers>=4.30.0 networkx>=3.0 plotly>=5.0.0 torch>=2.0.0 numpy>=1.21.0
 
 import gradio as gr
 import torch
 import networkx as nx
-import matplotlib.pyplot as plt
+import plotly.graph_objects as go
 from transformers import pipeline
 import numpy as np
-import io
-from PIL import Image
-import time
 import traceback
 
-# Check if GPU is available and print device info
+# Check device
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"Using device: {device}")
 
-# Load simpler text generation model for faster processing
+# Load models with fallback
 try:
-    summarizer = pipeline("summarization", model="facebook/bart-large-cnn", device=0 if device=="cuda" else -1)
-    text_generator = pipeline("text-generation", model="gpt2", device=0 if device=="cuda" else -1)
+    summarizer = pipeline("summarization", model="facebook/bart-large-cnn", device=0 if device == "cuda" else -1)
+    text_generator = pipeline("text-generation", model="gpt2", device=0 if device == "cuda" else -1)
     print("✓ Models loaded successfully")
 except Exception as e:
     print(f"Model loading error: {e}")
-    # Fallback to smaller models
     try:
-        summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-6-6", device=0 if device=="cuda" else -1)
-        text_generator = pipeline("text-generation", model="distilgpt2", device=0 if device=="cuda" else -1)
+        summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-6-6", device=0 if device == "cuda" else -1)
+        text_generator = pipeline("text-generation", model="distilgpt2", device=0 if device == "cuda" else -1)
         print("✓ Fallback models loaded successfully")
     except:
-        print("Critical error loading models. Please check your environment.")
+        print("Critical error loading models. Exiting.")
 
-# Add progress tracking
+# Progress tracking
 progress_status = {"value": 0, "desc": ""}
 
 def update_progress(value, desc=""):
-    """Update progress tracking"""
     progress_status["value"] = value
     progress_status["desc"] = desc
     print(f"Progress: {value}% - {desc}")
 
-# Function to generate summary (with error handling)
+# Simplified summary generation
 def generate_summary(topic):
-    """Generate a textual summary based on the input topic"""
     try:
-        update_progress(10, "Starting summary generation")
-        
-        # Create a prompt about the topic
-        prompt = f"""
-        Provide a comprehensive analysis of the startup idea: {topic}
-        
-        Include the following sections:
-        - Core concept and value proposition
-        - Target market and potential customers
-        - Technology and implementation requirements
-        - Business model and revenue streams
-        - Competitive advantages and market positioning
-        - Potential challenges and mitigation strategies
-        """
-        
-        # For startup ideas, generate more custom content rather than summarizing
-        # This simulates what the T5 model would do but with better error handling
-        update_progress(30, "Processing topic information")
+        update_progress(10, "Starting your idea analysis")
         
         if "AI" in topic or "artificial intelligence" in topic.lower():
-            ai_component = "The artificial intelligence component provides significant competitive advantage through data analysis and automation."
+            ai_component = "The AI part makes it super smart by figuring out patterns and doing tasks automatically!"
         else:
-            ai_component = "Adding AI capabilities could enhance this startup idea through data analysis and process automation."
+            ai_component = "Adding some AI could make it even cooler by helping with data or tasks."
             
-        # Generate the summary with custom components for startup ideas
         if "urban farming" in topic.lower() or "agriculture" in topic.lower():
             summary = f"""
-            {topic} represents an innovative approach to addressing food security and sustainability challenges.
-            
-            Core concept: This startup combines advanced technologies with urban agriculture to enable efficient food production in cities. The solution uses sensor networks and intelligent systems to monitor and optimize growing conditions in vertical farms, rooftop gardens, or indoor growing facilities.
-            
-            Target market: Primary customers include restaurants seeking farm-to-table produce, health-conscious urban consumers, grocery chains, and food service companies looking to reduce supply chain costs.
-            
-            Technology requirements: The implementation requires IoT sensor arrays, climate control systems, a central AI management platform, and mobile applications for monitoring. {ai_component}
-            
-            Business model: Revenue streams include B2B installations for commercial clients, subscription services for consumers, technology licensing, and potentially data monetization from agricultural insights.
-            
-            Competitive advantages: The solution offers fresher produce with lower transportation costs, reduced water usage (up to 95% compared to traditional farming), and year-round growing capabilities regardless of external climate conditions.
-            
-            Challenges include high initial capital costs, technical complexity, regulatory hurdles in some urban areas, and the need to demonstrate ROI to potential customers.
+            Your idea, {topic}, is a fresh way to grow food right in cities!
+
+            What it’s about: This startup uses cool tech to grow fresh food indoors or on rooftops. Think sensors and smart systems to keep plants happy.
+
+            Who it’s for: People like restaurants wanting fresh veggies, city folks who love healthy food, or stores looking to cut delivery costs.
+
+            How it works: You’d need things like sensors, grow lights, and a smart app to run it all. {ai_component}
+
+            How it makes money: Sell to businesses, charge people monthly for fresh food, or share your tech with others.
+
+            Why it stands out: Fresher food, less travel, and it works all year—no matter the weather!
+
+            Things to watch out for: It might cost a lot to start, and some cities have rules about this.
             """
         else:
-            # Generic startup analysis if not urban farming/agriculture
             outputs = text_generator(
-                f"A startup idea focused on {topic} would involve the following elements:", 
-                max_length=500, 
+                f"A startup idea about {topic} could be:", 
+                max_length=300, 
                 num_return_sequences=1,
                 temperature=0.7
             )
-            
             generated_text = outputs[0]['generated_text']
-            # Clean up and structure the output
             summary = f"""
-            {topic} represents an innovative startup opportunity with significant market potential.
-            
-            Core concept: This startup addresses [specific problem/need] by providing [solution approach] through innovative technology and business model design.
+            Your idea, {topic}, is a cool way to make something better!
+
+            What it’s about: This startup helps with [problem/need] by using [simple solution]. It’s special because [unique bit].
+
+            Who it’s for: People like [customer type] would love this—think [example customers].
+
+            How it works: You’d need [basic tools/tech] to build it. {ai_component}
+
+            How it makes money: You could [simple revenue idea, e.g., sell it or charge a fee].
+
+            Why it stands out: It’s better because [easy advantage, e.g., it’s simpler or cheaper].
+
+            Things to watch out for: Starting might be tough because of [simple challenge, e.g., money or time].
             
             {generated_text}
-            
-            {ai_component}
-            
-            Major challenges would include initial funding requirements, building the right team with domain expertise, and establishing market traction against existing competitors.
             """
         
-        update_progress(60, "Summary generated")
+        update_progress(60, "Idea analysis ready")
         return summary
         
     except Exception as e:
-        error_msg = f"Error generating summary: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        return f"Unable to generate summary. Error: {str(e)}\n\nPlease try again with a different topic or check your connection."
+        print(f"Error generating summary: {str(e)}\n{traceback.format_exc()}")
+        return f"Oops! Something went wrong: {str(e)}. Try again with a new idea!"
 
-# Function to generate mind map
+# Responsive interactive mind map with Plotly
 def generate_mindmap(topic, summary):
-    """Generate a mind map based on the topic and summary"""
     try:
-        update_progress(70, "Creating mind map")
+        update_progress(70, "Building your idea map")
         
-        # Extract concepts from summary (simplified for reliability)
         concepts = [
-            "Core Technology",
-            "Market Opportunity",
-            "Business Model",
-            "Competitive Advantage",
-            "Implementation Challenges"
+            "What It Does", "Who It’s For", "How It Makes Money",
+            "What Makes It Special", "What’s Needed", "Next Steps"
         ]
-        
-        # For each concept, create subconcepts
         subconcepts = {
-            "Core Technology": ["Key Components", "Technical Requirements", "Development Roadmap"],
-            "Market Opportunity": ["Target Customers", "Market Size", "Growth Potential"],
-            "Business Model": ["Revenue Streams", "Pricing Strategy", "Partnership Opportunities"],
-            "Competitive Advantage": ["Unique Selling Points", "Barriers to Entry", "IP Protection"],
-            "Implementation Challenges": ["Resource Requirements", "Regulatory Concerns", "Timeline"]
+            "What It Does": ["Main Idea", "Key Features"],
+            "Who It’s For": ["Customers", "Why They’d Like It"],
+            "How It Makes Money": ["Ways to Earn", "Pricing"],
+            "What Makes It Special": ["Standout Points", "Edge Over Others"],
+            "What’s Needed": ["Tools or Tech", "Skills"],
+            "Next Steps": ["First Moves", "Goals"]
         }
         
-        # Create a graph
-        G = nx.Graph()
-        
-        # Add the central node
-        G.add_node(topic, size=2000)
-        
-        # Add concept nodes and connect to central node
-        for concept in concepts:
-            G.add_node(concept, size=1000)
-            G.add_edge(topic, concept, weight=2)
-            
-            # Add subconcept nodes and connect to concept nodes
-            for subconcept in subconcepts[concept]:
-                G.add_node(subconcept, size=500)
-                G.add_edge(concept, subconcept, weight=1)
-        
-        update_progress(80, "Designing visualization")
-        
-        # Create a visually appealing mind map
-        plt.figure(figsize=(14, 10))
-        
-        # Use a more stable layout algorithm
-        pos = nx.spring_layout(G, k=0.5, seed=42)
-        
-        # Draw nodes with different sizes and colors
-        node_sizes = [G.nodes[node].get('size', 300) for node in G.nodes()]
-        
-        # Color scheme: main topic, concepts, subconcepts
-        node_colors = []
-        for node in G.nodes():
-            if node == topic:
-                node_colors.append('#FF9999')  # Red for main topic
-            elif node in concepts:
-                node_colors.append('#99CCFF')  # Blue for main concepts
-            else:
-                node_colors.append('#CCFF99')  # Green for subconcepts
-        
-        # Draw the network elements
-        nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color=node_colors, alpha=0.8)
-        nx.draw_networkx_edges(G, pos, width=1.5, alpha=0.5, edge_color='gray')
-        
-        # Custom node labels with different font sizes
-        for node, (x, y) in pos.items():
-            font_size = 15 if node == topic else 12 if node in concepts else 9
-            plt.text(
-                x, y, node,
-                fontsize=font_size,
-                ha='center', va='center',
-                bbox=dict(boxstyle="round,pad=0.3", fc='white', ec='gray', alpha=0.8)
-            )
-        
-        plt.title(f"Mind Map: {topic}", fontsize=16)
-        plt.axis('off')
-        
-        # Save figure to bytes
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=150, bbox_inches='tight')
-        buf.seek(0)
-        
-        # Convert to base64 for displaying in gradio
-        mindmap_img = Image.open(buf)
-        plt.close()
+        nodes = [topic] + concepts + [sub for concept in concepts for sub in subconcepts[concept]]
+        edges = [(topic, concept) for concept in concepts] + \
+                [(concept, sub) for concept in concepts for sub in subconcepts[concept]]
+        
+        pos = {topic: (0, 0)}
+        for i, concept in enumerate(concepts):
+            pos[concept] = (np.cos(i * 2 * np.pi / len(concepts)), np.sin(i * 2 * np.pi / len(concepts)))
+            for j, sub in enumerate(subconcepts[concept]):
+                pos[sub] = (pos[concept][0] + 0.3 * np.cos(j), pos[concept][1] + 0.3 * np.sin(j))
+        
+        edge_x, edge_y = [], []
+        for edge in edges:
+            x0, y0 = pos[edge[0]]
+            x1, y1 = pos[edge[1]]
+            edge_x.extend([x0, x1, None])
+            edge_y.extend([y0, y1, None])
+        
+        node_x, node_y = [pos[node][0] for node in nodes], [pos[node][1] for node in nodes]
+        
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(x=edge_x, y=edge_y, mode='lines', line=dict(color='gray', width=1), hoverinfo='none'))
+        fig.add_trace(go.Scatter(
+            x=node_x, y=node_y, mode='markers+text', text=nodes, textposition="middle center",
+            marker=dict(size=[30 if n == topic else 20 if n in concepts else 15 for n in nodes], 
+                       color=['#FF9999' if n == topic else '#99CCFF' if n in concepts else '#CCFF99' for n in nodes]),
+            hoverinfo='text'
+        ))
+        
+        # Responsive layout for mind map
+        fig.update_layout(
+            showlegend=False, 
+            title=f"Your Idea Map: {topic}", 
+            title_x=0.5, 
+            paper_bgcolor='white', 
+            plot_bgcolor='white',
+            autosize=True,  # Makes it scale with container
+            margin=dict(l=20, r=20, t=40, b=20)  # Reduced margins for mobile
+        )
         
-        update_progress(100, "Mind map completed")
-        return mindmap_img
+        update_progress(100, "Idea map ready")
+        return fig
         
     except Exception as e:
-        error_msg = f"Error generating mind map: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        
-        # Create a simple error image
-        plt.figure(figsize=(10, 6))
-        plt.text(0.5, 0.5, f"Mind map generation error:\n{str(e)}", 
-                 ha='center', va='center', fontsize=12, color='red',
-                 bbox=dict(facecolor='white', alpha=0.8))
-        plt.axis('off')
-        
-        # Save error image
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=100)
-        buf.seek(0)
-        error_img = Image.open(buf)
-        plt.close()
-        
-        return error_img
+        print(f"Error generating mind map: {str(e)}")
+        return None
 
-# Main processing function
+# Main processing
 def process_input(topic):
-    """Process the main topic input"""
     try:
         if not topic or len(topic.strip()) < 3:
-            return "Please enter a valid topic (at least 3 characters).", None, gr.update(visible=False)
-        
-        print(f"Processing topic: {topic}")
-        update_progress(0, "Starting processing")
+            return "Please enter a real idea (3+ characters)!", None, gr.update(visible=False)
         
-        # Generate summary
-        summary = generate_summary(topic)
+        print(f"Processing: {topic}")
+        update_progress(0, "Starting your idea journey")
         
-        # Generate mind map
+        summary = f"Congrats! You’ve started shaping {topic}. Here’s your plan:\n\n{generate_summary(topic)}"
         mindmap = generate_mindmap(topic, summary)
         
         return summary, mindmap, gr.update(visible=True)
     
     except Exception as e:
-        error_msg = f"Error in main processing: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        return f"An error occurred: {str(e)}", None, gr.update(visible=True)
+        print(f"Error in processing: {str(e)}\n{traceback.format_exc()}")
+        return f"Oops! Something broke: {str(e)}", None, gr.update(visible=True)
 
-# Function to process follow-up questions
+# Follow-up question processing
 def process_followup_question(question, current_summary):
-    """Process a follow-up question"""
     try:
         if not question or len(question.strip()) < 5:
-            return "Please enter a valid question (at least 5 characters).", None
+            return "Ask something longer (5+ characters)!", None
         
-        print(f"Processing follow-up question: {question}")
-        
-        # Generate answer using the text generator
+        print(f"Follow-up: {question}")
         prompt = f"Question: {question}\n\nContext: {current_summary}\n\nAnswer:"
         
-        response = text_generator(
-            prompt,
-            max_length=300,
-            num_return_sequences=1,
-            temperature=0.7
-        )
-        
-        # Extract and clean up the generated text
-        answer_text = response[0]['generated_text']
-        # Find where the answer starts
-        answer_start = answer_text.find("Answer:") + 7 if "Answer:" in answer_text else 0
-        answer = answer_text[answer_start:].strip()
+        response = text_generator(prompt, max_length=300, num_return_sequences=1, temperature=0.7)
+        answer = response[0]['generated_text'].split("Answer:")[-1].strip()
         
-        # For simplicity in this fixed version, we'll return the same mindmap
-        return answer, None
+        return f"Here’s your answer:\n\n{answer}", None
     
     except Exception as e:
-        error_msg = f"Error processing follow-up: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        return f"An error occurred while processing your question: {str(e)}", None
+        print(f"Error in follow-up: {str(e)}\n{traceback.format_exc()}")
+        return f"Sorry, something went wrong: {str(e)}", None
+
+# Save and load ideas
+def save_idea(name, summary, mindmap, saved):
+    if not name:
+        return gr.update(), "Please give your idea a name!"
+    saved[name] = {"summary": summary, "mindmap": mindmap}
+    return gr.update(choices=list(saved.keys())), f"Great job! '{name}' is saved—keep refining it!"
+
+def load_idea(name, saved):
+    if name in saved:
+        return saved[name]["summary"], saved[name]["mindmap"], gr.update(visible=True)
+    return "No idea found with that name.", None, gr.update(visible=False)
+
+# Custom CSS for responsiveness
+custom_css = """
+.container {
+    max-width: 100%;
+    padding: 10px;
+}
+.header {
+    font-size: clamp(1.5rem, 4vw, 2.5rem);
+    text-align: center;
+}
+.textbox {
+    width: 100% !important;
+    min-height: 100px;
+}
+.button {
+    width: 100%;
+    margin: 5px 0;
+}
+.plot {
+    width: 100% !important;
+    height: auto !important;
+}
+@media (max-width: 768px) {
+    .gr-row {
+        flex-direction: column !important;
+    }
+    .gr-column {
+        width: 100% !important;
+    }
+}
+"""
 
-# Create the Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+# Gradio interface
+with gr.Blocks(theme=gr.themes.Glass(primary_hue="blue", secondary_hue="green"), css=custom_css) as demo:
     current_summary = gr.State("")
-    
-    gr.Markdown("# 🧠 VisualMind Startup Idea Generator")
-    gr.Markdown("Enter a startup idea topic to generate a comprehensive analysis and mind map.")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            topic_input = gr.Textbox(
-                label="Enter Startup Topic", 
-                placeholder="e.g., AI-Powered Urban Farming, Blockchain for Supply Chain, Virtual Reality Education"
-            )
-            submit_btn = gr.Button("Generate Analysis", variant="primary")
-    
-    # Add a visible progress bar
-    with gr.Row():
-        progress = gr.Textbox(label="Status", value="Ready to generate", interactive=False)
-    
-    with gr.Row(visible=False) as results_container:
-        with gr.Column(scale=1):
-            summary_output = gr.Textbox(label="Startup Analysis", lines=15)
+    saved_ideas = gr.State({})
+
+    gr.Markdown("# 🧠 VisualMind - Grow Your Startup Idea", elem_classes=["header"])
+    gr.Markdown("Dream up a startup idea and watch it come to life—works great on any screen!", elem_classes=["container"])
+
+    with gr.Tabs():
+        with gr.Tab("Create Your Idea"):
+            with gr.Row(equal_height=False):
+                with gr.Column(scale=1, min_width=300):
+                    topic_input = gr.Textbox(
+                        label="Your Startup Idea", 
+                        placeholder="e.g., Smart Urban Gardens",
+                        elem_classes=["textbox"]
+                    )
+                    submit_btn = gr.Button("Build My Idea", variant="primary", elem_classes=["button"])
             
-            with gr.Accordion("Ask Follow-up Questions", open=False):
-                followup_input = gr.Textbox(
-                    label="Ask a question about this startup idea", 
-                    placeholder="e.g., What would be the initial funding requirements?"
-                )
-                followup_btn = gr.Button("Get Answer")
-                followup_output = gr.Textbox(label="Answer", lines=5)
-        
-        with gr.Column(scale=1):
-            mindmap_output = gr.Image(label="Mind Map", type="pil")
-    
-    # Set up event handlers
-    def update_status():
-        return f"{progress_status['value']}% - {progress_status['desc']}"
-    
+            progress = gr.Textbox(label="What’s Happening", value="Ready to start!", interactive=False, elem_classes=["textbox"])
+            
+            with gr.Row(visible=False, equal_height=False) as results_container:
+                with gr.Column(scale=1, min_width=300):
+                    summary_output = gr.Textbox(label="Your Idea Plan", lines=10, elem_classes=["textbox"])
+                    
+                    with gr.Accordion("Explore More", open=False):
+                        followup_input = gr.Textbox(
+                            label="Got a question?", 
+                            placeholder="e.g., How do I start small?",
+                            elem_classes=["textbox"]
+                        )
+                        followup_btn = gr.Button("Ask Away", elem_classes=["button"])
+                        followup_output = gr.Textbox(label="Here’s What We Think", lines=5, elem_classes=["textbox"])
+                        gr.Markdown("""
+                        ### Need Ideas to Ask?
+                        - How can I make this stand out?
+                        - Who might love this?
+                        - What’s my first step?
+                        """)
+                
+                with gr.Column(scale=1, min_width=300):
+                    mindmap_output = gr.Plot(label="Your Interactive Idea Map", elem_classes=["plot"])
+            
+            with gr.Row(equal_height=False):
+                with gr.Column(scale=1, min_width=150):
+                    idea_name = gr.Textbox(label="Name Your Idea", placeholder="e.g., GreenCity", elem_classes=["textbox"])
+                    save_btn = gr.Button("Save Idea", elem_classes=["button"])
+                with gr.Column(scale=1, min_width=150):
+                    load_dropdown = gr.Dropdown(label="Pick a Saved Idea", choices=[], elem_classes=["textbox"])
+                    load_btn = gr.Button("Load Idea", elem_classes=["button"])
+
+        with gr.Tab("Tips & Inspiration"):
+            gr.Markdown("""
+            ### Spark Your Next Big Thing!
+            - **Example:** *Eco-Friendly Packaging* - Uses plant-based materials and smart tech to cut waste.
+            - **Try This:** Think of something you wish worked better—how could an app or gadget fix it?
+            - **Tip:** Start small—test your idea with friends first!
+            """, elem_classes=["container"])
+
+    # Event handlers
     submit_btn.click(
-        fn=lambda: "Processing your startup topic...",
+        fn=lambda: "Bringing your idea to life...",
         inputs=None,
         outputs=progress
     ).then(
@@ -334,13 +311,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         inputs=[summary_output],
         outputs=[current_summary]
     ).then(
-        fn=lambda: "Ready for follow-up questions",
+        fn=lambda: "Ready for more questions—keep exploring!",
         inputs=None,
         outputs=progress
     )
     
     followup_btn.click(
-        fn=lambda: "Processing your question...",
+        fn=lambda: "Thinking about your question...",
         inputs=None,
         outputs=progress
     ).then(
@@ -348,32 +325,30 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         inputs=[followup_input, current_summary],
         outputs=[followup_output, mindmap_output]
     ).then(
-        fn=lambda: "Follow-up processed",
+        fn=lambda: "All set—ask another if you’d like!",
         inputs=None,
         outputs=progress
     )
     
-    gr.Markdown("### How It Works")
-    gr.Markdown("""
-    1. Enter a startup idea topic in the input field and click 'Generate Analysis'
-    2. The AI will analyze your startup concept and generate a comprehensive breakdown
-    3. A mind map will be created showing key aspects of the business idea
-    4. Ask follow-up questions to explore specific aspects of the startup concept
+    save_btn.click(
+        save_idea,
+        inputs=[idea_name, summary_output, mindmap_output, saved_ideas],
+        outputs=[load_dropdown, progress]
+    )
     
-    Note: This tool is for brainstorming and ideation purposes. Real startup validation requires market research and testing.
-    """)
+    load_btn.click(
+        load_idea,
+        inputs=[load_dropdown, saved_ideas],
+        outputs=[summary_output, mindmap_output, results_container]
+    )
 
-# Launch the app with better error handling
+# Launch with error handling
 try:
-    demo.launch(debug=True, share=True)
+    demo.launch(debug=True, share=True, height=800)  # Set a default height for better mobile scrolling
 except Exception as e:
-    print(f"Error launching Gradio app: {e}")
-    print("Trying alternative launch method...")
+    print(f"Launch error: {e}")
     try:
-        demo.launch(debug=True, server_name="0.0.0.0")
+        demo.launch(debug=True, server_name="0.0.0.0", height=800)
     except Exception as e2:
-        print(f"Second launch attempt failed: {e2}")
-        print("\nTROUBLESHOOTING TIPS:")
-        print("1. Make sure you're running this in Google Colab")
-        print("2. Try Runtime > Restart runtime and run again")
-        print("3. Check that all libraries installed correctly")
+        print(f"Second launch failed: {e2}")
+        print("Try restarting your runtime or checking library installations.")